Knut's Projects

A new hobby project

Knut Erik — Fri, 12 Nov 2010 23:59:24 +0000

I’ve been looking to start a new (semi-serious) hobby project. As usual with these things, the hard part is deciding what to make, not doing it (although I think this will be more than hard enough to make it interesting). I know I want to try creating a small(ish) game, and preferably something that I would enjoy myself. I also wanted to do it somewhat relevant to my job, where I use Java, so I decided to not use C++, which is the traditional language for these things. Should be exciting to see how that works.

To get started, I have been playing around with GUI programming, which is something I don’t usually do(at work I work on the server side of things). I created a small program to show panels on the screen, like so.

A panel being shown on screen

The panel shown is within the borders in the picture. Other examples.

Program options panel

Game options panel

For the program options panel, I also wrote some code for changing the screen resolution. I’m designing the program to run in fullscreen mode by default, and so far the resolution is the only option(supported resolutions taken from the OS). So, what happens when clicking on start in that last panel?

An empty panel to be precise

Well, right now, nothing. Or to be precise, an empty panel with a single functionality, which is to return to the main menu if ESC is pressed. So now I just need to make something interesting to fill that empty space with. Server side programming is more my turf, so this should hopefully go smoothly.

Adding GUI

Knut Erik — Sun, 23 May 2010 18:50:47 +0000

If this project is going to end anywhere interesting, it needs a GUI. And GUI means windows, buttons etc etc. I created a GUI model, with elements, containers and all that good stuff. Or at least a prototype:

First Windows

Not too bad. But what is a GUI without mouse support? And windows that can be selected?

First Windows Show Off

So I have a GUI that can draw windows, and responds to mouse input. Not a bad start, although it still needs a lot of work. First job will be to allow text rendering.

Improving the configuration framework

Knut Erik — Sun, 28 Mar 2010 22:06:28 +0000

In the last post I described the configuration framework I created for the Universal project. I also discovered an important limitation, I had not included list functionality. So I revised my visual guide:

Config Tree

I changed all the star types and icons to a new configuration file, and also added a new star type, witch is easy now, no code changes are needed.

Pretty?

Now I think it’s time to start adding some form of user interface.

Adding a configuration framework

Knut Erik — Wed, 10 Mar 2010 17:57:29 +0000

The goal of this project is to generate an interesting universe from scratch. Any form of procedural generation needs quite a few parameters to work properly, in my case things like galaxy size, star density etc. I’m sure a lot of other values will be added later, I’m already thinking of different star types and planet types. Even just adding stars to a universe requires between five and ten parameters, maybe even more, especially since I want different types. Even at this very early stage, it’s a good idea to have all of these in one place, and when the project has grown large and fat, it’s absolutely essential. Preferably with the ability to group parameters together. I considered a few approaches to this problem:

I could have all the parameters in a header file, or maybe more files as the project grows. This would be the fastest approach, but it’s not very flexible since I would need to recompile every time I make a change. Very inconvenient. Also, if I ever want to add saving/loading of parameters, this method would not be good enough.
I considered having a text file with parameters, which would then be loaded into a special class, or a set of classes, containing all the values, and making them available to the rest of the program. I’ve used this approach before, so I know how to make it work. It’s also quite fast, and it’s easy enough to group parameters together. However, the container classes will grow very large, and it’s tough to add new values.
I could place the parameters in a text file as above, but create a framework that would load them at runtime into a generic configuration tree. This is flexible, easy enough to work with, and I can group the parameters into branches of the tree. However, it might be a bit slower than the other approaches. However, it’s also the most interesting to implement. This is the approach I selected.

Having never implemented a system like this in C++ before, I thought it would be a good idea to make a visual guide.

The configuration tree visualized

So I implemented it pretty much like that, using maps and void pointers in the ConfigEntry class, and creating a ConfigHandler class to deal with the loading of the configuration files. The configuration files are very simple, sort of “poor mans xml”. I think I might change it to use real xml in the future. But it works fine for the time being, I can define parameters, their type and name, and group them into complex attributes.

So with the system ready, I moved the (currently three) parameters from their previous place in a header file, to the new configuration file. And it works very well.:) The file gets loaded at startup, so I don’t have to recompile, and it’s pretty easy to get the attribute I want, with all the maps wrapped in a nice ConfigEntry object.

And then I thought, what else should I add to the configuration system. The list of images used as the star icons maybe? Good idea. But no list…hmmm…already showing limitations…

Guess it still needs some work. But that should be pretty easy and quick I hope.

Adding more star icons

Knut Erik — Sun, 21 Feb 2010 20:18:16 +0000

The graphical output of the Universal program is not surprisingly better than the text, but it still looks quite dull and flat. To help with this, I added a background image. But to ensure some randomness, I created an image bigger than the sector size, and a random part of it will be selected.

Added background

Another background

Both star positions and the background image are different for each time the program runs. To add even more variance, O created some more star icons, and had the program choose between these. The result is quite nice:

Different star icons

I also created some red stars, but just for show. I’ve add the different star types later, with different planet types etc. For now, it’s just for the visuals.

