The Infernicore: Flash Game to Unity Game Part 2

This is the second part of the two-part post where I’m describing my experience with transferring a Flash game into Unity. In the first part I went over the differences in the physics and overall coding structure between the two pieces of software. In this part I’ll talk about creating objects dynamically, as well as my findings with transferring graphical assets.


Unless I’ve overlooked something, in Unity you can’t spawn objects from your project panel directly into your game scene without having had a reference to them already at compile time. But I really don’t think this should be a deal-breaker for any game. It’s quite simple to do. For example, in The Infernicore, I created a script called ICMain and attached it directly to the Main Camera object as a Component (the Main Camera is created in every scene by default). Within the ICMain script itself, I declared a variable called oreObject. Upon saving the script and returning to the Unity editor, I saw that “Ore Object” became a property in the Inspector Panel of the Main Camera object. I could then drag my Ore prefab from my project Panel directly onto the “Ore Object” section of the Inspector Panel. Voila! My main then had a reference to an Ore object, in code, that it could create at will. When I needed to do just that, I called Unity’s Instantiate()method and a new Ore object was created.

Referencing Objects to Instantiate
Create a variable and drag the object from your Project Panel to this field in the Properties Panel.

Like I said, I don’t think being required to have a reference to an object at compile-time is necessarily a really bad thing. I can understand how someone, especially a programmer, may balk at the idea at first, perhaps claiming that it limits control over the project, but I think the way Unity handles it will work in the vast majority of situations.

UPDATE: It turns out there actually is a way to instantiate objects without having a direct reference to them at compile-time. Simply place them into a Resources folder and use Instantiate(Resources.Load(“Object”)) instead. This method does have its own pros and cons, however. See this page for more information.


Since The Infernicore was originally a Flash project, all of its graphics were vector-based. Fortunately, however, converting vectors to bitmaps is quite simple with the newest version of Flash Professional.

One thing I want to talk about is utilizing textures with alpha channels, despite their irrelevance to this particular game. When we first started developing this project in Unity, we weren’t sure if we wanted to do everything in 2D or 3D. We settled on 3D eventually, which meant that alpha textures were more or less not needed, due to the 3D models using form-fitting skin textures instead. When I first searched for the answer of how to use alpha textures, I was met with directions that told me to install plug-ins for Photoshop. That seemed like a pretty janky solution, and it confused me as to why something like that would be on Unity’s site when it actually wasn’t necessary.

In order to use alpha textures, you simply have to ensure that the background of your image is removed (such as by deleting the background layer in Photoshop and cropping the image accordingly), save it as a PNG, import it into Unity, create a material for it, and set the material’s shader to Transparent/Diffuse. This worked like a charm for me.

We still plan on using 2D images for things like backgrounds and GUI elements, obviously. And when it comes to all of the different screen sizes for the myriad of Android phones out there, I definitely have some testing to do. I may post my findings on that adventure later on, but for now I’ll leave it at this: the transition from Flash game to Unity game has been relatively painless, and I hope others can say the same.

The Infernicore: Flash Game to Unity Game Part 1

Jestermen’s first game project, titled “The Infernicore”, began as a casual Flash game I created in my spare time over a year ago. But then came the time to get into the real world of game development; The Infernicore needed a make over, and Jestermen decided that Unity was the right tool for such a job. In the next couple of posts I’m going to highlight some of my experiences with transferring The Infernicore from a Flash game to a Unity game.


If you’re familiar with Flash game development, then you know that there is almost nothing inherent in ActionScript 3.0 that makes it easy to simulate physics. Of noteworthy exception are the built-in collision detection functions, but effects such as gravity and velocity must be handled solely by the developer unless he or she decides to utilize plugins or other frameworks like the popular Box2D. I decided to handle all physics simulation on my own in the Flash version of The Infernicore rather than delegate those tasks to outside libraries so I could maintain full control over my project. That’s not to say that I think utilizing libraries is a bad thing; I just find it more rewarding and simpler to organize when I’m able to solve such problems on my own.

