Shooting Stars! out now!

How to support multiple languages in Unity

June 29, 2015

Together with our Publisher Noodlecake we have decided to translate Shooting Stars in order to boost the reach of the game. For the initial release we have decided to go with the 7 most common (AppStore) languages English, German, Italian, French, Spanish, Portuguese and Russian.

To implement more than one language without a lot of fuzz, we wanted to find a solution that perfectly fits our workflow. After a couple of experiments we have decided to create a custom Text component that allows our designer to easily build localized interfaces without the need to write a single line of code. To keep things simple, we are using simple .txt files to store our internationalized strings as key-value pairs.

For example:

key=This is a test text

So there is a .txt file for every language we support, with same keys and translated values. To prevent lags during gameplay I load the right language file in a static Dictionary on app start. As a fallback I also load the english version in a separate Dictionary in case of a missing key.

Next step was the actual display of the translated text. Therefore I have overridden the built in Text component and added a key field to my new component.

This is how I load the strings from the file into a Dictionary:

private void LoadLanguage(string lang){
    fields.Clear();
    TextAsset textAsset=Resources.Load("I18N/"+lang);
    string allTexts="";
    if(textAsset==null){
        textAsset=Resources.Load("I18N/en");
    }
    allTexts=textAsset.text;
    string[] lines=allTexts.Split(new string[] { "\r\n", "\n" },
        StringSplitOptions.None);
    string key, value;
    for(int i=0;i < lines.Length;i++){
        if(lines[i].IndexOf("=") >= 0 && !lines[i].StartsWith("#")){
            key=lines[i].Substring(0, lines[i].IndexOf("="));
            value=lines[i].Substring(lines[i].IndexOf("=")+1,
                    lines[i].Length-lines[i].IndexOf("=")-1).Replace("\\n", Environment.NewLine);
            fields.Add(key, value);
        }
    }
}

The custom Text component:

public class TextI18N : Text {

    public string i18NKey;

    void Awake(){
        Refresh();
    }

    public void Refresh(){
        text=I18N.Instance.Get(i18NKey, false);
    }
}

UPDATE

After posting this tutorial on reddit, the user justaghostofanother wrote a super detailed do's and don'ts about localization which can be found in the /r/unity3d thread.

Add the date to your calendar (ics file)

Shooting Stars is coming July 9th

June 24, 2015

As most of you may know, we've spent the last six months working non-stop to create the worlds best mobile game called Shooting Stars! This game strives to combine great gameplay, super easy controls and lots and lots of fun. Or in other words, we drank about 12 megatankers of coffee, fred bull and horst limo (they should start paying us for this shameless product placement).

And as the first reviews and hands on are coming in, it seems like we've done a pretty good job! But hey... we are not here to tell you how awesome we are, we are here to tell you, how awesome every single one of you is! Without your help and feedback, we wouldn't have made it this far! Thanks a million! (delivered with rainbow glitter)

And since you are super important to us, we want to share a huge secret with you. Are you ready?

🎈Shooting Stars will be available July 9th for iOS🎈

For us, this announcement feels like birthdays, international burger day, rainbow unicorn day and stroke a kitty day coming all at once! Supercalifragilisticexpialidocious, isn't it? So, we've decided to put together a new Release Trailer just for this super awesome! Ready, set, watch!

AppStore: https://itunes.apple.com/us/app/shooting-stars!/id1000418188?ls=1&mt=8 This game is the answer to one of the most important questions in life: "I can haz lazer kitty?" Yes you can! Shooting Stars is a refreshing colorful and funny take on the classic arcade shoot'em up, bullet hell, shmup, space invader like, whatever you want to call it - but finally, with evil aliens disguised as superstars, cats and rainbow lazers.

Android Version coming later that July

We did not forget about you fellow Android folks. Shooting Stars is coming for Android in July too but we need to do some more polishing and testing. And everyone knows that shipping a buggy version sucks.

Except the fact that we're so incredibly excited about the upcoming weeks there's nothing to add!

Bloodirony joins forces with Noodlecake Games

May 27, 2015

When we started to work on Shooting Stars, we planned certain milestones and things we want to achieve within our six months timebox. For example, we planned to release a nice and polished beta every six weeks. What we haven't planned back then was how are we going to release Shooting Stars. Not because we had no ideas or simply didn't want to. No, we always wanted to wait and see what happens next.

A few months later, after releasing the official Shooting Stars announcement trailer, things just started to fall into place and we just happened to be in negotiations with the lovely folks of an Canadian publisher. A publisher for mobile indie games that started pretty much like we did. A publisher that understands our needs perfectly and gives us the creative freedom to let the schwartz flow.

Ladies, Gentleman and Unicorns, we are extremely happy to announce that we are joining forces with the Canadian mobile games publisher Noodlecake Games for our upcoming game Shooting Stars.

“We are super excited to be working with Bloodirony Games on their game Shooting Stars. The second we saw it, we knew it was something special and after meeting the team at Bloodirony Games, it really was a match made in heaven.”

— Noodlecake Games

Shooting Stars will be released this July for iOS and Android. If you haven't signed up for the beta, you'd better hurry!

Oh and if you're looking for the official announcement, you can find it at the Noodlecake Games blog

How to create a random tileset in Unity2D

May 27, 2015

When it comes to the background, classic shmups usually use something like infinite scrolling. Because we are not making a normal shmup with spaceships and other flying stuff we wanted to handle this completely different.

Therefore we created a static background, which is not moving during the actual battle. To give the user some feedback regarding progress, we also move the background after defined waves or a boss fight.

To avoid creating hundreds of full sized background assets we thought of randomly create these backgrounds out of a tileset image.

This is actually quite easy, the only thing you need is a image with a defined grid of single tiles. Next thing you will need is something to draw the tiles on. I used the unity plane component with a mesh renderer for that.