Some red star icons

Thats the visuals for a while, next i need to look at adding configuration files to the project.

A new project

Knut Erik — Sun, 21 Feb 2010 19:04:32 +0000

I thought it would be fun to do a little program that creates a universe from scratch. Not a “real” universe, but maybe a sci-fi one. Perhaps I’ll make it into a little game or something, I’m not sure.

I started the project by using SDL to fire up a window. I thought that my galaxy should consists of sectors. So a good start would be to add some stars to one sector, randomly. Here’s the first result, in glorious text mode:

Text output. Stars being stars and dots being empty space

Not too bad start, although I really would prefer to have some graphic output instead. So, using Gimp, I created a star icon. Then I used SDL to create an image for the sector, and added star icons where applicable. The result is not too bad:

Star icons of a sector

The program generates this image at startup, and therefore will only draw one image each time it iterates through the main loop. So it’s fast. Not that it would have mattered at this stage, but hopefully I will expand this program enough that it will matter.

Creating a server/client application in Java

Knut Erik — Fri, 28 Aug 2009 20:15:10 +0000

I’m experimenting with network programming in Java, and writing a server/client application. The basic socket handling in Java is pretty simple. Just create a ServerSocket and instruct it to listen. It will return a Socket object whenever it receives an incoming connection.

		try{
			Socket socket = new ServerSocket(10000);
		} catch (IOException ioe) {
			throw new IOException("Could not open server socket 10000", ioe);
		}

On the client it’s even easier.

		try {
			Socket socket = new Socket("127.0.0.1", 10000);
		} catch (IOException ioe) {
			throw new IOException("Could not open connection to 127.0.0.1", ioe);
		}

This will open a socket using port 10000 on the server and client side. However, a server written like this can only handle one client. This is fine for many applications, but I wanted to create a server capable of handling several clients at the same time. Therefore I created a class in the server project that represents the clients. A new instance of these will be created for each client that connects to the server.

	private LinkedList clients = new LinkedList();

	...

	private void HandleNewClient(Socket newSocket) {
		clients.addLast(new Client(newSocket));		//Add a new client to the list
	}

Each instance of the Client class spawns a thread listening for messages from the client program, and handles them by itself.

Generating random terrain

Knut Erik — Fri, 26 Jun 2009 20:35:48 +0000

I have implemented a random terrain generator, and after some tweaking it, it produces pretty good results.

Randomly generated terrain

I can seed the generator as I wish, and get the same result every time, or use some other value like the system time to get a new terrain every time.

Another view

Another view of the terrain

Also, the artifacts from the previous post have been eliminated.:) The light is working as I want it now.

Light model working

The lighting is nice, but it doesn’t do shadows. At least not yet. That will be the next focus for me.

-Knut

Adding light part 2

Knut Erik — Sat, 20 Jun 2009 18:35:58 +0000

I’ve changed the way the program calculates the light level on the textures, so it should be more realistic. The sun’s position is configurable, and is used to shade one side of a hill, while the other one will be bright.

Better light model

The sun would on the left side of this picture, you can see a small valley in the middle with a hill behind it. Notice the difference in light levels between the right and left sides of the valley and hill. This is actually looking very nice.

From above

Same valley, seen from above. The walls are about the same steepness. However, there are a few problems and limitations. Firstly, the sun’s position can only be specified in the east-west range. This is not much of a problem, and is easily corrected if necessary. Secondly, there are no shadows yet, but I plan to add support for this. And thirdly, there are these artifacts here on the textures:

Artifacts on the terrain

See those lines there. They are everywhere. Actually, they appeared when I implemented the texture splatting as well, but then I managed to work around them, for the most part. But now, I have a plan to get rid of them. The problem is, the height map has integer values. So on many slopes the steepness map will be like a stair instead of a smooth slope. To counter this, I think I need to create a random terrain generator.

I’ve been searching around a bit, and I want too implement a fractal generator for the terrain, preferably in a way that allow me to feed it a number to generate a terrain from(seed), or use an random one. Hopefully this will get me smooth slopes as well as interesting terrain, and i hope to complete this as soon as possible.

-Knut

Adding light to the terrain

Knut Erik — Sun, 07 Jun 2009 18:25:16 +0000

I wanted to add lighting to the terrain engine, but I did not want to use OpenGL’s implementation, instead I wanted to create my own. So I added a light map to the terrain data, and set the program to modify the pixels when creating the textures. Then I added a very simple algorithm to fill it with some interesting data; I just use the height map so that hight pixels will be bright, and low pixels will be dark. The result is better than I hoped for:

With light

Even with this very simple light scheme, the terrain looks a lot better It looks even better when moving the camera around. This was a lot easier to add than I expected. Here is another angle:

Another angle

But as you can see, the deep valleys are where the simple scheme falls through. The terrain is just too dark.

Dark valley

I need to change the lighting scheme to use normals compared to a artificial sun. I will also add some minimum amount of light, to simulate ambient light. Hopefully this will not be too difficult.

-Knut