Jordan's UOIT Game Dev Blog @jordanuoitgamedev - Tumblr Blog

Our GDW Game Vase - i2350

Well, the semester is coming to a close, and I thought I'd wrap up my blogs with an overview of our Game Development Workshop game - Vase. Of course, I have to relate this to our shaders course, so of course, I will be talking about the graphics techniques we used.

Vase is an isometric action game. It features a female heroine who has been cast in to a world where all the vases and pots have come to life to wreak havok upon the world. It is her job to smash these pots with her spells, and restore peace and order to the land.

We wanted the graphics in Vase to accompany the comedic nature of our game, and still be visually appealing. In Vase, we use per fragment lighting, cel shading + sobel edge detection to create toon shading, motion blur using the accumulation buffer, and baked ambient occlusion textures.

So here is what Vase looks like without any shaders. Keep in mind that some of the textures were incorrect at this point.

After we apply all of our graphics algorithms to the game, here is what it looks like.

Without the motion blur.

And now with the motion blur. Motion blur is triggered when the player collects a time stone powerup (the purple object in the picture).

As you can see, we wanted to make our game as colourful and vibrant as possible. We also wanted it to look like a hand drawn cartoon.

The first shading techniques we applied to the game were per fragment lighting and cel shading. We used the phong model for our lighting calculations. The diffuse, specular, and ambient values are calculated in the fragment shader, then added together to create the lighting intensity. From here, we take the intensity and limit it to certain values to create the cel shading. For example... if (intensity > 0.75){ intensity = 0.75; } We use 10 levels of intensity in our shading. On top of this, we threw in our sobel edge detection shader to get those black outlines.

Creating motion blur using the accumulation buffer was relatively easy. We have a boolean variable called accumBlur, which gets set to true if the player collects a powerup. After a few seconds, accumBlur is set to false and the motion blur stops. Here is what our display looks like. if(accumBlur){ static int i = 0; const int n = 2; if(i==0){glAccum(GL_LOAD, 1.0/n);} else{glAccum(GL_ACCUM, 1.0/n);} i++; if (i>=n){ i=0; glAccum(GL_RETURN, 1.0); App->Display(); } } else { App->Display(); } The 'n' variable represents how many frames are to be blurred. Since we didn't want the motion blur to make the game seemingly unplayable, we only blur two frames.

The ambient occlusion textures are baked on to all of our models. Here is an example of the gate model texture with no AO.

And here is an example of the gate, when AO has been baked on.

The ambient occlusion textures are meant to represent how light reflects internally on an object.

That's about it for this blog. Thanks for reading.

#i2350 #uoitgamedev

Ambient Occlusion - i2350

Ambient occlusion is a technique used in almost every 3D game today. It is used to simulate the way light radiates off of objects. In other words, it changes the brightness of certain parts of the object to simulate its environment to add realism. Here is a prism I created with a baked AO texture, in a scene with some lighting.

As you can see, there seem to be internal shadows within the object. Ambient occlusion is an effect that often goes unnoticed in games. However, when turned off, the game just doesn't look right. The lighting on objects feels off, and the '3Dness' of the game doesn't seem as apparent.

Here is the same prism in Maya. The one on the right is the prism, with a basic lambert texture applied to it. The one on the left has the AO texture on it. As you can see, the one on the left looks much better! If you want to ambient occlusion in a game or application that you are creating, Maya has a tool to create occlusion textures. However, you will not achieve ambient occlusion to its full realistic potential this way. Baking all your ambient occlusion on as textures will result in models that have static internal lighting. If you want dynamic ambient occlusion, you should use SSAO (screen spaced ambient occlusion). This post processing effect uses surface normals from the g-buffer to calculate the RGB values of a model, and linear depth values to calculate the alpha of the model. So the next time you open up the options menu in a game, check to see if they have the option to toggle ambient occlusion. If your pc can handle it, turn it on and bask in its realism.

#i2350 #uoitgamedev

jodoi2350

Cel shading is a shader technique that gives a cartoony or hand-drawn effect to a scene. It does this by averaging the colour on certain sections of the model. This is often combined with lighting calculations to achieve dynamic shading on a model.

Here is an example of cel shading on a model....

Object Space Normal Mapping - i2350

Normal mapping, or bump mapping is a technique widely used in 3D games and applications. Its main purpose is to add details to a model without increasing the polygon count. The normal map of a model is a texture that essentially tells the program how light should reflect off of the model. Below is an example of object space normal mapping from my shader program.