First step, initialize the mesh:

int numTiles = size_x * size_y;
int numTris = numTiles * 2;

int vsize_x = size_x + 1;
int vsize_y = size_y + 1;
int numVerts = vsize_x * vsize_y;

Vector3[] vertices = new Vector3[ numVerts ];
Vector3[] normals = new Vector3[numVerts];
Vector2[] uv = new Vector2[numVerts];

int[] triangles = new int[ numTris * 3 ];

int x, z;
for(z=0; z < vsize_y; z++) {
    for(x=0; x < vsize_x; x++) {
        vertices[ z * vsize_x + x ] = new Vector3( x*tileSize, 0, -z*tileSize );
        normals[ z * vsize_x + x ] = Vector3.up;
        uv[ z * vsize_x + x ] = new Vector2( (float)x / size_x, 1f - (float)z / size_y );
    }
}

for(z=0; z < size_y; z++) {
    for(x=0; x < size_x; x++) {
        int squareIndex = z * size_x + x;
        int triOffset = squareIndex * 6;
        triangles[triOffset + 0] = z * vsize_x + x +           0;
        triangles[triOffset + 2] = z * vsize_x + x + vsize_x + 0;
        triangles[triOffset + 1] = z * vsize_x + x + vsize_x + 1;

        triangles[triOffset + 3] = z * vsize_x + x +           0;
        triangles[triOffset + 5] = z * vsize_x + x + vsize_x + 1;
        triangles[triOffset + 4] = z * vsize_x + x +           1;
    }
}

// Create a new Mesh and populate with the data
Mesh mesh = new Mesh();
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.normals = normals;
mesh.uv = uv;

// Assign our mesh to our filter/renderer/collider
MeshFilter mesh_filter = plane.GetComponent();
MeshCollider mesh_collider = plane.GetComponent();

mesh_filter.mesh = mesh;

Next step, split your background image into single tiles:

private Color[][] SplitTiles() {
    int numTilesPerRow = texture.width / tileResolution;
    int numRows = texture.height / tileResolution;

    Color[][] tiles = new Color[numTilesPerRow*numRows][];

    for(int y=0; y < numRows; y++) {
        for(int x=0; x < numTilesPerRow; x++) {
            tiles[y*numTilesPerRow + x] = texture.GetPixels( x*tileResolution , y*tileResolution, tileResolution, tileResolution );
        }
    }

    return tiles;
}

Final step, draw your random tiles on the mesh:

int texWidth = size_x * tileResolution;
int texHeight = size_y * tileResolution;
Texture2D newTexture = new Texture2D(texWidth, texHeight,texture.format, false);

Color[][] tiles = SplitTiles();

for(int y=0; y < size_y; y++) {
    for(int x=0; x < size_x; x++) {
        Color[] p = tiles[Random.Range(0, 30)];
        newTexture.SetPixels(x*tileResolution, y*tileResolution, tileResolution, tileResolution, p);
    }
}
newTexture.anisoLevel=1;
newTexture.mipMapBias=0f;
newTexture.filterMode = FilterMode.Point;
newTexture.wrapMode = TextureWrapMode.Clamp;
newTexture.Apply();

MeshRenderer mesh_renderer = _plane.GetComponent();
mesh_renderer.sharedMaterials[0].mainTexture = newTexture;

With a shader on top the final result looks like this

Download Unity 5 Sample Project

As with every previous tutorial, we provide you with a sample project for Unity 5.

Download Unity 5 Project

Foodwar: Voxel vs. Pixel (updated)

May 8, 2015

A few weeks ago we've been at the very relaxed A Maze Festival in Berlin. Besides presenting Shooting Stars to an incredible crowd I accidentally started a voxel vs. pixel foodwar with my buddy Josef – Whoops!

On top of that, I even lost the first round. But luckily for me, Josef is challenging me for a second round and now it's time to defend my honor.

Ladies, Gentleman and Unicorns, are you ready for the second world changing and mesmerizing voxel vs. pixel Foodwar?

In the left corner of the ring, Voxel-Josef and in the right corner, Pixel-Stefan.

Ready, set, vote! [UPDATE: voting is over]

Please help us to determine a winner for the second voxel vs. pixel Foodwar.

Btw: Josef is using his cool voxel stuff for a pretty cool game called "Checkout".

"Checkout" is a playful commentary about modern day society, consumption and the gap between rich and poor. You are playing a supermarket cashier who works really hard to achieve just about minimum legal wage. At the same time you are contributing to the profit growth of a global food retail chain and its owner's astronomical wealth.

"Checkout" is developed by Josef Wiesner & Felix Bohatsch and combines social commentary with the arcadey fun of improving your scanning skills.

Update

We have a winner!

Unfortunately, it's not me. But I want to thank the 172 voters to participate in our foodwar. And I especially want to thank those 80 beautiful people who voted for me. I will definitely challenge Josef for a third round, whenever my broken ego is healed.

Anyway, congratulations Josef, you have earned this victory.

Top community comments on Shooting Stars

April 24, 2015

In order to understand todays blogpost slightly better, you need to apply two of the very basic cool-kids-indie-studio-club rules.

Rule #1: take life super seriously.
Rule #2: act professional, always.

Those two rules are the foundation of everything we do and why we do what we do so professionally.

A Maze Festival – here we come.
A MAZE. Festival Berlin – here we come. Thx to our buddies from Blossom, Securebeam, sharedspaces.at and Stockwerk Coworking for helping us out.
Posted by Bloodirony Games on Tuesday, April 21, 2015

Thankfully, most of the people who signed up to our beta or commented on our channels understood those two rules very well. So, we have decided to share some comments that fit our quirky humor.

