Street Scene: Photoshop crashing

So recently I've run into a slight problem. By slight I mean huge. I updated my drivers, as you do when there's a new update, and thought nothing else about it. When I next went to use Photoshop however, I experienced some unusual crashes. It started off when I tried to offset an image so that it would tile nicely, when just clicking offset crashed the program. So I restarted Photoshop, opened my image again, pressed offset, and it crashed. This happened once more before actually working.

Now that I had finally offset the image I wanted to edit it. Clicking the clone stamp tool crashed the program. It was very clear now that something was wrong so I headed in to university to ask my module leader what the issue could be. After explaining the situation he suggested it could be my GPU settings in Photoshop which when I got home and checked, I found out the latest updates had caused an error and would no longer allow my graphics card to interact with Photoshop.

I've tried to update the drivers and reset everything but so far there isn't any new developments. This means my only current solution is to do all of my texturing and artwork in the labs at my university, which isn't too bad an option considering the circumstances. The only other thing I can think of is completely uninstall then reinstall the program, which I'll try at some point soon.

Street Scene: Start of texturing

With all of the modelling pretty much sorted, it was about time to start texturing the scene. Like with the modelling, I wanted to start with the saloon as it's the focus point of my scene due to the ability to enter inside it. Being a western themed saloon I knew I was going to need a lot of wooden textures but they'd need to be different in shade,colour and appearance so everything didn't look the same and blend into one. Since I'm not a good artist in any sense of the word, to texture things I found images online, brought them into Photoshop and edited them enough so that they were like a different image that I could use.

Textured saloon

I used contrasting textures for different areas of the saloon to make sure nothing clashed. I found a nice light board texture for the walls and used a darker wood texture for the furniture. To balance them even further I used a 'medium' texture (brightness between the two others) for the floor which is easy on the eyes. For the bar, stairs and landing I tried to use a texture that falls between the darker furniture and light walls, just to differentiate between the 3 sections.

Street Scene: Audio & Story

For my game to be an actual game, I need the player to be told part of the story each time they trigger a point. This meant I needed to use Audacity for some voice and sound recording, which I was really looking forward too after how much I enjoyed doing the sound work in sessions. Before I could do any voice acting, I needed to come up with a story concept. My story is about a man who has lost everything and each story point is a memory. The character had a wife and 2 children, but lost all of them to accidents/illness. Following this, his farm is destroyed in a storm and he slips into depression. The ending is the player leaving town on a train from the train station.

 I broke the story and points down into 6 sections:
1) Characters wedding day
2) Loss of characters wife
3) Loss of characters daughter
4) Loss of characters son
5) Farm is destroyed
6) Depression takes over the man

Once I had the story concept I could write a small script for each story point and detail what background affects/noises I wanted to accompany the voice acting.

AA shooter: Turrets and particles

With Richard absent this week, I worked on my AA project with the time given. I had a great idea in mind for my two player objects. Player one would have control of a machine gun turret that would fire lots of bullets very quickly, that would be controlled by aiming with the mouse and pressing LMB to fire. Player 2 would have a slower firing but harder hitting rocket launcher that used the Xbox 360 controller, with the right stick aiming and RT firing.

This contrast in weapons means that players will need to co-ordinate themselves and work together in order to win the game and not let the generator be destroyed. The faster firing player 1 needs to worry less about accuracy as they're firing a huge amount of bullets, but also deal less damage, whilst the rocket launcher is slower so needs to be more accurate and packs a much bigger punch as result. 

Picture of turrets next to each other

Street Scene: Day/Night & prototyping

Using what I was taught this week, I added a day/night cycle into my street scene. My game involves the player triggering a series of story points, so I came up with the idea to change the time of day each time they made progress by getting one of the points. I created a script and added it to the light which, when a point is triggered, rotates the entire object slightly on a single axis for a few seconds.

Unfortunately it's a little difficult to tell that the sun is moving unless you focus on the shadows on the ground, so if it's possible, adding some form of colour affect to the light at different stages would make it a more effective mechanic.

Code activated each time a point is triggered

AA Shooting game: AI path-finding

For my game I'd like to have enemies that move up towards the player from cover to cover, before finally approaching the generator object and attacking it. In order to do this I need to use a navigation mesh and set points for the enemies to move between. I've created an array of points for the enemies to choose from, where they're limited to choosing from groups of four at a time. With the checkpoints set in rows of four, the enemies move from row to row advancing towards the players and generator.

rows of checkpoints

Unfortunately when all areas around the generator are occupied by enemies, even though I tell the next wave to wait until they're free, they try to occupy the spaces and cause a huge stack overload. Hence for now I've been forced to step back from the AI path-finding and had to stick with simply spawning them at set points around the players. I would like to play with this again when I have more time but for now, I have to give up on it.

Street Scene: Modelling the street & Mood Boards