The picture on the left is the model with a simple texture. The picture in the middle is the object space normal map. When these two are combined, we get the picture on the right; A highly detailed statue figure. However, we can't just bind the normal map texture and the regular texture and achieve this effect. We need to write a normal map shader to handle the object space normal map. Noticeably, the normal map is comprised of colours (RGB values). We can use these RGB values to do our calculations. Our fragment shader is going to take in two textures. Texture 1, will be the object base texture (the image on the left). Texture 2 will be the object normal map (the center image). Texture 1 (object texture) vec3 textureMap = texture2D(tex1, texcoord.st).rgb; Texture2 (object normal map) vec3 N= texture2D(tex2, texcoord.st).rgb; Since a normal map has a range of -1 and 1, and an RGB texture has a range of only 0 to 1, we need to convert the RGB texture to be compatible with our normals. This can be accomplished as follows: N = normalize((N-0.5)* 2.0); Now all we need to do is multiply by the normal matrix. N = (mat3(gl_NormalMatrix) * N); And thus we are finished handling our normal map. If you want to achieve the same effect as the image above, you will also need per fragment lighting. Since this blog is mainly about object space normal mapping and not per fragment lighting, I will only briefly cover it. In my program, I use the Phong model for my lighting. This is done by taking the sum of the ambient, diffuse, and specular calculations and returning them as one texture. The diffuse coefficient can be calculated using the surface normal and a normalized vector towards the light source. float diffuseCoefficient = max(dot(N, L), 0);

To calculate the specular coefficient you need to take a normalized half way vector between the light source and the viewer. vec3 P = vec3(eyePos); vec3 V = normalize(-P); vec3 H = normalize(L + V); Using this, you can calculate the specular reflection of a model in the following way.

float specularCoefficient = pow(max(dot(N, H), 0), shiny); Now all you need to do add your diffuse coefficient, specular coefficient, and ambient intensity. Multiply your object texture and your newly calculated lighting and return it as your out colour and your finished! Thanks for reading!

#i2350 #uoitgamedev

Particle Systems (CPU) - Part 2 - Effects - i2350

In part 1, I covered how to set up a basic particle system. This blog will cover a couple effects that you can achieve with particles. Effect 1 - Burst

So you want to make a fancy explosion? Well you'd best start with a burst function. The burst function is a fairly simple one to write, as it is only a few steps. Step 1: Center the particles First, the particles will need to be centered along each axis. In your burst function, you will need to loop through each particle, and set its position to 0 along each axis. Step 2: Burst the particles! Now, you will need to actually burst the particles. This can be done my randomizing the direction along each axis, and multiplying it by a constant in order to speed it up. For example;

particle[i].direction =float((rand()%50)-25.0f)*10.0f;

Step 3: Round the edges Looking at step 2, you can see that the particles are bursting in to a box shape. This is caused by the way we randomized the direction. For some, this may be a desired effect. However, I prefer my particles to burst in to a sphere rather than a cube. In order to burst the particles in to a sphere shape, you simply need to normalize the direction of the particles after bursting them. This is done by taking the direction, and dividing it by the square route of itself squared. Putting this in to x,y,z terms;

float divisor = sqrt(x*x + y*y + z*z); x /= divisor; y /= divisor; z /= divisor; Following these steps should give you a nice burst! Effect 2 - Rocket Particles

To achieve this effect, I used a Catmull-Rom spline. The steps for this effect are as follows. Set up points(coordinates), set up a catmull-rom function and a delta time, update points, call the function.

Step 1: Setting up the points: This is relatively simple, you only need a struct/ vector/ array/ floats/ whatever else you can think of, that holds the XYZ location of 4 points. Step 2: Setting up a catmull-rom function Above is a catmull rom function, using a matrix of delta time, a catmull rom matrix, and a matrix of points. You will need to set up a function that handles this equation along each axis and stores the newly calculated positions in to a new XYZ vector.

Step 3: Update points In your update, you will need to update your catmull rom points. Example; point1(position) = point2(position); point2(position) = point3(position); point3(position) = point4(position); For the 4th point, you can chose a randomized value.

point4(position) = rand()%value1 - value2;

Base this off of your delta time. I used an if statement to do this. Step 4: Call the function

Now all you need to do is update your delta time, and call your catmull rom function and you're done!

