Instantiate Unity

Handling Music and Sound Effects In Your Games

2014-03-12T11:11:00.002-05:00

Initiative

While developing Treva's Adventure I had to figure out a way to handle multiple music tracks and sound effects in a clean manner or suffer horribly. What was going to help me achieve a simple solution was taking all the different sounds and centralizing them in a single class in order to black box them. Any other code trying to play a sound wouldn't even know the sound file's name. All code trying to play a music track would reference a enum that defines all the track names.

Defining The Class

Creating The Enum

When I first started defining types in my enumeration, I was naming the types to be exactly like the file name. For a scary sound effect I had found a file named "ghost breath". So around my code would be scattered lines like SoundManager.Play(SoundEffectType.GhostBreath); This was fine until I found a sound that better fit the situation it was being used in, and decided to use "ghost breath" for a different situation like a enemy screeching. To incorporate the new sound effect required going through every place SoundEffectType.GhostBreath is referenced and change it. The moral of the story is make enum type names ambiguous to the files name. Name the sound effect as being in the situation your planning to use it in. So instead of SoundEffectType.GhostBreath, I would instead call SoundEffectType.SpookPlayer. So advantages are:

If you wanted to change the SpookPlayer sound effect, you would go into the SoundManager class and have it reference a different file, Instead of sifting through thousands of lines of code trying to find the 6 places you said GhostBreath.
Other programmers coming behind you coding will have a better idea of what your trying to achieve when you say SpookPlayer instead of GhostBreath.

Static

Music and sound effects are present through out the game. They are present in your GUI when the player clicks a button. Casting a fire ball needs to be heard so the player feels the significance of what they just did. Without background music the game just feels empty. In conclusion It's not a bad idea to create your SoundManager class and it's methods as static. I originally attempted using a singleton method, but typing SoundManager.GetInstance().Play(SoundEffect.GhostBreath) got very old very quickly with as frequent I was calling it.

Methods

Now that all your sound effects are black boxed behind one class, you can easily adjust the volume for ALL sound effects ever played by calling just one method. Have methods such as SetSound(), GetSound(), and Mute(), Pause() (might not be suited for sound effects), as well as Play().

Two Classes (At least)

This is only a suggestion. I've found it easier to break up music tracks and and sound effects into two different classes for a few reasons. Sound Effects don't really need a pause button like a music track does. When you pause the music, you don't want it interfering with button clicking sounds. Yes, you could create separate methods like playSoundEffect() and playSoundTrack(). Then you can create separate methods for each like getSoundEffectVolume() getSoundTrackVolume(), and this way works. All that starts to happen is your AudioManager Class becomes pretty clustered with many methods with similar names and the eye strains begin. So my suggestion is to create a AudioManager abstract class, and create your classes extending from that. Some example classes would be MusicManager, GUISoundManager, SoundEffectManager, and 3DSoundEffectManager.

Some tips in Unity

Storing and Loading Sounds

Keep them under a folder named "Resources/Audio". Unity has a Resources class that you can load data from any folder named Resources so you can load a file with just Resources.Load(). Depending on what your using the sound for, you need to change how the sound is imported. If the audio is small and is being used for something like a button click, then you should have the file Decompress on Load. If the file is a music track then you should have the load type to steam from disk. You can read more here.

Sound Effects In Scene (3D vs 2D)

Unity imports sounds as either 3D or 2D. 3D sounds are positioned in the scene and if the camera(or wherever the audio listener is) is not near the Audio Source when it's playing, then is won't pick up on it, which is not optimal in some cases. When calling Play() on a 3d sound, your going to need a second parameter that will take into account for position in the scene. Another thought to ponder when writing these Audio Managing classes is whether or not you want to be able to be playing multiple sound effects if you want. Usually with things like GUI sound effects, it's not needed to play multiple sounds at once. Though with 3D sounds, your probably going to need multiple sounds playing at once, thus multiple AudioSources. The sample code at the end of the post allows for as many audio sources at once, but does not delete the audio sources after the code is done playing. If your using my code, I suggest creating a script that you call to self destruct after the audio is done playing.

Don't Destroy On Load

In games I usually hear music tracks constantly being played. In boss fights to loading screens your constantly hearing music, and never two tracks at once. Unity has a method that allows GameObjects to not be deleted when you load different scenes. So by using that you only have to instantiate the AudioSource once.

    static GameObject soundObjectInstance = null;   
    static AudioSource GetAudioSource(){   
       //if it's null, build the object   
       if(soundObjectInstance == null){
         soundObjectInstance = new GameObject("Music Track Audio");   
         soundObjectInstance.AddComponent<AudioSource>();
         DontDestroyOnLoad(soundObjectInstance);
       }   
       return soundObjectInstance.GetComponent<AudioSource>();   
    }

Sample Code..

So here is some of the code I wrote for the game some 6 months ago. With your own experience and after reading this post you can easily improve it. Feel free to use it as you please. Any questions or suggestions are always welcomed.

 using UnityEngine;  
 using System.Collections;  
 public enum SoundEffectTypes{  
      OnButtonUp,  
      NotificationPopUp,  
      NotificationClose,  
      SpellCast,  
      BoulderExplosion,  
      Screech,  
      Hit  
 }  
 public static class SoundEffects  {  
      public static void Play(SoundEffectTypes effectToPlay){  
           GetAudioSource().clip = GetSoundEffect(effectToPlay);  
           GetAudioSource().Play();  
      }  
      public static GameObject PlayInWorld(SoundEffectTypes effectToPlay, Vector3 positionToPlayAt){  
           soundObjectInstance = new GameObject("Sound Effect Object");  
           soundObjectInstance.transform.position = positionToPlayAt;  
           soundObjectInstance.AddComponent<AudioSource>();  
           soundObjectInstance.GetComponent<AudioSource>().clip = GetSoundEffect(effectToPlay);  
           soundObjectInstance.GetComponent<AudioSource>().Play();  
           soundObjectInstance.GetComponent<AudioSource>().loop = false;  
           soundObjectInstance.GetComponent<AudioSource>().priority = 1;  
           return soundObjectInstance;  
      }  
      static GameObject soundObjectInstance = null;  
      static AudioSource GetAudioSource(){  
           //if it's null, build the object  
           if(soundObjectInstance == null){  
                soundObjectInstance = new GameObject("Sound Effect Object");  
                soundObjectInstance.AddComponent<AudioSource>();  
           }  
           return soundObjectInstance.GetComponent<AudioSource>();  
      }  
      public static void SetVolume(float newVolume){  
           GetAudioSource().volume = newVolume;  
      }  
      public static float GetCurrentVolume(){  
           return GetAudioSource().volume;  
      }  
      static AudioClip GetSoundEffect(SoundEffectTypes effectToPlay){  
           switch(effectToPlay){  
                case SoundEffectTypes.OnButtonUp:  
                     return Resources.Load("MusicAndFx/ButtonUp") as AudioClip;  
                break;  
                case SoundEffectTypes.NotificationPopUp:  
                     return Resources.Load("MusicAndFx/NotificationPopUp") as AudioClip;  
                break;  
                case SoundEffectTypes.SpellCast:  
                     return Resources.Load("MusicAndFx/spellCasting") as AudioClip;  
                break;  
                case SoundEffectTypes.BoulderExplosion:  
                     return Resources.Load("MusicAndFx/BoulderHit") as AudioClip;  
                break;  
                case SoundEffectTypes.Screech:  
                     return Resources.Load("MusicAndFx/ghostbreath") as AudioClip;  
                break;  
                case SoundEffectTypes.Hit:  
                     return Resources.Load("MusicAndFx/hit24") as AudioClip;  
                break;  
           }  
           return null;  
      }  
 }

Clean up in GIMP

2013-06-02T19:11:00.000-05:00

Some of you may think, "Dang, that's a clean looking tree." And in fact, like this, it looks pretty clean. And some of you if you drew a tree like this would sign it off as done and ready for some game action. However, if you take a closer look (About 200%)

Oh wait, those colors are still inside the lines! I guess it really is read-

WAIT. LOOK CLOSER. (In other words, add a black background)

Filthy, filthy tree. Tree is not ready for the game. So, now that you can see where all your little pesky errors are, you can whip that tree into shape

Which means you need your handy dandy eraser.

HOWEVER!

Before we start erasing, we are first going to select the black outline and copy it, and for those who don't know how to do so, this is how:

That is your magic wand, you want to select it.

Then you click on the black outline (note: this is for if your outline and and colors are on the same layer, if they are not (e.g. your outline is on one layer) then you go to that layer, hit CTRL + A to select, then CTRL + C to copy, and then CTRL + A to deselect.)