With the buildings of my street scene in place, it was time to add some more detail to them. I was considering working on some of the smaller buildings first in order to fill the scene out quickly, but in the end thought that constructing the interior of my saloon would be a better idea. Each of the buildings in the street is designed to be looked at and admired by the saloon is a key focal point as it's the only building players can enter. So I made this my starting point and started planning out what would be in a Western saloon.

I wanted to have two floors so players would have even more to explore, so put in some stairs and a landing to start with. What to fill the actual floor space with took a little more planning, so after a short bit of research online and in games, I decided on having 3 main things: seating, a bar and a piano. I started by allocating the space for the bar and putting that in first, seeing as it would take up the most room. I followed on from the bar with tables and chairs in the main space of the room, leaving a wall free by the stairs for the piano.

When I was done with the ground floor, I planned out what could be done upstairs, with my conclusion being a single room that would tie in with the game aspect of the project.

Finished saloon interior modelling in 3DS Max

Finished saloon interior modelling in Unity

Dark Arts 4: Statics, XML and Shaders

Static classes cannot be allocated, therefore there can be only one of them in which every method and variable must also be static. They can be used to load in files and store variables from them, such as settings, as well as wrap up methods you know will be needed in multiple places. Static classes are never deallocated which makes them really useful for keeping data around between scenes in Unity, like textures which would save on loading times.

Static class to add and remove textures at will

XML was designed to be easily read by people as well as computers. All XML files must begin with the header of    <?xml version="1.0" encoding="utf-8" ?>    .  From there you have to define an element which will be the name to call when needing the data inside (similar to a class). Inside that other elements can be defined which contain the precise data you require, in the form of a 'Key Value' pair e.g <player lives="3"/>. Every value is recorded as a string.
To use an XML file, you need to first parse it into Unity and then select the base element you want. Then you can walk through any children and use the key/value pairs as needed.

XML parsing class

UI Card Game part 3

The final stage of the game, was the actual game mechanic itself. With the cards randomly shuffling upon starting the game, all I had to do was set the card backs to display as opposed to the front. I needed to set cards to flip upon being clicked and check if it matched the ID of the next card being flipped. If so then the cards needed to remain upright, otherwise flip them back.

To do this I needed a method in the card behaviour that passed the cards information to the game manager upon it being clicked. When two cards have been clicked and passed their information, a co-routine to compare the cards is started. If the two cards match, the tally for pairs needed to win increased, bringing the player one step closer to finishing and they then remain unclickable. If they don't match, both cards are flipped back and made clickable again.

Card game partway through

The final thing to do was provide a win screen when the player matched every card. This was easily done by checking if the pair tally equaled 8 or not. If so then a delegate message is sent to display the win overlay image and I even added music to make it more of a celebration.

Finished game with win display

Street Scene: Initial Street Building & Mind map

After the first week working on my street scene, I've planned out the layout and done some basic work an a few buildings. I decided on the five major buildings I was going to make and also wanted to add a few extra filler buildings to flesh out the scene. The smaller teal coloured buildings are the filler buildings that will have the same generic size and shape but a slightly different decorative roof board and decals. The far left building is going to become a church with a bell tower and stained glass windows. The light pink building will become a general store, the yellow one is the train station, deep purple will be a doctors and the big darker pink building is the saloon. I have plans for different props, to add more detail to the scene, such as barrels, crates, shacks and foliage.

Street scene in 3DS Max

I've imported the street model into Unity and edit it from there, so any changes I make in 3DS Max instantly appear for me to explore in-game. This way I can check scaling and the feel of things with ease as soon as I've made them. This also allows me to easily integrate my game mechanics with the street scene such as moving doors and interactive pieces when I get to that stage.

Street scene in Unity

This was also the stage where I turned my brainstorm into a mind map. This wasn't very difficult seeing as my brainstorm for this project was relatively clear in the first place, but it still gives me a well laid out feel for my whole plan.

Mind map

Transparency and Decals

Transparency is used on textures to make parts of textures see through to make them more realistic. The degree of transparency goes from 1-0 where 1 is fully opaque and 0 is fully transparent. To make use of transparency you have to create an alpha source for the texture. Anything you want the player to see should be white, whilst anything you want to disappear and be see-through should be in black. Transparency is used mainly for fences, windows and even foliage.

To test it out we had to find a chain link texture and take it into Photoshop. The actual fence part needed to be made white with the space around the edge and inside made black so it becomes see through.

Chain link alpha source

We then added the original texture to the diffuse section in the material editor in 3DS and applied the alpha source to the opacity setting. This then applies the texture and the opacity meaning you get the effect of a chain link fence that you can see through.

Added texture and alpha source into 3DS Max

I then decided to add it into a scene in Unity to see if it looked the same and the effect works exactly as it did in 3DS Max.

My fence in Unity with transparency still working