The music of Marc Bolan & T Rex can often be used to soothe a rash or hush a cranky child.
– Mothy
Oh my George Foreman! That looks amazeballs! 😃😜😃
– skylined87
Stop saying "awesome" already!
– Jonathan
I am hungry to defile Justin Belieber by using a big f*cking cat gun!
– Markus
I’m the worst online player between Scheibs and Nebraska.
– Martin
IT HAS BACON!!!
– Design by Adrian
David Bowie is likely an alien.
– Matthew

And then there is one comment that captured my heart on our toucharcade thread:

I still can't get over the fact, that these small indie studio's that consist of only 2/3 (very talented) people, can produce such amazing, high caliber and fun games. Bloodirony Games, Bloody Awesome 1st game! Looking forward to the release in July (also my birthday that month).
– new_ipodtouch5G_owner

If people keep signing up at this rate and leave comments like that, it's likely that we will update this post regularly.

How to create a Lightning Strike in Unity2D

April 20, 2015

After creating some Sci-Fi attacks like the Rainbow Lazer or the Ro-Cat-Paw Launcher we thought the next special attack should be something more RPG like. So this Blogpost is about how I created a cool chaining lightning strike.

The main idea behind the lightning is to have some line renderers between enemies and generate random line renderer points to get some movement into it. To get amount of points I callculate the distance from the lightning source to its target and split it into segments. After that i know how much points I need. To get the distance between our hero and the enemies I maintain a list of all alive enemies. Just add some randomness and you are almost done.

To make the line renderers look like lightnings I used a texture with a gradient. To make it even more better looking I added one more line renderer simulating a light.

For creating single lightning Bolts I created a separate class:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class ChainLightning : MonoBehaviour{
    [Header("Prefabs")]
    public GameObject lineRendererPrefab;
    public GameObject lightRendererPrefab;

    [Header("Config")]
    public int chainLength;
    public int lightnings;

    private float nextRefresh;
    private float segmentLength=0.2f;

    private List LightningBolts{get; set;}
    private List Targets{get; set;}

    void Awake(){
        LightningBolts=new List();
        Targets=new List();

        LightningBolt tmpLightningBolt;
        for(int i=0;i < chainLength;i++){
            tmpLightningBolt=new LightningBolt(segmentLength, i);
            tmpLightningBolt.Init(lightnings, lineRendererPrefab, lightRendererPrefab);
            LightningBolts.Add(tmpLightningBolt);
        }
        BuildChain();
    }

    public void BuildChain(){
        //Build a chain, in a real project this might be enemies ;)
        for(int i=0;i < chainLength;i++){
            Targets.Add(new Vector2(Random.Range (-2f, 2f), Random.Range (-2f, 2f)));
            LightningBolts[i].Activate();
        }
    }

    void Update(){
        //Refresh the LightningBolts
        if(Time.time>nextRefresh){
            BuildChain();
            for(int i=0;i < Targets.Count;i++){
                if(i==0){
                    LightningBolts[i].DrawLightning(Vector2.zero, Targets[i]);
                }else{
                    LightningBolts[i].DrawLightning(Targets[i-1], Targets[i]);
                }
            }
            nextRefresh=Time.time+0.01f;
        }
    }
}

To draw the actual lightning segments I created another class:

using UnityEngine;
using System.Collections;

public class LightningBolt {

    public LineRenderer[] lineRenderer{get; set;}
    public LineRenderer lightRenderer{get; set;}

    public float SegmentLength{get; set;}
    public int Index{get; private set;}
    public bool IsActive{get; private set;}

    public LightningBolt(float segmentLength, int index){
        SegmentLength=segmentLength;
        Index=index;
    }

    public void Init(int lineRendererCount, 
            GameObject lineRendererPrefab, GameObject lightRendererPrefab){
        //Create the needed LineRenderer instances
        lineRenderer=new LineRenderer[lineRendererCount];
        for(int i=0;i < lineRendererCount;i++){
            lineRenderer[i]=(GameObject.Instantiate(lineRendererPrefab) as GameObject)
                .GetComponent();
            lineRenderer[i].enabled=false;
        }
        lightRenderer=(GameObject.Instantiate(lightRendererPrefab) as GameObject)
            .GetComponent();
        IsActive=false;
    }

    public void Activate(){
        //Active this LightningBolt with all of its LineRenderers
        for(int i=0;i < lineRenderer.Length;i++){
            lineRenderer[i].enabled=true;
        }
        lightRenderer.enabled=true;
        IsActive=true;
    }

    public void DrawLightning(Vector2 source, Vector2 target){
        //Calculated amount of Segments
        float distance=Vector2.Distance(source, target);
        int segments=5;
        if(distance > SegmentLength){
            segments=Mathf.FloorToInt( distance / SegmentLength)+2;
        }else{
            segments=4;
        }

        for(int i=0;i < lineRenderer.Length;i++){
            // Set the amount of points to the calculated value
            lineRenderer[i].SetVertexCount(segments);
            lineRenderer[i].SetPosition(0, source);
            Vector2 lastPosition=source;
            for(int j=1;j < segments-1;j++){
                //Go linear from source to target
                Vector2 tmp=Vector2.Lerp(source, target, (float)j / (float)segments);
                //Add randomness
                lastPosition=new Vector2(tmp.x+Random.Range(-0.1f, 0.1f), 
                    tmp.y+Random.Range(-0.1f, 0.1f));
                //Set the calculated position
                lineRenderer[i].SetPosition(j, lastPosition);
            }
            lineRenderer[i].SetPosition(segments-1, target);
        }
        //Set the points for the light
        lightRenderer.SetPosition(0, source);
        lightRenderer.SetPosition(1, target);
        //Set the color of the light
        Color lightColor=new Color(0.5647f, 0.58823f, 1f, Random.Range (0.2f, 1f));
        lightRenderer.SetColors(lightColor, lightColor);
    }
}

