I have just been working on a couple of bugs with my networking that have been annoying me, particularly the camera and player model becoming out of sync and also the spells were being fired in the wrong direction. I have now fixed both of these issues and I can now seamlessly fly around my demo level shooting spells, which is a relief.

Next week me and a colleague are going to demo some of the functionality that has been added to our projects. We have been doing this every so often as I think this keeps motivation quite high and can spark some interesting discussions about implementations. For this demo I want to be able to have two clients connected to a game, flying around damaging each other with spells. This does seem quite achievable but It means I will need to put some extra work into the physics integration in my engine.  

Currently the physics implementation is fairly minimal, allowing for collisions to be resolved and callbacks to be triggered for the two entities involved. I want to go much further than this and allow the new bounds functionality to be used for the physics shapes. I also want to allow the change of certain properties like restitution and friction for each physics object.

Currently the physics code is not being sent across the network which is also something that will need to be resolved. each client will still need to do some sort of collision resolution to keep the game looking smooth, but the server will once again need to have the overall say so this will be a challenge. 

I'm excited to get this demo up and running :) 

Just an update, I've recently added Bounding Box Rendering to my project. I have added an extra few classes including, Bounds and the Bounding Box class. The bounds holds the AABB (axis aligned bounding box ) and also spherical bounds. The Bounding Box Class stores a Cube that corresponds to the bounds of any loaded mesh. 

Currently the Bounding Box Class doesn't give axis aligned bounding box, instead it takes the meshes original AABB and transforms that with the world matrix of the mesh instance to create a bounding box that surrounds the mesh instance. For me to support AABB for each mesh instance I would need to recreate the AABB each frame which at the moment I don't really need. This is just as a visualisation technique for what will be my level editor and also to create simple representations of a mesh for the physics. 

In the future I will want to provide AABB's as it will be useful especially for things such as quad trees, but that is quite a while off yet. 

Things are moving forward, need to do some housekeeping of my rendering code and also crack on with GUI advancements and also Network debugging.

Cheers :)

After a while battling with implementing networking code I realised how difficult it actually is. Bugs are much harder to track and this really has slowed me down quite considerably. I asked on the gamedev forums about other peoples techniques for debugging networking code and some of the answers were pretty good such as:

• Packet Logging Per Executable
• Unit Tests for all packet classes
• Outputting logs to the screen

Most of the tips were to implement a more sophisticated logging system, currently mine just outputs all the server and client information into one log which isn't helpful at all as a few clients can be writing to the file at the same time and causing issues. 

So creating independant logs for each client and the server is my first priority along with outputting more information e.g. Timestamps / Full Packet Information. 

I will also be creating a more thorough logger that allows you to set priorities for the logging, this will be ideal for when I output logging information to screen as I can just visualise high priority data like specific errors. This leads me onto the next part as currently my GUI is not complete enough to allow for an onscreen debug log.

After realising I was going to need to do some more work with the GUI to make it more complete and allow for debug logging, this got me thinking about another important tool that I should be working towards which is a Level Editor. 

I am going to use my own GUI code to create all the elements for the Level Editor but there is still one thing that is crucially missing which is the ability to do Picking. It also gave me a break from doing debugging the Networking code. 

I have now implemented a basic picking algorithm using colour based picking. It is really quite simplistic in it's nature and only took about an hour or so to throw together. All that needs to be done is create a unique colour for each Entity that you want to do picking for and output that colour in the fragment shader.

The second part of picking is to actually pick a pixel and read back it's colour, which can be decoded to give you the unique ID for the Entity. 

Now that I have got the Picking working I need to address the rest of the GUI as currently there are definitely parts of it that don't work particularly well such as the Font Rendering. The sizing of text needs to be looked at as currently there is a lot of guess work needed to get text looking correct. 

Okay so there is a lot to be done but I'm sure I can get through it, hopefully I will have something fairly impressive to show soon. I am going to focus on getting the GUI correct and start work on the Level Editor as a test to see how well the GUI does work.

Thanks :)

It has been what seems like an age since my last post, and I have been holding off because I wanted to get something a little more substantial before I posted an update. 

I have been working mostly on the Networking but also sorting out some issues that I was having with my matrices due to the library I am using ( which I ended up writing some of the functions myself ). This means that now my FPS Camera is fully working which is a massive relief.

Now that I have got that out the way let's talk about some of the Networking I have been doing. As a starter I suppose it is best to mention that I created all this networking code as a separate library that is used by my Engine. This took a little bit of refactoring and some tinkering with the Visual Studio Project options but was a great learning curve as it has made me think of the other parts of my code that could be their own projects. particularly:

• Sound ( Now Done )
• Physics
• Rendering
• Input
• JBEngine

The first three libraries will be a great start and will be the easiest to create, these will then be part of the JBEngine project which will be the product as a whole. 

Doing this means that If i want to create a development tool such as a level editor I can just link the Rendering, Physics and Input libraries and build the application code on top of that and there won't be any extra bulk that I don't need. 

I have been adding a lot of code for various "packet" classes and sorting out exactly how a client and server communicates with one another.

The basics of it is that I create a specific packet object such as a Camera Movement Packet and this class alone deals with both stuffing its data into and out of the packet class of the Network Library.

This has made it fairly flexible and easy to implement passing new data between the client and server. 

Anyway without any further ado, here is where the project is currently at: 

There are still some major issues that I need to sort out, specifically the camera getting out of sync with the player model. This is due to some latency issues and I should have it sorted fairly soon. 

Overall I think It is still going very well, although I think I need to up productivity massively.

Cheers :)