We were then taught that transparency can be used for decals. This is the process of adding a texture to an object that already has a texture, in order to give it some more detail. The decal won't cover up the entirety of the original texture, it simply adds something more on top of it. Examples would be stains, dirt and graffiti on surfaces. I made a graffiti decal and then created the alpha source for it which was more difficult seeing as it was multiple lines for text rather than an overall shape. Eventually I managed to do it and applied both in the material editor, exactly how I did for the fence texture.

Graffiti on wall in 3DS Max

As I said earlier, foliage can be created by using alpha sources to make the space between and around leaves/plants transparent. We were shown how to create a leaf and then curve it slightly for realism and adding a lot of these leaves together gives the appearance of a small tropical plant. Another way to create foliage is to use the same texture multiple times with them at different sizes/angles and we used this to create a bush. The final piece of foliage made was a tree that I rotated multiple times to give a more 3D effect.

Foliage textures with alpha source

For home study I was tasked with creating some particle effects in Unity which is a something I've never tried before. In order to make a particle effect I had to add a particle system to my scene. This is a default effect producing white orbs at a steady state, in which a huge amount of settings can be changed. The 3 particle effects I created were: an explosion, exhaust fumes and a glowing golden ball of light. These 3 effects varied in size, speed, emission shape, lifetime and textures.
The explosion needed to be fast expanding and quick to end with the particle size decreasing as it blasts out. The exhaust fumes puffed out at a steady speed both rising and disappearing over time. The golden orb is quick and compact in a spherical shape with the particles fading quickly.

My particles in a GIF

Dark Arts 3: Delegates and Co-routines

Delegates are used as a reference to a method with specific parameters. We can use them if we have multiple versions of a method that we need to choose from and how to handle each one. To define the delegate all you need is:  public delegate <Type>   MethodName(<Type> variable);
Another good use of delegates is a messaging system between classes. A list of delegates can be created as a way to keep track of the receivers, that way we always know where the message will be going. The 'listeners' can then chose whether or not they act on the message depending on what it is.

Example of using delegates for message system

A co-routine is a method that can be paused and continued later. This is very useful to script events and create situations where something is waited for or triggered at a certain time. Using a co-routine that contains yield is what causes it to continue in the next frame from where it left off in the last one, rather than starting from scratch. This is what I've done in order to fade out the bullet holes in previous projects I've done so it's good to find out I did it to a proper standard. A co-routine can also be stopped at any time but only by calling it's name, giving you even greater control on how it carries out.

Co-routine that fades and resets colour

UI Card Game Part 2

With the main menu sorted from last week, the next objective was actually adding cards to the game scene. Rather than layout every card individually and be limited to the space available, we were taught a clever way to set up the scene so that cards are generated upon playing the game. In order to do this I needed to add a background to the game scene, which is what would control the card position and generation for me. The component that allows me to preset the positions and spacing of the cards is a 'Grid Layout Group', which has cell sizing and spacing values. I needed to add a few cards initially and set the cell size to fit the card, then adjust the spacing to my liking. From there I set the starting position (top left), alignment (middle centre) and constraint count i.e. number of rows(4).

Components in the background object

Once the card layout was done I could clear all cards off the scene and start on the generating scripts. To start a card face is needed so we created a card model class that creates the variables, then a behaviour class which assigns them to the card. The next step was having a game controller that creates a grid list for cards to be generated into and then fills it. However this on it's own would put each matching pair together, so we need something to shuffle the cards around. We were provided with a complex method that made use of the generics we were taught two weeks ago by Richard. The method uses the 'RNGCryptoServiceProvider' class which is essentially a random number generator. From what I can gather, it uses this to generate a byte for a box position and then assign a card to that space. The finished product of this week is a game screen filled with shuffled cards.

Shuffled cards in game

Shuffling code

Street Scene Project & Brainstorm

All of the game design work in recent weeks has been building up to be put in a GDD, where somebody can look through it and get an idea of exactly what my game is and how it should look. That section has been finished now and in it's place I have a new project. This is to construct an interactive street scene that is created in 3DS Max, then has a game created around it in Unity. Straight away my idea was to make the western high street I had planned for my game design process. I had already put plenty of thought and planning into how everything would look, so adjusting it slightly into a more open street would be no trouble and I'd love to see how it turns out. My inspiration for the design is going to follow the town of Armadillo from Red Dead Redemption, therefore this is almost going to be the guide I try to recreate. I won't be making the buildings look identical and will have my own take on them, the town layout is simply my aim.

The town of Armadillo from Red Dead Redemption

As for the game aspect, I'd like to have a story based, walking simulator. As the entire point of the street scene is to make it look great, I'd much rather have the character explore the area and appreciate the scene rather than run around ignoring everything because they're too focused on a crazy objective of some form. I've planned out the story of a middle aged man who lost his wife and children along with his farm and home. With nothing left in the town he heads down the street towards the train station but along the way players will encounter glowing orbs of light. Upon walking into them, they will hear a voice recording where parts of the characters tragic backstory is revealed. The player needs to find every glowing light before they can head to the train station and leave town. The glowing light look that I'm aiming for is similar to the ones that appear in 'Everybody's gone to the Rapture'.

