Richard Pickering- Games Programmer

Update On Work

2010-09-30T04:30:00.002+01:00

Hello,

I thought I'll write to my blog detailing what I've been up to over summer. As some of you may know I am making a business, which I am naming Pickering Game Development for my placement year at university. I have designed several games, however I am unable to comment on these, as they are still in initial development phases, so I shall write in more detail about them when they are further on in their development. Instead, I shall detail some of the work which I have done for my business from a musical point of view throughout this blog entry. I have composed and recorded/mixed several songs which I plan on using within different game projects for my business. A list of links should be displayed below leading to the youtube videos of said songs:

http://www.youtube.com/watch?v=nwZA6FHxwwQ
http://www.youtube.com/watch?v=iz3H1gCteyg
http://www.youtube.com/watch?v=xbOnzSSJgF4
http://www.youtube.com/watch?v=6fZ7iZ-Nzew
http://www.youtube.com/watch?v=DQ1PDLYB9SA

Please feel free to leave comments on the videos, as I appreciate any feedback which is provided. The music has been created with the assistance of Apple's Garageband music creation software. Thanks for reading, I hope you enjoy the music :D.

Richard

What I've Been Up To, + Plans For The Future

2010-07-22T16:11:00.002+01:00

Hello everybody,

I know it's been a long time since my last post, so I just thought I'd give everyone an update as to what I'm currently doing at the moment, and what I plan on doing over the next year. As some of you may know, it is my placement year at the moment on my degree. This means that I should have gone and found a placement with a business of some description, doing an IT role of some description. I, however, was unable to do this due to the lack of interest from companies, due to the economic climate at the moment. Instead I have decided to work for myself, and create games and applications, which people can download digitally. I am doing this using a number of services. I am writing games in XNA Game Studio 3.1 at the moment, which I am presenting to the public using the Creators' Club and Xbox Live Arcade. I am also developing iPhone applications and games, to present to the community using the App Store.

I am currently developing a game which has an in-house title of Project Nerd. This game will be an indie RPG game, and will be a long time coming, as this game will be the fruits of roughly eight months of work. I am also developing a title called "Fighterspace Racers" which should be released in approximately two months. This will be released via XBLA, and if successful on that platform, will also be released on iPhone.

In terms of iPhone development, I am currently searching for contracts to develop iPhone applications for businesses. I have not currently made any commercially available iPhone applications, however I should have one or two on the market (on the app store) in approximately one to two months. I am also learning several other software languages in between doing all this, making me a bit of a busy bee at the moment.

Project Nerd will have a trailer, marketing related materials and demo version available to the community before the year is up, so keep an eye out! :D. Fighterspace Racers should be available from 30th September, 2010, so if you play games on the XBox and have an XBox Live account, please feel free to download it, and play :D. If anyone wants to contact me on any of the information I have presented in this article, email me at richard.pickering@hotmail.co.uk. Thanks for reading,

Richard

Teaser of things to follow!

2010-05-21T16:07:00.001+01:00

This week the second year of University has finished, leaving my time free to create all kinds of weird and wonderful applications. Here is a small teaser of what is to come on this blog:

B2D- Borealis 2-Dimensions is a 2-Dimensional game engine that I will develop over summer for both iPhone and PC. This does mean that the engine will be written firstly in C++ and then in Objective-C, however I believe that this is an achievable game engine, and will be used in games which I release of the next fifteen months. I will also make aspects of this engine available for the community upon its release.

Borealis- 3D Game engine that I have already begun development on. This engine will be used to provide decent 3D Graphics to any 3D PC games which I may decide to write. The logo is provided above.

Iphone Games- I shall be making iPhone games for the next fifteen months, and detailed descriptions of these games shall be featured on this blog. Some code may even be posted :D.

PC Games- I shall be working on making different game engines and using these I shall develop different PC games. I shall release these games using a file server and setting up my own website. Watch out for the post on here when I set it up, as the address will be included within the post. Detailed descriptions of these games will be posted, as well as development notation, and possibly code :D.

Thanks for reading, :D.

P.S. The white areas in the attached picture are actually supposed to be transparent, as they will appear when used within the engine.

Borealis- Game Engine

2010-04-19T03:22:00.000+01:00

Hi all,

It has been a long time since my last post, and I just thought I would fill you in on what I have been up to. I have been working on a lot of projects lately, but the one which has taken the majority of my time up has consistently been one for Interactive3D Graphics. I am making a game engine, which I have affectionately named "Borealis". That is also the reason for this post today, as I have made quite a lot of progress with this engine lately.

The game engine itself uses DirectX 9.0c for rendering and makes use of the Win32 API for the application side of this engine. Due to this it is compatible only with Windows OS installed computers with the DirectX 9.0c drivers or later.

There are a great many features of this engine which I have added in, and the first one that you may notice is that I have the ability to load meshes from file, which in itself is quite a simple task. The truth is that I am loading the mesh into a data structure of my own, the BMesh, which contains a DirectX mesh, but also has several other data members. The first is a shader, which is a small program that can be run on the graphics card. It also has a large number of textures and materials, which are stored in dynamic arrays. It has a position too.

The interesting part about the shader I previously mentioned is that I have made my own data container for that too, BEffect. In fact, quite a lot of the areas that my game engine uses DirectX functions from are covered in my own, so that I can make the engine multi-platform and more universal.

With the shaders, I have been able to make particle effects, phong shading for meshes, terrain lighting, and more. Some of the results I have been able to achieve are shown in the images displayed above. The first image (the red skull) is actually an error which I received from a badly programmed shader. The reason for it being so badly shaded is that I had incorrectly set the materials and normal vectors, so the entire lighting and shading of the object was incorrect for the Phong model. The reason I have included it here is because I thought it had a certain visual aesthetic to it, which made it interesting.

The particle effects that can be seen within the above images are entirely processed on the GPU (Graphical Processing Unit) instead of the CPU (Central Processing Unit), leavint the CPU to perform other tasks. This is the reason that the frame counter sticks at a constant 60 FPS throughout the imagery, even though thousands of particles are being processed.

There are many areas of this engine which I am not displaying in this post, as they are not yet entirely complete, however I hope this gives an insight into the development of a game engine. I will update with another post containing more feature demos soon. Expect to see bump mapping, environment mapping and much more next time. Thanks for reading,

Richard

XNA Terrain Generator

2010-02-17T01:21:00.000Z

Hello all,

I know I've not posted in quite a while, so I thought I'd make up for it by posting information about a terrain generator which I'm making for an assignment at University. This is just an XNA rapidly created prototype, so all of the kinks aren't quite worked out yet. It's fairly high-res with approximately 1 million verts being displayed in the most advanced outputs which it creates.

The way that it does this in the most advanced version is that it fires "rays" around and then modifies the terrain height map using the distance from interpolated points along these rays which is then attenuated by a random value. After this the verts are "smoothed" out using an averaging algorithm. I know that it's fairly basic, but this is a basic prototype, I am planning to create a new prototype fairly soon using the quite fast, high detail Diamond-Square algorithm. Thanks for reading,

Richard