When bringing The Infernicore into Unity, one of the bigger decisions I had to make was whether or not I wanted to keep the physics logic I had already written in the Flash version or replace it with Unity’s pre-built physics engine. Gravity, velocity, and collision detection are automatically supported with Unity, and would only require accessing the requisite properties and functions when necessary. That’s exactly what I did when it came to collision detection. One interesting note, however, is that I actually had to scale down each ore object’s Box Collider Component by 10% in order to attain the desired results. If I hadn’t done this, then collisions would have been triggered when I didn’t actually want them to; namely, when two ores’ edges were touching but not actually overlapping. For the purposes of this game, where ores are constantly sidling up next to each other, I needed to have a smaller “hit box”, if you will.

When it came to velocity and gravity, I fell back to my old Flash habits. I experimented with Unity’s gravity at first, but I kept getting unexpected results. That’s not to say that there’s anything wrong with Unity’s physics (I have no reason to believe that there is), but it felt and looked better to just use “fake” gravity by manipulating objects’ y-coordinates through the game loop. In the future I may take another shot at using Unity’s built-in velocity and gravity functions, but for this project they weren’t necessary.


Coming from an ActionScript 3.0 background, I found it incredibly helpful to be able to do all of The Infernicore’s code in JavaScript when I put it into Unity. The syntax differences between AS3 and JS are very few and far between. In fact, I literally copied and pasted all of the source code from my AS classes into JavaScript files that I created directly from the Unity IDE. Of course, heavy modification was required, but I was able to keep some of the code exactly the same.

The biggest change between AS3 and JavaScript was undoubtedly the lack of events and event listeners in JavaScript. That functionality had to be replaced with code that directly accessed objects that needed to be talked to, rather than dispatching and listening for events.

Some other changes included: replacing my class constructors with Unity’s Awake() function (it serves basically the same purpose); detecting keyboard input during the main game loop instead of listening for key press events; utilizing delegate methods to simulate changing game screens (very interesting concept); accessing other Components and Game Objects via Unity’s methods (see my previous post for more information); and wrapping my brain around the fact that (as far as I’m aware) it’s not possible dynamically instantiate objects in Unity without references to them beforehand. But no worries! That’s not as bad as it sounds.

In my next post I’ll go over how to create objects at run-time, as well as my experience with converting graphical elements from Flash to Unity.

Unity Components: Scripts

One of the things I really enjoy about Unity is the way the engine handles objects in the game world. Everything you add to your game scene is inherently a Game Object, which is a data type built into the engine. The interesting part is the ability to attach different Components to any Game Object. For example, going to GameObject > Create Other > Cube will spawn a cube object in the scene with four pre-defined Components attached to it: Transform, Mesh Filter, Box Collider, and Mesh Renderer. But really it’s the same thing as if you had gone to GameObject > Create Empty and added those Components to the newly-created object manually. If you need to, you can even remove most of the Components. This allows a wide range of customization options for game objects within Unity.

Scripts are also considered Components that can be attached directly to Game Objects. They essentially provide the developer the ability to manipulate an object by giving allowing more control over it via a programming interface. From within a script, the developer can access any part of its parent Game Object, including its other Components and their properties.

Since all components except scripts have pre-determined names, accessing them through a script requires the knowledge of each Component’s corresponding property name within code. The entire list, along with every Component’s description, can be found in the official Unity documentation, but here they are in a nutshell:

  • Transform is accessed as transform
  • Rigid Body is accessed as rigidbody
  • Renderer is accessed as renderer
  • Camera is accessed as camera
  • Light is accessed as light
  • Animation is accessed as animation
  • Collider is accessed as collider
Script Example
Accessing the Mesh Renderer Component attached to this script's Game Object when the object is created at run-time.

In order to access another script on the current object, you’ll have to refer to the name of the script directly by passing it to the GetComponent method. For example, if I want to access the “CharacterController” script but I’m currently in the “Main” script, I would use GetComponent(CharacterController).propertyName.

Accessing Other Scripts
Use the other script's name in order to access it.

In the example above, you can see references to several components and properties within the thisOre GameObject. Its x- and y-coordinates can be found within the Transform Component attached to the object. Those properties are set to variables that have been determined in other locations, one of which is the height variable that is only accessible by retrieving it from thisOre’s “ICOre” script.