Lights from Everybody's Gone to the Rapture

Sound Design: NanoStudio and CGD Ident

In the final week of sound work we were shown the most complicated program yet, NanoStudio. This is the most industry standard program we've used so far and it's easy to see why with the amount of settings and editing options that can be used on it. First of all we set to just learning the layout and what different settings did, but then we were given the task of mixing a track. NanoStudio has a list of premade tracks to showoff what can be done, so I had to open one of them and then play around changing as much as I could without adjusting the actual notes being played. Fair to say I had plenty of options to toy with so spent the next 20 mins adjusting as much as I could. I recorded the changes I made using OBS and then overlaid the music to create a small video of the outcome.

After sorting all of that out, we were given an ident for the CGD course. An ident is essentially a tiny clip with sound used to represent (identify) a company/brand. An example would be BBC2 and the different clips of the number 2 they show in between shows. Another is whenever you load up a games console and get the tiny splash screen to begin with. Our new task was to take the video clip and change the sound to something new and different that we could make in any program we wanted. I chose to use Audacity and add in audio because it's easy to manipulate sound and get it just how you want it. In order to separate the video from the sound I had to use Adobe Audition and in order to put the two together required the use of Premier. When I finished the sound and wanted to add it to the video I was at home so used a website called wevideo which unfortunately added a watermark and advert at the end.

Original CGD Ident

 My Finished Ident

Dark Arts 2: Singletons and Entities

In the second of our dark arts sessions we were taught about the uses of singletons and entities in our coding. As I've already covered the singleton pattern in Java, it was simple recap when Richard talked about how to use it, however it was very useful to see the examples he gave of where in a game it could be used such as for UI managers. The singleton pattern is where you set something up that is only created once and called anytime it's ever needed. This stops multiple copies of the same object from being instantiated, lowering the amount of errors you could get and also keeping memory management tidier. The downsides are that it isn't thread safe and everything can access it, which is just as useful as it is a liability.

How to instantiate and keep an singleton

Virtual methods were the second subject Richard covered, which are methods a class can essentially inherit from, unless the method is overwritten. Essentially it allows you to write one class with a lot of methods in for a variety of objects that will use them, but be able to change it for each object if needs be. The base class is essentially the game entity with all other classes using it if they require the methods.

Example of two classes using a base class but one overriding the method

UI Card Game

Over the next 3 weeks I'm going to be taught how to use the UI system in Unity to it's full capabilities. The game is a simple copy of a card matching game where you flip the cards to try and find the pairs. This first week covered the basics of the new Unity canvas system and how to make a menu from it. The first step was to add the background for our menu that everything else will be laid on top of. I needed to play around with the anchoring to make sure the background covered the whole screen upon playing the game.

The next focus was adding buttons so the player can navigate from the main menu to the actual game.
Buttons in Unity 5 are far easier to use because they come with a preset OnClick() section. All I had to do in order to make a working button was create a script containing no more than:

public void LoadLevel(int _levelIndex)
    {
        Application.LoadLevel (_levelIndex);
    }

This is all that is needed to create a loading button. I checked the build settings so I new which scene had which number, then added the script and game number into the button script. When I started up the game and pressed play, it took me straight into the game scene. I then just needed to position the button using anchors again then add a title and I had finished the main menu.

Finished menu screen

Figure and Launchpad

In the sound session this week we also played with an app called Figure, which is available on the iPad. I would have added both tracks I created to the other sound post I made this week however I wanted to play around with them a bit more before putting them up. Figure is also a very easy tool to use in the sense that you can personally play around with and record 3 separate pieces and stick them together. You're limited to using drums, bass and synth but there are a lot of different types to choose from for these instruments. The app also allows you to set the rhythm, scale steps and range of both the bass and synth, whilst choosing which parts of the drum kit do what. There is also a tweaks section where you get to modify and distort sounds in case you wanted something slightly different from what you recorded.

The first track I recorded made use of the Studio drum-kit, 'Scream At Me' bass and the Coffee synth set. It was mostly the result of me playing with each instrument to see what I could get rather than planning out a tune and replicating it.



The second tune I created in Figure was much more structured than the first and had a far better beat to it in my opinion. This one used the Elektro drum-kit, Multipass bass and Unpredictalead synth.



The other app we were briefly shown was called Launchpad. We were only given a quick demonstration and rather than practice it in session we were told to try it out in our spare time. This app was possibly the most fun as it takes care of all the timing for you, not initiating the pad you press until the next bar starts. This makes it sound far more rounded than the music I could produce in Figure and far more detailed than Bosca Ceoil. All you have to do is tap the pad you want to play and the app will leave it going until you press it again, which makes it very easy to have an underlying beat whilst you focus on developing the track.

