[Game] Adrenaline Racing – My New Game on Google Play

Put the pedal to the metal in my latest game on Google Play! It’s a topdown racing game with a small twist. The roads are not straight and this makes the game more fun. Also the position of the handheld it’s horizontal and this way it’s more natural than vertical topdown racing games. Give it a try and leave some feedback.

Here’s the Google Play store link.

In the next update I’ll introduce accelerometer handling and some user experience improvements based on user feedback.

 

[Blog] My First Game on Steam – 60K downloads

Purgatory it’s my first game developed for PC. Here’s the steam page http://store.steampowered.com/app/473470. It’s a tactical rpg with pixel art. The game is created from scratch with Unity3d and I’ve created all assets from pixel art to code architecture. It has a lot of influence from our childhood masterpiece Heroes III. I just loved that game. I’m happy that now I can develop games and hopefully one day create a solid game that will be just as half fun as it was Heroes.

And here’s a SteamSpy screenshot:

Purgatory

I wasn’t expecting almost 60k downloads. Wow! So I thanks all guys out there that downloaded the game. It means a lot for me and give me a boost of confidence to create better games.

We’ve made couple of mistakes regarding early launch but we’ve fixed them in the following patches. Lesson learn!  Now I’m working with Ross, they guy behind New Reality Games, on the Purgatory successor which will be better polished and will have more content. User feedback it’s was crucial to us. I’ll keep you posted with updates. For now here’s a sneak peak:

Purgatory_2

[Code][Unity3d] Quick And Dirty Object Pool Manager

Object pool managers are very useful when building optimized mobile games. Instantiating a new GameObject takes time, and when you have lots of objects to instantiate like bullets or ships you need a architecture that bypasses the the objects instantiation. The solution is simple: instantiate the objects and disable and enable them when needed.

ObjectPoolManager

I created a quick and dirty object pool manager that manages to reuse GameObject instances organized by tags. This means that when request from the pool manager a new instance is served based on the prefab tag provided. The idea it’s simple – create 2 lists of GameObject instances, one for the disabled objects one and another for the enabled ones. When you need an instance of an object with certain tag the pool manager tries to pull one from the disabled list, if none is found then it instantiate a new one based on the provided prefab.

To be more clear I’ll make and example of usage:

//"shipPrefab" it's the GameObject prefab provided
GameObject newShip = PoolManager.Instance.GetObject(shipPrefab);

Now it’s done. When you disable or enable the object the pool manager handles all things for you. Easy peasy lemon squeezy!

Now the magic behind this:

The PoolManager class looks like this. It is inheriting the Manager class that makes it behave like a singleton and can be access with static parameter Instance. In the next posts I’ll share the Manager class and give more in depth explanation. For now this is how it looks.

public class PoolManager : Manager<PoolManager> {

    #region Helpers
    public class Pool
    {
        public List<GameObject> enabled = new List<GameObject>();
        public List<GameObject> disabled = new List<GameObject>();

        public GameObject GetObject()
        {
            //check if disable has objects
            if(disabled.Count > 0)
            {
                //get the first one
                GameObject obj = disabled[0];

                //setActive
                obj.SetActive(true);

                return obj;
            }
            return null;
        }

        public GameObject AddNewObject(GameObject prefab)
        {
            //Create new instance
            GameObject obj = Instantiate(prefab);
            ObjectPoolable objPoolable = obj.AddComponent<ObjectPoolable>();
            objPoolable.SetPool(this);
            
            //add object to enabled
            enabled.Add(obj);

            //retun it
            return obj;
        }

        public void Enable(GameObject obj)
        {
            disabled.Remove(obj);
            enabled.Add(obj);
        }

        public void Disable(GameObject obj)
        {
            enabled.Remove(obj);
            disabled.Add(obj);
        }
    }
    #endregion

    #region Private Vars
    public List<string> tags = new List<string>();
    public List<Pool> objPools = new List<Pool>();
    #endregion