After you have the outline selected, hit CTRL + C to copy and then CTRL+ A to deselect.

Turn the black back on so that it is easier to see the mistakes while you erase.

Bam! Cleanliness. Now you can turn off the black layer or delete it all together. Once you do that, you are left with...

Ugh, those lines. Chances are that you erased some of your lines while you were trying to clean up what was outside of them. But fret not, for you copied your line art!

Simply hit CTRL + V

(If you had to use the magic wand tool, you may have to realign the lines a bit, but nothing too difficult.)

Hit that little anchor button to anchor the layer to the layer you were pasting to.

And NOW your pretty little tree is ready for your game. However, how do you keep a transparent background is something you may ask. There are two options to really choose from. Either a .PSD file type (Photoshop image) or a .PNG, both which save your image with a transparent background. I am going to save it as a .PNG because the file is smaller. When you save it as a .PNG, however, do not rush to just hit the 'export' and 'save' button. Take a look.

You're going to want to make sure that the bubble saying 'Merge Visible Layers' is marked rather than 'Flatten Image'. Flattening the image will give it a background, which is the opposite of what you (may) want.

The next window will look like this:

Make sure that the 'Save background color' box isn't checked. Once you have that done, go ahead and click that save button, you now have a proper, clean transparent image ready for your game!

By the way, be sure to check out our game at IndieDB and look at our dirty, dirty assets that I need to go back and clean up.

Creating 2D Animation For A Side Scroller In Unity3D

2013-04-22T23:23:00.000-05:00

Update 3-13-14
Unity kinda released some really nice 2D tools, I really don't know how relevant or helpful this is now.

I've been working on a 2D side scroller. Being my cheap self I'm not going to bother buying some helpful tool that would probably speed up everything a substantial amount, and created my own method of 2D animation for things in Unity3D. This code does not work with a sprite sheet, but I hope it makes it easy enough for you to incorporate one if you wanted to.

Warnings:
The animation is displayed by updating the meshes material's texture each frame (this can mess up at high frame speeds).
This code is assuming the 2D sprites are moving along the X and Y axis.
When changing directions, it is scaling the transform negatively across it's x axis.
Its assuming default direction facing is right.

 using UnityEngine;  
 using System.Collections;  
   
 public enum Directions{left,right}  
 public class FlatCharacterAnimation : MonoBehaviour {  
        
      public FlatAnimation[] animations;  
        
      public string defaultAnimation;  
        
        
      FlatAnimation currentAnimationPlaying;  
        
      string animationCurrentlyPlaying = "";  
      Texture2D[] framesToPlay;  
      float frameSpeed;  
      int currentFrame = 0;  
      Directions directionCharactersFacing = Directions.right;  
      bool animationIsPlaying;  
        
      #region FlatAnimationClass  
      [System.Serializable]  
      public class FlatAnimation{  
           public string name ="";       
           public Texture2D[] frames;  
           public float frameSpeed;  
             
           public Texture2D[] GetFrames(){  
                return frames;  
           }  
        
             
      }  
      #endregion  
        
      public Directions GetDirectionFacing(){  
           return directionCharactersFacing;       
      }  
        
        
      public void Play(string animation){  
           if(animation != animationCurrentlyPlaying){  
                ChangeAnimation(GetAnimation(animation));  
                animationIsPlaying = true;  
           }  
      }  
        
      public void Play(string animation, Directions direction){  
           if(animation != animationCurrentlyPlaying){  
                ChangeAnimation(GetAnimation(animation));  
                animationIsPlaying = true;  
           }  
             
           if(direction != directionCharactersFacing)               //make sure players facing right direction, if not, changes direction  
                ChangeDirectionPlayersFacing(direction);  
      }  
        
      FlatAnimation GetAnimation(string animationName){  
           for(int i = 0; i < animations.Length; i++){  
                  
                if(animations[i].name == animationName){  
                     return animations[i];  
                }   
           }  
           Debug.LogWarning("The animation you are trying to play does not exist! Try checking spelling and capitalization");  
   
           return null;  
      }  
        
   
        
      void ChangeAnimation(FlatAnimation newAnimation){  
           animationCurrentlyPlaying = newAnimation.name;  
           framesToPlay = newAnimation.frames;  
           frameSpeed = newAnimation.frameSpeed;  
           currentFrame = 0;  
      }  
        
      void ChangeDirectionPlayersFacing(Directions direction){  
           Vector3 scale;  
           directionCharactersFacing = direction;  
           switch(direction){  
                case Directions.left:  
                     //Debug.Log("Left Direction");  
                     scale = gameObject.transform.localScale;  
                     scale.x *= -1;  
                     gameObject.transform.localScale = scale;  
                break;  
                  
                case Directions.right:  
                     //Debug.Log("Left Direction");  
                     scale = gameObject.transform.localScale;  
                     scale.x *= -1;  
                     gameObject.transform.localScale = scale;  
                break;  
                  
           }  
      }  
        
      float nextFrameTime;  
      void UpdateAnimation(){  
             
           if(nextFrameTime < Time.time &&framesToPlay != null){  
                //Debug.Log ("current frame: " + currentFrame + "currentAnimationFrames Legth: "+currentAnimationFrames.Length);  
                nextFrameTime = frameSpeed+Time.time;  
                if(currentFrame == framesToPlay.Length-1){  
                     currentFrame = 0;  
                } else if(currentFrame < framesToPlay.Length){  
                     currentFrame += 1;  
                }  
                gameObject.GetComponent<MeshRenderer>().material.mainTexture = framesToPlay[currentFrame];  
                  
           }  
      }  
        
      // Use this for initialization  
      void Start () {  
        
      }  
        
      // Update is called once per frame  
      void Update () {  
           if (animationIsPlaying){  
                UpdateAnimation();       
           }  
      }  
 }

Setting this up:

Its more than just dragging and dropping the script, but it doesn't take much time. To begin, in case any of you still have graphics and code on the same Game Object, stop it, please. To create your graphics object for this, you can do it three ways.

Create a Primitive Cube. Use this method if your shader for the material is going to ignore light. Scale one of the axis to 0. Reasons for creating a cube over a plane is that a cube has fewer faces than the default plane for some reason in unity. The shader you would use for this on the material would be Unlit>Transparent.
Create a Primitive Plane. Use this method if your material will not ignore light. This method will have more faces, but in most cases it will not be considered to serious. Make sure the y axis stays 1. The shader you would use on the material for this option would be Transparent/Cutout/YourOption
Create Your Own Object To Render It. Takes time, more faces than a cube usually, but can be less faces that a plane.

If your developing for a mobile device, consider using option 1. Not so much for the poly count, but for the shader. Unlit shaders take less power to process.

In my example I'm going to be using option 2, and these are the steps.

Create an Empty Game Object (Cntrl+Shift+N), and rename Enemy
Create a Primitive Plane and parent it to Enemy. Rename Plane to graphics.
Set rotations on plane to (90, 180, 0),
Add Flat Character Animation (Script Above) to graphics object.
Re-size Animations Size to however animations you need.
For each animation, set the name(IMPORTANT), frames, and Frame Speed.

Frame speed works in reverse to frame rate, don't get these confused. If you want the frame rate to be 30 seconds, set the frame speed to .033 (1/30).

Frames are the individual pictures you want to play in sequence for the animation.

To play the animation, grab the instance of the flat character animation, and call either Play(string nameOfAnimation); or Player(string nameOfAnimation, Directions, directionToFace);

Example of the Inspector

Example of the Object in the scene

Check out the game this code was made for!

2D Level Visual (De)compisition and Preparing for a 2D Game

2013-03-18T10:59:00.000-05:00

Alrighty you guys, I haven't been on in a while, as you can see with the massive delay between the Making Images in GIMP Part 2 and the to-be Making Images in GIMP Part 3, school has been piling on the projects and I can only work the video games during the slim slots of free time I have, so in order to keep from going completely off the map with blog posts, this will be a tipper in the composition of 2D game levels.

In the game we are currently working on right now, we have to focus on keeping a consistent style of a Kirby-esque side-scroller. Doing something like this has its ups and downs, such as the nostalgia that comes from playing a straight-on game side scroller where the objective is clear while the game itself has some difficulties. Arranging the actual environment, however, is quite the stress-inducer, and requires you to become organized if you aren't already, otherwise you won't be able to get through it without ~~some~~ a hella ton of tears. So get the folders ready, the will power revving, and the wrist exercised, because this is going to tax the hell out of your artist.