My first recording in Lauchpad used the 'House 2' pad set. I played around to see which pads I liked best and when I had a small plan in my head of which would work well together, I hit record and did what I could.


I then looked at what other sets were available and the 'Drum&Bass' set caught my eye. After exploring the pad I found a lot that I felt I could weave together to make something pretty decent. So I messed around finding good combinations then hit record and was pretty happy with with I had afterwards.

Sound Design: Bosca Ceoil

Having used Audacity last week to produce sound effects, today we moved onto something we can create music in. We were introduced to a program called Bosca Ceoil which is incredibly easy to learn but difficult to master. To make a song you simply choose your instrument from the wide selection, then click on the page to play a note. Each 'page' of notes is 8 beats so you set up your song in small chunks, with a massive choice of how each note sounds. Making a little tune is very easy but recreating 8-bit music proved much harder than I anticipated.

My first practice tune was simply adding more sound to each section as the song progressed. I tried a few different instruments to mix things up and try out a variety of sounds. In the end I used velohigh guitar, SiON drum-kit, chopper bass, Dis.guitar3- and voice o3-o5.


The second track was similar to the first in the way that more was added over time, but I dragged it out a little more and made more of a build up by having the start slower than later parts. This tune made use of the SiON drum-kit again, Polysynth pad and a special item called Digital 2.


The third and final track I produced was a more upbeat happy tune using a mix of the Aco piano, Midi drum-kit, clarinet and Dis.guitar3-.

Dark arts 1: Generics

This week we had the first of our ‘Dark Arts’ sessions with Richard Weeks. Richard is head of a company called Total Monkery that operates from Plymouth and we’ve been lucky enough for him to come in and teach us some industry standard programming methods. Having somebody who runs his own company and has experienced the games industry first hand come in to teach us is an excellent opportunity. While what I’ve learnt so far at University has been essential, Richard is going through ways to make Unity work in ways it normally wouldn’t, hence why these are called ‘Dark Arts’ sessions.

The first session covered generics. This allows us to make custom types for classes, methods and variables which has lots of uses. When used for a class, it allows the user to get the variables and constructors, meaning you can create objects in the generic class from another. When using a generic method, the type of object you want to pass in must be specified before the parameter, this way a single generic method can perform an operation on many varying data types. One example (shown below) is a method to create entities where a list of different entities can all be passed in. Dictionaries can use generics to form lists with a variety of different types by having a generic key with a corresponding value.

In an example we were shown, one method assigned class types and names, while the other passed in a large variety of different types of entities.This is something I could use in my game to make it less prone to errors and easier to work with as a whole.

Entity inheritance example

Brand New Game Idea

Following on from my demo session on Monday, the last person to go over my game was my module instructor. When he played through my game he started talking about an entirely different game concept to the one I'd planned and constructed. Rather than talking about my original idea of the western themed target based shooter, he brought up the idea of an anti-aircraft style shooter. My characters are locked in place so can't move, yet can still look around and shoot from those positions. He said this reminded him of an AA turret style and that idea would probably be far more interesting and immersive. Originally I was skeptical of this idea but the more I thought about it and went over it in my mind, the better it was sounding and I've now decided to take this concept forward as my new game.

The new idea revolves around each player being in command of a turret and trying to defend a generator from swarms of enemies. Player 1 will control a machine gun turret which fires very fast but doesn't do a huge amount of damage. Player 2 will control a cannon like turret which fires slower than player 1 but packs a much bigger punch with it's shots. Both players must defend the generator from oncoming waves of both ground infantry and air forces. Infantry will be easier to kill, therefore there will be a lot more of them rushing the player, whilst aircraft are far tougher and in fewer numbers. If the enemy destroys the generator it's game over.

AA gun appearance I want to recreate

For extra mechanics I thought about airdrops every now and again to buff the players or hinder the enemy in some way shape or form. These will float down from the sky and players must shoot them before they land in order to activate it. On top of these, players will level up based on how many enemies they've killed. Leveling up allows players to add extra weapons, increase their fire rate/damage and increase the generators strength for example. I will be going through the entire design process for this game shortly in order to come up with a more refined and complete plan.

Airdrop that players can receive 

I think this game concept will be more successful because it's far more immersive for players compared to my original idea. I liked the Western game but I could see how people could become bored very easily, especially since I made it quite slow and the need for precision is necessary. This new idea is much faster paced and has far more explosions, which everybody loves in games. I was sold by what little my instructor suggested and feel what I've built on top of this is nothing but an improvement.

Demo Results

So Monday marked the first presentation of our games for the development module so far. For the past 2 weeks or so I've been working on a variation of the Western themed shooter that I've been designing. The mechanic of target shooting has stayed the same however I've chosen to lock the player in place and situate both players next to each other. I made this change because if both players could see each other then I would need to spend a lot of time making character models and animations. Locking the players in place together meant I could have a nice looking game without the need to make character models.