That's all I am going to cover for effects. A few extra things you may want to set up are: A speed vector, some colour or sprite matrices, and an alpha value and alpha blending for smoothness. You can also throw some cool shaders like blur and bloom on to your particle system using frame buffer objects. Blur can also be achieved via the accumulation buffer. That's about it for this blog! Play around with some of the physics attributes of the particles and you can get really cool effects like this!

#i2350 #uoitgamedev #jodogamedevi2350longhastag

Particle Systems Part 1 (CPU) - Physics - i2350

Many of today's games have some sort of particle system implemented in them. Most of the time, the particles are used to add aesthetics to the game. In this blog, I will be talking about the basic physics behind a particle system, and how to set up a particle class.

First, you will need to define a max amount of particles, you can use #define for this. The MAX_PARTICLES in the image above is 30000.

Second you will need to create your particle class. Once that is created, you have to set up a few attributes for the particles. The particles are going to need: float life - holds the particles life value, easiest if life stays between 0 and 1 float fade - the rate at which the particles will die float R,G,B - colour values for the particles - if you do not plan to texture them float X,Y,Z - position of the particles - can be held in a vector float xD,yD,zD - direction of the particles along each axis - can also be held in a vector float xG,yG,zG - gravity(pull) towards each axis - likewise, can be held in a vector Now that that the particles have their basic properties, a draw can be set up for the particles.

void drawPoint(float x, float y, float z){ glPointSize(size); glBegin(GL_POINTS); glVertex3f(x, y, z); glEnd(); }

void drawSprite(float x, float y, float z){ glBindTexture(GL_TEXTURE_2D, texture_handle); glBegin(GL_TRIANGLE_STRIP); glTexCoord2d(1,1); glVertex3f(x+(size/10),y+(size/10),z); glTexCoord2d(0,1); glVertex3f(x-(size/10),y+(size/10),z); glTexCoord2d(1,0); glVertex3f(x+(size/10),y-(size/10),z); glTexCoord2d(0,0); glVertex3f(x-(size/10),y-(size/10),z); glEnd(); glBindTexture(GL_TEXTURE_2D, 0); }

Here are two of my draws for different particle types. The top one draws points, and the bottom draws a box, which is textured with a sprite. After the draws are set up, the particles basic attributes must be initialized. Create an initialize function, that has a 'for' loop in it which loops through every particle - for (int i = 0; i < MAX_PARTICLES; i++) - for example. Inside this loop, you can set up all of your physics attributes. Example attributes are as follows.

particle[i].life = 1.0f; // Set life to 1 (full) particle[i].fade = float(rand()%100) // Random Fade Speed particle[i].xD = float((rand()%75); // Random Speed On X Axis particle[i].yD = float((rand()%75); // Random Speed On Y Axis particle[i].zD = float((rand()%75); // Random Speed On Z Axis particle[i].xG = 0.0f; // Set Pull On X Axis particle[i].yG = -1.0f; // Set Pull On Y Axis particle[i].zG = 0.0f; // Set Pull On Z Axis These can be tweaked depending on the effects you are trying to accomplish. In your initialize, you may also want to set up image handling, if you wish to load sprites. Finally, the particles need to be updated. For this, you can use another 'for' loop which loops through each particle. You will need to do 4 things: Update the particle position based on direction, update direction based on gravity, draw the particle at its position, and reset the particles attributes once they die. 1. Movement based on direction: particle[i].position += particle[i].direction; 2. Direction based on gravity: particle[i].direction += particle[i].gravity; 3. Draw at position: drawPoint(particle[i].position); 4. Rebirth on death: If (particle[i].life <= 0){ 're initialize the particles' } That about sums up how to set up a basic particle system. In part 2, I will cover different particle effects.

#i2350 #uoitgamedev #jodogamedevi2350longhastag

Reflection - i2350

Reflection is a complex visual to mimic properly in games. To reflect an image across a plane, you need to essentially mirror that image over that plane. This means to take the vertices of the image, and flip them across the plane in to their negative or positive corresponding points (5 to -5, -19 to 19, etc.). However, in games some objects are reflective; and those objects will need to reflect other objects. Dynamically reflecting an environment on to an object can be solved with ray tracing. Rays of light have to bounce off of the object or multiple objects and get sent to the eye, or camera.This is incredibly expensive to constantly update in a game, and isn't very practical to use. A great way to mimic reflection in games is to use environment mapping. To sum up this technique, environment mapping stores the environment surrounding and object as a texture, and textures the object with it. When talking about reflection shaders in this blog, I will be using Borderlands 2 as an example.

