• Advertisement
Sign in to follow this  
  • entries
  • comments
  • views

About this blog

*not a guarantee

Entries in this blog

Ah thank god.

My family recently got a cabin in the middle of freaking nowhere of NY state. So I've been staying up here for a week as it's a much better environment to get work done. But the internet hasn't been hooked up until today. I was doing pretty well surviving for the first few days, but then I started going a little stir crazy. Everything's all better now.


Status check:

My dream of interactive programming continues to elude me. I've gotten it to work in special cases, but I want to be able to do it everywhere, without too much set-up work. BeanShell seems to have problems if you a) load a script, b) create an object with that script, then c) reload the script and try to use newly-defined code on that object. The object hangs on to references to the old script's structures. So I actually got an error that said "Error: Cannot cast class BlockType to class BlockType", because one of the BlockTypes was the new version and one was the old version, and it didn't figure out that they should be the same just cause they have the same name. Oy.

I've been playing the game Psychonauts. The art is amazing. The animation is amazing. The level design, and the entire premise of the game is delightfully weird and great. If you take everything that was great about Grim Fandango and multiply it by 5 then that's what the game is like.

It's just too bad you need to endure hours of annoying platform-jumping to enjoy all that great stuff. The gameplay mechanics are the least revolutionary thing about the game, so much that they drag down everything else.

Overall I think that the whole "jumping" mechanic just needs to die. It was silly to begin with, and it's been overdone to death, so maybe as an industry we can all just collectively move on.

I have a logo!

Astute readers will notice that the test code I posted 2 entries ago is the same code that renders the yellow spikey things in a circle. Except that the final version used 300 steps instead of 70, and the other values were tweaked too.

And, by the way, since the rendering was script code, I was able to fiddle with those numbers *live* and see the changes immediately. Interactive programming rocks. I think it might be worthy of writing a tutorial article, since it rocks so much.

Anyway, time to write a game.


Woooo, just finished evaluating BeanShell. It's great!

The BeanShell version of that last test ran at 8 fps (where the pure Java version runs at 12 fps and the JRuby version ran at 3 fps). So the slowdown isn't too bad, plus the clincher is that I can copy-paste any performance-critical BeanShell code into java.

(ps, the reason those FPS numbers are so low is that the test is re-rendering the SVG tree on every draw. In the real game, if I do use SVG sprites, they'll be pre-drawn and cached)

Plus BeanShell gets a heap of bonus points because it worked the first time, and behaved just like I expected. I can't say the same for those other engines :)


Yeah I change my mind a lot.

After evaluating Rhino, I came to this conclusion: really no scripting language has a very fluid way of passing Java objects to a script.

So with that knowledge in hand, I went back to JRuby because a) I have a crush on that language, and b) I do know a roundabout way to pass a java object to a ruby script (just use the BSF).

So I set up a performance test. On one side is this ruby code:

include_class 'SVGSprite'

def draw
num_steps = 70;

for step in 0...num_steps
angle = step * 1.0 / num_steps * 2 * 3.1415926545;
loc_x = 100+ 40*Math.cos(angle);
loc_y = 100+ 30*Math.sin(angle);
$sprite.setRotation(angle + 3.1415926545/2);
$sprite.setPreferedSize(2, 15);
$g.draw($sprite, loc_x, loc_y, SVGSprite::CENTER);

public :draw

and the other side is the java version:

int num_steps = 70;
for (int step=0; step < num_steps; step++)
double angle = (float) step / num_steps * 2 * Math.PI;
double loc_x = 100+ 40*Math.cos(angle);
double loc_y = 100+ 30*Math.sin(angle);
sprite.setRotation(angle + Math.PI/2);
sprite.setPreferedSize(2, 15);
sprite.draw(g, (int)loc_x, (int)loc_y, SVGSprite.CENTER);

And the result is that the Java version worked 4 times faster than the JRuby version. That's ridiculous! The bulk of the processing time *should* be in the SVG rendering and the actual image drawing (the details of which are handled in java code), but somehow JRuby manages to take forever doing its thing. So that's it, that's the nail in the coffin, I'm done with it I promise.

So I think I'm going with BeanShell like H_o_p_s suggests. The nice thing is BeanShell looks a lot like Java, so if I ever get worried about performance, I can just copy-paste BeanShell code into java.

Also, while I had JRuby working, I did get to enjoy a few moments of interactive development (that is, changing the code while the game is running, and seeing the results right away). And let me tell you, it was delightful.

