zero0.org

I don’t know why I haven’t gotten into this earlier. Here are some of the things I’ve learned while tinkering around.

Don’t use static variables.

The tutorials I’ve read say to use static final variables in your code for readability. I totally agree with this, except for the part about declaring the variables static. When you declare a static variable, the name of the variable gets stored in the string pool in the header. Even if it’s final. And even if it’s private. That means that every one of the static variables’ names is spelled out in modified-utf8 in the header. There goes your class size, exploding out of proportion.

The solution to this to declare local final variables just as you would static ones. This way your code is still readable and there is no need to store the name of the variable in the header, since it’s not visible to other classes. Win-win. Also, the value will be used used directly instead of referencing the variable, even though it’s local. Win-win-win.

An example:

No:
public class A extends JFrame {
private static final int DEFAULT_CLOSE_OPERATION = 3; //that's a lot of modified-utf8
public A() {
setDefaultCloseOperation(DEFAULT_CLOSE_OPERATION); //value of 3 is used
...

Yes:
public class A extends JFrame {
public A() {
final int DEFAULT_CLOSE_OPERATION = 3;
setDefaultCloseOperation(DEFAULT_CLOSE_OPERATION); //value of 3 is used, no other info stored
...

Reference one-dimensional arrays, not multidimensional arrays.

This really just boils down to the following examples:

No:
int[][] enemies = new int[10][4];
for(int i = 10; i-->0;) {
enemies[i][0] = 0;
enemies[i][1] = 1;
enemies[i][2] = 2;
}

Yes:
int[][] enemies = new int[10][4];
int[] e;
for(int i = 10; i-->0;) {
e = enemies[i];
e[0] = 0;
e[1] = 1;
e[2] = 2;
}

In the first example, the enemies array must be loaded for each assignment; then the sub-array is retrieved from index i; finally, the value is stored at the given index in the sub-array.

For the second example, the enemies array is loaded once and stored in a local variable; the value is then stored at the given array in the local array.

Not really a big difference for these trivial examples (2 less opcodes for the second example compared to the first), but if your accessing into a multidimensional array over and over again, this will decrease your final class size quite noticeably.

Reference local variables only.

If you didn’t already know, accessing a field of a class is more expensive than accessing a local variable in time, resources, and class size. Loading a class field,getfield or getstatic, is 3 bytes wide; while loading a local variable, aload, is 2 bytes. Unless it’s aload_[0..3], then it’s 1 byte wide. Lucky variables. But, note thataload_0 is always this, so there are only 3 of those cool 1 byte variable references available.

Remove debug junk.

It is possible to remove debug information from the class file, and it should be done irregardless, unless there is an actual bug that needs a-fixin’; but, remove it again when it’s fixed. To do this from the command line, run javac with the option -g:none. That’s it.

For those of us that are not hardcore enough to use the command line; in Eclipse, right click on your project -> Properties. Enable project specific settings if your workspace has other projects in it that use different settings. Under the Java Compiler property, uncheck everything under Classfile Generation. Click Apply and Yes to rebuilding the project. That’s it.

A strange thing I’ve noticed is that Java 1.6 adds a bunch of stack information to the class file, bloating it with unwanted bytes. Under the same Java Compiler property, change the JDK Compliance to 1.5 or lower to remove the bloat.

JFrame rendering.

To be as minimalist as possible, your game should extend from JFrame. This gives you a window, input capturing and graphics buffering already built in. How nice. But, with all the good things about JFrame, there’s a seedy underbelly.

The first thing to note is that coordinate (0,0) is located in the upper left hand corner. That means increasing Y direction is down the screen, like OpenGL.

Other thing to note is that the coordinate (0,0) is not located in on the canvas area of the window, but the upper left corner of the window. That means that the title bar and side bars cover the drawing area. So, if you draw a circle at (0,0) with a radius of 25 pixels, you would only see the very bottom of that circle at the top left of the window because the title bar height is about 20 pixels and the border bars are about 4 pixels wide, for Windows anyway.

What is one to do! A solution to this is to move point (0,0) and pad the window’s size. Example:

public class A extends JFrame {
public A() {
final int WIDTH = 640, HEIGHT = 480;
final int PADDING = 5, PADDING_TOP = 20;
final int WINDOW_WIDTH = PADDING + WIDTH + PADDING;
final int WINDOW_HEIGHT = PADDING_TOP + PADDING + HEIGHT + PADDING;
setSize( WINDOW_WIDTH, WINDOW_HEIGHT );
final AffineTransform identity = new AffineTransform();
identity.translate( PADDING, PADDING_TOP + PADDING );
...
//rendering
gr.clearRect( 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT ); //graphics is the size of the window
gr.setTransform( identity ); //now point (0,0) is visible inside the window, as well as point (WIDTH, HEIGHT)
...

The “Reverse For Loop.”

If you noticed, in a previous example I used a reverse for loop. There are many reasons to use them instead of the plain old ones:

• They are faster. Comparing a number to 0 is much faster than loading a variable and then comparing it to another number. Some ALU’s did comparisons by subtracting the one number from the other, then comparing the result to 0. You’re just skipping the extra subtracting all together. At least they used to compare numbers that way; not sure now.
• Don’t quote me on this, but subtraction is faster than addition as well. At least that’s what I heard somewhere.
• It also looks better. “i --> 0”, “as i goes to 0”.
• When the order of operations don’t matter.
• If the for loop is going against an array or collection, you would call array.length or collection.size() for every comparison. Wouldn’t you just want to call them once?
• for( int i = 0; i < 10; i++ ) {} is 14 bytes long
  for( int i = 10; i --> 0; ) {} is 10 bytes long