The picture above, shows water spilled on to a floor, which is reflecting the building above it. If the displacement mapping of the water is combined with an environment map, you can achieve realistic and dynamic water with reflections.

To reflect an object using a shader, you need to deal with the user position relative to the reflected object and the objects position relative to its environment. This can all be done using vectors.

As input to the vertex shader we can take the object position, and the normal vectors of the object. The output of the vertex shader will take the position of object, and the texture that will be applied to it. The vertex shader will output the reflection as a function that takes the world relative to the object position, the viewers position in the world, and direction of the viewer relative to the first world to object position. Anyway, that's it for the blog this week!

#jodogamedevi2350longhastag

Shadows and using sprites in the place of models - i2350 - GW2

This weeks blog is on shadows, and using sprites in the place of models. I will be looking at these two features in Guild Wars 2. Shadows are a very important feature if a developer wishes to add a realistic element to their game. Though Guild Wars 2 is a fantasy game, the style is very realistic. Shadows are cast off of almost everything in the game, and this gives the game a very realistic look.

As you can see in the two images above, the shadows are very precise in their shape. In the first image, even though the tree in the top left is hard to see, you can tell that it is a tree because of the distinct shape of the shadow. In the second image, the shadow is projected from my character on the roof of a building to the ground below. In order to cast a shadow, the saturation of the colour of what the shadow is projected on to must be reduced. The shape/size and darkness of the shadow is calculated using an algorithm that used the normals of the object, the direction of the light source on to the object, and the intensity of the light. Moving on, Guild Wars 2 uses sprites in the place of models in many places, in order to save memory. This fence illustrates the use of sprites in the place of models.

The fence in the image above is actually just a textured polygon with a hit box for collision. This is noticeable when we rotate the camera.

As you can see, the fence has no 'Z' dimensions. Using a texture in the place of a model like this will save memory. This is an important technique for such a detailed game. All and all, Guild Wars 2 is a visually stunning game and is definitely smart in the ways it saves memory and uses shadows and sprites.

#jodogamedevi2350longhastag

Blur and Bloom in Need For Speed - i2350

Blur and bloom are two post processing effects that are used widely in the modern games industry. Blur is used widely to simulate distorted perception due to factors such as speed, daze, fear, etc. Bloom is a technique used to replicate light artifacts commonly produced by cameras. Bloom "stretches" the bright pixels over top of their border on to other pixels. This produces a glow effect - like a flashlight being pointed in to your face. This week, I took a look at how these two techniques are used in Need For Speed Most Wanted (the second one). I'll start with bloom. Bloom is most prominent in the game on the car/street lights and on pretty much all particles. Here is a screenshot of me crashing in to a guard rail and speed sign. There are sparks flying in every direction. All of which are particles - all of which have bloom. As you can see on the edges of the car, the sign, and the yellow rail, the light pixels of the particles are being stretched and blended over top of the current frame. The lamp posts in the distance also have a bloom shader applied to them. Motion blur is exactly what it sounds like. Blur because of motion. In Need For Speed, along with many other racing games, this technique is used to simulate speed. Motion blur can be achieved through frame buffer objects (FBO's). Instead of instantly swapping the front and back buffers, you can slowly change between the two frames - displaying both frames for a very short time. This will create a blurry effect. Here is an example of motion blur and bloom combined. This screen shot was taken as I was crashing. As you can see, the environment is extremely blurred - simulating speed, and a daze as I crash. The contrast is increased to make the impact seem stronger, and bloom is applied to the whole scene to blend it all together. That about wraps up my blog for this week. Bloom and blur are two widely used shader techniques used in modern games, and certainly bring a realism element to them.

#jodogamedevi2350longhastag

i2350 - GLSL Sandbox

For this week’s blog I will be reviewing a really awesome website that I stumbled upon while I was researching shaders! The website is a GLSL Sandbox, where users can edit and post different Web GL shaders for others to play with and learn from. Perhaps the greatest part of the website is that YOU GET ALL THE CODE!!! :D You can read the code, and edit it how you wish and the website will compile it on the fly.

As you can see, the program runs as the page in the background and the code is displayed on top.