In preparation for the game demo I made a google form with some questions on it to record peoples feedback for my game. I asked questions about everything I'd currently implemented such as the characters shooting ability, the targets and the dual wield power-up.

Character Shooting - Overall the feedback for the shooting was that to firing was too slow, even   though it was meant to represent a revolver, and that the aim sensitivity was far too high. Changing each of these is very simple and just involves adjusting a few variables in the inspector. Other feedback around the character was that UI elements were too small to notice.

Targets - The size of the targets was commended however many people said adding a variety of sizes worth different points would be a good idea, which is something I was planning to do. Moving targets was also something that was suggested that I'd planned to do meaning I'm along the right track in terms of targets for the game. The only suggestion I hadn't planned was to vary the spawn rate throughout the game. Either a random time generator or perhaps more spawning as time goes up to ramp up the pressure of hitting them.

Re-sized targets

Dual Wielding - A common comment about this idea is that the controls are confusing. I'd set it up so that LMB fires the right hand weapon, like in most games but then RMB fires the left gun when active. This was a bad move because it confused most people, even myself at times. A few comments suggested sticking to LMB alternating the shots rather than 2 separate buttons which I agree with. One person suggested adding tougher targets to make use of the extra fire power which I quite liked the idea of.

Enjoyed - People seemed to enjoy the whole concept of shooting targets in a shooting range style.

Disliked - The things that cropped up the most were the using alternate mouse buttons to fire, the sensitivity and the small UI messages.


Taking everything into account I have plenty to work on to make the game smoother and more enjoyable as a whole a few of which I've already started on. Refining the shooting is the feature because it is the main element of my game.

Re-sized UI text

Story and Production Line

With every plan and idea coming together, only one thing remains to do: develop a story. Now my game is designed to be a quick, arcade-like game so from the start I never really considered introducing a story to it. Saying that, I think there should be some form of context to what the players are doing somewhere in the game but not one that’s too in depth else it will slow down the fast pace of the game.

My short and quick concept is that each player is one of two brothers who are arguing about which one of them is the best shooter in the West. Eventually they decide to resolve the issue with a target shooting contest. At the end of the game, the player who did best is crowned the winner and that brother is the best shooter of the two.

Coming up with a short story didn’t take very long and adds a little bit extra to the game in terms of some context. Finishing that allowed me to go onto the final stage of the design process: the production line. This isn’t the same as in a factory where items are created, instead it’s a timeline of the projects design, showing when criteria were accomplished and when deadlines are approaching. My production line starts at the end of October, with the first marker being the creation of my specification, and ends approximately halfway through December when I’ll hand in my GDD containing all the details and plans of my game. Production lines are good for monitoring the progress of a project and assessing what areas may have needed more time put into them.

Production Line

Sound Design: Audacity

Our design module has now changed from arts and modelling to covering sound design for a few weeks, which is something I personally think makes or breaks a game. Having the correct sounds in a scene can turn it into a piece of art if used correctly, for example a sad moment in a game will have a much more profound affect on the user if sad music and sound is played. Equally, a strong intense moment of game play will profit from fast paced/heavy music to empower the player.

For our introductory session we were taught about Audacity which can generate it's own sounds, or let you record some, then go on to add effects and edit them. To practice the software I created a selection of spot sounds and loops that could be used for a variety of situations. I had a few ideas of what to do for certain sounds so tried my best to create them first, other spot sounds simply occurred from recording a noise and fiddling around with effects, with the result actually being quite pleasing.


The first of my spot sounds took an auto generated, constant beep, which I broke down into segments to give a phone dial up tone. It isn't hugely impressive but it was the first thing I tried and it could be used for a phone call if ever needed.



The second sound was the result of me hitting my desk and playing around with a few settings. I found one called 'Paulstretch' which stretches out and echoes sounds to an almost eerie standard. The result of this made the slam on the table sound very distant, almost like a rock or object being kicked or dropped in a cave or dungeon.



Using the same 'Paulstretch' effect I recorded myself moaning and applied the effect to make a creepy distant groan. This reminded me of RPG games in dungeons with ambient creature noises and so I entitled the sound 'Ghosts'.


I attempted one more spot sound with 'Paulstretch' as the effect really intrigued me but I needed to have some variety in what I was making. I flicked a glass to make a high pitched ringing sound, then applied the affect and listened to the result. To me the sound is like a discovery noise for something dark or sinister such as a cave entrance or a dangerous scene.



Moving on to different sounds, I wanted to make a very simple light pick-up noise. I auto generated two pings of different pitches and attached them to roll from one into the other. The result sounded like an 80's style coin collection noise.