The Result

DOWNLOAD UNITY 5 SAMPLE PROJECT

As usual, we want to share a sample project with you – so, it's much easier to understand what we are talking about. Same as last time, be fair and please don't use the graphic assets in your own games.

Download Unity 5 Project

Shooting Stars Announcement Trailer

April 16, 2015

We are super excited about the progress we've made in these past few weeks with our game Shooting Stars. We are just about to finalize the basic gameplay to finally kick off content production in order to include tons and tons of great stuff in the game.

So, let's not bore you to death, it's time to present you our first Shooting Stars Announcement Trailer.

Ladies, gentleman & unicorns. Fasten your seatbelt and enjoy the show!

New Shooting Stars Beta "Techno Viking"

We haven't spent the past few weeks just polishing our trailer. So from today on, there is a new and exciting beta of Shooting Stars in town, or at least on your phone. It's called "Techno Viking" and is completely different to what the previous beta looked like. And of course, it is not affiliated to the real Techno Viking in any way. (So, it's not a cheap ripoff, it's just harder, better and faster)

As mentioned before, we're pretty happy with the basic gameplay and most of the stuff is already where it is supposed to be. But as usual, we still have incredible arrays of open tasks and ideas to make the game even better than we as promised it to be.

If you aren't among the existing beta testers feel free to signup to our beta testers mailing list!

When is the final version of Shooting Stars coming?

There is no exact date yet, but we will launch it at the beginning of July. In the mean time, we will keep you up to date through our social media channels. (Mostly by showing you gifs of cute little kittens)

Meet us at the A Maze Festival Berlin

We are super happy to announce that we've been selected to present Shooting Stars at the A Maze Festival 2015 in Berlin. We'd love to meet you at our booth on Friday from 8pm to 12am. Just look out for this super cool hipster dude on a hoverboard with a lazer cat in his arms.

May the Rainbow Unicorn be with you!

7 Comments

How to create a Rocket-Launcher in Unity

March 23, 2015

One thing every cool action-game should have, at least in my opinion, is something like a rocket launcher. In our case, it is the death bringing Ro-Cat-Paw-Launcher, which shoots, surprise surprise, cat paws.

The main idea behind our version of the rocket launcher is, that the launched rockets start to fly along a nice curve and chase the nearest enemy after that.

To achieve that I did the following: The rocket itself is moved by an added velocity every frame. To chase the chosen enemy the rocket changes its rotation, in a limited angle each frame, toward the enemy. To prevent the rocket to circle around an enemy I increase the possible turn angle by a given amount over time.

Create the rocket with a smoke trail

Since I you may already know how you create a simple GameObject with an animated sprite renderer I want to give you some insights on how we created the smoke trail – which gives the whole scene a nice atmosphere. But basically, it's nothing less than a particle emitter with an animated texture.

Create a new Material from the Smoke trail sprite called "Smoke" and set the shader to "Sprites/Default"
Create a new ParticleSystem and set the Simulation Space to "World" – This is one of the most important parts. Every particle will stay where it was emitted (if speed is 0) and will not be moved by the parent object.
Setup speed, lifetime, size and the other parameters to whatever may fit your purpose. We wanted to reduce the movement of the particles to a minimum since the trail movement is already generated by the rocket.

As a shape we've used a pretty narrow cone, so the particles will be emitted at one central point (after burner)
In order to smoothly dissolve the particles after a while we make use of "Color by Speed" to fade out and "Size over Lifetime" to scale out the particles.

To give every particle as much dynamic as possible we've also added a little "Rotation over Lifetime"
Finally to the magic part: activate "Texture Sheet Animation" set the tiles to the number of sprites you have. In our case its just 5 sprites on the x-axis.
Drag the material you've created in the first step into the material slot and you are good to go.

The Launcher

private IEnumerator LaunchRockets(EnemyController target){
       for(int i=0;i < rockets;i++){
           float rotation=0f;
           if(i%2==0){
               rotation=Random.Range(-140f, -45f);
           }else{
               rotation=Random.Range(45f, 140f);
           }
           GameObject rocketGO=Instantiate(rocketPrefab, startPosition,
               Quaternion.Euler(0f, 0f, rotation)) as GameObject;
           Rocket rocket=rocketGO.GetComponent();
           rocket.Target=target;
           rocket.MissileSpeed=missileSpeed;
           yield return new WaitForSeconds(delay);
       }
   }

The Rocket

newRotation = Quaternion.LookRotation(transform.position - Target.transform.position, 
    Vector3.forward);
newRotation.x = 0.0f;
newRotation.y = 0.0f;
transform.rotation = Quaternion.Slerp(transform.rotation, 
    newRotation, Time.deltaTime * turn);
rocketRigidbody.velocity=transform.up * MissileSpeed;
if(turn<40f){
    lastTurn+=Time.deltaTime*Time.deltaTime*50f;
    turn+=lastTurn;
}

The Result

Download Unity 5 Sample Project

As usual, we want to share a sample project with you – so, it's much easier to understand what we are talking about. Same as last time, be fair and don't use the graphic assets in your own games.

Download Unity 5 Project

7 Comments

Ro-Cat-Paw-Launcher

March 14, 2015

Once again our Rainbow Unicorn Research Labs had an amazing technological breakthrough. We are proud to present the mighty and meowtastic RO-CAT-PAW-Launcher!

We asked the leading engineer for a statement and all he had to say was: "Relax dude, it's not Ro-Cat Science"

As usual we will soon publish a short tutorial on how we created this attack.

Insights #1: Premium vs. Free-to-Play Games

March 11, 2015

