The Elder Scrolls V: Skyrim is the latest addition to the Elder Scrolls (TES) series of Role Playing Games (RPGs) released by the developer studio Bethesda. The Elder Scrolls series has a long history, beginning with The Elder Scrolls: Arena released in 1994 for the PC. Followed by The Elder Scrolls: Daggerfall released in 1996 and a few unnumbered titles (Battle Spire, and TES adventures: Redgaurd) in the latter part of the 90s. In this Article, I will compare Skyrim to its two predecessors, Oblivion (the fourth game in the series, and the one that Skyrim followed) and Morrowind (the third part of the series, that Oblivion followed).

Skyrim

First let’s look at Skyrim itself. The original release build was riddled with bugs (something Bethesda fans now expect and accept), some of which were debilitating (preventing players from advancing though the main storyline). Historically, Elder Scrolls games tend to be relatively bug heavy. However, the extensive nature of the game makes releasing a bug free build near impossible, so it would be difficult to fault Bethesda, especially since patches were made exactly for this type of situation. Beyond the bugs, the game is absolutely fantastic. The game landscape itself is incredibly detailed and gorgeous, and this is an opinion from someone who is fanatical about their hatred of snow! The old trademark of the TES series, a wide expansive world where you can essentially do and be whatever character you wish, continues to be a dominant theme within in Skyrim (perhaps even stronger than it is in Oblivion arguably, but I digress. The main story line and various side and faction quest lines are well done for the most part. In fact, my only real gripe is with the Bard College quest “line” was inherently less robust. I was greatly disappointed that the Bard College quests lacked depth and were essentially a collection of disconnected fetch quests devoid of any overarching theme or quest chain. Moreover, not only could you not advance in the college, once you were done with the quest line, the college basically becomes useless, unless of course, you’re interested in the few skill trainers available. You can’t even learn to play an instrument!

The change to the skill system was awesome. Instead of the original system, where you had to have a specific class, and you could only level up by increasing your major and minor skills, you can level up from any skill increase. However, as you level up, you need more skill increases to level (as opposed to Oblivion and Morrowind, where you only needed 10 skill level ups, regardless of what level you are.) In addition, I really loved the new perk system that was introduced. It allowed them to simplify the skill system by reducing the amount of skills you have to keep track of, while letting you customize your character as much or more than you could in either Morrowind or Oblivion. Personally, I think it might have been better to have changed how many perk points you get per level. At a certain point, even with a high level in something, it becomes less useful than it would be in, say, Morrowind, because you may not have spent your perk points. For example, I can have a character with 70 smithing, but I wouldn’t be able to make iron or leather gear unless I invested skill points down that tree. When you get to a high level, leveling up, and obtaining perk points is more time consuming, so it becomes difficult to get to a desired skill level since you can’t just level up the skill anymore to be effective.

The crafting system in Skyrim is also vastly improved from that of its predecessors. In this current iteration you can actually make armor and weapons with the smithing skill, instead of just being able to repair your armor and weapons (via the “armorer” skill). This not only provides a function for the various mines you come across in Tamriel, but it’s another way to “be what you want!” When it comes to the enchanting skill I have mixed feelings. On one hand I like what they’ve done with disenchanting , basically giving a purpose to all the otherwise worthless magical items. However, I disapprove of their decision to make disenchanting the only means of learning now enchantments. Personally, I prefer the Morrowind system, where the enchantments you can do was based on the spells you know.

Comparison

As is the case with any sequel, inevitably there will be a comparison made between the sequel and its predecessor(s). Skyrim of course is no exception, so using my perspective let’s take a look at how Skyrim compares to Oblivion and Morrowind.

Many people (myself included) thought that Oblivion, while excellent in its own right, was a step backward compared to Morrowind and even Daggerfall. However, Skyrim does not follow this path. In my opinion, Skyrim is leaps and bounds ahead of Oblivion in nearly every aspect of the game. Skyrim improves on many of the more lackluster elements in Oblivion. For example, Skyrim’s crafting system is far superior to it predecessor.

Quests

The main quest in Skyrim is far more fun and engaging than in Oblivion. For me, the first couple of Oblivion gates I had to close were quite interesting, but eventually the game play becomes boring and stale. I found myself dreading coming across Oblivion gates in Oblivion because going inside was repetitive. It essentially boiled down to get in, bash skulls until you get to the right building, and activate the sigil to close the gate. These encounters were also incredibly time consuming. There is nothing I dislike more than being on my way to completing some unrelated quest, only to have to trudge through a long pseudo dungeon in order to continue. Of course, I’m sure I could have just skipped closing the gates, but I was sort of compelled by a sense of duty. It became kind of like a job, which is a description that no game should aspire to obtain. Skyrim’s version of these encounters (dragon attacks) are far superior; they are shorter, making it more of a temporary epic battle, rather than a long trudge through deadre after deadre. Notably, while the story is more engaging, it also feels shorter in its entirety. Despite disliking the long drawn out dungeon crawls to close various gates, I did find the story’s depth appealing. Conversely, Skyrim’s story feels much too short for such an epic tale. My senses tell me that I shouldn’t have been able to foil the plans of the “Eater of Worlds” so quickly, this is one aspect where Skyrim falls short. Morrowind’s story felt truly epic both in scale and in action. Although the actions in Skyrim’s main quest are great, it doesn’t quite have the depth required to meet the bar set by

Morrowind.

The same holds true for Skyrim’s faction quest lines. For example, when traversing the College of Winterhold quest chain, it seemed like it was just a random encounter and they decided that I would handle extremely important tasks right off the bat (well like 2 quests in). A few (in game) days later and I’m Arch-Mage just like that. At least in Oblivion, they have you doing menial tasks first so you at least rise through the ranks, but it seems like the College of Winterhold (and indeed the other factions as well) were just waiting for someone to come along to be named Arch-Mage. All the factions seemed be just an express lane to becoming their leader, rather than an organic guild that actually cares about someone rising through the ranks before they are tasked with important stuff. In Morrowind, when joining and completing quests for a guild, it actually seems like I’m rising through the ranks, rather than just randomly becoming the most important person in the guild overnight. While some people would be glad to be rid of the meaningless quests that acted as fillers before you were deemed important enough to get to the real work, these “meaningless” tasks actually added a lot to the role playing aspect of the game.

Game Mechanics

There are many game mechanics present in TES series that Skyrim really improved upon. Combat in Skyrim is the best implementation in the series bar none. The dual wielding mechanic was expertly done, and really makes combat much more fluid and organic, and dual wielding swords/maces/what have you is an awesome feeling! Casting spells is also much better now because of this new system. In Morrowind and Oblivion, while I loved the magic system, casting magic spells in combat just seemed clunky and awkward. However, sometimes I do find myself instinctively mashing the C key to no avail. As discussed, the crafting system far surpasses the implementation in the third and fourth installment of the series in most regards. I’m glad that they added back the Morrowind style fast travel (where you basically fast travel to preset locations by paying someone to take you there).

Unfortunately, there are also some mechanics in Skyrim that, in my opinion, are not improvements to the previous iterations in Morrowind and Oblivion. One glaring problem I discovered is the complete lack of Deadric armor/weapons in the game world. As far as I know (and I’ve done quite a bit of research in this area), you cannot find Deadric armor and weapons (aside from the artifacts that are rewards for the various Deadric quests) in the game world, but have to smith them yourself. I love the crafting system, but I don’t like being forced to level up a certain skill just to wear the best armor in the game. There should be other ways of getting Deadric armor that, while much harder than simply smithing it, is still available for those who don’t want to have a high level smithing character. Not to mention the need to not only level smithing, but get the correct perks as well.

I miss the ability to create your own spells. The spells in Skyrim are all quite satisfying (at least the destruction spells) but not having a way to create your own simply reduces a player’s choices when customizing their character. While I’m not privy to Bethesda’s rationale was for omitting this feature, I can’t imagine anything that could have justified the decision.

Bethesda also greatly simplified the armor system. Where originally you would have separate pieces for the chest, legs, etc. now you have fewer pieces (for example, armor is now what in Morrowind was a Cuirass, left and right pauldrens (shoulder armor) and greaves. Morrowind was a bit overboard, I think they simplified the armor too much. Essentially, what it comes down to is fewer choices for customization in exchange for simpler game play. I can appreciate wanting to simplify things that were a little too complicated, but it calls for a balancing act and in my opinion they leaned a little too far towards simplification. Moreover, it doesn’t stop at armor. The entire stat system has been completely jettisoned and you can no longer select becoming stronger, faster, or more intelligent. Now you simply pick whether you think you should have more health, stamina, or magicka, an oversimplification in my opinion that takes something substantial away from the game.

In Closing

Ultimately, I would give Skyrim a rating just below Morrowind, but above Oblivion. By itself it is an amazing (albeit buggy) game. Bethesda seems to be going along with the current trend in the gaming industry to simplify their game in an attempt to make it more accessible. However, while they were successful in certain aspects, other areas suffered from an oversimplified. Nevertheless, Bethesda delivered an awesome game, and I hope they keep delivering more!

This is the final article in a 4 part series on starting your first Unity project. This article will provide some basic scripts that are common among different genres. These are meant to be a starting point, and by no means are they complete.

Basic Movement

The following code moves an object by 1 unit in the x or z direction. It is very simple, but can easily be expanded. You can change this to work on a speed variable, and easily add acceleration or other basic physics.


if (Input.GetKeyDown("a") || Input.GetKeyDown("d")){
 deltaX = (Input.GetKeyDown("a")) ? -1 : 1;
}
if (Input.GetKeyDown("s") || Input.GetKeyDown("w")){
 deltaY = (Input.GetKeyDown("s")) ? -1 : 1;
}

transform.position += new Vector3(deltaX,0,deltaY);

This simpy uses the GetKeyDown function of the Input object to determine if the a, d, s, or w key is pressed, and if so act accordingly. Note, that GetKeyDown is only true on the frame that the key was pressed. If you want to check if a key is pressed, disregarding whether it has been pressed for a while or was just pressed, use GetKey instead.

Programmatically Instantiating Objects

Sometimes we need to instantiate different objects programmatically, rather than in the Unity editor. This is especially true for things like bullets, and enemies. Now, there are many different ways to instantiate something, but I will go over the basic methods. You can easily instantiate a primitive object (like a sphere, cube, or plain) or a model.

One way to instantiate your own models, is to create a reference variable (like we did in part 2 with inter script communication) and drag the object you want to instantiate onto your script in the inspector panel. Once you do this, we can do the following


var objectTransform : Transform;//reference variable to model

 

var temp : GameObject = Instantiate(objectTransform, transform.position, Quaternion.identity);

This create whatever object you want to create at the location of the GameObject that has this script. You can of course change the location. The Quaternion.identity part is for the rotation. Rotation is stored at a Quaternion in Unity, and the identity Quaternion is essentially no rotation.

Tracking Points/Cash/Etc.

Tracking points is a fundamental part of most games, but can be somewhat tricky if you have a lot of different way to gain points spread across different scripts. The best and simplest way to keep track of points is to have a single script in charge of keeping track, adding and subtracting points, and setting up methods as interfaces that other functions can use. For example, we could do something like


//point tracking script: PointTracker.js
private var Points = 0;

function AddPoints(x){
 Points += x;
}

function RemovePoints(x){
 Points -= x;
}

 

//usage
if (/*player did something awesome*/){
 var pt : PointTracker = GetComponent(PointTracker);
 pt.AddPoints(50);
}

However, this is more or less the same as if we just used a public variable. Changing the behavior of similar actions that generate the same amount of points would be tedious. However, we could use a system like the following


//point tracking system: PointTracker.js

private var Points = 0
enum PointType{ small = 50, medium = 100, large = 200 }

function AddPoints(type : PointType){
 if (type == PointType.small) Points += 50;
 if (type == PointType.medium) Points += 100;
 if (type == PointType.large) Points += 150;
}
function Remove(type : PointType){
 if (type == PointType.small) Points -= 50;
 if (type == PointType.medium) Points -= 100;
 if (type == PointType.large) Points -= 150;
}

//usage

 

if (/*player did something awesome*/){
 var pt : PointTracker = GetComponent(PointTracker);
 pt.AddPoints(PointType.small);
}
if (/*player did something even more awesome*/){
 var pt : PointTracker = GetComponent(PointTracker);
 pt.AddPoints(PointType.medium);
}

This way, if we want to change the rules for how small point gains work, we only have to change it in 1 place, rather than many!

Basic Timing

Timing in games is very important. Unity provides you with a Timing class called Time, that we can use whenever we need to count something. For example, if you want something to happen every 5 minutes, you would need to do timing. Lets take an example. Say I want to print a message every 5 seconds. I could do


//print a message every 5 seconds
var lastPrint = 0;

function Update() {
if (Time.time - lastPrint > 5){
 print("A message printed every 5 seconds!");
}
}

Another, more practical example may be if I wanted to add something like a bullet delay.

//add 1 sec shooting delay
var lastShoot = 0;

function Update() {
if (Time.time – lastShoot > 1 && if (Input.GetKeyDown(“space”)){
//code to shoot a bullet in game
}
}

[/code]

That ends the four part series in starting Unity. If you have any questions, leave them in the comments below!

This is the third part in a four part series about starting your first project in Unity. This post will focus on GUI programming, and more specifically, a simple state based system. GUI programming is a rather broad topic, and so I will not be going over the more advance topics. I will not be going over similar topics like GUI styles, but rather the scripting involved with GUIs. There are many good GUI tutorials online, and there are even  a few on the Unity3D website!

State Based System:

This is a system (sometimes referred to as a Finite State Machine) where a program (or machine!) operates differently, depending on the different states it could be in. This type of system for a menu is perfect, for it allows us to neatly and efficiently show different screens and menu items depending on the state.

This system can be very simple, or rather complex depending on how complex your game is, but they all have certain similarities. They all depend on some variable or value that represents some state. Sometimes its an enum, sometimes a boolean, and sometimes an int. In my example, I will be using a boolean value. Before we get into a

GUI in Unity

Unity takes a step away from the normal GUI model in a very unique but elegant form. Instead of the general pattern or setting up some sort of GUI element, than setting up some sort of listener for it, and acting on events. Instead, Unity combines the creation of the GUI element, with its listener. Using an if statement, you can both check if, say, a button is being clicked. GUI elements are reserved to execution in an OnGUI() function. this function is called every cycle (like Update) and you should put all GUI related code here. Consider the following:


//All of this takes place in an OnGui() function
if (GUI.Button (new Rect(50,50,70,20) "Ok!")) {
//create a button
//if its pressed, we go into this code block
print("You pressed me!");

}

Other GUI elements (like Boxes and labels) can simply be created without any if statements, like so:


//box
GUI.Box (new Rect(150,150,300,500), "Box text. Use new lines \n to go to new lines!");
//label
GUI.Label (new Rect(150, 700, 300, 300, "Label Text");

Introducing states to this model is trivial. All we need to do is keep track of the right variables. I will show an example with two states, but you can add more states at your leisure.


var MainState = true;
var OtherState = false;

function OnGui(){
 if (MainState){
 //we are in the main state.
 //show button to go to other state
 if (GUI.Button (new Rect(50,50,100,20) "Other State!")) {
 MainState = false;
 OtherState = true;
 }
 }
 else if (Other State){
 //we are in the main state.
 //show button to go to other state
 if (GUI.Button (new Rect(50,50,100,20) "Main State!")) {
 MainState = true;
 OtherState = false;
 }
 }
}

As you can see, we use two variables, MainState, and OtherState, that we use to keep track of what state we are on. We could alternatively use an enum, 1 value for every state, and have one variable which we change the value of once. This way, we don”t have to remember to set every other state to false. However, this assumes that we only want one state active at a time. There are some times (like when we are showing the user an alert style message) where we don’t need or want to remove other GUI elements, like the main GUI toolbar, or something of equal importance.

To end this article, I will also provide the code for a helper function I have been able to make good use of. It basically returns a rectangle that can be used in a GUI function call centered in the middle of the screen.


function Center(w:float,h:float){
 //halve height and width
 var h2 : float = h/2;
 var w2 : float = h/2;

 var x : float = ScreenCenter.x - w2;
 var y : float = ScreenCenter.y - h2;
 //print (x + " " + y);

 return new Rect(x,y,w,h);
}

Click here to see the final entry in this four part series: http://wp.me/p1AGMt-5K

This is part two of a four part series detailing starting your own game. I will talk about actually creating the game, and how to think about coding  your game features. This tutorial is geared mostly towards Unity, but the concepts can be applied to any game engine! The first part of this article well focus on concepts behind the creation of your game, specifically on game mechanics. The second part will get in the nuts and bolts of coding. The fourth part of this series will have some code examples of common basic game functions.

Creating the game

When creating your game, regardless of the genre, the first thing you have to think about are your game features. How will your game function, and what mechanics will the player interact with? For my game, the core mechanics rest of simulations and AI. Basically, the player provides the stimulus, and the game reacts to it. In many other genres, the game provides the stimulus that the player reacts to, like shooting at an enemy, and bouncing a ball. However, these mechanics are often built upon many simple mechanics. These “micro” mechanics are what make up the different mechanics of a game, and these are where you should start.

Deciding on Core features:

The first thing a developer should do when creating their game is make a list of core features that they want in their game. For example, in a platformer, one may want to focus on movement and jumping. Someone creating a building game (whether a classic RTS, or city sim, or combination) may want to focus on spawning buildings (at a mouse click, or at a certain position) first. These would be the micro mechanics that make up that larger more general game mechanics. Once you create this core functionality, you can add to it without worrying about disturbing the underlying functionality. They key to doing this is making sure that you thoroughly test the core features, and make sure they are done well! Unity’s unique development environment makes incremental development like this a breeze, and you don’t have to go through the hassle of compiling and recompiling your assets over and over again.

Modular Development

Because of the unique environment Unity offers detailed above, developing different aspects of your game as if they were different modules and an easy and effective way to get your game done! Different scripts that create different functionality can be kept separate, and turned off at will. This also makes debugging very easy. Separate game mechanics can be their own GameObjects, composed of various scripts, sounds, and other things that make make up the micro mechanics. Unity’s use of Object Oriented programming also adds support to modular development, as well as the availability of prefabs. I will discuss prefabs in more detail later..

Importing Assets

One thing I haven’t touched upon yet are the visual assets of your game. Importing these, as I said earlier, is extremely easy, but I thought i’d give an overview of your process.

Whether you are importing textures, models, music, or entire prefabs to your Unity project, you simply follow these steps:

  1. Make sure your Unity Project is created, and navigate to “Assets” folder in your projects root directory
  2. Either Copy and Paste your assets to the correct folder inside the Assets directory, or save the image/model/sound/etc. directly to correct folder inside the Assets directory
  3. Open Unity and your asset should be imported!

Thats it! Simple as pie

Writing the Code

The first decision to make when you start to write code is what language to choose. While I haven’t used to Unity flavor of C# much, I find this topic worth talking about. Javascript in Unity has whats known as type hinting, which is a solution for when you want to take advantage of typing, without having to use typing at all times. Unlike C#, which is a statically typed language. This makes getting into Javascript much easier, and with all the libraries supplied by Unity, Javascript is just as robust as C#. However, at times I wish that I had chose C# instead of Unity. the dynamic typing sometimes run into strange problems. Many of these problems can be fixed with clever use of type hinting, but these solutions aren’t readily apparent. C# bypasses these problems by virture of being statically typed. C# also has various programming language features that Javascript doesn’t (like operator overloading, explicitly passing by reference, etc.). I am also starting to run into typing problems with my user defined classes. While I have been able to overcome these problems, at times I envy a statically typed environment. Whether you would like to take advantage of arguably quicker and easier development times versus more stability in terms of typing and other aspects of the language, sticking to one language certainly makes development easier. You can write in 2 (or more) different languages (Unity also has Boo, which I won’t get into) but it slightly complicates the development process.

Getting Different Scripts to Talk

One of the early hurdles that any game developer using Unity will run into will be getting different scripts to communicate with each other. Certain information (like a users life, held inside the script that controls the user’s different stats and attributes) will be needed by certain other scripts (like the combat script, or AI script). Luckily, Unity makes it easy for different scripts to talk!

GameObjects: To understand how Unity has each individual object communicate, it helps to understand how things work internally. Everything in a game is a GameObject. These GameObjects can be empty, or composed of what Unity calls components. Components can be scripts, mesh colliders, and other various generic objects that have a variety of functions. GameObjects can also be composed of other GameObjects (which would become children of the base GameObject). GameObjects, in code, are a class, and thus have certain methods and attributes. Of interest to us will be a method called GetComponent, which returns an object that represents the component of a specific game object. This component could be a sound (or AudioSource), or a script, or any other component. What we’ll be mostly doing is grabbing other script components.

Now, there are several ways in which we can get another script that depends on where exactly this script resides (or rather, what GameObject is this script a part of). There are two cases here.

The first is if we have two scripts wanting to communicate in the same game object. To communicate, we simply call the GetComponent method, and use the scripts name (case sensitive) as an argument. Consider the following:

Script1


var Points = 0;
var health = 100;

function Update(){
 //called every cycle
 //do walking and other character related stuff.
}

This could be a script that holds all the actions and information a player object has. Another script, Script2, could be in charge of some other unrelated function, like gathering and computing stats to be displayed


...
function Update() {
 ... gather other metrics ...
 //we want to display the points
 //first we grab the component script, titled Script1
 //the colon lets us use type hinting, to tell javascript what type is going into this variable
 scriptObject : Script1 = GetComponent(Script1);
 points = scriptObject.Points;//we can access the scripts variables just like any other objects attributes

 Display(points);//Display() is some helper function, perhaps communicating with some GUI script
 ... rest of logic ...

}
...

You can infer from above that if you call the GetComponent method without an object reference attached to it, GetComponent gets called on the GameObject that the script is a part of. If you want to get a script (or other component) that is part of a different GameObject, you need a variable to reference that GameObject.

Now there are several ways to get access to a GameObject, many of which are explained here: http://unity3d.com/support/documentation/ScriptReference/index.Accessing_Other_Game_Objects.html. I will go over the simplest method, using a reference that you can set up in the inspector view (part of Unity’s GUI).

The first thing you do, is add a variable to the script you want to do the communicating with. In the case above, If Script1 and Script2 were instead part of different GameObjects, I would add this variable in Script2, since its the one that queries Script1 for its data. This variable will be a reference to the GameObject that contains Script1. Lets say that this GameObject was called player (and we could call the GameObject with Script2 ScoreKeeper). Assuming these GameObjects already exist in your Object hierarchy (lower left side in most Unity setups), in Script2, we add a variable called, say, player, like so


var player : GameObject;

...
function Update() {
 ... gather other metrics ...

Now, we need to go object hierarchy, and select our GameObject called ScoreKeeper. We will then select Script2 in the inspector panel (there should be a slot for our newly added variable added), and go back to the hierarchy panel and drag the Player GameObject on to the player variable in the Script2 component. Once we do that the link is made! Now we can go back into Script2 and change it to the following


var player : GameObject;
function Update() {
 ... gather other metrics ...
 //we want to display the points
 //now we use the player GetComponenet method on the player GameObject, rather than the current scripts GameObject
 scriptObject : Script1 = player.GetComponent(Script1);
 points = scriptObject.Points;//we can access the scripts variables just like any other objects attributes

 Display(points);//Display() is some helper function, perhaps communicating with some GUI script
 ... rest of logic ...

}
...

Now regardless of what object we call GetComponent on, we can use the resulting object to call methods, just like we use it to get public attributes. So for example, we could do


function Update(){
 otherscript : OtherScript = GetComponent(OtherScript);
 var othervalue = OtherScript.OtherMethod();
 print(othervalue);
}

Separate Functionality: Because of the ability to communicate between scripts, separating out functionality, and making different interfaces (like methods and attributes) for two scripts to interact further aids the modular development I discussed above.

AI Basics: 

Writing AI can be a very difficult but rewarding experience. Depending on how complex your game is, you may need fairly complex AI, but many times you can, at least temporarily, get by with simple AI. For example, when developing the various AIs that control various city and building properties in order to see how they interact with each other in a timely manner, I started with very basic simulation. For example, originally, simulating happiness was only  based on the amount of water resource available. Now it is a function of many different city properties! AI is a vast and complicated subject of its own, so I won’t talk much more on it until a later article.

View the third part of this series here: http://wp.me/p1AGMt-5H

view the first part here: http://wp.me/p1AGMt-5E

This will be the first of 4 part series on getting started with Unity. In this portion, I will go over some things I learned while starting my first project, as well as some design issues I came across, as well as how to solve them. In addition I will talk about starting a game from scratch. This section won’t be too heavy on code or follow-able examples, so if you want to skip ahead to the more code heavy parts in section II, III, and IV, feel free. These posts assume you have basic knowledge of Unity’s GUI, and have to navigate it.

What I learned:

I’ve been using Unity for a few months now, and I’ve learned quite a bit about game design in general. The types of problems you come across in game programming are much different than on other domains. For example, in a web or mobile development, you spend a lot of time processing and retrieving data from various databases or calculations, and presenting it in a simple manner to the user. In game development, you have to work with things like positioning, and rotation, and figure out solutions to things like path finding, combat, and artificial intelligence.

The most interesting part of developing a game is definitely designing the individual game mechanics. When deciding on which mechanics to work on first, starting on the simplest, or most fundamental to your game is key. This is one things I learned while developing the simulated city game I am currently working on. For example, in a game like mine, where spawning certain buildings or other objects in a key part of the game, starting with a simple script to place objects (ignoring resources, and similar) is important. Once you have that basic functionality done, you can continue adding to it without worrying about whether the basic functionality of it will work. In a platformer game (like Lerpz 2), focusing on the movement of the player controlled character is also very important and should be one of the first things designed.

In addition to coding, the look and feel of your game is also important. Unlike web design, where creativity can be borrowed from free templates and similar sources, getting visual content for your game can be difficult. There are online services that offer free game assets, but getting a large group of assets that look good together can be difficult. This actually brings me to my next point.

Starting from Scratch

Starting a game from scratch can become a daunting process, and unfortunately many would be game developers get eternally stuck at this part of the process. I wrote a post a while ago with a bunch of different resources: http://blackscorner.me/2011/10/04/list-of-unity-game-assets-both-free-and-paid/. This is a great place to start for free assets of all kinds. Things like sounds and textures (I use http://www.cgtextures.com/ for textures, and http://www.freesound.org/ for sounds) are easy to get, and using these resources saves a whole lot of time. However, for models, many models, while of good quality, just don’t fit with what you need. Some are too high poly, some or too low poly, and some just don’t fit the style. Sometimes you need to make your own models

Modeling

Modeling can be a very difficult process, especially for those whose experience lies mostly in coding. Choosing what 3D modeling software depends on quite a few factors. The free and open source alternative, called Blender (Blender.org) is a very popular choice for indie game developers who don’t have the money to put towards one of the proprietary pieces of software. Other alternatives are Maya, 3Ds Max, and others. I have experience with Blender, so what is what I will talk about briefly.

There are many online tutorials for Blender (you can find many on this page: http://en.wikibooks.org/wiki/Blender_3D:_Noob_to_Pro/Tutorial_Links_List). The learning curve is somewhat complex, but once you learn how to successfully create and texture a simple model, things get easier. I am by no means an expert, or really even good at modeling, but making your own models at least as place holders can really make development faster. You can always change the models, but if you are waiting on models before you can do code related stuff, the development process really slows down. The great part is that importing 3D models from Blender (and really, most other 3D modeling software) is extremely easy.

View the second part of this series here: Link

For those who haven’t been following It’s a City building simulation game with a unique RTS twist. This is a very very very early form of the game. This simply consists of the foundation on which I’m going to develop my game. I have a few (poorly made) models but the real magic happens behind the scenes in the programming that simulates this world. Check out the Simulated City Game page (link above) to view about these stats and how the simulation works. I have created a video of the game (below) and took quite a few screen shots.

Simulated City Game video

If you view the video, make sure you pay attention to the stats, and how they change as I build the city. This video shows quite a few things.

Achievements: This video shows two achievements, Barter System, which is an economic achievement, and Community, which is a social achievement. Achievements are what define your civilization, and certain achievements make other achievements possible to get, and bar you from achieving others. The third achievement (not shown in the video) is Tribalism, which is unattainable when you get community. In the future, I may make this barring more flexible, as civilizations do change with time. Achievements also open up new buildings, techonology, and even new game mechanics. At a certain point, a civilization will be rewarded with an economic achievement (probably called currency) that will allow the player to enact taxes. Different tech trees will allow different forms of government, and there are further implementations that I haven’t even thought of yet! The achievement system really makes the possibilities almost endless!

Simulations: This is the bread and butter of my game. This is what makes the world change with time and what will (in the future, once I develop this game further) make the world interactive. Eventually I will have actual moving parts! I plan on adding civilians who will walk around (probably spawn at certain buildings, and un-spawn at others, perhaps going to work, going out to have fun, etc.) and a combat system. Right now, you can see this simulation unfold by watching the stats change as the player (me) builds different buildings. You can see how certain buildings depend on others (IE trade carts need goods to trade! so farms have to be built for people to start working at trade carts). I also simulate the global averages for other civilizations near yours. This will give a point of reference when calculating various stats about your city (like desirability, which uses the global averages), and in the future, determining things like trade agreements, war, etc.

Misc: The video also shows various other features of the game. I have a few sound effects in the game (some for buildings, general ambiance music, and error sounds (like when you try to build, but can’t). It also shows the GUI, which has menus for building, achievements, global stats, city stats, and a message system that hasn’t been utilized yet. It also has text alerts at the bottom of the page (for things like not having enough money, being blocked from building, etc.) The game also features 6 spiffy (read terrible) models!

 

The Future: For the future, there are several things I want to implement. As I stated above, in the long term future, I want to get a combat system, and a robust implementation of the achievements. The achievements will be one of the main game play mechanics that the player will interact with. In the near future, in addition to adding more content (buildings, achievements, etc.) I want to add some new mechanics. This includes:

  • Simulate Wealth gain/loss
  • Supply and demand
  • static, low frequency population increase (due to births and stuff)
  • Upkeep and revenue generation from buildings

And this game still needs a name! If you have an idea for a name, leave it on the Simulation Game page (link above!). Any other comments or questions, leave them below! Suggestions, and feedback is welcome!

View the screenshots below (which I started taking after I stopped recording the video)

This slideshow requires JavaScript.

The music streaming service Spotify took a hit today after over 200 labels, which all fall under the distributor STHoldings dropped their agreement. The main article can be read here: http://venturebeat.com/2011/11/19/spotfiy-stholdings-labels/

To be completely honest, I am unsure of what to think of this development. On one hand, losing over 200 labels is a terrible precedence. If other labels agree with this distributors rational for dropping suit, and follow their lead, this could usher in a domino effect. STHoldings, being only one independent European distributor, lack the capacity to do any real damage, but if the larger American labels find their claims to be relevant, and follow suit, this could effectively kill Spotify. Granted, this is only a hypothetical scenario, and as with any hypothetical, its quite possible that nothing of the sort will happen.

Spokesman from the distributor say that continuing doing business with Spotify isn’t financially beneficial. They claim that their decision to drop the contract is due to the streaming services inability to meet acceptable levels of revenue, as well as the negative impact that the service has on the distributors sales. Clearly, without access to their financial data, I can not speak to the voracity of this claim.However, anecdotal evidence suggests that their may be merit to these claims. Thinking about these transactions logically, one might expect sales to fall off for users of the service. Considering that most people already paying for access to their favorite songs would be unlikely to purchase those same songs simply for the pleasure of owning them. The distributor would have had to expect that revenue gained from Spotify would offset these losses, but if the distributor is to be believed, they clearly haven’t.

Now, this begs the question: is this an isolated incident? Is there something unique about the arrangements between STHoldings and Spotify that leads to the unsatisfactory revenue, but that doesn’t apply to most other distributors? The real danger lies in the fact that upon seeing this, many other distributors may see this and then review their own financials. If they find themselves in a similar situation, the dye would have been cast and Spotify, along with services like it, could find themselves at the event horizon.

While personally I’m not a fan of music streaming services beyond the occasional interaction with Pandora, I would hate to see an entire medium killed off. If Spotify (and others like it) are indeed doomed, the failure would be so swift that I believe we would see the end of streaming services, because we wouldn’t have a chance to take a second look at the business model, and try to make it more feasible.

An interesting quote from the article reads:

"Add to that, the feeling that their music loses its specialness by its exploitation as a low value/free commodity. Quoting one of our labels “Let’s keep the music special, f*ck Spotify"

As a Capitalist, I can surely sympathize with the distributors financial predicament, but I draw the line at their claims that music streaming services devalue the product. You don’t have to be a financial guru or music industry insider to see this claim as the nonsense it is. The “specialness” of a song is gained from access to the product, not how the product is delivered. That would be like saying that I enjoyed the book I just read a lot more because I went to the store during business hours and waited in line to buy it rather than downloaded it 2:00 AM to my Kindle when I couldn’t sleep and had nothing to do. Regardless of how you listen to your music, whether it be individual songs or entire albums, what makes the music special is the connection you feel to it, and having it on demand. Not many can argue with the fact that Spotify, along with internet radio and other streaming services are a step forward for the music industry. Not only do Spotify and similar services unshackel revenue growth previously limited by distribution networks set by brick and mortar outlets, they provide the only digital competition to iTunes, as well as an easy alternative for those who would normally pirate their music. One thing that STHoldings doesn’t seem to realize, is that many of the people who use Spotify are actually converted pirates. Getting rid of Spotify will only cause the users to go back to their original pirating ways.

Let’s face it, today it’s all about catering to your clientele, and although I’m unlikely to lose any sleep over the fate of Spotify I would hate to see the this distribution cancellation become the beginning of some sort of trend.