Life Sim Game by Me

2010-01-07T21:40:00.000Z

Hi,

Just thought I'd talk this week about a life simulator game that I've made. It simulates the conditions in which cells must survive. It is basically a toy, as it has no end goals or conditions, you just get to play with it, however it is quite interesting, as the cells can be created at will by pressing the "C" key and then you watch them flourish. Their size is directly related to how many times that they have mated, however, if they are too sparsely spread they will die of loneliness. They also cannot survive a single tool which I added, called "Fire". At the moment the purpose of this application was an experiment into some AI type areas to be honest, however, it is quite impressive to watch it in action, due to the sheer speed of the mating of these cells.

Fire can be spread to different cells, which makes this tool a chain reaction weapon, which can be used to test the hardiness of the cells which you have created. It is surprising how fast that the cells actually recover their lost numbers after a wave of fire through their numbers. Anyways, the images posted will show the rest. This application only took me a few hours to be honest, but it is quite interesting in terms of the "Psychology" of the AI of the Cells. Thanks for reading, I should have another post up quite soon about any other applications which I have been developing over Christmas and New Year.

Renderer- Intro to 3d- Scanline rasterization

2009-12-03T00:13:00.000Z

I finally have scan-line rasterization working, which is, by far, the most complex mathematical thing I have EVER had to do. It involves interpolating between the vertices which make up the triangle, in order to get a number of points on its surface. These points are then used as pixels and the areas in between the extents of the pixels are filled with colour. This is a kind of per-poly rasterization at the moment, but it is easy to make it a per-pixel rasterization technique, by simply interpolating colour across the surface of an object.

At the moment I simple have scan-line flat shading, which I also have in Gdiplus. However, scan line drawing does work significantly slower than using gdiplus. However scan line, due to it's per-pixel nature does have a significant advantage over gdiplus, which is by nature shape and vector based. I am looking forward to getting gouraud and some kind of phong shading working within this renderer too, since I already have scan line rasterization finished (which I only began implementing yesterday, not bad to say it's my birthday as of half an hour ago lol).

The screenshots are shown above this text. Thanks for reading,

Richard

Game Dev Tech Radio Model

2009-11-26T17:41:00.000Z

Hi,

I'm writing today about a model which I've made for Game Development Techniques at University using my favourite (as by now most of you know) modelling software Blender. It is supposed to be an old fashioned radio, for my Famous Five game. It is fully UV Mapped and textured, using solid colours only at current, as I didn't have time to go through properly texturing it. It is shown rendered with a space background which is within the settings for Blender, which I think is a really cool feature, which saves a lot of time, instead of having to find an image of a starry sky and set that as a background image.

A cool thing about this radio too is its scale compared to the reference image, as it is pretty much on a 1:1 scale, and is pretty accurate as a representation. The only downside as I say is the lack of complexity within the UV texture. However, I don't think its a bad attempt, considering that I am a programmer, not an artist.

Blender, due to its ability to export to .lwo file extensions is directly exportable into UnrealEd and from there into a static mesh package for Unreal Engine 2, making it really easy to make mods and things with Blender, as you can program the Unreal Script within notepad++ (a really cool tool that I highly recommend). Another cool thing about this radio is that it was created by sub-surfing an extruded cube. Subsurfing actually simply subdivides the original polygons and allows you to add 'crease' to the model before applying the subsurfacing modifier. You can make faces and things within it, as is shown in some Blender tutorials, however, I am just a beginner with the entire 3D modelling thing, so I'm not going to be that ambitious.

Creasing the model allows you to create different angles with the 'smoother' image, and in order to save on verts, you can even join or 'merge' verts which are only on flat surfaces together. This results in no drop of model quality, however it does save on processing time by quite a lot. :D. Other optimisations which can be made are adding spheres or other objects which are already subdivided into the object later on (after subsurfing).

I hope you've enjoyed reading this as much as I have had writing, thanks.

Introduction to 3D Graphics Programming- Renderer Lighting

2009-11-25T01:38:00.000Z

Hi and welcome to my latest post on my blog! :D. I am writing to let you know that I finally have flat shading working correctly within my 3D Renderer for Introduction to 3D Graphics Programming. I have modelled Ambient and Diffuse Lighting (for Directional Lighting). On top of this I have also transformed the object from model space into world space, which effectively can be used for any models I wish to load into my project. Within this world space transform I have made the model of my choice rotate around the 'Y' axis, so it has the effect of constantly turning and spinning at a fairly slow rate.

The above images demonstrate what I have been talking about.

Over this week I have also been working on a multi-source file application which is incredibly simple, however is also compiled within the Unix BASH terminal, which is very handy as it comes with Linux, as Linux is based on Unix and I have Linux installed on one of my computers :D. I will post some code for the directional lighting soon, and there will also be notes on some of the errors which can be encountered whilst modelling this form of lighting (ones I ran into lol). Thanks for reading.

Intro to 3D-- Finally Rendering!

2009-11-16T23:34:00.000Z

Yay, I have finally got my 3D software renderer to work for my University Module, Intro to 3D. It is very simple at the moment as a renderer, and only has 3 options; draw wireframe, draw solid colour polygons, and very basic (and wrong) flat shading lol. It is simply a starting point upon which further more advanced versions shall be created.

So how does this renderer work. Well to put it simply, under the hood it has a rendering pipline, which transforms 4-dimensional co-ordinates to 3-dimensional co-ordinates, to 2-dimensional co-ordinates, and then those co-ordinates are translated and scaled to become the screen transform. When a set of vertices are transformed by these stages within my pipeline and my renderer, they are rendered to screen. The actual 'drawing' code actually takes up a surprisingly small amount of space. My "rasterizer" file is no more than 150 lines of code, and this draws the outputs of the different mathematical processes to a bitmap image, which is then drawn to screen.

The actual steps which are followed by the program are:

Build Camera Transform: the viewing transform is built which takes the position of the camera into account during the transformation process. In later versions it may also deal with the rotation of the camera, however for now, it will only deal with its position.
Build Projection Transform: the projection transform is the transformation actually deforming the vertices you would see on screen, for instance, it is used in this code to produce a 'perspective' camera transform where vertices will appear closer to the horizon the further away they become.
Dehomogenise: dehomogenising the vertices literally means dividing all the elements by the fourth component of the vector which is also known as 'W'. It is a very simple stage, and is used to transform 4-D co-ordinates to 3-D co-ordinates.
Build Screen Transform: the screen transform scales the vertices in order to put them onto screen and make them fit better inside the viewing window. It also changes the origin to the top left corner of the screen, instead of the middle of the screen, as most applications use the top left corner of the screen as the origin point.
Draw Wireframe/Poly: this is the bit of the code which actually draws the data we have after all that mathematical mumbo-jumbo into a bitmap image. It is fairly simple, and at this point, only uses Gdiplus to "rasterize" the image.
Draw to Screen: this is a tiny bit of code, which is actually really simple. It simply takes the image being drawn in the rasterizer and copies it to screen in the window, using the windows generated window identification number (HWND).