First off, get organized. Don't just set up folders though, set objectives for yourself, create some lists and stick to them. As tempting as it is to do the easiest stuff first, in the long run it's better to do the most important - though maybe more difficult- assets first. This will typically be the environment (i.e. ground, background, transition, obscurities, etc.)

Mmm, look at that sweet, sweet, organization. Keeping everything clean will make things easier for you and everyone you are collaborating with.

Second thing, get yourself physically ready. You need to be able to sit down and get things done. Eat a snack, drink a drink, take a piss, and DO SOME STRETCHES. Stretch your back, touch your toes, prepare your wrists. I mean, I'm not going to lie, it's going to get pretty boring, drawing everything, cleaning everything, making sure what needs to loop actually loops properly. I mean, I have three different sets of trees, you just have to push yourself and remember that the ultimate outcome will actually look good. You are going to want to cry and go to bed to the sweet sound of apathy. But do you know what you have to do?

The actual working part is probably the worst part. Through out it, you may find that somethings looks really good as individuals, but looks terrible all together, or vice versa, the best thing to remember is that things can be changed. I've gone back and revised a lot of things, it's just a part of the process. You have to keep in mind, a lot of things will come in sets. Such as the trees, in order to keep things from looking too consistent, it's important to have a variety of scenery so that the player doesn't get bored. Something just as important as variety though, is the way you layer things. The game is 2D, but you still want to give it depth. This is where staying organized (see step one) is important. More than just foreground and background, you want something that gives the game more than just minimal depth. This is where singular trees, rocks, fungi, etc. comes in. The way that these obscurities layer on top of each other as well as inside the actual game gives extra pizzazz to the environment. This gives the player the idea that you actually understand how perspective works if you size everything correctly (things get smaller as they go back, bigger as they come forward). The best mindset to have probably is to not expect everything come out right the first time, and therefor not be daunted by mistakes.

Here's an example of what the scene looks like prior and during rendering of game play. It's all about the layers and will power. Things will come together in the end, you just have to believe in your capabilities.

A Few Pointers On Switching From JavaScript To C#

2013-01-18T16:40:00.003-06:00

One does not simply add to an array.

In JavaScript you might have familiarity with using arrays.
You might also be familiar with "adding" to arrays.
Well Unity sugarcoated that for you.
Arrays are not really re-sizable.
When you declare an array in c#, you have to define it right there.

If your looking for something similar to re-sizable arrays, use lists.
To use Lists in Unity c#, you must add the line
"using System.Collections.Generic;" At the top of your code.

Declaring a list of Game Objects would go something like this
List<GameObject> myGameObjectList = new List<GameObject>();

Then adding to the list would is as simple as
myGameObjectList.Add(gameObjectInstance);

Then if you really just want an array you would say something like
GameObject[] gameObjectArray = myGameObjectList.ToArray();

The API is not what it always seems.

Unity has also sugar coated some of its API, some parts to the point where its practically lying to you in the provided documentation. I learned this the hard way in a short game I did in JavaScript a while back, I had blood splats come up on the screen, and then fade away. To have a fade property, I had the blood splats change their GUI alpha value gradually to 0.

Sometimes when you think your going crazy, simply go to Google.

Everything is a class

In the begging of your coding experience, you were probably not familiar with classes. In fact in "real" JavaScript you can not simply declare a class. Unity had made it though, so that you can declare a class in a similar way compared to the rest of it's syntax.

So now in c#, when you create a c# script in Unity and open it in MonoDevelop(or what ever editor your using), you will see now at the top you have something like:
public class ScriptName : MonoBehaviour {}

***Make sure you script name matches your class name!!!!***

Example, if you have created a file in Unity named Example.cs, in your code you must have
public class Example: MonoBehaviour {}
If you do not do this your compiler will throw you back an error.

Declaring Methods and Returning Variables

Like in all Object oriented languages declaring methods follow the same flow in syntax. In JavaScript, declaring methods is simply typing function(){}. C# follows the same flow except you use VOID instead of function.

But this is not always the case in C#! In Javascript, methods labeled function could return variables. In order for a method in C# to return variables, two things must occur

1) Void must be replaced with the type of variable you want to return.

2) The method must be declared public for other classes to call it!

You can not anymore say:

void GetPlayersHealth(){

return Health;

}

You need to now say:

public int GetPlayersHealth(){

return Health;

}

Declaring variables for Inspector View

With JavaScript all variables declared at the top of the script, unless declared as private, where shown in the inspector view in Unity as variables to manipulate. For C# you need to declare the variable as public or it will not show up in the Inspector pane in Unity's Editor.

Getting Instances of Other Scripts and Components

Let's say you want to get an instance of the players behavior in order to add damage to it. To get it as a variable in the code your currently working on, you now must use the needed class name as the variable type. Getting components is also different, as in the way you call it. In JavaScript it might look like this

var playerBehavoirInst = GameObject.Find("Player").GetComponent(PlayerBehavior);

Now in C#, its change to

PlayerBehavior playerBehaviorInst = GameObject.Find("Player").GetComponent<PlayerBehavior>();

Notice the get Component and how it's called.

Making Multiple Instances of Windows With Same Window Method

2013-01-16T23:22:00.003-06:00

So when developing a small little web-player, I ran into the problem of trying to render multiple instances of the same window function.

My plan was for my user interface component to iterate through all the thought components and for each thought, render its contents in a new window. The windows need to be draggable also.

My first attempt of this implementation failed.

  Rect thoughtRect = new Rect(20, 20, 200, 100);
  void OnGUI(){
    for (int i = 0; i < allthoughts.Length; i++){
      thoughtRect = GUI.Window(0+i, thoughtRect, DoThoughtWindow, ""+allthoughts[i].GetContent());
    }
  }
  
  
    void DoThoughtWindow(int windowID) {
        
        GUI.DragWindow(new Rect(0, 0, 10000, 10000));
    }

For those who don't see the problem with this, I'll explain.

All three windows are using the same Rect thoughtRect so all the windows are drawn on top of eachother. You might think this won't pose a problem due to the windows being draggable, you can just move one away from the other, but this is Unity's GUI class, it's not fun. The GUI.DragWindow adjusts the thoughtRect, which in turn moves all 3 windows at once, still keeping them on top of each other.

So on my second attempt of implementing my feature, I got it thankfully. I probably coded my program differently from what others would, but I hope at-least it might give you an idea to fix a problem now or in the future.

In my thought class, I made a variable "Rect positionOnScreen", which keeps up of that thoughts position. I've also added two new methods in the thought class.

One, GetPosition(), returns a Rect, the positionOnScreen;

The other SetPosition(), is called to set the new Rect in the Though class's positionOnScreen.

When it gets to a certain thought in the for statement, it sets that certain thought to the currentThought. The point in this is so the DoThoughtWindow method has something to reference when its rendering it's contents. ***Notice currentThought = allthoughts[i]; is called BEFORE the DoThoughtWindow() is***

     Thought currentThought;  
     void OnGUI(){  
         for (int i = 0; i < allthoughts.Length; i++){  
             currentThought = allthoughts[i];  
             currentThought.SetPosition(GUI.Window(0+i, currentThought.GetPosition(), DoThoughtWindow, ""+currentThought.GetTitle()));  
         }  
     }  
       
       
   void DoThoughtWindow(int windowID) {  
     if (GUI.Button(new Rect(currentThought.GetPosition().width-120, currentThought.GetPosition().height-30, 100, 20), "Edit")){  
       Debug.Log ("We need to edit this");  
     }  
       
         GUI.Box(new Rect(10,25 ,currentThought.GetPosition().width - 20,currentThought.GetPosition().height-65),"");  
           
     GUI.DragWindow(new Rect(0, 0, 10000, 10000));  
   }

My thought class so far in case you want to look at it yourself.

 using UnityEngine;  
 using System.Collections;  
 using System.Collections.Generic;  
   
 public class Thought : MonoBehaviour {  
       
     string thoughtTitle = "Thought";  
     public string thoughtContent = "Substance Goes Here";  
     List<GameObject> connectedThoughts = new List<GameObject>();  
     Rect positionOnScreen = new Rect(20, 20, 200, 200);  
       
       
     // Use this for initialization  
     void Start () {  
       
     }  
       
     // Update is called once per frame  
     void Update () {  
       
     }  
       
   public string GetContent(){  
         return thoughtContent;  
     }  
       
     public string GetTitle(){  
         return thoughtTitle;  
     }  
       
     public Rect GetPosition(){  
         return positionOnScreen;      
     }  
       
     public void SetPosition(Rect newPos){  
         positionOnScreen = newPos;  
     }  
       
   
 }