My final 2 spot sounds were very spacey/futuristic to me in the way that they sound like laser/teleportation noises.While different to each other I believe they could be used for teleport noises or at the very least, lasers.



For the loops, I had to create something that could replay nicely without people knowing when it had restarted. Unfortunately I can't make them loop from the links, but listening to them on SoundCloud allows you to loop it on there. I chose more generic sounds that would be played continuously in game or during a scene, as these are where loops come into play the most.

My first loop was a crackling fire which was actually just light rustling of a plastic bag. I didn't want the crackling to be too loud otherwise the affect would be unrealistic, so didn't normalise the track unlike with others where I needed the sounds louder.



Following on from fire I wanted to do another ambient sound, so decided to attempt a soft rustling wind. I simply blew past my mic for this one and then normalised it so it was easily audible and I think in a scene where the noise is just in the background it could be quite effective.



My final sound was an attempt at crunching leaves underfoot, which involved crumpling a piece of paper. In a loop the clip sounds quite good, however on it's own it isn't so effective, therefore it would sound much nicer in game than here on it's own.

Xbox Controllers

For my game I need to have different types of input so that two people can play the game at the same time. Obviously for a PC game I’m going to use the mouse and keyboard for one player, then for the other I’m going with an Xbox controller as it’s set up to work well in Unity. Setting the input axes for the controller has been quite simple and I think it’ll be easy to implement the controls into my final game.

To start with I wanted to add movement and look inputs. I discovered that the input manager is already configured to move the player with the left stick which saved me one job, however the right stick look controls needed to be implemented. I needed to create 2 new inputs called Controller look X/Y which were set to the 4^th and 5^th axis respectively. Upon playing the game, right stick caused the player to look around, although the Y axis was inverted so I simply checked the box the reverse it.

Two custom inputs

The other things I wanted to play around with was adding the ability to sprint, crouch and jump from the controller. I decided that the controls I wanted were: pressing in left stick (8 on diagram) would sprint, A (0) would jump and B (1) would crouch. Each of these were surprisingly easy as all I needed to do was add an OR condition to my if statements that check the corresponding action can be performed. This solution means that the player can move with either the keyboard and mouse or controller, so for my actual game I’ll need to add a check at the very start of the movement script to assign each player a single input type rather than the ability to use both.

Xbox controls map for reference in Unity

Leap Controllers

Using the Leap motion controller was definitely a new experience for me. It works by using infrared cameras and registering what objects appear in the way, rendering them into game objects. I personally don’t think I’ll be using them in my game but it was a fun experience and I had a few ideas about what they could be used for nonetheless. We were provided with a Unity project containing lots of different scenes that showed off the Leap’s uses and we were told to have a play around, getting use to this new tool.

The first scene simply showed the users hands and responded to you doing different things like clenching your fist, wiggling your fingers and moving them around. This scene is only to show how the Leap controller registers you, so doesn’t have much to do in it.

Simple hands scene

The next scene allowed me to interact with an object, in this case a flower. The flower grows in the centre of the screen allowing you to pick it and hold it. From there you can move it around to look at it and even pull off petals one at a time. This could be a little fiddly at times and the Leap can be a little temperamental, especially if something is covered from below so the Leap can’t see it entirely. However this was a nice little scene to show some basic interaction.

Scene showing how delicate the Leap can be

My favourite scene was where you had 6 little cubes that you could gently pick up and stack upon one another. Again the Leap could have slight problems of freaking out making it very difficult to stack all of the cubes, but as long as your hand wasn’t too near the tower you would be alright. This example of the ability to move objects around and place them down could be very useful in a two player platform game of some form. 

Tower stacking scene

The final scene was very enjoyable and contained a room full of boxes which the user can scoop up and throw about at will. This is more of an example of mass movement/control over a situation using the Leap. It was quite fun and relaxing to spend a minute or two throwing boxes around and watching them bounce off the walls for a while.

Messy block scene

Tutorial and UI Flow

At this point in the design process we have our game mechanics pretty much figured out and everything is falling into place. The next step is figuring out what goes on outside of the main game, by which I mean we need to plan out the menu system the players will interact with. Having an amazing game is one thing, but if the player struggles to get into it then the experience of the game will be damaged.

Upon starting the game, the player will be shown the splash screen and then taken to the main menu screen. Here they’ll have 3 buttons they can press: play game, options and quit game. Clicking play game will first play the optional tutorial video, then take the players into the game. Upon finishing, the win screen is displayed and players can choose whether or not to go again. If they press yes the game restarts else, if no, both players are returned to the main menu.

The options menu gives players a choice of another 3 buttons: audio, video and controls. The audio option allows players to adjust the overall volume and the SFX volume. Video lets players adjust the brightness and resolution to suit their needs. Finally, controls can be configured to meet the players needs/preferences.

Quit game brings up a yes or no option. Clicking yes exits the application, no returns them to the main menu. 

UI flow diagram