After all this is performed, post-processing can also happen, but none is happening at the moment within my renderer. In the above images, there is a helicopter renderer using wireframe rendering, solid colour polygon rendering and flat rendering. Thanks for reading, I hope you enjoy the images, and the thought provoking description of my renderer.

Solar Blender Render

2009-11-14T13:20:00.000Z

Wow, I'm even more busy than I was before, so I thought I'd take a little time out to write a post on here :). See I do still think about all you guys. I have finished working on a render of Earth and the Sun in Blender (not to actual sizes of course lol). It's got UV texture mapping, different shaders applied and all sorts of cool stuff. The render is shown in the attached image to this post.

Right then, just a quick overview of how I made this ultra-cool scene in Blender. Firstly I simply added an Icosphere, as the flow lines work better with texture mapping. This was subdivided 5 times in its default properties, which means that each poly on the surface of the object was halved 5 times, effectively doubling the number of polys and giving a much more seamless effect. I then mapped a large texture onto its surface using UV texture mapping. This large image was actually taken from the NASA website, and is a picture from a satelite of North and South America. I used this same image on both sides of the sphere, which means that there is 2 America's on the render and no other continents or countries. For this reason the render is using the camera co-ordinates above one side of the sphere, so that you don't see America on both sides on the render.

I then added the sun, which actually uses no textures as it is procedurally generated by Blender itself. It simply uses the surface normals to establish where to put colour, which is randomly selected according to a few parameters, such as Halo size, Ring size, etc. This emits a LOT of light, as a material, but this light didn't actually reach the Earth model, due to the distance it was away from it, so I also made a lamp and placed it in the correct position to give realistic results between the 'Earth' and 'Sun'.

The only other effects that can be seen on the render include the starfield that populates the 'sky'. This is simply another cool Blender feature. It is created/used by modifying the material that the camera draws as its plane of projection. It is literally a couple of checkboxes, and star density and stuff can be set. It's a very useful feature. Blender overall is also an incredibly useful software piece.

The shaders used in this scene are mainly used on Earth, which is CookTorr specular and Lambert diffuse shading. These produced the most realistic results, so I decided to use them.

Note: on the 'Earth' model I also selected the option "set smooth". This was to stop the shaders from doing any kind of flat shading and stuff, which looks quite ineffective for what I was trying to achieve.

Special thanks to the good people of Linux, and to the different GNU software pieces. I used the GIMP editor to create/modify the textures to the correct format, Blender for the actual modelling process, and Linux Mint as the operating system which I ran these different programs within.

What's coming up in the next week or so

2009-11-03T23:41:00.000Z

Dear all readers,

I just thought I'd post this to let you know what's coming up in the next week or so. I shall be posting the following list:

All unreal script code so far
Any unfinished, or unposted MIPS tutorials I have done (about 3 chapters probs)
All code for 3D Renderer in C++ (Don't bother copying it, it won't work without the required resource files lol)
News of PPD Tutorials
Plans for IGF entrance (game competition)
Creators Club plans
Some AI programming in C# and UnrealScript
Anything else that comes to mind.

I hope you look forward to reading about all these cool things as much as I have enjoyed programming them. Hope you're looking forward to my next post, news of PPD stuff lol. Should be...interesting :P. Thanks for reading,

Richard

MIPS Assembly- Chapter 14/15 Kjell's Tutorials

2009-11-01T21:41:00.000Z

I know that there's not been too much activity on here recently, I've just not had a chance to put things up on here too much recently lol. So this time I've prepared the answers to some of Kjell's online MIPS assembly tutorials and things. To find these tutorials, they're on the website, which can be found by typing "Kjell's MIPS Tutorials" into google.

Ok, so the first tutorial that I'm going to show is the first question from Chapter 14. The task was as follows, which is the exact task as worded by Kjell on the website.

*Exercise 1

Write a program to evaluate a polynomial, similar to newMult.asm from the chapter. Evaluate the polynomial:

3x² + 5x - 12

Pick a register to contain x and initialize it to an integer value (positive or negative) at the beginning of the program. Assume that x is small enough so that all results remain in the lo result register. Evaluate the polynomial and leave its value in a register.

Verify that the program works by using several initial values for x. Use x = 0 and x = 1 to start since this will make debugging easy.

Optional: write the program following the hardware rule that two or more instructions must follow a mflo instruction before another mult instruction. Try to put useful instructions in the two slots that follow the mflo. Otherwise put no-op instructions, sll $0,$0,0, in the two slots.

So in order to achieve the desired result for the above question, I wrote the following code:

#Equation to work out: 3x (to the power of 2) + 5x - 12

#Variable initialisation
ori $8, $0, 1 #Register to contain x
ori $9, $0, 0 #Register to contain result
ori $10, $0, 3 #temporary register

#First part of the equation
multu $8, $10 #multiply reg 8 by reg 10
mflo $9 #get result from lo register and put it into reg 9. Result of 3 * x
nop # Cannot perform any multiplier operations
nop # within 2 instructions of mflo (hardware restriction)

#Squaring the first part of the equation
multu $9, $9 #square the result from the previous operation
mflo $9 #store the result in the result register

#Second part of the equation
ori $10, $0, 5 #set reg 10 to 5
nop #hardware restriction as earlier
multu $8, $10 #multiply reg 8 (x) by reg 10 (5 atm)
mflo $10 #store result in reg 10 temporarily

#Assembling equation
addu $9, $9, $10 #add 3x(squared) to 5x and store the result of that operation in reg 9
ori $10, $0, 12 #temporary value for 12, which is used in the latter part of the equation

#Last part of assembling the equation
subu $9, $9, $10 #subtract 12 from the previously computed value

As can be seen, the code is very well commented, and is quite easy to read due to this :D. It's quite simple, and achieves the required results quite well. If you want to see this, simply plug this code into the MARS software or SPIM and take a look at the assembly of this code. Swiftly moving on, got loads to get through after all, we are going to take a look at question 2, which is a little more difficult than the first question, obviously lol. The actual question is shown below:

*Exercise 2

Write a program similar to divEg.asm from the chapter to evaluate a rational function:

(3x+7)/(2x+8)

Verify that the program works by using several initial values for x. Use x = 0 and x = 1 to start since this will make debugging easy. Try some other values, then check what happens when x = -4.

In order to complete this question, I wrote the following code shown below:

#Designed to run the following equation: (3x+7)/(2x+8)

ori $8, $0, 2 #x register
ori $9, $0, 0 #result register
ori $10, $0, 3 #temporary store, at the moment contains the first multiplier of x

#first bracket

#first multiplication
multu $8, $10 #multiplies x by 3 (contained in reg 10)
mflo $9 #store what's in the lo register in reg 9

ori $10, $0, 7 #set reg 10 to a value of 7
addu $9, $9, $10 #add 7 (stored in reg 10) to the result of the previous op

#second bracket

ori $11, $0, 0 #bracket 2 result
ori $10, $0, 2 #second multipler, 2 in reg 10

#second multiplication
multu $8, $10 #multiply x by 2
mflo $11 #store whatever's in reg lo in reg 11
ori $10, $0, 8 #addition in second bracket number required
addu $11, $11, $10 #store the result of adding registers 11 and 10 in register 11