    public GameObject GetObject(GameObject prefab)
    {
        string tag = prefab.tag;

        GameObject obj;

        int index = tags.FindIndex(y => y == tag);

        if (index > -1)
        {
            //get the corect pool
            Pool pool = objPools[index];
            obj = pool.GetObject();

            //check if has disabled object, if not create a new one
            if (obj == null)
                obj = pool.AddNewObject(prefab);
        }
        else
        {
            //add new pool
            tags.Add(tag);
            Pool newPool = new Pool();
            objPools.Add(newPool);

            //Create a new instance of prefab
            obj = newPool.AddNewObject(prefab);
        }

        return obj;
    }
}

The trick to make the object pool manager simpler to use is to create a component (named ObjectPoolable) that attaches to the GameObject that is pooled and when the object gets disabled it auto pulls himself from the pool manager enabled list and adds it to the disabled list. Here’s the ObjectPoolable class:

public class ObjectPoolable : MonoBehaviour {

    #region Private Vars
    private PoolManager.Pool _pool;
    #endregion

    void OnEnable()
    {
        if (_pool != null)
            _pool.Enable(gameObject);
    }

    void OnDisable()
    {
        if (_pool != null)
            _pool.Disable(gameObject);
    }

    public void SetPool(PoolManager.Pool pool)
    {
        _pool = pool;
    }
}

On the link below can find the two .cs file needed for the object pool manager.

PoolManager_cs_files

Hope it helps. For any clarification and question don’t hesitate to use the comments section.

[Code] Unity3d Quick Tip: Better Organize Variables in Inspector

Have you ever had problems organizing your variables in the Unity’s Inspector? Too many of them? Here’s a quick fix that helps a lot when dealing with scripts with many public variables.

Header

You can use in your scripts the HeaderAttribute (here’s the link to Unity’s documentation) before the group of variables. Here’s the code snipet (c# code):

[Header("Input")]
public InputForCar swiper;

[Header("Stats")]
public float shieldDuration;
public float strifeDuration = 3;
public float speedUpDuration = 5;
public float strifeMultiplier = 1.5f;
public float speedUpMultipleier = 1.5f;
public float timeBeforeKickIn = 0.1f;

[Header("Strife detection")]
public float radiusForStrife;
public Vector2 boxInvulnerability;

Very easy way to keep track of the groups of variables. Adds a plus to productivity.

[Game] Upcoming Racing Car Game

As I’ve promised in the last post, I’ll give some teasers about my new racing car game. It doesn’t have a name yet so I’ll refer to it for now as “the racing game”. Here’s a screenshot.Racing Car GameYeah, the player car drifts. Hell yeah, it gonna be fun. The objective of the game is to reach the checkpoints before the time runs out. To do that you need to switch lanes, avoid traffic cars, pick up speed power ups and drift.

The gameplay core mechanics are implemented. Right now I was working on the other scenes to implement the panels and all that GUI stuff. Here’s the car selection scene where you can choose your car and modified the stats of it.cars3As I advance with the development I’ll post updates. Hope that by the end of this week to wrap up the game and prepare it for app store review.

[Art] Step-by-step Children Book Illustration

It has been a while since last post. Not good. Despite the fact that half of the year has past I’ll try to cover the lost ground and keep one of my New Year’s resolutions: get more exposure and keep the blog updated. So here we are, no more talk, let’s put some content to this blog post.

Today, in a break of my usual work (the following blog post will spill some details about the current game I’m working on), I’ve made a cute illustration for poem book of a friend of mine. The poems are for little kids and they are very lovely so I got involved with the project.

Here’s the process. Firstly I’ve stated with a sketch.

Sketch - Children Book IllustrationI’ve kept the sketch on separate layer turned down the layer transparency to 20-30% and created a new layer for the tired cat. Damn, that cat looks so tired :)).

Then I’ve added some blobs of colors, one by one and made form time to time with some puffy brush some shadows. With a hard brush I’ve made the finer details like eyebrows and eyes.

I’ve made a collage of couple of screenshot to be easier to follow the process. The numbers of layer I’ve keep to the minimum, I didn’t felt the need for more than one per item/character.

Collage - Children Book IllustrationHope that showing a bit of the drawing process it will help some of you guys. Oh, and of course, all critics and comments are welcomed.