We are making great progress with the development of our game Shooting Stars and as this progress continues we have to face lots of different challenges every day. Many of those challenges have minor impact on how to play the game or how the game looks like and most of this decisions can be even changed later without much fuss. But unfortunately, life isn't just a colorful world with Rainbow Unicorns singing Eminems Slim Shady in a beautifully weird honkytonk-ish mashup. We have to face major decisions too, like going Free-to-Play or premium which will radically change the complete game.

For this reason we have decided to share some of our decisions and challenges with you and most importantly why we are going that way. Don't expect this series to be too regularly, but whenever something important comes up we'll let you know.

Free-to-Play vs. Premium Mobile Games

If you are a regular visitor on our Blog you may have already stumpled upon the fact that this is our first game as a team. So we try not to rush things and instead learn as much as possible to make rational decisions based on our core mission to save mobile gaming.

Ever since we have started with the development of Shooting Stars we had one question in mind: Free-to-Play or Premium? And after endless discussions we came to a point that the perfect fit for Shooting Stars is to become a Premium title. But how did we come to this conclusion?

Our Situation

First things first – the bigger picture: We are a small studio of three people with limited funds and a time box of six months to create (the worlds best) mobile game. Even though this is our first game as a team and the short period of six months, we are confident to do an outstanding job – especially the great feedback we receive on our first prototype (Mitch) proofs us right.

Why Premium instead of Free-To-Play?

If we fade out the needs of our target group, Free-To-Play makes total sense from a financial point of view – and our game would easily allow some cool InApp extensions. In our case, we could add new enemy celebrities, items, attacks, skins, ... every month. We have to change the overall gameplay to balance the In-App-Purchases but we may be able to establish a system with an constant income stream. To keep it short and simple: income is always a good thing and a constant income stream is even better!

In theory, to implement a system like this sounds super easy. (I imagine that everyone who reads this secretly wants to slap me in the face) – but even though it may not be that hard to implement Free-To-Play mechanics, there is a lot of overhead to consider. We need to define the Free-To-Play mechanics. We have to design and implement additional interfaces. We need to setup, test and maintain all the possible In-App-Purchases and the technical handling for two platforms. And most importantly, we need to balance those In-App-Purchases. Based on our assumptions, all this together will consume most of the time.

On top of that, we don't want to hide the fact that we are lacking Free-to-Play monetization knowledge. We don't want to start with a risky experiment in a field where we have not enough experience yet.

Going premium allows us to solely focus on gamedesign & gameplay mechanics, arts, UI/UX, sound design, the overall story and a solid polishing job – not to forget to mention all the side jobs like planning a marketing campaign for the game.

Another very important event, which gave us a huge confidence boost about our decision, was Apples promotion of Games without In-App-Purchases within the AppStore and we hope that over the course of the next months, Apple will expand that "category" further.

Furthermore, the setup of our game will be an action packed – meme-ified – pixel art – roguelike – shoot 'em up, where we are able to selectively narrow down the target audience to a mixture of various niches. This allows us to focus our marketing efforts on fewer channels without the need to tackle mainstream media in the first place.

Pricing of Shooting stars?

We haven't decided yet on what the final price for Shooting Stars will be. But we will let you know as soon as possible. In the meantime, there is an excellent read on Gamasutra about this.

your opinion on Premium vs. Free-to-Play?

We would love to hear your opinion on Premium vs. Free-To-Play. What are your thoughts when it comes to Premium, Freemium, F2P? If you are a Gamedev yourself, tell us how have you handled this decision.

Download Unity 5 Sample Project

How to create a Mega-Rainbow-Lazer in Unity2D

March 6, 2015

Every time we thought about cool special attacks we could include in Shooting Stars, the mighty Mega-Rainbow-Lazer came into our minds first. So now I will describe how we created that awesome piece of destruction.

When I thought about how to build that weapon, I feared that it will be quite complicated. My first approach was to use a LineRenderer with an animated texture for the lazer itself. But here we stumpled upon some difficulties by combining animated textures with a dynamic lazer height. After some tests with the LineRenderer we realized that we don't necessarily need an expandable lazer which made things a lot easier. So, I decided to switch to a Sprite Renderer that is stretched bigger than our screen will ever get.

But we still had a problem with the animated lazer "stripe"-thingies to give the lazer more juicyness. The easiest solution to solve that was to handle those white stripes (haha) like bullets that even deal damage to enemies – which fortunately solved the problem on how we deal damage to enemies on the fly.

Basically the solution I used for the lazer is to create a stretched Game Object with a Sprite Renderer that renders the rainbow texture and just move the bullets up on the rainbow sprite. The dynamic lightning is created by a Sprite Renderer behind the actual lazer with a mobile/particle/additive shader. To give the lazer some additional dynamics I changed the width and opacity of the sprites randomly.

To pimp the launch area of the lazer a bit, I simply used a white circle with colored border and animated the strength of the border.

Our lazer consists of five main parts:

Here is the code that adds the mentioned dynamic effect to our fancy lazer:

float scaleX=Random.Range (0.8f, 1.2f);
laserGO.transform.localScale=new Vector3(scaleX, 1f);

float lightOpacity=Random.Range (-0.1f, 0f);
Color newColor=lightMiddleSpriteRenderer.color;
newColor.a=startLightOpacity+lightOpacity;

lightMiddleSpriteRenderer.color=newColor;
lightStartSpriteRenderer.color=newColor;

Everything mixed together results in a cool looking Mega-Rainbow-Lazer:

Update #1
gobgobs asked us:

"Is it possible if you can expand a little on the light created?"

Sure, creating the dynamic light was pretty easy.