#overall divide
divu $9, $11 #Divides the two separate results.
mflo $9 #stores the result in register 9

Again, this code is quite well commented, and is quite simple to read. To fully evaluate this code, simply stick this code into your assembler simulator thingy and check out the assembly of the above code. In order to assign different values to x, simply change the first line (the initialisation of register 8) to whatever value you want x to be. Moving on again, I didn't complete Question 3, but question 4's completed answer can be seen below:

*Exercise 4

Write a program that determines the value of the following expression:

(x*y)/z

Use x = 1600000 (=0x186A00), y = 80000 (=0x13880), and z = 400000 (=61A80). Initialize three registers to these values. Since the immediate operand of the ori instruction is only 16 bits wide, use shift instructions to move bits into the correct locations of the registers.

Choose wisely the order of multiply and divide operations so that the significant bits always remain in the lo result register.

So, the solution to the above problem is demonstrated below:

#Designed to demonstrate ways around bit width for immediates and stuff
#Does the following equation: (x*y)/z

ori $8, $0, 1562 #x- 1600000- all shifted right, needs to be shifted left to be 32 bit, its shift is 10
ori $9, $0, 78 #y- 80000- shifted right 10, needs to be shifted left to be 32 bit wide
ori $10, $0, 390 #z- 400000- shifted right 10, needs to be shifted left to be 32 bit wide

ori $11, $0, 0 #temp register

multu $8, $9 #x * y
mflo $11 #temporarily store the result of x and y

nop
nop

divu $11, $10 #divides z by the result of x * y
mflo $11 #stores the result in register 11

sll $11, $11, 10 #shifts the binary left

#end of program
#result is almost as good as doing left shift earlier in code, but its good enough. It's got a margin of error of
#about 1000 or so.

The above code simply shifts a binary number right to a certain number of places, performs a function on the values, then shifts the number left again, in order to fit 32 bit calculations into 16 bit areas and stuff. It works :D. Again, stick this into your MIPS assembly simulator to check out the result, it's pretty cool. Now that is the end of Chapter 14, lets move quickly onwards to Chapter 15. This chapter is mostly about storing and loading data to and from memory and then to perform an operation, then stick the resulting data back into memory. The first question can be seen below:

Exercise 1

Modify exercise 1 of the previous chapter so that the value x is in memory. Store the value of the polynomial back to memory. The program will be similary to poly.asm from this chapter. Evaluate the polynomial:

3x² + 5x - 12

Use symbolic addresses x and poly. Assume that the value in x is small enough so that all results fit into 32 bits. Since load delays are turned on in SPIM be careful what instructions are placed in the load delay slot.

Verify that the program works by using several initial values for x. Use x = 0 and x = 1 to start since this will make debugging easy. Then try some other values, such as x = 10 and x = -1.

In order to solve the above problem, I wrote the following code:

# Evaluates the following equation
# And also uses memory locations :D.
# 3x(squared) + 5x - 12

.text
.globl main

main:

lui $14, 0x1001 #Finds base value and stores it inside
lw $9, 0($14) #Loads x into register 9

ori $10, $0, 3 #Multiplier value in reg 10

multu $9, $9 #Multiplies registers 9 by itself (x(squared))
mflo $11 #Stores the result in register 11

nop
nop

multu $11, $10 #Multiplies registers 11 and 10 together (3x)
mflo $12 #Stores the result in register 12

nop
ori $10, $0, 5 #Multiplier

multu $9, $10 #Multiplies registers 9 and 10 together (5x)
mflo $13 #Stores result in register 13

addu $11, $13, $12 #Adds 3x(squared) to 5x and stores in reg 11
ori $10, $0, 12 #Stores 12 in reg 10
subu $11, $11, $10 #Subtracts 12 from the result so far

sw $11, 4($14) #Stores result in poly

.data
x: .word 10
poly: .word 0

Note: the symbollic addresses at the bottom aren't really the assembly code stuff, they're just messages to the compiler to reserve a little bit of memory and initialise some data at the default spot within MARS. I have tested the above code quite thoroughly and am confident that it works to a sufficient level. It's pretty awesome :). And again, stick it into your assembly simulator to see how it performs and things :). Don't worry, you have my permission to view this code in action :P. Anyways, swiftly moving onwards yet again. Below is question

Exercise 2

Evaluate the expression:

17xy - 12x - 6y + 12

Use symbolic addresses x, y, and answer. Assume that the values are small enough so that all results fit into 32 bits. Since load delays are turned on in SPIM be careful what instructions are placed in the load delay slot.

Verify that the program works by using several initial values for x and y. Use x=0, y=1 and x=1, y=0 to start since this will make debugging easy. Then try some other values. As an option, follow the precaution for multiplication, as above.

To solve the above problem, I wrote the following code:

#Evaluates the following expression, and also uses memory :D.
#17xy - 12x - 6y + 12

.text
.globl main

main:

lui $15, 0x1001 #Loads base into reg 15
lw $9, 0($15) #Loads x into reg 9
nop

lw $10, 4($15) #Loads y into reg 10

ori $14, $0, 17 #Multiplier register init

multu $9, $10
mflo $13 #Result of xy

nop
nop

multu $13, $14 #Multiplies result of xy by 17
mflo $13 #Stores result of 17xy

nop
ori $14, $0, 12 #Changes multiplier to 12

multu $9, $14 #12x
mflo $12 #Stores result in reg 12

subu $13, $13, $12 #17xy - 12x

ori $14, $0, 6 #Multiplier changed to 6

multu $10, $14 #6y
mflo $12 #6y stored in reg 12

subu $13, $13, $12 #17xy - 12x - 6y
ori $14, $0, 12 #Multiplier changed to 12

addu $13, $13, $14 #17xy - 12x - 6y + 12

sw $13, 8($15) #Stores result in answer

.data
x: .word 10
y: .word 10
answer: .word 0

It's not the most efficient code in the world, however for this instance it will do :). The results that it produces are very accurate too, try it out :D. Oh yes, and it's also commented quite thoroughly too, to make sure that it's quite easy to understand what each line does exactly. I'm afraid to say that I didn't attempt questions 3 or 4, because I found out by this stage that I had already been using Horner's method in some of my code and understand it quite well already :D. To make up for this though, I will show my answers to chapter 17 questions 1 and 2. These are displayed below:

*Exercise 1 -- Non-ending Loop

Write a program that computes the sum:

1 + 2 + 3 + 4 + 5 + ...

Do this by using the j instruction to implement a non-ending loop. Before the loop, initialize a register to zero to contain the sum, and initialize another register to one to be the counter. Inside the loop add the counter to the sum, increment the counter, and jump to the top of the loop.

Execute the program by single-stepping (by pushing F10). After you have done this enough to confirm that the program works, look at SPIM's menu and select Simulator and Multiple Step. Enter a number of steps (such as 40) into the window and click "OK". Each step is the execution of one machine cycle. Once you see how this works you can do the same thing more easily by pushing F11.

The solution to this is shown below:

# Designed to be a non-ending loop
# Calculates the sum of 1 + 2 + 3 + 4 + 5.....

.text
.globl init

init:
ori $8, $0, 0 #Initialises variable (reg 8) to 0
ori $9, $0, 0 #Loop counter
j main #Jumps to the loop :D
nop #Branch delay slot

main:
addi $9, $9, 1 #Increment reg 9(loop counter) by 1 per loop cycle
addu $8, $8, $9 #Add count number to reg 8
j main #Jump to beginning of label "main"
nop #Branch delay slot

As can be seen, this code is simple, and quite efficient. It, like all my code, is heavily commented, so it's quite easy to see exactly what each line does. Take note of the "j" instruction. This is the instruction that modifies the program counter to jump to a certain instruction label, in this case, the jumps all lead to the label "main". Also take note of the fact that a "nop" instruction has been used in the instruction slot directly after each of the jump instructions. This is because the instruction directly after the jump command is always executed, even though the program counter has been changed. This is simply because it takes on machine cycle to change the program counter, so until it's been properly changed it just keeps executing the different instructions. Moving on to question 2:

*Exercise 2 -- Non-ending Loop with Overflow

Write a program that adds $8 to itself inside a non-ending loop. Initialize $8 before the loop is entered. Use the add instruction so that when overflow is detected the program ends with a trap.

Now change the add instruction to addu. Now when overflow occurs, nothing happens. Run the program and observe the difference.

Ok, so the solution to this is below:

# Overflow program :D. Adds reg 8 to itself to cause overflow within the loop.

.text
.globl init

init:
ori $8, $0, 1 #Initialises variable (reg 8)
j main #Jumps to main
nop #Branch delay slot

main:
addu $8, $8, $8 #Add reg 8 to itself.
j main #Jump to the beginning of the loop
nop #Branch delay slot

Ok then, so in order to change between the different version of this program, to look at the overflow trap, the "u" on addu must simply be deleted. The current, no overflow trapped version executes the code, and then, when the value overflows, the register is set to a value of 0. With overflow trap, the program exits and it simply stops itself. That is the only difference, therefore add will not be a regularly used command, as most programmers want their programs to keep going. Anyways, that is all for tonight, thanks for reading, and I hope you'll stop by this site again to read more interesting mips stuff, and also unrealscript and C++ program code. Thanks :D.

What's coming soon!

2009-10-23T11:32:00.000+01:00

I've got loads of new content on this blog coming up, should have some more on over the weekend :D. Mainly I'll have a renderer coming up at some point, but first I'll have a virtual camera class added over the weekend, and then hopefully I should have some more MIPS up too. I'm yet to start my Famous Five map yet, just working out the details in my head, but screenies of v1.0 will be up over the next week :D. Thanks for reading, and I hope you'll stay tuned in to this blog, lol.

MIPS Assembly Exercises

2009-10-21T19:15:00.000+01:00

Hi,

I've been doing some MIPS assembly programming recently, for a module at University called Console Development, and I've been doing some tutorials and exercises online. This entry will cover some of those exercises, and some of the different instructions that I've been looking at.

So, what is MIPS?

MIPS is an assembly level language used in many micro-processors in small devices and some console platforms. MIPS chips are often found in phones, MP3 players, in the Sony PlayStation Portable, and Sony PlayStation 2. It is the base of many games for the PlayStation 2 and stuff, as some parts of the game engines for certain games are written in Assembly code, in order to optimise and increase efficiency, although all code, at some point, is compiled into machine code. Assembly's just closer to machine code than a high level code, like C++ or C#.

A major difference with an assembly level language is that only one operation can be performed per instruction, which means that the number of lines of binary are directly proportional to the number of lines of assembly code. Also assembly level languages use assesmblers to convert it into machine code, whereas high level languages use compilers, which do more, so the code you write in assembly looks more like the output than what the high level equivalent does.

So here's some code:

#Designed to demonstrate ways around bit width for immediates and stuff
#Does the following equation: (x*y)/z

ori $8, $0, 1562 #x- 1600000- all shifted right, needs to be shifted left to be 32 bit, its shift is 10
ori $9, $0, 78 #y- 80000- shifted right 10, needs to be shifted left to be 32 bit wide
ori $10, $0, 390 #z- 400000- shifted right 10, needs to be shifted left to be 32 bit wide

ori $11, $0, 0 #temp register

multu $8, $9 #x * y
mflo $11 #temporarily store the result of x and y

nop
nop

divu $11, $10 #divides z by the result of x * y
mflo $11 #stores the result in register 11

sll $11, $11, 10 #shifts the binary left

#end of program
#result is almost as good as doing left shift earlier in code, but its good enough. It's got a margin of error of
#about 1000 or so.

As can be seen from the above code, variables aren't really used, registers are used to store values instead, which is useful, lol. The code shown above makes use of registers to temporarily hold values, and also store them for use later in the code. None of this operation uses any of the RAM however, as no load word or store word commands are used. Ok, so lets go through the code and see what each part of it does. The ori command is first. It basically means or immediate (not evil anti-ancient stargate SG1 beings lol). It is used to store a value within a register. The register that the value will be stored in is shown first, then the zero register is called, and finally the value is shown within the syntax.

The next new command that you'll come across is the multu command, which means multiply unsigned. This operation multiplies values stored in registers, which are unsigned binary values. You may be confused however by the way that this operation works as the destination register is not called within the multu command. Instead the value is stored within 2 registers, called hi and lo. Lo stores the quotient, which is the lower portion of the number, or the significant part. Hi stores the remainder, which is used when the value to be stored is too big to fit into just the lo register. In order to get the value from the lo or lo register, the command mflo or mfhi is used, and the only argument this requires is the destination register. Also when mflo or mfhi is used, no multiplication/divide instructions can be used within 2 instruction spaces after it, as it takes a moment to update whilst still keeping the program running and performing active calculations. That is why I have used nop in certain places within this code. It literally performs no operations, which is what it also means. Useful for creating a blank instruction space.

Finally the last major part of this code is sll, which shifts the bits to the left, in terms of their position in the binary sequence. This increases their value. The arguments passed into this are the destination register first, the register to be operated on or the first operand, and then the register containing a number which states how many positions to shift the binary numbers by.

There is also right shift, which decreases the value of the binary number sequence, and this works in the same way.

That is all for this post anyway. I have included a few screenshots of the code in action and the results, within the MARS simulator, so I hope you have fun looking at these, and I'll be back very soon with another post, maybe containing some more MIPS assembly.

Thanks for reading :D.

Matrix/Vector Code

2009-10-21T00:56:00.000+01:00

Hi,

This time I've decided to put up some code that I've written in C++, which is a Matrix class, and also there are some improvements on the Vector class which was shown in one of my previous posts. This has been done mainly for Introduction to 3D Graphics Programming (a university module). This code also times the test code for the matrix class and the vector class is only used for an incredibly small portion of this code. That is creating a transformation matrix. So here's some code to look over, have fun :D.

MatrixApp:

// MatrixApp.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Matrix.h"
#include "Vector.h"
#include "conio.h"
#include "windows.h"