And a look at it being rendered.

Fixing Sketch Up blank window (white box) problem

2013-01-14T22:55:00.001-06:00

When downgrading my OS over Christmas, I was faced with many problems, one of which is getting my Google sketch-up working.

Almost everything was working perfectly, except one little thing, The 3D Warehouse.

It was just displaying a blank screen. At first I thought I had blocked permissions for giving it internet access. Though my computer said it was allowing it to go over the network. I tried turning off my firewall and still nothing happened. I don't have any anti-virus software so I didn't worry about that.

Guess what fixed it this annoying problem?

Updating INTERNET EXPLORER.
Just check for updates, and updates for what ever you computers default browser is also.

Now everything's back in harmony

Choose Binding Time Consciously, Awake and Start functions for Initialization

2013-01-03T22:04:00.004-06:00

So I ran into a simple but annoying problem when I was trying to hurry up and finish a game I have been working on for a while so I could move on to start a new idea. I was being stupid an hard coding the last features I wanted to include in the game, and of course came across a problem that I spent 30 minutes on that I could of easily avoided if I was thinking.

Here is how the problem began. I needed a way to keep up with all the Light projectors in my scene and figure out which ones are close to me. This sounded easy enough, but alas I managed to screw it up.

The code I wrote used an array that was set on the awake method using GameObject.FindGameObjectsWithTag("TagName"); In my scene, the player is already in my scene, and the lights are not. When my scene is played, a script called GameInit calls the city generator which in turn calls the multiple factories, one being the factory that generates all the lights in my game. Although it looks like when my scene starts up everything is instantiated at once and all called together, its not. The players awake is called long before the lights are created.

Not only initialization was the problem, but lights could be destroyed throughout game play, which would call for updating the array. In the end of the 30 minutes I went with continually updating the array with the update routine.

This brings up a concept in the book I've been reading that talks on the subject some of Choosing Binding Time Consciously. Whether its updating *shudder* global variables, or any other variables that are being constantly being changed for other scripts to pull from, be careful. Especially in initialization of your code.

Making Images in GIMP Part Two

2012-11-06T20:29:00.001-06:00

In the previous post about making images in GIMP, I went over the process of creating the composition and creating clean line art. In this next part I will explain the steps I go through in coloring my picture, including flats, foreground, background, extra detail, and lighting.

And let us continue!

The next thing I did after making the line art was add a new layer on screen mode and filled it with an orangish-brown color. This will tie the piece together in the end by giving all the colors a similar hue while they still pertain to their individuality. The opacity of the screen is about 52% so that it's not too overwhelming. Along with this I have brought down the line art layers to 80% opacity to give it a softer effect.

Here you can clearly tell the palette I have chosen for this piece, it's going to be filled with earthy tones. The flat colors for the foreground are fairly basic and cooperate with each other. Don't be afraid to take your time, make sure that it is cleaned up before continuing to the next layer of colors. To help make sure that I get everything clean, I often toggle the visibility of the white background on and off.

The background colors are done on a separate layer.

Here you can see an ant line going around the blue of the sky, this was selected by using the magic wand tool. This is because it'd be sort of boring for the sky to be just blue, so I'm going to use a gradation to give it more life.

Here you can see the tool I have selected along with the colors that I'm going to use for the sky, fading from purple to orange. For those of you who don't know how to use the gradation tool, to make the pattern vertical you pull a straight line from top to bottom. You can actually make the pattern go in any direction depending on where you drag the line. The intensity of each color will also vary depending on how long you make the line. As you can see, I made the line span across the whole image to make sure that the color is fairly evenly distributed.

Next I color in the building and water area white. This will make seeing where I need to color in easier and also using the magic wand tool it allows me to color messily without getting the color all over the picture.

I color in the water a sort of periwinkle color to give off the illusion of reflection of the sky onto the water.

Using the same method of coloring I used for the sky using the gradient tool, I use a yellowish and purplish color on a low opacity to color the water.

I reselect the sky because I've decided to amp up the saturation. Because of the placement of the colors on the spectrum (they're on opposite sides) the purple will fade to orange-red and then yellow, giving a more natural sunset feel..

In order to make sure the water conforms to this color change, I open the Adjust Color Balance window (colors> color balance) and add in some more orangish tones.

With the water still selected, I use the same gradient I used for the sky on the water so that it looks more like the sky is reflecting onto it.

This tutorial will be continued in Part three, but this concludes part two of constructing images in GIMP. If you'd like to see more notes on creating compositions, a nice tutorial is here.

How To Instantiate Along A Grid (Simple City Generator Method)

2012-10-21T21:03:00.001-05:00

A city created at run time that was instantiated along a grid.

The reason for this post is to allow people to understand how to make something like this easy and simple. The city is instantiated along a grid using the restraints of the length and width perimeters passed through into the generator. Tiles are incremented through a constant that defines the width/length of the tile square. Here's the code I've constructed for the current explanation :

var tileConstant:float = so and so number;

var tileObject:GameObject;