Something I was debating about whether to add to the menu or not was a tutorial. I was considering a small section where players could read up about what to do and how everything plays out, but felt something visual was more interesting. My new plan was to play a small ‘cut scene’ at the beginning of the game for players to watch and learn from. Both players can opt to skip it if they already know what they’re doing because being forced to watch a tutorial you already know is very boring.

It starts off with the main camera panning around the town then zooming in on targets and explaining the controls and to shoot as many targets as possible in the time remaining. The camera then pans over to the power ups and briefly explains each one before cutting the screen to black and starting the game.

3D Materials

For design work this week we focused on improving texturing and the appearance of objects when they are imported from 3DS Max into Unity. Setting a block of colour to an object gives it a very unrealistic appearance so effects can be used to make them look much nicer. In real life, objects like walls are slightly bumpy and never completely smooth, therefore adding a single sheet of colour will make it look strange. This can be helped by adding a layer of noise, which will create a form of static and make the wall look slightly bumpy, giving it an overall more realistic feel.

To practice to texturing we did last week, we were tasked with creating a cube and adding a different texture to each side. The six different textures were: brick, gravel, window, carpet, clean wall and dirty wall.

Carpet, clean wall and dirty wall

Gravel, brick and window

We then went into Unity and learnt about editing materials to change their appearance and tailor them to specific objects. The two settings we focused on were metallic and smoothness. The metallic setting determines how light is reflected off the object; the higher the setting, the more reflective the object is and the less colour is visible. Smoothness increases the objects micro surface detail and makes things look more or less glossy. For example, a wooden or stone object will have very little, if any, of either of these settings. Whilst a plastic or metal object will have larger values of each.

Stone(left), plastic(centre) and metal(right) materials

The final thing we were taught was that when an object from 3DS Max is imported into Unity, it's textures can be edited to change the materials appearance. This is very useful when you import an object and want to make the separate components look like different materials. To practice this I created a table in 3DS Max and imported it, then changed the settings to make the legs look metallic and the actual table top look like varnished wood with a plastic edging.

Render in 3DS Max

Changed materials in Unity

Fading Bullet holes

When I was playing around with the bullet holes, something I definitely wanted to do was cause them to fade out over time rather than just disappear immediately. The effect is slow and subtle so won't pull people out of the immersion of the game unlike constantly destroying the texture instantly would. After a bit I research I discovered that textures have an alpha setting along with the RGB settings. Alpha is the transparency of the texture, so in order to get my bullet hole texture to fade I needed to adjust the alpha setting over time. The way I thought of doing this was to use the interpolation mechanic I'd been taught the other week, to slowly adjust the setting from max to 0 over the course of three seconds.

Fading alpha interpolation code

After figuring all of this out and getting it to work I added it to my prototype scene to show it off.

Bullet hole partially faded

Pendulums and More Shooting

Continuing on from last weeks work about shooting, we added a few modifications to the scene. The first addition was adding a cross hair so the player could see where they were going to hit when firing. Using the new Unity 5 UI system makes adding text and images to the UI incredibly easy. Rather than having to code the entire object in a script, you can add a canvas to the scene and place an object upon that canvas. For images just move it into the position you want and for text items, do the same them add the text in and even stylise it if needs be. So I placed the cross hair image dead center of the screen, adjusting my bullet spawner to fire at the same point upon clicking.

Cross hair in scene used to destroy block

The second thing added to my shooter this week was a bullet hole upon impact. In order to do this I had to use Ray Casts for the game to judge on whether an object would be hit upon firing. If this is found to be true then a bullet hole will be instantiated at the point of impact giving a more realistic affect to the scenery. To stop graphical glitches, the bullet hole is not applied directly onto the object it hits, but set as a quad 0.01 units in front of the collision point. This stops the created bullet hole and target object from fighting for the same world space and flickering when looked at by the player.

Bullet hole created by bullet collision

When this was all implemented however, I very quickly found that the holes stacked upon one another. On top of this, since they were just placed where there was a collision, if the object the bullet hits gets moved then the bullet hole is left floating in space. To solve the first problem I needed to destroy the bullet holes after a little while to stop them from filling up space, so created a script which waited for 3 seconds after being created, before destroying it. To stop floating holes I had to set the object getting hit as a parent of the bullet hole. This means wherever the object hit goes, the bullet hole will go with it.

Code to create bullet hole and set object collided with as parent

After we finished with the new shooting mechanics, we moved onto something new: pendulums. Making a pendulum was surprisingly quick and easy, since all you need to add to an object is a Rigidbody and a hinge joint. When applying the hinge joint you add the object that will be the connected body and that causes the two objects to act as a hinge. Adding multiple objects in a row and hinging each to the previous one creates a chain that we added a sphere to the end of. After creating a wrecking ball it only made sense to add a wall to knock down with it, which is exactly what I did.

Pendulums swinging to destroy wall