Create a new GameObject, add a Sprite Renderer with a Sprite like the Rainbow Light Texture from above. Your object will look like #1.
Create a new Material, in our case we named it "AdditiveLight", and set the Shader to "Particles/Additive (Soft)" or "Mobile/Particles/Additive". Now all you have to do is to drag the new material into the material slot at the Sprite Renderer (replace the "Sprite-Default" material) The rendered GameObject will look like #2.
Since we are using a black/white Sprite we can make use of the "Color" option to tint the Sprite in whatever color we prefer. Play around with the color and opacity settings and you get an effect like #3

In our case we just scaled the light a lot up and turned the alpha channel of the "color" option pretty low. While shooting the lazer beam we dynamically randomize the width of the lazer which gives us this nice dynamic light effect. (see the script above)

We are using the same technique quite often, e.g. as a permanent light effect for our main character Tscherno or to give our bullets and rockets more atmosphere.

Update #2
We've been asked on Reddit to share a sample project on how to create the lazer and the dynamic light. There is nothing we love more than to share what we've learned in the last couple of months. – Please be fair and don't use our graphic assets in your own project.

Mega-Rainbow-Lazer

February 27, 2015

The last couple of days we have spent a lot of time to create a framework for our lazer attacks for our upcoming game Shooting Stars – and we simply love the result!

I proudly present you the uber-awesome and cat-tastic Mega Rainbow Lazer

Stay tuned for more, next week we'll publish a short tutorial on how we made this lazer in Unity2D.

Get the Shooting Stars tunes (Free DL)

February 20, 2015

On Monday we kicked off the early beta test for our game Shooting Stars. The positiv feedback we received so far was simply overwhelming. Thank you for all the great suggestions to improve the game!

Since the launch, we have established this little morning routine where Michael shows us the latest highscore entries. So, two days into the beta run, we had this jaw-dropping moment when we saw that the player "Duderino" has quadrupled our personal highscore with a score of 1644. In words: onethousandsixhundredfourtyandfreakingfour. This is completely amazing! – We should mention that you need to play for approximately two hours to reach a score like that.

If you want to beat Duderinos highscore, feel free to join the cool kids beta club and sign up. We'll send you an invitation link as soon as possible.

Well, back to the original topic. Since it's Friday, the sun is shining and after a great week like this, we feel like celebrating with you. And just because we know that there is no better way to celebrate then with music, we want to share some tracks that we have made. Feel free to download and share them.

To be as cryptic as possible: some of those tracks are already available in the current beta. Some of them may be available in the near future and... I'm sorry I'm not allowed to tell you, but it's going to be awesome! (just imagine this "awesome" in a super high pitched voice).

So, enjoy some of asebists great retro tracks:

Enjoy some tracks I've made for Shooting Stars:

If you haven't signed up to our beta, clap your hands! (Or click here)

Shooting Stars Beta Release – Mitch gone wild!

February 16, 2015

I want to start this post by saying thanks to all the wonderful people who have supported us in the last couple of weeks. You guys are simply awesome!

As we have mentioned, approximately 12000 times, on our social media channels we'll release a playable beta every six weeks to give you an overview of what we're doing and how the game will look like. So, six weeks after the launch of Bloodirony Games we are here to keep our promise.

We are proud and super excited to announce the very first Shooting Stars beta, called "Mitch". (this is the moment where you start drooling and yodeling which of course is accompanied by a smooth and sexy drum roll)

We've sent out a mail to all the signed up beta testers, with all the necessary instructions to install the beta and to finally start shooting stars. (Ahhhh... now everything makes sense) If you feel left out and desperately want to be part of the cool beta kids club, Y U NO SIGNUP? Just signup to our beta and you'll receive an invitation to play this super awesome and exciting Shoot 'em up.

Random facts about Mitch