The code can be tinkered with, and the website will recompile the program. If there are errors in the code, it will ignore the changes. Looking at the shader example above, gave me a good idea about how to approach Phong lighting, shadow mapping, and reflections. There are hundreds of other examples on the website, covering tons of different kinds of shaders, and it is a great learning tool. GLSL Sandbox Gallery has multiple pages of these examples and I look at the new posts almost daily. It is a great way to get ahead in learning different types of shaders, and is super fun to play with! Well, that's all for my blog this week. Here is the website link: http://glsl.heroku.com *I really recommend that i2350 students check this out

#jodogamedevi2350longhastag

i2350 - Photoshop your game!

Though our game is already SUPER pretty (just kidding it's was pretty ugly..) we are going to make it even more beautiful this semester by implementing shaders! Our task was to take a screenshot of our game, throw that in to Photoshop, and try to make it pretty.

Here is a photo of what the game looks like now. As you can see, objects do not cast shadows on to other objects. When i light shines on to an object, only the color of a certain surface is manipulated. With shaders, we hope to fix this. As for the two nodes with the particles; we plan to use shaders for those too, and texture and blend them to create appealing effects such as smoke, fire, blood, magic etc. I took the liberty of using my super pro Photoshop skills to attempt to preview what the game might look like with shaders. ...Ok my Photoshop skills aren't actually that great, but in general, this is what I hope the game can look like! As you can see, the house is now casting a shadow on to the ground, and the two particle nodes look a bit smoother. In the actual game the measurements of the shadows and the blending and texturing of the particles will hopefully look much better. All in all, I am super excited to work on our game, and we have already started re-vamping the engine and creating new textures, and particle systems!

#jodogamedevi2350longhastag

i2330 - Healthy Game - Greedy Farmer

Greedy Farmer For our final GDP challenge, we had to create a board game which would teach people what fruits and vegetables are in season. Creating an educational game which is fun is a challenging task. However, with our new game, “Greedy Farmer” I believe we have done that. Greedy Farmer combines luck and skill. If you already know what fruits and vegetables grow in which season, you will have an edge over the other players. For the less experienced players, the list of in season items is given to them. The challenge in Greedy Farmer is keeping an eye on your collection of cards, as well as your opponents. At the same time, you must make sure that you are collecting fruits and vegetables that grow in the same season. I love collection games, and collection in games. However I find most vegetables tasteless and educational games boring. However, even to someone like me, this game is a good time. The rules of Greedy Farmer are as follows:

RULES Before starting the game, players sit across from each other. Deal 4 cards to each player, placing the rest of the deck in the middle of everyone. Four cards are then picked off of the top of the deck and placed face down on the ground. Everyone counts down from 3 and on `1`each player flips over a face down card. When the cards are flipped over, players are open to trade the cards in their hands with the cards on the ground. Each player can ONLY have a max of 4 cards in their hand at all times. You can choose to exchange one, none, or all of your cards with whatever cards are on the ground, but only from what’s available. When players are done exchanging cards, place those 4 cards on the ground aside and draw 4 new cards off the top of the deck and begin a new “round”.

Players continue to play until on player claims that he is “the Greedy Farmer”. When a player does that, he must show his cards to everyone to ensure he has actually won. If that player falsely announces his victory, he loses and a new game is begun.

Fruits and Vegetables/Season (In Ontario):

Season

Fruits and Vegetables

Winter

baby bokchoy, bokchoy, cabbage, carrots, parsnips, turnips, beets, onions, Spanish/red onions, squash/pumpkin, potatoes, leeks, garlic, mushrooms

Spring

beets, onions, parsnips, potatoes, mushrooms, cabbage, carrots, turnips, rhubarb, carrots, turnips, radishes, onions, spinach, asparagus, baby bokchoy, mushrooms

Summer

plums, cherries, peaches, apricots, strawberries, raspberries, blueberries, bok choy, tomatoes (field), sweet corn, cucumber (field), peas, snow peas, green/yellow beans, cabbage, cauliflower, broccoli, radishes, onions, green onions, celery, lettuce, radicchio, rapini, spinach, peppers (field), potatoes, green onions, zucchini, kale, swiss chard, basil, garlic, mushrooms

Fall

pears, plums, tomatoes (field), cucumber (field), green beans, cabbage, Nappa (Chinese cabbage), cauliflower, broccoli, brussel sprouts, carrots, parsnips, turnips, beets, radishes, onions, green onions, Spanish/red onions, celery, lettuce, rapini, kale, spinach, peppers (field), squash/pumpkin, potatoes, leeks, rutabaga, sweet potatoes, zucchini, eggplant, swiss chard, basil, garlic, mushrooms

The game is designed for 4 players of all ages, and takes roughly 20 minutes to complete. Since we live in Ontario, we used the in season fruits and vegetables from our province.

In the end, Greedy Farmer is based on both luck and skill, and is a good time whether you want to learn or not.

#i2330 #uoitgamedev

i2330 - Prototype #3 - Dancing - Dance Pants

Dance Pants is the game we designed for our third and final game design prototype. The requirements for this game were that the game captured the essence of “Chaiyya Chaiyya”, a Bollywood dance. The game had to be at least four players, and recommended eight. After meeting with the group, we decided that making a game where the players actually danced would be great! We wanted to keep the game simple, yet fun. We also wanted the game to be a good party game.

We were told that we were to assume we were funded by producers with a large budget, so we created a “Scene-It” style dancing game. The game is DVD based, and because of its simplicity, can be ported to multiple platforms.

The rules of the game are as follows:

Dance Pants Dance Pants is a fun party game with only one goal. To be the best Bollywood dancer out there! ..or at least amongst your friends.

Dance Pants players are pitted against each other in a multitude of dancing goals to achieve the most points by the end. The end of the game is not predetermined but rather entirely up to the players. The players may choose to play to an agreed upon point limit or time limit or round limit. Alternatively, they may simply choose to play until they get bored, or everyone is exhausted from dancing. Ultimately the goal is for the players to have fun and have a little friendly competition between friends! To setup the game, the players must simply place the DVD into a DVD player and shuffle the deck of cards. One player is selected randomly at the start of each round and is dubbed the "judge". He or she is in charge of choosing the winner for that particular round. The judge draws a card from the deck and announces the card aloud to the other players. Located on the cards are the number of participants and the corresponding clip that the judge must select from the DvD. The clip contains a particular dance and song number from a Bollywood film. After watching the clip, the players dance! Following the dance, the judge must then select the team with that they believed performed better, and said team is then awarded 1 point per player. A new judge is selected and the round starts again. At the end, players tally up their points and the person with the most points is declared the winner! (Ties may be sorted with a dance-off)

The game DVD would have multiple options, such as controlling the length of the game (the amount of dance clips that the players have to imitate), freestyle dancing mode (players can chose a clip to watch and dance to), karaoke mode (players can sing along to songs as the words flow across the screen), and card-less mode (the DVD will chose the dances randomly for the players).

The target audience for Dance Pants is any one of any age who enjoys Bollywood dance.

#uoitgamedev #i2330

i2330 - Character Bio - Antonello (Anthony) Marino

Current Year: 2012 Name: Antonello (Anthony) Marino Age: 28 Date of Birth: March 12, 1984 Background: Italian – Moved to Australia alone when he was 15 Legal Occupation: Wheat Farmer – Marino Goods Current Country: Australia Current City: Sydney Relationship Status: Single Children: None Religion: Catholic Look: - Always wears a dress shirt and tie, with a blazer and navy blue jeans - Curly short black hair - No facial hair - Looks Caucasian, slight tan - Weighs 165 - Muscular - Long legs - No scars Interesting Attributes: Underground arms dealer – has a gang working for him Fears: None, besides the gang that murdered his family Friends: None, only clients Hobbies: Researching stocks, playing the market Personality: Extremely serious. Isn’t afraid to “off” a client who tries to rip him off. Patient unless his money in jeopardy. Other Attributes: - Sometimes finds it hard to sleep, due to him thinking about what happened to his family - Wealthy, but his property doesn’t show it

History of Antonello Marino Antonello Marino (Anthony as he prefers) is a 28 year old entrepreneur living in Sydney Australia. Growing up, Marino lived in Venice Italy where he witnessed tons of crime. His family’s income was very low; and in an attempt to make some money his father turned to doing favours for a very notorious gang. The gang called themselves “Murky Waters” though most referred to them as “the Murks.” Because of his father’s gang involvement, Anthony was witness to many violent crimes.

One night, about a month before Anthony’s 12th birthday, there was a loud bang on the door. Before Anthony’s father could get up to answer it, there was the ear piercing noise of gun fire. Anthony ran upstairs and hid under his bed. He could hear the screams of his family as they were gunned down by the Murks. Once the gunfire had stopped, Anthony made his was downstairs, where his mother and father lay dead on the floor. The image was burned in to Anthony’s brain. The next few years were rough for Anthony, who resorted to doing odd jobs, and stealing in order to make a living. When he was 15 he found a family who owned a farm, and took him in as a son. They gave him a weekly allowance to work on their farm. After saving up about $5000 from odd jobs and allowance, he snuck his way on to an export ship headed to Australia. Upon arrival, Anthony went to the closest library, where he found a sneaky spot behind a wall in the basement that he could make a home. He got a job at the library stocking shelves and doing some routine maintenance. Anthony was paid in cash, and for the next 4 years he lived out his life in his hole behind the wall, never being discovered. During his free time, Anthony would use the computers and read books to research about the stock market, and imports and exports. One day, when Anthony was 20, he began investing in growing stocks. He nearly doubled his money in the first month. Once he had saved up enough, Anthony purchased some land, where he started his wheat company from the ground up. However, wheat is not all that Anthony sells. He runs an underground arms trafficking business. Anthony sells weapons overpriced weapons to whoever, whenever. Because of Anthony, the crime rates in Sydney have risen 40% since 2008. Because of the nature of his underground business, Anthony has employed the largest gang in Sydney to work for him. The gang is loyal to Marino, and never mentions a word to anyone about their business from him. As far as the law goes, Anthony is only a wheat farmer. The gang is responsible for the physical exchange of the weapons for cash, and to deal with any problematic clients. Antonello Marino lives a day-to-day life. He doesn’t have any plans for the future, but would love to see Murky Waters brought to justice.

#i2330 #uoitgamedev

i2330 - Nocturnal Journey Modification

Nocturnal Journey Original Rules – Created By Myself and Hysteria Gaming

Setting up the Game - The arrows are placed on the statues - On/off tokens are placed on lamps (one each) - The red/green squares are placed on the street lights (one each) - The clean/graffiti tokens are placed on the walls (one each) - The open/closed tokens are placed on the doors (one each) Every player choses one player piece and places it on any blank square they chose.

Starting the Game - Hand out one card to each player making sure the hint side is facing upwards and that players do not look at the goal side of the card – the hints relate to the goal on the other side - Players are not allowed to look at any goal until the game ends - Players decide amongst themselves who starts. - Play continues clockwise.

Turns - At the start of the turn, players roll the dice and move the corresponding number of spaces in any direction - Players are not permitted to move over a square they have already been on during the same turn - If player lands on an object, they may choose to interact with the object (flipping a lamp from on to off, turning a statue east etc.) - If a player lands on another player, they can chose to swap goals with that player (without looking at the goals) - Play continues for 20 turns (one turn = every time a player takes a turn) - Once the game is over, players flip over their goal cards and see if they have met the requirements - If any player has fulfilled every goal on their card that player wins the game – there can be multiple winners/ losers

World Objects - Lamps – On/ Off - Street Lights – Red/Green - Walls – Graffiti/Clean - Doors – Open/Closed - Statues – North, South, East, West - New Goal Space – Player swaps their current goal for a new one in the deck – they are still not permitted to look at either goal

Modifications - Instead of a free-for-all, the game is now played in teams of 2 - The two teams sit across from each other - Each player on each team receives two goal cards (4 goal cards per team) - Each team is allowed to look at the goal cards given to them; however they are trying to complete what is written on the other team’s goal cards - After 15 turns, the game ends and the teams switch goal cards - The team with the most goals satisfied wins This turns the game from a game of primarily chance to a game of primarily skill. Players need to determine what their goal is by the other team’s moves, and try to beat their opponent by making the board NOT satisfy the opponent’s goals.

#i2330 #uoitgamedev

i2330 - TicTacToe Modification

Tic Tac Toe is a simple skill based game played by two players on a 3x3 grid. The goal is to get a chain of 3 X's or O's (depending on your side) before the other player. The X's or O's are drawn on any blank space, and players alternate turns. Many times, neither player wins. I modified Tic Tac Toe, to make it lengthier, and have an element of luck. The rules are as follows.

Tic-Tac-Toe Rule Modification Instead of a 3x3 square, the game is now played on a 6x6 square.

-The goal is to acquire as much territory as you can by making chains of 3 x’s or 3 o’s (depending on your side) -Every time a chain of 3 is made, the player rolls a dice. If the dice shows a 3 or higher, then that square is shaded in by the player, of a color they chose. If the dice shows a 1 or 2, their opponent gets to shade in the chain with their color.

-Chains of 3 cannot be added on to. Every chain must be independent. -Once no more moves can be made, the players count up how many squares they have acquired. Only squares that are part of chains may be included in the count

Red = 9 Blue = 12 If the players chose to stop here, then Blue is the winner. -If players would like a longer game, then the game is restarted and the grid size is reduced by 1 on both axis’, until 3x3 (6x6 -> 5x5 -> 4x4 -> 3x3)

-After every game, the score is recorded -Once the players have played through every grid size, the scores from every game are added up. The one with the highest score wins

There were no problems with balance while play testing this. And it seemed to engage all the people who tested it. Some even called for rematches and continued to 3x3 every time. So if you want a quick fun game that you can basically play anywhere, try out this tic-tac-toe modification!

#i2330 #uoitgamedev

i2330 - Prototype #2 - Starry Night - Nocturnal Journey

“Starry Night” is a famous painting by Vincent Van Gogh. Like many art pieces, its meaning is up to interpretation. My interpretation of the painting is that one sees things differently at night than they would during day. We were tasked with creating an art board game. This game did not have to be fun, but players had to make meaningful decisions. We were to portray a “Starry Night” atmosphere, and base the game off of our interpretation of the painting.

*game board Design Process We combined our various thoughts on the painting and concluded that we would base the game off of the feeling of being lost at night; and being able to see more clearly during the day. We started off with deciding a goal for the game. We thought it would be cool if every player (like in real life) had their own goal. Sticking true to our theme, we decided that players would not be allowed to know their goal until day time. Instead of a path that players follow we created a grid, where they can move in any direction they want. On the grid we placed objects that players could interact with. The objects are: 4 lamps – players can turn these on or off, 2 statues – players can turn these to face north, south, east, or west, 2 street lights – players can turn these red or green, 2 doors – players can open or close these, 2 walls – players can decide to draw graffiti on the walls or clean them off, and a new goal space – players can swap their current goal for a new one. The players interact with the objects in any way they want by simply landing on one of the squares the object covers. Every goal card relates to either these objects, or the other players. On the back of every goal card, there is a vague hint. This is to guide the player to their goal – if they are able to interpret the hint correctly. Players can also look at other players hints in order to try to figure out their goal. Once the game ends, players flip up their goal cards to see if they have met the requirements. This symbolizes day time. The player should now fully understand how the hint relates to their goal. Because the hints are displayed on the back of the cards, the game is the most interesting the first time it is played – because all players are truly lost. A few examples of goals and their hints include – GOAL: At least 3 lamps are turned off – HINT: “I can barely see”, GOAL: All other players lose – HINT: “For one to rise, many shall fall”, GOAL: The two statues are facing each other, HINT: “Best friends.” The game's name was decided last. We play tested it, and decided the name. We called it "Nocturnal Journey." The game was left in black and white on purpose. Rules

Our Interpretations on the Game Most members of our group have varying thoughts on what the game’s meaning is. Some include: “It is hard to see at night, and daylight brings clear vision – your decisions represent your sight”, and “Seemingly useless decisions can make an impact in the future.”

Conclusions on Nocturnal Journey Nocturnal Journey is an art game that is completely up to interpretation by the player. It is not meant to be fun to play, rather to make the player think and to come up with their own interpretations of what it means, and what they are trying to accomplish. “Starry Night Moments” in Other Games (Opinion) To me, “Starry Night Moments” happen in many open world “go around and do whatever you want” games; such as the Fallout Series, The Elder Scrolls series, Dragon Age, The Sims, or any other ‘chose your own adventure’ game. Though these games have a little guidance, your goal can change in an instance. The player can feel lost many times, until they interact with something that helps them find their way. Meaningful decisions are made all the time in these games, some having a greater impact than others. Many times, the player doesn’t know why they are doing something, or what they are supposed to be doing, until later on when it all becomes clear. “Starry Night Moments” are not just the feeling of being lost however. Games such as Bastion, Guild Wars 2, Uncharted, Jak and Daxter, have a certain awe to them. The sheer beauty and liveliness of the environments leave the player lusting for adventure and discovery. When I look at Starry Night, I appreciate its beauty, and it makes me think of the beauty of the world.

#i2330 #uoitgamedev

Trending Blogs

Recently Viewed Blogs

Jordan's UOIT Game Dev Blog