tool overload

Okay, I'm coming to terms with the fact that I am suffering from tool overdose.

Batik? Cool, but it doesn't really help me.

JRuby? The language looks fun, but the Java->JRuby interaction really has been a pain. I can't get it to work the way I want, plus there's something about the implementation that makes it really inefficient. Every time you pass JRuby code a Java object, it seems like it needs to fully ruby-ize the java object, and if you pass it a big object (like say Graphics), it literally sits there working for 10 seconds. I'm not going to have a loading bar for my scripting engine! (though they say this inefficiency will be fixed in the December release)

So JRuby is outta here. Hopefully sometime in the future I'll have an excuse to learn this fun language.

Rhino is looking better and better, I think I'm using that now. It seems to be the only library I can find that has a sane way for Java code to call a scripted method. javascript might not be as charming a language as Ruby, but as long as I have some way in my game to interactively change the game code, I'll be happy.

java svg code

I figured someone might be interested, so here is my java code for getting a simple SVG-backed sprite up and running:

import org.apache.batik.gvt.renderer.StaticRenderer;
import org.w3c.dom.svg.SVGDocument;
import org.apache.batik.bridge.*;
import org.apache.batik.gvt.*;

import java.awt.geom.*;
import java.awt.*;

class SVGSprite
// svg data
SVGDocument document;
BridgeContext bridgeContext;
StaticRenderer renderer = new StaticRenderer();
SVGUserAgent userAgent = new SVGUserAgent();
static GVTBuilder builder = new GVTBuilder();

double documentW, documentH;
double preferedW, preferedH;
int offscreenW, offscreenH;

// sprite data
double rotation = 0;
double translate_x = 0, translate_y = 0;
boolean needs_redraw = true;

// flags
public static final int CENTER = 1;

public SVGSprite(String svg_file_name)
document = SVGLayer.loadDocument(svg_file_name);

bridgeContext = new BridgeContext(userAgent);

GraphicsNode root = builder.build(bridgeContext, document);
Dimension2D docSize = bridgeContext.getDocumentSize();
documentW = docSize.getWidth();
documentH = docSize.getHeight();
setPreferedSize(documentW, documentH);

needs_redraw = true;

void setPreferedSize(double size_x, double size_y)
preferedW = size_x;
preferedH = size_y;
double max_diam = Math.max(preferedW, preferedH);
max_diam = max_diam * 1.5;
offscreenW = (int) (max_diam);
offscreenH = (int) (max_diam);
renderer.updateOffScreen(offscreenW, offscreenH);
needs_redraw = true;

void setRotation(double rot)
rotation = rot;
needs_redraw = true;
void setTranslation(double x, double y)
// this method can useful for setting the draw coordinates with float-precision
translate_x = x;
translate_y = y;
needs_redraw = true;

AffineTransform cached_transform = new AffineTransform();
void redraw()
cached_transform.translate(translate_x, translate_y);
cached_transform.rotate(rotation, offscreenW/2f, offscreenH/2f);
cached_transform.translate((offscreenW - documentW)/2f, (offscreenH - documentH)/2f);
cached_transform.scale(preferedW/documentW, preferedH/documentH);
renderer.repaint(new Rectangle(0, 0, offscreenW, offscreenH));
needs_redraw = false;

void draw(Graphics2D g, int loc_x, int loc_y, int flags)
if (needs_redraw) redraw();

if ((flags & CENTER) != 0)
loc_x -= offscreenW;
loc_y -= offscreenH;

g.drawImage(renderer.getOffScreen(), null, loc_x, loc_y);
//g.drawRect(loc_x, loc_y, offscreenW, offscreenH);

// *************
import java.awt.*;
import java.awt.geom.*;
import java.io.IOException;

import org.apache.batik.dom.svg.SAXSVGDocumentFactory;
import org.apache.batik.dom.svg.SVGDocumentFactory;
import org.apache.batik.util.XMLResourceDescriptor;
import org.w3c.dom.svg.SVGDocument;
import org.apache.batik.bridge.*;
import org.apache.batik.transcoder.*;
import org.apache.batik.gvt.GraphicsNode;
import org.apache.batik.gvt.renderer.StaticRenderer;

public class SVGLayer
protected static SVGDocumentFactory factory;