It's a simple vertical endless shoot 'em up where you have to fight Minions and their level boss with an online highscore.
The game has absolutely no affiliation with any known TV character. Honestly!*
We started as ridiculous (kack-) noobs with no knowledge of Unity. This version is what we've learned in 4 weeks (+ a bit of optimization stuff).
The game is now optimized to even run on rather low performance devices. (We haven't decided yet if we support the Nokia 3210).

Electra, here we come!

Oh, come on! Don't say you haven't expected something like this? Electra was the only suitable name for the next version.

In the last days we've decided to completely start over with all the learnings we've made. We've also redefined our concept to be a bit more... erm... different. (And by different we mean better) Expect it to be completely random(!), probably as random as this crazy internet thingy is. Following our release cycle the next beta will be available on April 1st – jokes on you!

By the way, if you're able to guess the name of the 0.3 release, post it on our Facebook wall and if you are lucky, you can name the 0.4 release.

Don't forget to like us on Facebook and follow us on Twitter to get all updates.

* I lied.

The Art of Screenshake in Unity2D

February 6, 2015

Due to the fact that our Big Bad Bearded Boss is a huge Vlambeer fan, my first task was to watch the presentation of Vlambeers Jan Willem Nijman Gamefeel. JW showed 30 little tricks to make your action game more fun. This post is about how to implement some of this tricks in Unity for our upcoming game Shooting Stars.

Screenshake

Let's start with the screenshake effect. The main approach is to shake the camera randomly in special moments of the game. For example on a bullet impact or an explosion. My first attempt to get this done was using iTweens ShakePosition(). The effect itself was really cool, BUT there was a problem with multiple screenshakes at the same time using ShakePosition(), so I started to implement my own solution:

private Vector3 cameraStartPosition;
private float shakeAmountX;
private float shakeAmountY;
private float time;
bool reset=true;

public void Init () {
    cameraStartPosition=Camera.main.gameObject.transform.position;
    InvokeRepeating("CameraShake", 0, .01f);
}

public void ScreenShake(float amountX, float amountY, float _time){
    if(amountX>shakeAmountX){
        shakeAmountX = amountX;
    }

    if(amountY>shakeAmountY){
        shakeAmountY = amountY;
    }
    if(_time>time){
        time=_time;
    }
    reset=false;    
}

public void ScreenShake(float amount, float _time){
    if(amount>shakeAmountX && amount>shakeAmountY){
        shakeAmountX = amount;
        shakeAmountY = amount;
    }
    if(_time>time){
        time=_time;
    }
    reset=false;
}

void CameraShake(){
    if(shakeAmountX>0 && shakeAmountY>0 && time>0) {
        time-=.01f;
        float quakeAmtX = UnityEngine.Random.value*Mathf.Sin( shakeAmountX)*2 - shakeAmountX;
        float quakeAmtY = UnityEngine.Random.value*Mathf.Sin(shakeAmountY)*2 - shakeAmountY;
        Vector3 pp = cameraStartPosition;
        pp.y+= quakeAmtY; // can also add to x and/or z
        pp.x+= quakeAmtX;
        Camera.main.transform.position = pp;
    }else if(!reset){
        Camera.main.transform.position=cameraStartPosition;
        reset=true;
    }
}

Kickback on Shoot

Another thing I wanted to implement is a little kickback whenever our main character is shooting lazers, bullets or whatever. Due to the fact that our game is a vertical shootemup this was quite easy to implement. Whenever our main character is shooting I manipulate his y position by a small random amount:

targetPosition.y=targetPosition.y-UnityEngine.Random.Range (0.1f, 0.3f);

Permanence

I also thought about implementing some permanence. So I decided to make our “lazer shells” permanent. First of all I created a flight path for our shells by using iTweens MoveTo(). Not really satisfied with the result I added some rotation to the shells by using RotateBy(). After the movement of our shells is over the GameObjects will stay whereever they moved to. The problem is, that after some minutes of constantly shooting, you have a lot of shells lying around. This is not a problem for the PC or Mac version, but will be a problem for mobile devices due to limited amount of available Memory. So for performance reasons I have to destroy the shells (or move them back to a pool) after some time.

float height=UnityEngine.Random.Range (0.2f, 0.7f);
iTween.MoveTo(gameObject, iTween.Hash("path",new Vector3[]{
    new Vector3(transform.position.x+0.4f,transform.position.y+height,0), 
new Vector3(transform.position.x+height+0.2f,transform.position.y-0.4f,0)}, "time",1,"easetype",iTween.EaseType.linear));
iTween.RotateBy(gameObject, iTween.Hash(
    "name", "ShellRotation", "looptype",iTween.LoopType.none, "z", Random.Range(-6f, 6f), "time",  0.9f));
Destroy (gameObject, 10f);

What's next?

Because of problems with permanence, missing image effects, etc. we consider switching from the free version to Unity Pro. Come back soon, if you want to know which way we will go.

Negativity and Rant make me confident to do this

January 30, 2015

Making games for a living was never harder than it is today. There are the big players who take in all the money from whales and sit in the app-store charts unable to move away. There is one app submitted to the AppStore every minute, same with the Google Play Store. Steam releases must be gated by greenlights. Dealing with publishers was never as hard as it is right now. And no one knows what will happen in 3 months. What will be the next big thing that makes money?

There was a lot of negativity and definitely some 'orchestrated' rant present at some talks at CEGConf. "Want to make a game for mobile and maybe try to make it cost 1$. Why don't you shoot yourself in the knee!" One could also notice some negative vibes if it comes to paid game engines. They sure are the reason for more competition but hey, they are really helpfull in any way. You can make the most awesome presentations with game maker for example. And games that release and get to players. And prototypes. I sensed some bitternes from industry veterans and I really can understand that. But if not NOW, when would be the best time to take risks and try something new, away from the known predefined ways?

Now, when nobody knows what the next big thing will be. Now, when you can connect, meet and share knowledge with more devs, gamedesigners, artists and players than ever before. Game Engines fast dev stations, meetup groups, conferences, indie-festivals can be the tools to be succesful, go out in the world and show new stuff. And Pixel Art is respected again, though a lot of people react strange when they see pixel art nowadays but I really think it is an art form and not just retro, right?

All negativity aside, the conference was mega-awesome, with very interesting talks and a lot of nice and encouraging people to meet and talk. The feedback for our 10 days young prototype was overwhelming which was mainly the reason for a completely stoked sprint planning and rebase of our backlog the next monday. Good stuff is coming. Good stuff is coming...

The last week and the time at the conference sharpened our mission to have a somehow polished beta version for everyone interested EVERY 6 Weeks. And the first release (V.01-Mitch ) will be good, nice and done at Monday, February 16.

We plan to have really, really great music in the game from a very, very talented musician. Which is only fair, since it will be the game that brings balance to the force and saves mobile gaming. Oh, and not to forget to mention that we're saving planet earth as well! More on that another time.

Now it's time to brag: take a look at our 3 week old build, 2 weeks before we start shipping the beta to your device:

What the heck is indie? #CEGC15

January 26, 2015

Last week we've spent two days at the first Central European Games Conference 2015, at the University of Applied Sciences Technikum Wien. And to keep it as short and simple at possible: we've greatly enjoyed being there. We've especially enjoyed the high quality of speakers, interesting (and mostly bearded) attendees, the overall organization and of course the afterparties. #CEGC16 we are coming!

Tscherno photobombs a speakers panel at the Central European Games Conference / Photocredit: www.cegconf.com — Tscherno photobombs a speakers panel at the Central European Games Conference / Photocredit: www.cegconf.com

While we were talking to lots of attendees and showing them our Shooting Stars prototype we had several discussion about our way to develop this game. Not from a tech-related point of view but much more how our game-jam(-ish) approach works and whats the ideology behind all that. There, we realized that the definition of being an indie game developer creating indie games couldn't be more diverse. Especially when everybody claims to be indie. Which (obviously) led us to the question:

What the heck is indie?

If we trust Wikipedia being indie or being an indie game developer means nothing less than:

"Independent video games (commonly referred to as indie games) are video games created by individuals or small teams generally without video game publisher financial support."

So, that basically means: If you decide to make a video game without a publisher you are an indie game developer. ~~End of story!~~

If we compare a title like This War of Mine with e.g. Binding of Isaac, both being indie games, you're able to see lots of differences like graphics, sound, gameplay, ... but in our case none of those differences matter. Because the thing you can't see is the biggest differentiator: the budget!

So, This War of Mine is kind of an AAA indie game but separating the indie scene into AAA games and "other" games seems pretty useless to us. Because, we believe that having 30+ people on your payroll, and according to 11bit studios Design Director, Michal Drozdowski, 14 people in the core-team just working on This War of Mine, you need a shitload of money to fund this. And to earn this pile of money you need to have investors or a valid and working business (in 11 bit studios case they are just doing a pretty good job creating games).

And to finally come to my point, I'm going to borrow a definition from the startup-world.

"A startup company or startup is a company, a partnership or temporary organization designed to search for a repeatable and scalable business model." – Steve Blank

So, if you are able to pay for people other than the usual founders and maybe first employees you've probably left the startup/indie phase and are in a growth phase but much likely it's not a startup anymore – it's a company, a company with a clear and valid business case.

In our case, we have decided to be an indie studio. We want to keep our team small, and work on crazy and funny projects that seem ridiculous. There is no desperate wish to roll in money and to head straight to our IPO. But sure if things happen differently than planned we may leave the indie phase to become a "regular game studio" like 11 bit studios is today.

To sum things up

We believe that being indie is a phase (that you don't necessarily have to leave):

"An indie game developer or indie studio is a company, a partnership or temporary organization designed to search for a repeatable and scalable business model." – Steve ~~Blank~~ Malzner

Oh and by the way, we actually love what 11 bit studios are doing! Additionally they're creating jobs, (hopefully) pay taxes and of course they create pretty awesome games. So, this article is not supposed to be a rant, they are just a perfect example for the situation we're talking about.

Feel free to discuss this article with us and don't forget to follow us on Twitter, like us on Facebook and sign up to our Shooting Stars Beta.

The Bloodirony Founders Story

January 20, 2015

As stated in our Bloodirony 101 we are three people from Vienna, Austria with a clear-cut mission: We need to save mobile gaming – the indie way. To start things up we had to decide on a name. So everyone came up with a couple of ideas. The clear winner was Bloodirony. How, why and what? We will let you know later. Promise! Basically, it just felt right. And let's be honest it sounds and looks awesome. So, why not?

We have clear goals. very early player involvement and quick results are the things that we want to make our vision work. We invest passion, time, and money to accomplish our mission and reach our goals. And it is about about fun, agile fun. Creating games should be fun, fun for the player and fun for the creator. We go mulitplatform, because it is fun.

Recently, my 5 year old son told me he wants to create a game when he grows up. "Cool," I said and asked him if it would be a video game, tabletop game or something like that. "No," he said, "it won't be a video game, it will be a game for the iPad."

Mobile games are not the sort of video games we grew up with and learned to love. They certainly are no console games either, because 99% of the time the reason to buy a console is to play games (except if you fell for the trap Sony set with the PS2 and PS3 that were supposed to be DVD/BlueRay Players and gaming consoles at the same time). You hardly ever buy a smart phone or tablet just out of the urge to play games. However, we think mobile devices have everything in place to become a platform that can become the next big thing in the evolution of digital games. The only thing missing is someone to create and actually build them without being afraid to try something new and different and not follow everything that kind of works and just copy it.

THE VISION

We want to create games for touch devices that feel like real video games but are native to mobile.

That means overcoming the challenges of touch controls aka controlling a game with a sausage, breaking out of porting handheld game concepts to phones with d-pad controls, and taking the chance to step away from having IPs that sell anyway and to just add sequels. WE WANT TO CREATE SOMETHING GENUINE AND NEW THAT WORKS AND IS FUN.

And yes, this is challenging, definitely not easy, and unlikely to pull off. But hey, it is about fun! And it is a chance. We take it. Everything else is herealready: the devices, the software-tools, the fail and success stories, and most importantly, our ambition to do it.

Let's look at the time frame: We started in January 2015 and the first game must be released by July 1 at the latest. So our time frame is only 6 months. You can see it as an expansive game jam: 3 people creating a game to fulfill our vision in 6 months. We are confident that we will reach our goal. Follow us on twitter, subscribe to our blog to get weekly updates, and gain (free) early access by subscribing to our newsletter. The first playable release of our first game will come in mid February.

Shooting Stars

If you want to become the indie game studio that saves mobile gaming, you need to start somewhere, and we start with our first title: Shooting Stars. We will keep our development and design decisions open, and we will keep you up to date about them. You can follow the development on our Twitter Channel. This is the place where you can be a part of it and tell us what you think after you played an (really) early beta, and you will have the chance to get great in-game items exclusive to early beta testers. Be a part of it. Follow us and subscribe to the newsletter. We want you to be on board as early as possible. The first Version (0.1, named Mitch) will be available mid February. The 1.0 Version (named C.J.) will be out on July 1, at the latest. More on the roadmap in another blogpost.

Read the Shooting Star page. Sign up to the Newsletter and gain access to the early beta. Follow us on twitter and facebook so you can keep updated on how we save mobile gaming. We will have a blog post at least once a week and give juicy, funny insights that are worth reading. All in excellent Austrish (no, not the giant bird from Africa but the perfect blend of Austrian German and English), because that's where we are from.