function BuildCity(desiredLength:int, desiredWidth:int){

 var length:int=1;

 var width:int=1;

while(length<=desiredLength){

Instantiate(tileObject, Vector3(width*tileConstant,0,length*tileConstant), Quaternion.identity);

//incrementing

if(length ==(desiredLength)&&width <desiredWidth){

length = 1;

width +=1;

}else{

length+=1;

}

}

This code it attached to an empty gameobject inside the scene!

So with this code now, we have a tile constant. Keep in mind the constant is assuming both the width and length of the tile are the same. When the function BuildCity is called and the parameters are passed in, the generator starts a while statement that starts with a length and width of 1. The while statement instantiates a tileObject and puts it in the right location. Location is determined by taking the current length and multiplying by the constant. Therefor if the tile constant was a 5, tile length of 1 would be created at 5, tile length of 2 created at 10, so on and so on. Incrementing from getting to one tile to the next deals with just two logical statements, the while statement and the if-else statement. In the method shown here, the while statement runs through all the tiles on the length side before jumping to the next incrementation of width, and begins creating all the tiles of length again. Since the method is set up so that it instantiates along the length first, the while statement runs until length is greater than desiredLength. Here is an example of what we have in the code.

The width = 4 and height = 3. The constant is 10. The tile object is Unity's plane mesh with a point light parented to it. The function is being called by the start function.

Now with the code we have now, we can have a grid of any dimensions we want created. Now what if we want to build a border around the city? The next step we're going to take is edge detection so we know when we're at the end of the grid. With this comes two method options for creating edges. My city generator created buildings on top of the tile as a border, but for the sake of simplicity of the blog post, we're just going to use a separate tile that has borders attached to it. Not only are we going to need border tiles, but corner tiles also. Here is the new code compensating for our needs:




var createCityOnStart:boolean = true;



var width:int;

var height:int;



enum KindOfTile{plain, leftBorder, rightBorder, topBorder, bottomBorder, topLeftCorner, topRightCorner, bottomLeftCorner, bottomRightCorner}



var tileConstant:float = 10;



var tileObject:GameObject;

var tileCornerObject:GameObject;

var tileEdgeObject:GameObject;



function Start () {

 if(createCityOnStart == true){

  BuildCity(height,width);

 }

}



function BuildCity(desiredLength:int, desiredWidth:int){



 var length:int=1;

 var width:int=1;

 var location;

  while(length<=desiredLength){

      

        location = Vector3(width*tileConstant,0,length*tileConstant);

      

  //getting edges

  if(length == 1 &&width == 1){//bottomleftCorner

   BuildBase(KindOfTile.bottomLeftCorner,location);

 

  }else if(length == 1 && width == desiredWidth){//bottomrightCorner

   BuildBase(KindOfTile.bottomRightCorner,location);

   

  }else if(length == (desiredLength) && width == desiredWidth){//top right corner

   BuildBase(KindOfTile.topRightCorner,location);

   

  }else if(length == (desiredLength) && width == 1){//top left corner

   BuildBase(KindOfTile.topLeftCorner,location);

         

  } else if(length == 1&&width !=0){//bottom edge

   BuildBase(KindOfTile.bottomBorder,location);

   

  } else if(length == desiredLength) {//top edge

   BuildBase(KindOfTile.topBorder,location);

   

  }else if(width ==1&& length !=0){//left edge

   BuildBase(KindOfTile.leftBorder,location);

   

  }else if(width ==desiredWidth){//right edge

   BuildBase(KindOfTile.rightBorder,location);

   

  } else {//not an edge

   

   BuildBase(KindOfTile.plain, location);

   

  }

  

   //incrementing

  if(length ==(desiredLength)&&width <desiredWidth){

   length = 1;

   width +=1; 

  }else{

   length+=1;

  }

    

 }



}



function BuildBase(tile:KindOfTile, location:Vector3){

 var tileInst:GameObject;

 switch(tile){

  case KindOfTile.plain:

   tileInst = Instantiate(tileObject, location, Quaternion.identity);

  break;

  

  case KindOfTile.bottomBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 0;

  break;

  

  case KindOfTile.topBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 180;

  break;

  

  case KindOfTile.leftBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 90;

  break;



  case KindOfTile.rightBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 270;

  break;

  

  case KindOfTile.topLeftCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 90;

  break;

  case KindOfTile.topRightCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 180;

  break;

  case KindOfTile.bottomLeftCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 0;

  break;

  case KindOfTile.bottomRightCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 270;

  break;

 }

}

Now with this code we have made an addition to our while statement. This addition tells us whether or not the tile we are creating is an edge or a corner, then calls the BuildTile function to make the correct tile. Two new tile objects are needed. The edge tile is the original tile with an wall parented that is located towards the back of the tile. The corner tile is the original tile with two walls parented, one which is located towards the back of the tile, and the other to the most left of the tile. An enum called KinfOfTile has been created to keep up with all the different types a tile could be. When the while statement calls BuildTile function and passes in the KinfOfTile such as KinfOfTile.topLeftCorner, the BuildTile function rotates the object to the appropriate angle. Here's an example of what we have now.

Again, the width = 4 and height = 3. The constant is 10. The tile object is Unity's plane mesh with a point light parented to it. The function is being called by the start function.

But this still ins't a city, we need buildings. In this last part we're going to have two cases of buildings for each tile. One case will spawn multiple small buildings, where the other case will spawn one big building. Each case will go through all our different available buildings and pick one to be created. Here is the updated code:


#pragma strict



var createCityOnStart:boolean = true;



var width:int;

var height:int;



//List of buildings for the building creator to choose from

var smallBuildings:GameObject[];

var bigBuildings:GameObject[];

enum KindOfBuilding{small, big}



//the Tiles Constant

var tileConstant:float = 10;



//Tile objects to instantiate along grid

var tileObject:GameObject;

var tileCornerObject:GameObject;

var tileEdgeObject:GameObject;

enum KindOfTile{plain, leftBorder, rightBorder, topBorder, bottomBorder, topLeftCorner, topRightCorner, bottomLeftCorner, bottomRightCorner}





function Start () {

 if(createCityOnStart == true){

  BuildCity(height,width);

 }

}



function BuildCity(desiredLength:int, desiredWidth:int){



 var length:int=1;

 var width:int=1;

 var location;

  while(length<=desiredLength){

      

        location = Vector3(width*tileConstant,0,length*tileConstant);

      

  //getting edges

  if(length == 1 &&width == 1){//bottomleftCorner

   BuildTile(KindOfTile.bottomLeftCorner,location);

 

  }else if(length == 1 && width == desiredWidth){//bottomrightCorner

   BuildTile(KindOfTile.bottomRightCorner,location);

   

  }else if(length == (desiredLength) && width == desiredWidth){//top right corner

   BuildTile(KindOfTile.topRightCorner,location);

   

  }else if(length == (desiredLength) && width == 1){//top left corner

   BuildTile(KindOfTile.topLeftCorner,location);

         

  } else if(length == 1&&width !=0){//bottom edge

   BuildTile(KindOfTile.bottomBorder,location);

   

  } else if(length == desiredLength) {//top edge

   BuildTile(KindOfTile.topBorder,location);

   

  }else if(width ==1&& length !=0){//left edge

   BuildTile(KindOfTile.leftBorder,location);

   

  }else if(width ==desiredWidth){//right edge

   BuildTile(KindOfTile.rightBorder,location);

   

  } else {//not an edge

   

   BuildTile(KindOfTile.plain, location);

   

  }

  

   //incrementing

  if(length ==(desiredLength)&&width <desiredWidth){

   length = 1;

   width +=1; 

  }else{

   length+=1;

  }

    

 }



}



function BuildTile(tile:KindOfTile, location:Vector3){



 BuildBase(tile,location);



 if(Random.Range(1,5) <3){//Build 4 of Small Buildings

  BuildBuilding(KindOfBuilding.small, Vector3(location.x+1,location.y + 1, location.z +1));

  BuildBuilding(KindOfBuilding.small, Vector3(location.x+1,location.y + 1, location.z -1));

  BuildBuilding(KindOfBuilding.small, Vector3(location.x-1,location.y + 1, location.z +1));

  BuildBuilding(KindOfBuilding.small, Vector3(location.x-1,location.y + 1, location.z -1));  

 } else {// build a big building



  BuildBuilding(KindOfBuilding.big, Vector3(location.x,location.y + 2, location.z ));

 }



}



function BuildBuilding(type:KindOfBuilding, location:Vector3){

 var buildingInst:GameObject;

 

 switch(type){

  case KindOfBuilding.small:

   buildingInst = smallBuildings[Random.Range(0,smallBuildings.length)];

   Instantiate(buildingInst, location, Quaternion.identity);

  break;

  case KindOfBuilding.big:

   buildingInst = bigBuildings[Random.Range(0,bigBuildings.length)];

   Instantiate(buildingInst, location, Quaternion.identity);  

  break;

 }

 

}



function BuildBase(tile:KindOfTile, location:Vector3){

 var tileInst:GameObject;

 switch(tile){

  case KindOfTile.plain:

   tileInst = Instantiate(tileObject, location, Quaternion.identity);

  break;

  

  case KindOfTile.bottomBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 0;

  break;

  

  case KindOfTile.topBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 180;

  break;

  

  case KindOfTile.leftBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 90;

  break;



  case KindOfTile.rightBorder:

   tileInst = Instantiate(tileEdgeObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 270;

  break;

  

  case KindOfTile.topLeftCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 90;

  break;

  case KindOfTile.topRightCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 180;

  break;

  case KindOfTile.bottomLeftCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 0;

  break;

  case KindOfTile.bottomRightCorner:

   tileInst = Instantiate(tileCornerObject, location, Quaternion.identity);

   tileInst.transform.eulerAngles.y = 270;

  break;

 }

}

With this code, the function the BuildCity function is calling has changed to now BuildTile. BuildTile calls both BuildBase (Building the tile base or "floor") and the new function BuildBuilding, which builds a building. An enumeration for building size has been created to indicate what kind of building to create. Along with the enum two new GameObject Arrays has been created so the user can drag and drop their building models in the inspector with ease.BuildTile passes in location(which is different for each small building) and type(whether it's small or big) to BuildBuilding. BuildBuilding goes through the arrays and picks out a random one to create when called. Here's a look at the final out come.

One last time, the width = 4 and height = 3. The constant is 10. The tile object is Unity's plane mesh with a point light parented to it. The BuildCity function is being called by the start function. The small buildings (4 different kinds) are 2x2x2 and have parented cubes with the same dimensions at a different height to make the buildings look bigger or smaller to one another. The bigger buildings (2 of them) are 4x4x4 and again have parented cubes with the same dimensions to create variation between heights.

Here is a final look at the script atatched to the empty gameobject.

If you want a real look at teaching yourself some procedural generation techniques, you should consider reading this guys thesis.

If you have any questions or feed back please leave a comment!

Backing Up Your Projects

2012-10-13T15:42:00.001-05:00

What Prompted This Post:
Over the summer while working on one of my games, Unity 3D released an update which required your project to be "upgraded".It warned me to back up my project, but of course me being the stupid little high-school student I am, didn't even think twice and upgraded the project without any precautions. Upon the re opening of my Unity project, I was in shock. Where as the skeletons for all my prefabs, models, and materials still existed, they were all out of place and not put together. So a prefab of a enemy had the mesh component, but the mesh was not linked to it to render, the material was not linked to be rendered. The attached script was said to be missing (although still existed within my project, just not linked). This existed not only in prefabs but every game object in every scene. I was never able to get back my terrain (although height maps existed) so I had to end up remaking it. The whole process of linking everything back together took a good 4 hours. I ended up re-importing some meshes and re-creating some of the prefabs over. An experience I hope never to repeat.

Why It's Good To Back Up Your Project:
My scenario came out of pure ignorance, but other reasons might not be so ignorant. Sometimes you'll need a piece of code that you've deleted, or you might want to look at a certain way you set up a scene.Maybe you can use one of your older back ups as a template for a new game you'd like to start.

My Method Of Backing Up A Project:
I simply go to where ever all my unity projects are stored (for me the documents folder). You want to back up the entire project, so that means backing up the folder that contains your projects assets, project settings, library, and the rest of the stuff.

All I do is copy my entire project to a zipped folder, rename to the date backed up, and keep it there for later usage.

I back up my project when ever I make substantial progress in it which in return makes me think of all I lost over the summer and back it up. I suggest though backing up your project at least once a week though, which is better practice. Your going to want to stay organized so a method I use is making a separate folder for backups, then a sub folder for project, and within the sub folder holds the history of backups.

Taking Further Measures
I suggest also going at least one step further and backing your projects up on to a separate hard drive off your computer. There is no telling when your computer is going to fail on you being it a virus, or actual physical harm to it. Then again can't your separate hard drive be ruined also? If you haven't heard of Dropbox yet, you might want to look into it. The site gives you 2 GB of free storage on a cloud upon sign up. Having backed up on the internet frees you of the risk of loosing anything. Backing up to a separate source makes it easier when switching to a new computer.

Hope this makes you want to start backing up if you haven't already began!

Optimization Tip #1 - Windows As Textures

2012-09-23T00:19:00.001-05:00

A lot of games back before the super consoles of PS3 or the XBox 360, companies had to go to extra lengths to save on faces to boost the performance. Technology throughout the past 10 years has grown tremendously advanced for such a short period of time. We are though, still not to the point of having the ability to run the graphics of a PS3's prestige on an everyday tablet and not have major issues. All developers have to optimize their games of course, especially those who are developing for android or IOS. One way everyone has seen is UV mapping entire buildings with a texture. Doors and windows are flat and look like some one cut pictures out of a magazine and glued them on a cardboard box as part of an art project.

Now I'm not denouncing the method, its actually kind of crazy to think of trying to model a building in crazy detail. A lot of what makes a realistic looking model is the detail of the texture, instead of the complexity of the it's mesh. Big games like Call of Duty: MW3 still have not so complex buildings but still apply very detailed textures to make them realistic. This is a great way to make a computationally cheap building, especially one to put in the distance as something to glance over, or at least not to have too much attention on. Of course sometimes you just need low poly buildings because your selected platform does not have the kind of power to process today's graphics. I would like to give you a comparison on how much just changing windows to textures on a building can combat lag in your game.

Now I'm not a what you could call a true 3D modeler. I use a program called Google sketch-up to model buildings. I can not animate, rig, or even UV map textures. Nor does it include any of the editing tools blender contains. The program is as simple as Microsoft paint, but it is a 3D modeling software and has vertices and faces like any other model.

This building has a total of 2,133 faces taking up 641 KB of space on my computer. When nine instances of the model was placed alone in a scene on Unity, the scene contained a total of 77.3k vertices.

Now this building has had it's windows mesh altered and have had a texture applied to compensate for the changes. I simply took a screen shot of a window in orthographic view of the model, brought it into paint to crop, and then just applied to the model. The model has been reduced to 449 faces! The model also now takes up only 279 KB of memory. Part of the reason for such a drastic change is due to the windows being curved at the top, accounting for more faces than a regular straight line would of used.Now when nine instances where placed under the same conditions as the other model had, the scene now only contained a total of 13.6 k vertices.

Making Images in GIMP Part One

2012-09-09T19:22:00.001-05:00

This is a little off our usual topic, but still an important factor for games. When you walk into a game store and you're looking for no game in particular except for one that looks cool, you can't judge it off of game play, you have to go by the cover (and the description on the back of a game). And so, I shall show you the basics of making an image in GIMP.

NOTE OF WARNING: GIMP was not made primarily as a drawing tool, it was made for image manipulation, so while it has many of the same features that Photoshop has, it does not have everything.

I'm going to have to assume you have a basic understanding of anatomy and also drawing fundamentals. This tutorial is focusing more on composition and what it entails (depth, color usage, space, etc.) to create an interesting piece that draws attention. This piece is a mock up game cover.

Right now I have a rough draft and foreground sketch, simple enough.

Backgrounds tend to be the more tedious and difficult part of a piece. The job is to make sure that it cooperates with the foreground while not being too bland. For this process, I rely on a lot of reference images, especially for a subject matter like this that focuses on nature. I'll be getting most of my references here. Another thing to be careful with is where you want the attention of the audience to be drawn to. This is why I did not put the character in the middle of the page, you want the composition to be interesting. I put it off to the side and make sure that it fits correctly on the background (you don't want a character to float when it isn't supposed to) The way the image flows leads your eye around the whole piece.

And so we have this background, effectively utilizing the space and not overbearing on the foreground, although this is a pretty damn cliche scene. I create a sense of space by not only making the fortress figure in the back smaller, but also by bringing it closer to the horizon and giving it a more diluted tone, this is accentuation by the saturation of the green of the cliff that is closer to the front. During this part, don't be afraid to use general shapes to represent objects, the line art is where the detail comes in.

Next is creating a cleaner outline of everything.

I added in a pendant and took care of the folds in the clothes. The important thing about doing line art is that you always need to take your time, even if it takes a day or so to do.

And this is the finished line art. As you can see, the background closer to the viewer is in more detail while what is in the back is more general forms, it almost looks kind of lame. However, once it is colored it should regain the necessary detail that is needed for this to work as a piece. This whole image right now consists of five layers; a white background, a background rough sketch, a foreground rough sketch, a background line art, and a foreground line art. To add a new layer you can click the little white page under the layers.

I would like to encourage that when working with line art that you don't feel that you have to create your own style, nor that you have to copy other people's styles. I would suggest going out and finding pictures and studying the line art, the flow of the pen and the thickness in correlation to space and surrounding objects. There is nothing wrong with relying on reference or feeling the need to use a method you find suitable, nor is it required that you do so.

And this concludes the first part of creating an image in GIMP. If you have any questions about composing a picture or anything else such a preference for references, feel free to ask.

Importing Models and Animation From Blender

2012-07-06T20:46:00.003-05:00

NOTE - If nothing is showing up in your preview section, then you have exported the model wrong. Remember you need to have selected in Blender what to be exported. If you have done this, try reversing the faces in the model and re exporting.

So after you have your model from Blender rigged, animated, and exported, you can bring it in to the unity editor. Scale factor is by default 0.01, to change that, try looking at this link.

Anyways, your going to want to drag you model to your scene and adjust the scale factor till you have the desired size (scale factor 1 is rarely what you ever want it, its huge).

To start defining your animation, click the + button that's highlighted purple in the picture. You'll get something like this where you can name your animation, define starting and ending frames, and wrap mode.

Remember back when you were making the animation for your model? you had to define frames and you had a certain amount of frames in your overall animation? It's so simple. All you have to do is look at your animation in blender for your animation begin and end frame! If you have a looping animation, you would want to change wrap mode to Loop, and if it still doesn't work try checking the loop box.

There is five different wrap modes. Default, Loop, Ping Pong, Once, and Clamp.

Default uses the animation wrap mode option you chose (located above the split animations check box).

Once and Clamp are similar, but different. Once simply plays through the animation one time and them stops the animation, where as Clamp repeats the last frame of the animation over and over. This gives the appearance of it being played once. This also allows a blend of animation from one animation to the next, allowing more fluid movement.

Loop and Ping Pong are also similar. Loop plays through the entire animation, and in the end, goes back to the first frame and continues on and on. Ping Pong does basicaly this, but once played through the animation, it reverses itself and goes back ward through the animation, then forward again, then back, then... you get the idea. Or if you don't understand or would like to read more, click here.

So, after getting all your animations defined simply apply a script containing a line of code:

Animation.Play(), which plays default animation

Animation.Play("Animation Name")

Animation.Blend() for more seamless animation transitions. Click here to read more.

Make sure the script is attached to the game object with the animation component:

If you have any problems, questions, or suggestions, feel free to email me or comment on the post.

Animation Basics on Blender 2.57; Walking Cycle

2012-06-17T17:25:00.001-05:00

Now for animation. And I want to apologize for constantly changing the models I use for tutorials, I don't really have an excuse, I'll try to make this the last time I do it. For this introduction to animation I'll be using a honey badger model, already rigged. So, on that note, let us begin.

Here is the honey badger, rigged and ready to be animated.

Truth be told, basic animations are not all that hard to accomplish as long as you know what to and not to select. In order to start animating, click on the armature and go into pose mode, here you can edit the position of each armature and the vertices assigned to them freely. Animation in Blender is based on and made simplified by a key frame system, making the animation process easy and the finished product smooth. Now to actually conducting an animation.

Although you can manually put in keyframes, I prefer using the automatic keyframe setting, which can be enabled by selecting the two buttons which are circled in blue. Now when you edit a frame, a key frame will be added.

To start the animation, I'll keep honey badger in rest pose, this will be frame one. You can tell when a key frame is set by the yellow line that is marked in the timeline. You can save this pose in a couple of ways;

Select the entire skeleton and go to Pose> Pose Library> Add Pose. When you save a pose, it will only save the bones you have selected. The same goes for copying poses.
The other way is by, again selecting the skeleton, and clicking SHIFT + LKEY.

Now I deselect the entire object and jump to a point in the timeline a little further ahead, around frame 6. Make sure to deselect your object before adding a keyframe later in the timeline

Here is my new pose. If you play the animation (ALT+AKEY) you can watch how Blender makes the transition between the two poses smooth.

I deselect everything and jump ahead another 5 frames, adjust, and deselect.

After a few more frames are added, I set the object back to it's original resting position as the last frame, however, I set it so that the animation ends a couple frames before it reaches that last position, that way it smoothly loops into the beginning of the cycle.

When the model is exported, the animation is exported along with it, no tinkering with settings necessary. Hopefully this has been a helpful introduction to basic animation. If you have any questions, feel free to email the blog.

Making Characters: Rigging in Blender 2.57

2012-05-27T23:36:00.001-05:00

I suppose this could be considered a continuation off of here, only I'm using a different model. I've found people do rigging different ways, but the most effective way I've found is like this.

So, here I've got my model, took a couple hours, but is at this point one object, uno, ein, un. After you've got your object finished, add a single armature, set it inside your model and change the display of the armature to x-ray, like so.

As I go through making the skeleton, I'll be naming each bone, although once one is created there is already a preset name, however naming them myself seems to be easier. You can check the Name button in the Display menu in order to see the name of each bone as you go along (To rename individual bones, in edit mode, click on the little tab with the bone image and there is a name option for each individual bone). You can branch a bone of another by going into edit mode (TAB key) and clicking on the little ball and extruding (E key) in any direction.

This is what the skeleton looks like now, all named and placed. Now it's time for making the vertex groups. Select the model and go into edit mode.

Select the vertices for a certain portion of a body and go to the vertices tab and go to the vertex group tab. Here you can name the vertices in the portion you selected, in order for rigging to go smoothly later on, the name must be exactly like the name of the bone; it is case, space, and punctual sensitive. For example, I've selected all the vertices in the general region of the "Left arm" and I have named the group thus. After you have it named, hit assign, select, then deselect. To make sure if the assignment work, click the group and click select. The vertices assigned to that group should be highlighted. Make sure to make a new group for each

And that is the bear with all of it's groups and stuff. This last step is the easiest. Select the object and then the armature, hit CTRL P and click Armature Deform.

Now, if you select the armature and go into pose mode, simply move one of the armature bones and the vertices assigned to it should move with it.

With your object rigged, you are now ready for animating. If you have any questions, feel free to email the blog.

How To Import and Use Fonts

2012-05-13T11:56:00.001-05:00

-Made by Chrome Fx Films

To use different fonts in your game, your going to have to acquire some fonts. You can go somewhere like 1001 free fonts and download ones you like and want to use.

When you download the file, you'll need to extract the file if its in a .zip

The text file should have the extension .ttf. If you text files have a FFIL extension, simply rename the font file (yourname.ttf).

Drag the text file into unity to import. By default the Character variable should be labeled Dynamic.

The Dynamic setting means that Unity won't pre-generate the texture, so if you look at your material containing your font, It probably will be blank. (read more here)

Now your over all objective should be getting your font to look like this (unless you prefer dynamic):

Where the characters of the font are not jumbled up and visible.

Now usually all you have to do to achieve this is change the Character variable from Dynamic to Unicode.

and that should work.

Now what some people overlook is that fonts are still another persons's work, and they are not all simply free to the domain to do as one pleases. Make sure you check out the licensing on the fonts you use!

How To Make a Hellish Looking Sky Box

2012-03-26T22:15:00.000-05:00

I came across this problem while constructing my scene of Hell in a little project I've been working on, and could not find a reasonable sky box on the web for what I want. Maybe I was not looking hard enough, but I ended up making nice substitute.

If you think the sky box looks familiar, then your right. The Sky box I'm using is already packaged with Unity3D! To import the sky boxes Unity has made for you, simply go to Assets>Import Package>Skyboxes. The sky boxes will appear in your projects tab under a folder named "Standard Assets".

To make this sky box, first you must find the folder containing all the sky box materials and open it up. In it will be a list of sky boxes for your disposal. To get this skybox, I decided to tweak the "StarryNight Skybox" (But the "MoonShine Skybox" looks pretty cool also!). Select the sky box and view it under the inspector tab. Underneath the properties there will be a tint color variable allowing you to, well tweak the tint color of the sky box.

Just change the tint to the hue of red (or any other color) you want!

If your wondering how to make a sky box click here to view my previous post on how its done and what it is.

How Do You Make a Skybox in Unity3D?

2012-03-22T01:35:00.000-05:00

So we have a nice hellish looking scene in our Unity 3D game, and our default blue background really doesn't belong here

You can change the color of the background.. Or you could add a skybox for more detail and awe your players with the scenery.

An example of our Scene with a skybox:

So, you may be asking your self "How do I Make a Skybox?".

Before I begin, Unity has already created many nice presets for everyone's use. You can simply go to

Assets>Import Package>Skyboxes.

The skyboxes will appear in your projects tab under a folder named "Standard Assets".

So to begin with making your own Skybox, you should start out making a new material in your projects tab

Now change your new material's shader properties from diffuse to RenderFX>Skybox

You material should now show 6 slots(up, down, left, right, front and back) in which to put your textures in to build your skybox like so,

Now you simply apply all the textures your have into their correct placement in the material. There are websites out there, such as http://www.3delyvisions.com/skf1.htm, that has free Skyboxes to download. Once you have completed filling up all the texture slots in the material, you need to go to the camera in which your Scene uses and attach a Skybox component to it by going to Component>Rendering>Skybox.

Now all you have to do is drag your own skybox material into the camera's skybox component slot and there you have it, your own skybox being rendered.

Making a character model Blender 2.57 Part one

2012-02-29T21:58:00.000-06:00

New tutorial on another way on making a character. For reference, I'll be doing this from right-ortho perspective, which you can switch to by pressing 3 on a numberpad, or if you have an emulated numberpad, the 3 on the number row.

So, you start out with your basic cube, go into edit mode and subdivide it. Press Z to change it to wireframe mode and select the bottom half and the quarter to the right and delete it. You should be left with a rectangular prism with a missing bottom and side. You can fix this by selecting two adjacent edges then pressing F which will join the two edges together with a face, or you can leave it hollow.

The next part is mirroring the object. Select the object and go to modifiers. Since I'm doing the object from right-ortho, I will make it so it mirrors on the y axis, and y axis only. Under options, check merge, clippings, and vertex groups. This makes sure that the object mirrors correctly and also while you are modeling it doesn't make creases in the middle of the model.

Creating the character is all about knowing how to extrude, loop cut and merge edges. If you don't know how to do this stuff (you have to be in edit mode);

extrude: select a face, edge, or vertice and press E. When you've extruded it to the length that you want it, click the left mouse button (LMB)

loop cut: have your cursor over the face you want to add an edge to and hit CTRL R and click the LMB. The purple line will change to an orange line, of which you can change the placement, when you have the placement you want, click the LMB to set it.

Using these tools will allow you to add more detail to your piece and also make it smoother. Using this method, I've found that my models have come out better and more appealing, it is also easier to cooperate with, that is, using a hollow mesh and deleting 3/4 of the cube before mirroring, and also clipping.

Withing the first couple minutes.

I extruded on all sides and joined edges where it was necessary to make the legs

I loop cut on the leg vertically a couple times in order to get the general roundness and once horizontally to show the knee and get the natural bend of the leg. When I got the general roundness, it still was quite as round as I liked it, so I selected the leg and clicked the smooth vertex option.

At this point, it's starting to look similar to a Magical Melody Character, which that cute stoutness is what I'm aiming for this character.

Change of plans, proportional body. After I got the general sizings, placements, and such planed out, I selected the whole body and smoothed the vertices some the moved the sides closer together.

How To Make A Gun Shot Sound (SFX On Unity 3D)

2011-12-27T14:01:00.003-06:00

When it comes to audio in Unity, there are four components:
Audio Clip, Audio Source, Audio Listener, and Audio Re-verb Zone.

Audio Clips are the actual audio file imported into your game. Unity supports file formats: .aif, .wav, .mp3, and .ogg. When imported, you can compress them greatly, with the price of loosing some quality. You can do this by first selecting the audio clip, view it in the inspector. Under the Audio Importer component, you can switch the audio format from Native to the audio clip, to a compressed format applied by Unity. You can change how compressed the file is by dragging the bar at the bottom, then hitting apply.

You can get plenty of free good SFX from a site called freesound.org. All you have to do is create an account for free, and download all the sounds you want. I found a nice gun shot sound here. Simply download and load into your Project.

Audio Source actually plays the audio clip in your scene. They are an component, so it must be attached to a game object to play in the scene. You can quickly make a empty game object with an attached audio source by dragging an audio clip on to your scene. By default, they play on Awake, which means once the scene loads and plays, the sound will also. With the method of my game, I simply attached a Audio Source (Component>Audio>Audio Source) to my gun, and on instantiate of a bullet (or whatever method you have of firing your wepon), I played the sound. It goes something like this:

var bb = Instantiate(bullet, bSpawn.transform.position, bSpawn.transform.rotation);

bb.rigidbody.AddForce(bb.transform.TransformDirection (Vector3.forward)*10000);

transform.GetComponent(AudioSource).Play();

Keep in mind, you can have only one Audio Source attached to a game object. You can assign an audio clip to a source by dragging the clip to Audio clip variable under the Audio Source component like this,

Simple right?

Audio Listener Is the device that picks up audio played in the scene. You can have ONE audio listener per scene. The main camera in a scene normally already has audio listener component attached to it. The Audio listener picks up the sounds played around it, the further it is from a sound, the weaker, or less loud, the sound is. I always attach the audio listener to the player.

Audio Re-verb Zone is a component that can be used to make your sounds reverberate, or more common term, echo in your scene. Read the Reference Manual for the best description.

making a gun- blender 2.57

2011-12-11T12:43:00.000-06:00

Blender obviously gives you all the tools you need to make a gun, so this shall be a tutorial on how to make one

Something you probably want to use is a reference image, however, if you understand what a gun looks like or if you have your own gun design in mind, you may not need one. For those of you who want to use a reference image, press N on your keyboard to bring up a new menu. Scroll down to the Background submenu and click the checkbox by it. Click the add image button and it will come up with more stuff. Click the file button to pull up and upload menu and click the image file you want. Keep in mind that Blender can't upload .gif files, so if the image isn't importing, check to make sure that the image format isn't .gif.

If the file format isn't a .gif, but the image still isn't rendering, press the 5 key and this should show the image. Also, a default opacity for a background is 50% (0.500) but you can change this by double click the opacity bar under the back ground settings and then typing in a new number (0.01 thru 1.0) Another thing to remember is that the image will only be visible in orthographic views, so it's a good idea to keep another window open to keep at a different perspective. You can do this by clicking and dragging the little lines in the top right corner to divide the blender screen.

You can join it into one screen gain by right clicking the divider and click join.

Alright, now time to actually start on the gun. Gun models are pretty damn simple, mostly because one side is symmetrical to the other and also guns are primarily geometric. I've already started on a Barrett 50 cal.

but through much of the making of it so far, I've kept the modeling preview in wire-frame, which you can switch to just by pressing Z. This allows you to manipulate all the vertices, edges, and faces, but also allow you to see the reference image. Making a gun is really no different from any other model, using tools like loop cut, stretch, grab, rotate, etc. but I'm going to use a different tool than I usually do.

In order to keep everything proportional, I want to make everything all at once rather than multiple separate objects at different times, however, I want the clip and the scope to be detachable.

Completed model

What you do is highlight all the faces you want separate from the rest of it, this can be made easier by staying in wireframe mode and using the box tool (B key) to select the faces.

The press P, which should come up with options like this:
Click the first option, selection, which will separate the the faces selected from the rest of the model.

And voila! Your selection should turn into a single outline without all extra details. This just means that it is incompatible in edit because it is no longer the primary subject in it. You can return to object mode, select the separated object, and go into edit mode with it separate from the original model.

If you want to join the two objects back together, go to object mode and select both of them by holding down Shift. Then, in your toolbox, press the join button to bring them back together.

How To Sync Up Unity Projects

2011-12-09T23:35:00.001-06:00

Want to work on the same Unity Project over multiple computers? Even have multiple people work on one project all at once? Well theirs a free easy method that works!

Step 1:
Go to dropbox.com. Make an account and download their soft ware. You have 2GB of space for free! It's not much to expand on that either, but I've yet to run across any space issues.

Step 2:
Open up Unity. Go to file>New Project. Under project location, Browse, and create a new folder under your dropbox folder. Make that where your project lies.

Step 3:
Go share! You can install dropbox at any computer and log in with your account. Your assets will be loaded into the dropbox folder. To open you Unity project from dropbox, simply go to file>open project, then find the folder that contains your unity project and hit open. You can also log into your dropbox account, and send other drop box users an invitation to share your folder, you have to know their email. When they accept their drop box will now contain the projects folder. They just open it the same way.

Limitations:
Of course there is the amount of memory you have, but its not a big fee what so ever to upgrade. 10$ a month allows you to upgrade to 50GB. You need internet connection so the Assets folder can properly update. Updating all modified objects takes a while also, but not to terribly long. If a computer is shut down, while others are working on the project, when you turn it on, you should wait for your dropbox to finnish updating before you open up the Unity Editor. Before you turn off your computer after working on the project. you should wait till your computer is done updating all the assets within the folder before you shut it down.

Any questions or problems? Leave a comment or message me!

Making A Laser Pointer

2011-10-13T19:11:00.000-05:00

Want a frieking lazer pointer?
BOOM.

Attach a Line Renderer component to the object you have the script below attached to.

(Component> Miscellaneous>Line Renderer)

Code:

function Update () {
    var lineRenderer : LineRenderer = GetComponent(LineRenderer);
    lineRenderer.useWorldSpace = false;
    lineRenderer.SetVertexCount(2);
    var hit : RaycastHit;
    Physics.Raycast(transform.position,transform.forward,hit);
    if(hit.collider){
    lineRenderer.SetPosition(1,Vector3(0,0,hit.distance));
    }
    else{
        lineRenderer.SetPosition(1,Vector3(0,0,5000));
    }
}

@script RequireComponent(LineRenderer)

Thank 3dDude for the script.
Original Source here.

Limiting Rotation of an Object

2011-10-06T19:24:00.002-05:00

I made this script for my Beach Defender Game. It was to keep the player from rotating more than I want his to, because I'm a mean person like that. Any way it took me awhile to figure out how to not make them turn to far to the left, right, up, down.. You know. Here's the script. Pretty simple. Put under Update function. Feel free to suggest different ways. Or ask any questions.

           var upDown = Input.GetAxis("Vertical") *Time.deltaTime * (rotateSpeed-10);  
           var leftRight = Input.GetAxis("Horizontal") * Time.deltaTime * (rotateSpeed-10);  
           //making it turn up or down  
           if(transform.localEulerAngles.x < 25 ){  
                transform.Rotate(upDown, 0, 0);  
           } else if (transform.localEulerAngles.x > 295){  
                transform.Rotate(upDown, 0, 0);                 
           }  
           //making it turn left or right  
           if(transform.localEulerAngles.y < 65 ){  
                transform.Rotate(0, -leftRight, 0);  
           } else if (transform.localEulerAngles.y > 295){  
                transform.Rotate(0, -leftRight, 0);                 
           }  
           //making it not exceed rotation limit (left and right) and preventing it lock up  
           if(transform.localEulerAngles.y >= 65 && transform.localEulerAngles.y < 295){  
                if(transform.localEulerAngles.y < 180){  
                     transform.localEulerAngles.y = 64.9;  
                } else{  
                     transform.localEulerAngles.y = 295.1;  
                }  
           }  
           //making it not exeed rotation limit (up and down) and preventing it lock up  
           if(transform.localEulerAngles.x >= 25 && transform.localEulerAngles.x < 295){  
                if(transform.localEulerAngles.x < 180){  
                     transform.localEulerAngles.x = 24.9;  
                } else{  
                     transform.localEulerAngles.x = 295.1;  
                }  
           }  
           //making sure it doesn't turn on it's z axis  
           if(transform.localEulerAngles.z != 0){  
                transform.localEulerAngles.z = 0;  
           }