static SVGDocument loadDocument(String uri)
if (factory == null)
// create document factory
String parser = XMLResourceDescriptor.getXMLParserClassName();
factory = new SAXSVGDocumentFactory(parser);

try {
return factory.createSVGDocument(uri);
} catch (IOException e)
return null;
// **************

import java.awt.*;
import java.awt.geom.*;
import org.apache.batik.bridge.UserAgentAdapter;

class SVGUserAgent extends UserAgentAdapter
AffineTransform transform = new AffineTransform();

public AffineTransform getTransform()
return transform;

public Dimension2D getViewportSize()
return new Dimension(100,100);

public void displayError(String message)
throw new RuntimeException(message);
public void displayError(Exception e)
public void displayMessage(String message)
throw new RuntimeException(message);

// ****************

and here is sample code of it being used:

public void paint(Graphics2D g2d)
SVGSprite = new SVGSprite("file:a.svg");
sprite.setPreferedSize(20, 20);
sprite.draw(g2d, 10, 10, SVGSprite.CENTER);

svg in java

So I thought it would be cool to use SVG in my java games. The standard library to do this is Batik. The library is pretty sweet, but damn is it huge- 4mb of class files. 1mb of this is from the included XML reader Xerces. Damned if I know how an XML reader can take up 1mb.

It works well, but you can tell Batik is meant for the high-end user. Doing something that seems like it would be simple (like, hey, how about you just draw this SVG file where I tell you to?) is actually a lot of work. And it's made more difficult by the huge API to swim through.

This graph pretty much sums it up. According to Batik, I am a "serious hacker"

Anyway, I think I have it under control- I already have a class that loads a document and renders it to an offscreen image, suitable for drawing.

Also, I looked into SVGSalamander, which sounded promising because it's suppossed to be optimized for games. But I couldn't even get it to work, even when I tried using their example code. Soooooo, yeah.
Okay the time has come for some RAD. I'm looking into scripting engines to use in conjunction with Java, because I feel like I can really tear things up if I get a nice scripting engine with an interactive mode that lets me edit scripts while playing the game.

So I checked out what's available and I narrowed it down to Jython and JRuby.

Jython pros:
- The Python language is pretty popular for games
- Looks pretty stable (they are up to version 2)

Jython cons:
- Library is 2.7mb, which is pretty big if I ever hope to sell any games to people on dial-up.
- The whitespace thing bugs me. Are brackets really so bad, that we need to come up with a clever way to avoid writing brackets?

JRuby pros:
- Smaller library (800k)
- I kind of like the language more. One of the things I want out of a scripting language is closures, the whole passing-functions-as-data thing. Python certainly supports closures, but the difference is Ruby encourages them, by making them so easy to do. Looking at Ruby code, you see them all over the freaking place.

JRuby cons:
- Not really finished. It seems like most of the upcoming work is for tighter integration with Java, which I don't really need except as far as it increases performance. But there's some important stuff missing, like continuations. I've never ever used a continuation, but maybe I want to!
- Performance concerns. I know that the point of a scripting language isn't high performance, but when I look at this, it makes me worried.