using namespace std;

void test_addition(int iterations);
void test_subtraction(int iterations);
void test_multiply(int iterations);
void test_matrixMultiply(int iterations);
void test_transform(int iterations);

int _tmain(int argc, _TCHAR* argv[])
{
int iterations = 1000000;

test_addition(iterations);
test_subtraction(iterations);
test_multiply(iterations);
test_matrixMultiply(iterations);
test_transform(iterations);

// Wait for keypress.
getch();
return 0;
}

void test_addition(int iterations)
{
DWORD start;
DWORD finish;
DWORD time;

Matrix matrix1(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);
Matrix matrix2(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);

Matrix result;

start = GetTickCount();

for (int i = 0; i < finish =" GetTickCount();" time =" finish" x =" 0;" y =" 0;" start =" GetTickCount();" i =" 0;" finish =" GetTickCount();" time =" finish" x =" 0;" y =" 0;" scalar =" 2.0;" start =" GetTickCount();" i =" 0;" finish =" GetTickCount();" time =" finish" x =" 0;" y =" 0;" start =" GetTickCount();" i =" 0;" finish =" GetTickCount();" time =" finish" x =" 0;" y =" 0;" start =" GetTickCount();" i =" 0;" finish =" GetTickCount();" time =" finish">
#include

// Initialises all variables
Matrix::Matrix()
{
for(int x = 0; x < y =" 0;" x =" 0;" y =" 0;">_m[x][y] = toCopy._m[x][y];
}
}
}

Matrix::Matrix(float a, float b, float c, float d, float e, float f, float g, float h , float i, float j, float k, float l, float m, float n, float o, float p)
{
_m[0][0] = a;
_m[1][0] = b;
_m[2][0] = c;
_m[3][0] = d;
_m[0][1] = e;
_m[1][1] = f;
_m[2][1] = g;
_m[3][1] = h;
_m[0][2] = i;
_m[1][2] = j;
_m[2][2] = k;
_m[3][2] = l;
_m[0][3] = m;
_m[1][3] = n;
_m[2][3] = o;
_m[3][3] = p;
}

// Almost forgot to put this in, gave weird errors, even though its unused.
Matrix::~Matrix(void)
{
}

// Goes through each different addition operation required and perform, using for loops.
void Matrix::Add(const Matrix& a, const Matrix& b, Matrix& c)
{
for (int x = 0; x < y =" 0;" x =" 0;" y =" 0;" x =" 0;" y =" 0;" x =" 0;" y =" 0;">

// default constructor
Vector::Vector(void)
{
_x = 0;
_y = 0;
_z = 0;
_w = 0;
}

// parameterised constructor
Vector::Vector(float x, float y , float z, float w)
{
_x = x;
_y = y;
_z = z;
_w = w;
}

// copy constructor
Vector::Vector(const Vector& rhs)
{
_x = rhs._x;
_y = rhs._y;
_z = rhs._z;
_w = rhs._w;
}

// destructor
// Unused currently
Vector::~Vector(void)
{
// do nothing
}

// assignment operator
Vector& Vector::operator=(Vector& rhs)
{
_x = rhs._x;
_y = rhs._y;
_z = rhs._z;
_w = rhs._w;
return *this;
}

// ARITHMETIC OPERATIONS //------------------------------

Vector Vector::Add(Vector rhs)
{
// TODO: this is not correct implementation yet
Vector result;
result._x = _x + rhs._x;
result._y = _y + rhs._y;
result._z = _z + rhs._z;
result._w = _w + rhs._w;
return result;
}

// TODO: implement subtract
Vector Vector::Subtract(Vector rhs)
{
Vector result;
result._x = _x - rhs._x;
result._y = _y - rhs._y;
result._z = _z - rhs._z;
result._w = _w - rhs._w;
return result;
}

// TODO: implement multiply with a scalar
Vector Vector::Multiply(float scalar)
{
Vector result;
result._x = _x * scalar;
result._y = _y * scalar;
result._z = _z * scalar;
result._w = _w * scalar;
return result;
}

// TODO: implement divide with a scalar
Vector Vector::Divide(float scalar)
{
Vector result;
result._x = _x / scalar;
result._y = _y / scalar;
result._z = _z / scalar;
result._w = _w / scalar;
return result;
}

// END ARITHMETIC OPERATIONS //--------------------------

// OTHER OPERATIONSN //----------------------------------

float Vector::Magnitude()
{
_x = _x * _x;
_y = _y * _y;
_z = _z * _z;
_w = _w * _w;
float result;
result = _x + _y + _z + _w;
result = sqrtf(result);

return result;
}

void Vector::MakeUnit()
{
float mag = Magnitude();
_x = _x / mag;
_y = _y / mag;
_z = _z / mag;
_w = _w / mag;
}

float Vector::DotProduct(Vector v)
{
float result;
return result = (_x * v._x) + (_y * v._y) + (_z * v._z);
}

Vector Vector::CrossProduct(Vector v)
{
Vector result;
result._x = (_y * v._z) - (_z * v._y);
result._y = (_x * v._z) - (_z * v._x);
result._z = (_x * v._y) - (_y * v._x);
result._w = 1;
return result;
}

//Setters and getters
// sets x based on the parameter passed.
void Vector::SetX(float x)
{
_x = x;
}
// returns x
float Vector::GetX()
{
return _x;
}

// Sets y based on a parameter
void Vector::SetY(float y)
{
_y = y;
}
// returns y
float Vector::GetY()
{
return _y;
}

// Sets z based on the parameter passed.
void Vector::SetZ(float z)
{
_z = z;
}
// returns z
float Vector::GetZ()
{
return _z;
}

// Sets w based on the float parameter
void Vector::SetW(float w)
{
_w = w;
}
// Returns the w aspect.
float Vector::GetW()
{
return _w;
}

// END OTHER OPERATIONS //--------------------------------

// print
std::ostream& operator<<(std::ostream& out, const Vector& vec) { return out << "<" <<>" << std::endl;
}

Also included in this post is some screenshots of this console application at work, displaying some generic efficiency values. Note that where it says Total Time within the screenshots, the number displayed afterwards is time in milli-seconds as its the number of ticks that the windows API has generated. Interestingly enough, these timings are not descriptive of individual operations, instead they are of the different operations being carried out 1000000 times.

Thanks for reading, I hope you've enjoyed looking at this code :D.

New Posts Very Soon!

2009-10-20T20:47:00.000+01:00

Hi, I've finished working on a few pieces of code, some classes, and have begun work on a virtual camera class, as well as a MIPS assembly based array system. It should be interesting on here for the next few days so stop by and check it out if you're interested :D. Should also have some XNA style code, for 2D pixel shaders and things like that in HLSL, which is incredibly simple however unfortunately at the moment.

C++ Vector class

2009-10-16T22:04:00.000+01:00

Hi all readers,

This time I'm posting about a C++ class that I've written for a university module called Introduction to 3D Graphics. It's a Vector class, which is quite basic, although it's still pretty cool. I know that it's also not the best way to implement this class. I wrote this about a week or so ago, so it's a bit of a late addition :(.

So here's the code:

Vector.cpp:

#include "StdAfx.h"
#include "Vector.h"
#include

// default constructor
Vector::Vector(void)
{
_x = 0;
_y = 0;
_z = 0;
}

// parameterised constructor
Vector::Vector(float x, float y , float z)
{
_x = x;
_y = y;
_z = z;
}

// copy constructor
Vector::Vector(const Vector& rhs)
{
_x = rhs._x;
_y = rhs._y;
_z = rhs._z;
}

// destructor
Vector::~Vector(void)
{
// do nothing
}

// assignment operator
Vector& Vector::operator=(Vector& rhs)
{
_x = rhs._x;
_y = rhs._y;
_z = rhs._z;
return *this;
}

// ARITHMETIC OPERATIONS //------------------------------

Vector Vector::Add(Vector rhs)
{
// TODO: this is not correct implementation yet
Vector result;
result._x = _x + rhs._x;
result._y = _y + rhs._y;
result._z = _z + rhs._z;
return result;
}

// TODO: implement subtract
Vector Vector::Subtract(Vector rhs)
{
Vector result;
result._x = _x - rhs._x;
result._y = _y - rhs._y;
result._z = _z - rhs._z;
return result;
}

// TODO: implement multiply with a scalar
Vector Vector::Multiply(float scalar)
{
Vector result;
result._x = _x * scalar;
result._y = _y * scalar;
result._z = _z * scalar;
return result;
}

// TODO: implement divide with a scalar
Vector Vector::Divide(float scalar)
{
Vector result;
result._x = _x / scalar;
result._y = _y / scalar;
result._z = _z / scalar;
return result;
}

// END ARITHMETIC OPERATIONS //--------------------------

// OTHER OPERATIONSN //----------------------------------

float Vector::Magnitude()
{
_x = _x * _x;
_y = _y * _y;
_z = _z * _z;
float result;
result = _x + _y + _z;
result = sqrtf(result);

return result;
}

void Vector::MakeUnit()
{
float mag = Magnitude();
_x = _x / mag;
_y = _y / mag;
_z = _z / mag;
}

float Vector::DotProduct(Vector v)
{
float result;
return result = (_x * v._x) + (_y * v._y) + (_z * v._z);
}

Vector Vector::CrossProduct(Vector v)
{
Vector result;
result._x = (_y * v._z) - (_z * v._y);
result._y = (_x * v._z) - (_z * v._x);
result._z = (_x * v._y) - (_y * v._x);
return result;
}

// END OTHER OPERATIONS //--------------------------------

// print
std::ostream& operator<<(std::ostream& out, const Vector& vec) { return out << "<" <<>" <<>

void test_addition();
void test_subtraction();
void test_multiplication();
void test_division();
void test_dotproduct();
void test_cross();

int _tmain(int argc, _TCHAR* argv[])
{
test_addition();
test_subtraction();
test_multiplication();
test_division();
test_dotproduct();
test_cross();

_getch();

return 0;
}

// tests addition.
// Outputs the result.
void test_addition()
{
Vector result;

std::cout << "additions" << std::endl;
std::cout << "---------" << std::endl;

// a
Vector a1(3.0f, 4.0f, 5.0f);
Vector a2(3.0f, 2.0f, 1.0f);
result = a1.Add(a2);
std::cout << result;

// add some more tests
}

// tests subtraction.
// Outputs the result.
void test_subtraction()
{
Vector result;

std::cout << "subtractions" << std::endl;
std::cout << "------------" << std::endl;

// a
Vector a1(5, 4, 3);
Vector a2(3, 3, 4);
result = a1.Subtract(a2);
std::cout << result;
}

// tests multiplication.
// Outputs the result.
void test_multiplication()
{
Vector result;

std::cout << "multiplications" << std::endl;
std::cout << "---------------" << std::endl;

//a
Vector a(5, 5, 5);
float aScalar = 2.0f;
result = a.Multiply(aScalar);

std::cout << result;
}

// tests division.
// Outputs the result.
void test_division()
{
Vector result;

std::cout << "divisions" << std::endl;
std::cout << "---------" << std::endl;

//a
Vector a(8, 3, 6);
float aScalar = 2.0f;
result = a.Divide(aScalar);

std::cout << result;
}

// tests dot product.
// Outputs the result.
void test_dotproduct()
{
float result;

std::cout << "Dot Product" << std::endl;
std::cout << "-----------" << std::endl;

//a
Vector a(1,1,1);
Vector b(1,1,1);
result = a.DotProduct(b);

std::cout << result << std::endl;
}

void test_cross()
{
Vector result;

std::cout << "Cross Product" << std::endl;
std::cout << "-------------" << std::endl;

//a
Vector a(1,1,1);
Vector b(1,1,1);
result = a.CrossProduct(b);

std::cout << result;
}

And that's the entire class. It runs quite slowly, so there is room for optimisation, but it does work with a really low margin of error from my tests that I've been running. I hope you've found today's post informative. Thanks :D.

UnrealEd- Resident Evil Shaft to Train

2009-10-12T22:16:00.001+01:00

Hi,

As some of you may know I am doing a piece of work to use in a large group collection for 10% of my grade in one of my modules at university. For those of you that didn't know, I am. The entire of the Computer Games Programming course at the University of Derby is in two groups, Group A (The good guys) and Group B (The bad guys). Note: group A are the good guys because I'm in group A :P.

Group A (my group) have opted to model the entire of the Hive and the mansion/train line from the first resident evil film, whereas our evil counterparts (Group B) are modelling Red Dwarf. We are also using Unreal Ed 3 with the Unreal 2 Engine. Although this does not contain the best graphics in the world, it can produce some VERY nice effects :D. Some of them are resource intensive, and some are not so much so, yet do produce some very nice effects. One of the major advantages of this engine is the Unreal Script technology, as I've probably already mentioned before, but I'm not going to go into that again in this post.

As can be seen from the images on the top part of this post, I have already completed a major section of this map, using textures gathered from the internet, from a CD provided with the Unreal Mastering Technologies book and with ones from the game Unreal Tournament 2004 itself. This has produced the effects that you can see in the above images. However I have also included several actor classes to produce a large number of effects. The most common of these is the lighting tool, but that is an incredibly common tool to use. Another actor class I have used is the ZoneInfo actor, which can be used to set zones up which provide certain effects. Within this context, it produces a small amount of black fog to make the level slightly darker and more eery.

Other than that I have included a variety of different other features, such as a vast quantity of static meshes, again gained from the Unreal Mastering Technologies accompanying CD and many other things. I have used a large quantity of different sized BSP brushes which are generated by UnrealEd itself, and can 'Add' mass to the environment and surfaces, or 'Subtract' them from the game world.

The main source of pride for me in this map however, is its design and its use of light, as different areas that I wanted to emphasize during gameplay are emphasized to the player through the creative use of lighting, of different brightnesses and shades.

If you have any questions feel free to e-mail me at richard.pickering@hotmail.co.uk. Thanks for reading and hope you stop by again soon :D!

Game Dev Tech 2009

2009-10-10T01:00:00.000+01:00

Hi,

Just thought I'd put yet another post up on here. I've found myself boooored and stuff in the early hours of the mornin so I thought what the hell, I'll bore you with another little talk on programming lol.

Unreal Engine is a fantastic piece of technology and software design whether you're trying to create a first person shooter, an RPG or even a flight sim type game. It includes masses of different software modules to create an impressive, high graphics game engine. This is why I'm so impressed that we're going to be using it in a module at uni called Game Development Techniques. :D.

At first glances unreal can be extremely daunting, but after taking a second look, it soon becomes bit by bit more familiar. The interface of UnrealEd is a scary sight for a newcomer to it, but for those already experienced in using the earlier versions of this software, it can be even more confusing. The buttons have changed, some things have been dropped and other things added. The main thing is to stick with it and weather the storm through re-learning quite a lot of tricks and techniques.

For my assignment for Game Dev Tech I've been told that I must create a game based around the Famous Five IP, preferably an action adventure or a point and click type adventure game. After reading the first book, and deciding that I didn't want to read any more of them, I decided on using that story as the basis for my game. Hopefully it will be a multi-genred, high graphic, slightly schitzophrenic masterpiece, but things don't always turn out that way. In this post I just thought I'd post a few tips for beginners to unreal engine to maybe follow to avoid some of the problems I've run into.

The first problem that I've run into was in unreal scripting. To put it plainly, I didn't want to be between applications, coding, then compiling that code, so I found out that there's a software you can use in conjunction with Visual Studio 2008 called nFringe. If you're interested, type it into a search engine, I'm sure it will come up with a download. Although you have to buy a licence if you want to use it commercially, this software is especially useful for non-commercial projects, such as Mutator creation for unreal games, and just scripting actor classes in general.

The next problem that I ran into was with UnrealEd itself, and this was that it keeps crashing after about an hour or two of using it, but I solved this by backing up more often and now it hardly affects me at all :D.

At the moment I am about two-thirds of the way towards finishing the main bulk of my level and have until Christmas to deliver the goods, so if I run into any more problems, there'll probably be another blog post or something, so watch out for that :D. I'm sure that more problems will crop up eventually knowing my luck.

Overall I think that this assignment should go well for me, and I will provide updates on this blog with screenshots and other media. Keep an eye out and thanks for reading :D.

Harvesting System

2009-10-09T00:07:00.000+01:00

Hi,

Wow, two posts in two days or so, not bad at the minute, I'm shooting them out :D. Ok so this post is about a small system that I've set up which I'm quite proud of. It involves one object which gathers resources from three other ones (the number can be scaled up if need be) and when the resources reach a thousand it offloads the resources at another object. It repeats this process until there are no more resources to collect at which point it stays at the resource "refinery" and waits for more resources to appear.

The images included in this post show this harvesting system. The triangle is the harvester, and each of the circles are resources. The resource collection point is more of an elipse shape (don't ask why I chose that shape, I just don't know, but it doesn't matter for a first try anyways :D).

The first image shows how the harvester sets straight off to the 'closest' set of resources to itself using a simple algorithm to select the closest one. When it reaches it (is at 12 pixels distance), the harvesting begins, and it takes one hundred resources per second from the resource cache. As soon as the first is dried up it moves onto the next until it has collected one thousand resources.

When it has collected one thousand resources it goes to the resource collection point to give the resources to that and transfers them at the same rate at which it gathers them. After all of the resources are offloaded the harvester goes away to collect more resources. And this is the cycle which this system follows.

I am planning on putting this system into a strategy game of some kind, but first I am going to rethink some of its selection code; I just think it has to be a bit more refined and intelligent than it is at current.

Note: the last image shows my trail particle system from the last post which I've included in this system. Just thought I'd point that out, because I am quite proud of it :D.

So to finish off, this system allows for some quite simple behaviour to be given to a game object in order for it to collect resources. For me the best part of it is the fact that it collects the resources without me having to input anything, so I am quite proud of that. Thanks for reading, and I'm sure I'll have something else up in the next few days. Keep checking back if you're interested :D.

Particle System

2009-10-07T17:57:00.000+01:00

This is a post detailing some of my recent work which I've been doing over the summer. :D. The pictures which you can see above show a particle system which I've made within XNA Game Studio 3.0 using the programming language C#.

There are multiple features to this particle system, including a series of different particle effects. For instance, there are 'drone' particles which follow the tank and whizz around it like bees, explosion particles, for explosions, and trail particles which create trails behind objects. Each of these different effects also have a fair few settings which can be changed to achieve different looks of the effects, such as having longer trails, smaller particles, etc.

The next image in this blog shows the trail particles in 'neutral' position. This means that the parent object is at a stand still, and the particles fly in every direction at random angles. Each particle currently has a life of one second and are 'destroyed' after that time. They are faded in on rendering and faded out by increasing their colour along with each update iteration and when they are at half their life span, they are faded out by the reverse of the previous method.

The image at the top of the screen shows the actual trail in effect. It is essentially the same as the previous method of particle creation except these aren't fired off at random angles. They simply stay still, creating a kind of trail effect for the parent object.

The next image shows another feature of my particle system in effect. This is my 'drone' particles. They circle and follow the tank around the screen acting as little 'follower' particles. They could be used for a number of things within games, like healing the tank when it's damaged, or taking fire from enemy tanks within an RTS.

The next image now is there to show that the 'drone' particles do not have any behaviour sub-routines or code to prevent them from overlapping, so all kinds of weird shapes form when they are created, however this three pronged shape is the most common that I have seen so far.

The next image shown is a demonstration of the particles flying in unison, however across their own paths, showing the fact that each particle has its own 'AI' behaviour, even if it is incredibly low level. It also shows that a relatively low number of particles can provide some very confusing and even overpopulated images, as there are 190 'drone' particles shown here, and my computer can handle numbers in the tens of thousands.

Next on display is the 'explode' feature of the particles, in which they turn away from the tank and just accelerate away from the tank.

The next two images show the explode effect. I have included two images to show the explosion properly occur. The first shows the first stage of the explosion, where the particles turn away from the tank and start moving. The next image shows them accelerate away from the tank and continue off the screen.

There are several features that aren't shown in the images which are included in this particle system. The main one being that the particles resize themselves to that of the parent tank or smaller, using a recursive algorithm. Another feature is that as many tanks as you like can be created, as long as your PC can handle it.

All in all this particle system is one that I'm proud of, mainly because it was one of the first projects that I've worked on in which I took the ideas of object oriented programming and put them into practice with a game uses and stuff. I hope you've enjoyed reading this post, and I look forward to putting more up- there'll probably be another up tomorrow :D.

First Post!

2009-10-05T23:59:00.000+01:00

Hi,

My name's Richard Pickering and I'm nearly 20 years old. I live in Dronfield in Derbyshire, and go to the University of Derby studying Computer Games Programming. This blog is going to show off my different projects that I'm working on at any particular time, so please stop by to have a look! Thanks for reading, and I hope you enjoy the blog in the months that follow. Please keep checking for new content, or any content at all at the moment lol.