Scripts can access not only the Components within the Game Object to which they are attached, but also any Game Object in the scene. This essentially allows the developer full control over any aspect of their game, through code. There are many ways to access other objects. So far I’ve found that GameObject.Find and FindObjectOfType have been reliable for accessing specific objects and scripts, respectively.

Accessing Other Objects
Any object or script can be referenced easily when needed.

Being able to reference the properties and methods of Components within a script’s corresponding Game Object, as well as the properties and methods within other objects’ Components is vital for maintaining full control over your project. Luckily, Unity makes such things very easy to do, with clear instructions right on their site.

Finally, one of the best things about Unity’s scripting is that it allows any of three languages: JavaScript, C#, or Boo (a dialect of Python). As I come from primarily an ActionScript 3.0 background, it was a great surprise to find that writing in JavaScript is almost identical to the way I do things in AS3. I would imagine that other programmers who are interested in Unity but could be wary of having to learn an entirely new language may breathe a similar sigh of relief.

The Decision to Use Unity, Part 2

So, what makes Unity better than the other game engines, in our eyes? That’s what I’d like to go over in this post. There are several reasons Matt and I chose Unity as our game engine for Jestermen’s first project, “The Infernicore”.

Its Simplicity

Unity's UI
Relatively simple, but effective!

Unlike quite a few other pieces of software I’ve used, Unity’s interface is exceedingly simple. It is intuitive, easy to use, and allows the user all of the options he or she needs without requiring row upon row of toolbars and menus. In fact, there are only five main panels within Unity: Scene, Game, Hierarchy, Project, and Inspector. The Scene panel displays the game assets during construction; easily navigable using common keyboard/mouse controls (such as holding Alt + dragging with left click to rotate the scene). The Game panel offers a view of the game as the user would see it; in fact, by simply pressing the play button at the top of the interface, one can immediately begin playing the game. The Hierarchy panel lists all assets that are currently in the scene. The Project panel displays every file that is in the Assets folder of the project for quick access to dropping any of them into the scene directly. And the Inspector panel simply waits for you to click on something, at which point it will display all properties associated with the clicked object. Of course, there are other buttons and menus, but the point is that none of them are vital to the core development process, which is why it was a smart move to keep them hidden until they’re needed.

Its Target Platforms

Unity 3D version 3.5 offers a new publishing option which has a potential that is quite difficult to overstate. Its ability to build projects directly into SWF files that automatically run in Adobe Flash Player means developers who want to distribute their content through the web no longer have to worry about whether sites support the Unity Web Player. And now that Flash Player 11 has a new 3D graphics rendering engine, the fact that Unity creates 3D content is also not a problem.

Unity 3D Build Settings
So many options, so few clicks!

Flash Player support isn’t the only upside to Unity’s publishing potential, however. The fact that it can build to so many different platforms without modifying a single line of code, as well as the ability to switch between target platforms with the click of a button (literally, just one button!) should be even further cause for excitement. PC standalone, Mac standalone, Flash Player, Unity Player, Android, iOS, XBox 360, PlayStation 3, and Wii build options are all supported.


Its Robustness

As if simplicity and distribution potential weren’t enough, Unity comes packed with enough features to make one wonder exactly why the entire program doesn’t require a purchased license in order to use it. For example, its built-in physics engine means developers don’t have to spend time messing with things like gravity and collision detection unless they really want to. Simply use the included script editor to apply a script with an OnCollisionEnter function. If more information is desired, the full documentation for every aspect of Scripting in Unity can be found on Unity’s website. JavaScript, C#, and Boo are the supported scripting languages. For the full list of features, look here.

What’s the downside to all of this? Surely it sounds too good to be true. I thought the same thing myself. And while I’m not exactly an expert Unity developer yet (I’ve only been using it for a couple months at most), I think I’ve seen enough to know that the pros greatly outweigh the cons. But as far as I can tell there is only one major con: the cost. Most features are present in the basic version, but building to anything except PC/Mac standalone and the Web Player will require a fee of some kind. Building to Android or iOS requires a $400 license for each. The Pro license costs $1500. And when version 3.5 comes out of public beta, publishing for the Flash Player will also require a fee. Jestermen encourages anyone to snag the basic version and actually develop something first, though. That’s what we’ve done, and we fell in love with the program. Try it and see!