But anyway, I think I'm going with JRuby, as that language seems more like what I want.
Well that's it, I'm quitting my job and going to attempt to become self-sufficient selling games on the internet. Why not, with all this indie hype (like Greg Costikyan's highly publicized move to indie), it just seems like the thing to do :)

I already got a company name: Fuzzy Games. It's a nice friendly name, and "fuzzy" is a term used in AI programming, which is something I'm planning on putting a lot of emphasis on.

My first game will be a twist on Tetris. Yeah I know, everybody does a twist on Tetris. But I think my twist will be kinda interesting (don't want to get into the specifics yet). And anyway, it's the first game so I want to kick off with something small & manageable.

My deadline to have this first game released is January 1st. It's kind of like a backwards new year's resolution :D


Yeah, I've never been good at keeping a blog updated regularly.

Anyway I have a new plan. The new plan is to quit my job and attempt to start a business selling games on the web. Anyone out there have any experience doing this?

I have pretty much all the logistics figured out. The games will be small and casual-oriented, and I'll aim to get a new game out there once every 3 months. Distribution is totally not a problem, there are a bazillion portals & etc sites that spew out new games all the time. And I can always make my own site and host them.

The platform I'm going to use is Java with Java Web Start. Web Start is such a terrific and underappreciated tool. It allows super-quick installation and checks for updated files every time you run it. It's basically a poor-man's Steam.

So I'll need to get the people to download the latest Java JRE, but I don't think this will be hard.


No updates for a while because I haven't made any progress in a while. The last week or so has been pretty busy. Last weekend I took a vacation to San Fran with my girl, that was fun. At work, the pressure has been up for the last few weeks to push the current game to release (similar to how the sphincter muscles contract when trying to expunge a piece of excrement). On friday, I got an expenses-paid trip to Boston for a job interview. That was pretty sweet. I think that was my first interview where they paid my travel expenses. It's nice to be at that point in my life =) . Then on friday night, I made it back for a Bloc Party concert, which was of course awesome.

Anyway, no actual progress to report, but I came up with a game concept. One of the questions that's been in the back of my head regarding this AI project is, exactly where am I going to use it? It's been harder than I thought to think of a game concept that would even take advantage of all this fancy shmancy AI.

Title: Counterplan
Basic concept: You must infiltrate a high-security location, form a plan to outwit the guards and security cameras, and accomplish some specified goal.
Some example levels: a prison level, where your goal is just to escape. Or a bank level, the goal is to get out the door with the money.
Interaction: Your character can manipulate various things in the world (set off alarms, lay traps, etc), and only a well-timed sequence of actions will get them to where they need. There's no combat or guns or anything. If you get caught, it's game over.
AI: The interesting part of this game is that there are several intelligent entities roaming around (guards), and they'll react to weird things happening in a rational way. In most cases, if you do something that the guards don't like, they'll just come straight at you and catch you. So the crux of the gameplay is, you have to think of what the guards will think, and trick them into believing something else. (an example, if you take apart some vent with a wrench, they'll get suspicious and catch you, but if you plant the wrench on someone else, they'll take him instead of you).
Graphics: 3d using some cheaply available engine. Also I'm thinking there could be an overhead map that can give you some rough idea of where guards are. And a text display that shows the guard's conversations, so that you have an idea of what the guards are thinking. (though you might need to find a "guard headest" item before you can see this).
Pricing model: As mentioned before, the game is episodic, which would make for a good pricing model. We give away 1 complete level for free. Then additional levels can be purchased and downloaded from our website.

As a side note, I came up with this concept while watching the show Prison Break =)
Although I haven't starting implementing training yet, I found an excellent training algorithm that will mesh really well with my app's design. It's called Cascade-Correlation (pdf). Basically, it adds one node at a time to the system, and trains a node as soon as it's added. Once the node is in place, it's frozen and isn't trained any more. So you can get higher accuracy by just continuing to add nodes. Apparently the whole thing works faster (fewer epochs) than back-prop, because training one node at a time solves the moving-target problem.

This algorithm is a good fit for two reasons:
1) my program keeps track of individual nodes seperately anyway (most neural networks and algorithms work with entire layers rather than individual nodes).

2) there's going to be both user-created nodes and training-created nodes in the system, and the last thing the user wants is for the training algorithm to f with the nodes that he put there by hand. So I need algorithms that can work without changing the net that's already there.

And as a side note, that paper is yet *another* connectionist-related development to come out of CMU. I'm looking at places to go for grad school, and the CNBC is definitely first on my list.

java hacking

Hey are you bummed by the fact that Java has no "friend" keyword? How would you like it if your function could assert that it was only being called by a certain class?

class MyUtils
static boolean callerIsOfClass(Class targetClass)
StackTraceElement stack[] = Thread.currentThread().getStackTrace();

// find our frame
int our_frame = 0;
while (!stack[our_frame].getMethodName().equals("callerIsOfClass"))

// the frame that the caller cares about is 2 above
StackTraceElement targetFrame = stack[our_frame + 2];

return targetFrame.getClassName().equals(targetClass.getName());

void exampleFunction()
assert MyUtils.callerIsOfClass(TheClassThatILike.class);


off and running

Running the network works! Also, it's all hooked up to the display, so you can watch nodes change color as their level of activation changes.

So far I have a simple repeater network running. It's a network with a chain of nodes, and the last node inhibits the first item. So these nodes alternate between on & off with a period equal to the length of the chain.

I'm going to start making more complex networks, but this requires work on multiple fronts. One, the editor will continue to need improvements that allow me to do the things I want. And two, I need to figure out how the hell to make anything that actually does something useful. After all, this project is simultaneously a learning experience, it's me learning how to make an ANN by hand.

I would post a screenshot, but a single image wouldn't really do it justice. It's something you have to watch in action. Once the thing is more polished, I'm going to upload an applet version, or a webstart app.

As expected, I'm thinking of more features as I go. One thing that I definitely want is the ability to edit the network as it's being run. Since I'm trying to keep the executed network as seperate as possible from the main app (the same model that typical programming languages use, the debug build is seperate from, but connected to, the IDE), this will add a layer of complexity to things.
Nodes finally have names :)

This came at the end of a long struggle, which started with a simple desire for me to have a pop-up toolbar on the right side where you can edit details about a node (such as its name). During the process, I ended up having to learn way more than I ever wanted to know about the interaction between Java components, containers, and layout managers. Here's what I learned:
#1 Layout managers are a good idea
#2 Java's selection of layout managers is crap
#3 The only decent general-purpose layout manager is SpringLayout
#4 SpringLayout hardly ever does what you want, you need to understand how it works internally in order to make it do what you want
#5 What the hell is the point of having a class if I need to understand how it works internally
#6 I'm going to roll my own general-purpose layout manager

But not today. I'm going back to getting real features done before I start fighting the GUI again. No doubt that I could spend weeks fiddling with Swing.

Also I did a TON of refactoring. And I deleted some abandoned source code, bringing my lines of code down to 3900 :(

Status report #1

Here's a pic of my project

It's not much to look at, but I figured it would help people better understand what the whole thing is about. You create nodes, you make connections between the nodes (the red ones are negative), and eventually you'll be able to run the whole network. That box in the lower right is a selection box being dragged by the mouse (Windows dissappeared my mouse)

Right now I'm trying to complete the absolute minimum amount of features such that the thing is actually usable. Still to do:
- naming/labeling nodes
- running the network
- this includes: the display being updated for the network's live state
- and: setting up an input stream
- extracting the input stream from a network that is embedded in a 3rd party app

Status overview-
Source code: 4091 lines in 36 files.
Number of class files: 53
Music currently playing: Joanna Newsom
Okay this is a resolution of the problems I asked about in this thread

The problem was.. well there were several problems. *One* of the problems was that I needed a good way to make undoable changes to the model. Saving the entire model state is a reliable way to do this, but this would make my undo stack take up a ton of memory.

So, change #1 was to give all nodes a unique ID, and have a hashtable to find nodes based on their ID. This was a good change, most of the stuff below would have been impossible without it.

For the incremental change thing, I *could* have had every Command object just keep track of how to undo itself. For example, the DeleteNode command could keep track of "nodes I just deleted". But this gets messy. Deleting a node will also kill all connections involving the node, so if you want to undo a deletion, you also need to remember all the connections. And it would be great if I could have a generalized way to do this, so I didn't have to go through the same messy process for every Command.

So attempt #1 was to have an UndoableOperation object that keeps track of every change made. Commands would do operations on the model through this object, and the UndoableOperation would break each action down to a bunch of undoable atomic operations. And it keeps all the atomic operations on a big stack, and when you tell it to undo, it pops everything off the stack and undos each step one at a time. This was to handle things like deleting a node (deleting a node would first produce a bunch of atomic delete connection items)

But this was messy and often failed in unexpected ways. And in certain situations it would be way inefficent. Say I am dragging a node with the mouse (which should be undoable). Every 1/20th of a second when a MouseMotionEvent is generated, the code is going to find that the mouse has moved over a few pixels, and it will tell the UndoableOperation to move the node, which will push a new "move the node a tiny little bit" operation on the stack. This is no good. Granted there are ways I could have improved this, but at this point my confidence in this method had dropped.

So attempt number 2, which will be called attempt number SUCCESS. It's called a ModelDelta object, although "partial memento" might be a better name. You can tell the delta object to "mark" any node or connection. Once marked, it saves that object in a Memento object. If the thing is already marked, it ignores you. And it has an "undo" command, which goes through all the marked objects and restores them to how they were before.

So now, every time to make a change to the network, you make sure to first mark the thing you are changing (and I have a wrapper, also called UndoableOperation, which takes care of marking for you). As long as everything gets marked, you can use ModelDelta.undo to restore the previous state. It works great. It's very clean. Everybody's happy.

Also I don't know if anyone has used this pattern before, but I'm using something I call the Phantom Memento. The phantom memento remembers that a certain object doesn't exist. If you do a command that adds a node, the delta object keeps a phantom memento to remember that this node wasn't here a second ago. "Restoring" a phantom memento means deleting the node. WoooooOOOOOooooOOOOOOOO. Spooky.
I broke java! The following code:

class Test
static public void main(String[] args)
HashMap hashmap = new HashMap();
long useless_number = 0;
useless_number += hashmap.get(0);

gave me this error:

An exception has occurred in the compiler (1.5.0-beta). Please file a bug at the Java Developer Connection (http://java.sun.com/cgi-bin/bugreport.cgi) after checking the Bug Parade for duplicates. Include your program and the following diagnostic in your report. Thank you.
java.lang.ArrayIndexOutOfBoundsException: -1
at com.sun.tools.javac.jvm.Code$State.pop(Code.java:1509)
at com.sun.tools.javac.jvm.Code.emitop1w(Code.java:871)
at com.sun.tools.javac.jvm.Items$LocalItem.store(Items.java:387)
at com.sun.tools.javac.jvm.Items$AssignItem.drop(Items.java:665)
at com.sun.tools.javac.jvm.Gen.visitExec(Gen.java:1599)
at com.sun.tools.javac.tree.Tree$Exec.accept(Tree.java:734)
at com.sun.tools.javac.jvm.Gen.genDef(Gen.java:651)
at com.sun.tools.javac.jvm.Gen.genStat(Gen.java:686)
at com.sun.tools.javac.jvm.Gen.genStat(Gen.java:672)
at com.sun.tools.javac.jvm.Gen.genStats(Gen.java:723)
at com.sun.tools.javac.jvm.Gen.visitBlock(Gen.java:970)
at com.sun.tools.javac.tree.Tree$Block.accept(Tree.java:540)
at com.sun.tools.javac.jvm.Gen.genDef(Gen.java:651)
at com.sun.tools.javac.jvm.Gen.genStat(Gen.java:686)
at com.sun.tools.javac.jvm.Gen.genStat(Gen.java:672)
at com.sun.tools.javac.jvm.Gen.genLoop(Gen.java:1016)
at com.sun.tools.javac.jvm.Gen.visitForLoop(Gen.java:987)
at com.sun.tools.javac.tree.Tree$ForLoop.accept(Tree.java:586)
at com.sun.tools.javac.jvm.Gen.genDef(Gen.java:651)
at com.sun.tools.javac.jvm.Gen.genStat(Gen.java:686)
at com.sun.tools.javac.jvm.Gen.genStat(Gen.java:672)
at com.sun.tools.javac.jvm.Gen.genStats(Gen.java:723)
at com.sun.tools.javac.jvm.Gen.visitBlock(Gen.java:970)
at com.sun.tools.javac.tree.Tree$Block.accept(Tree.java:540)
at com.sun.tools.javac.jvm.Gen.genDef(Gen.java:651)
at com.sun.tools.javac.jvm.Gen.genStat(Gen.java:686)
at com.sun.tools.javac.jvm.Gen.genMethod(Gen.java:908)
at com.sun.tools.javac.jvm.Gen.visitMethodDef(Gen.java:844)
at com.sun.tools.javac.tree.Tree$MethodDef.accept(Tree.java:482)
at com.sun.tools.javac.jvm.Gen.genDef(Gen.java:651)
at com.sun.tools.javac.jvm.Gen.genClass(Gen.java:2177)
at com.sun.tools.javac.main.JavaCompiler.genCode(JavaCompiler.java:325)
at com.sun.tools.javac.main.JavaCompiler.compile(JavaCompiler.java:467)
at com.sun.tools.javac.main.Main.compile(Main.java:593)
at com.sun.tools.javac.main.Main.compile(Main.java:545)
at com.sun.tools.javac.Main.compile(Main.java:44)
at com.sun.tools.javac.Main.main(Main.java:35)

WOO. Obviously it has something to do with the new unboxing stuff (the bug doesn't occur if I try to unbox to an int, only to a long). And I guess the compiler is technically a beta version. But still I feel proud.

first post

huzzah! I was planning to get gd+ activated when my current project was ready to distribute, but that's taking a while. And I felt like getting started with the dev journal.

First, complaint #1. Why in the world does it take 3 DAYS to get gdnet+ activated? Come on guys. This is the internet. This is 2005. I want INSTANT GRATIFICATION. Get on board the information superhighway!!
Sign in to follow this  
  • Advertisement