Idle game design document

By: Casey Shreve

I feel that I need to start the design document by stating that I have not
really paid much attention to the whole Idle Games genre. They have been
around for as long as people have been posting experimental flash games to
websites such as Newgrounds and even older Albinoblacksheep. But even then,
they never really took hold of my imagination.
There is something that feels rather alien and wrong about games that
practically play themselves and that throw away the concept of having an active
player. Its a concept Im not very happy about. However, for this assignment I
took a little time to think about how the idle game process is made and how to
implement it best for this assignment.
My largest focus was on the bonus portion. To answer the question about
how to keep the player involved. In other words, how do you keep the player from
becoming obsolete? The biggest thing I noticed was that idle games were an arms
race. By having clicks count as currency, and then having an auto-click system that
ramps up, they make the players contribution less and less as the auto-click
rewards get bigger and bigger.
I started my design by removing the idea that clicking equals currency.
Instead, I chose time as my currency. Or rather, an auto-clicker that clicks over
time. I used a value clamp to keep auto-clicker from giving out too much currency
at one time. I then decided to withhold the currency from the player, using it as a
ransom. The player can only collect the ransom by clicking. The game plays like
this:
Build > Wait > Click >Buy > Repeat
With several if/thens and loops depending on how much currency you have
amassed and when you go to the store. Using this method, the player must be
constantly vigilant and active through play. If they arent paying attention, the
auto-clicker will hit the cap, and then that time thereafter is wasted and not
generating any revenue. If they dont click, they wont get paid in points.
After I had gotten this concept down, I had to decide on what I wanted to
represent these states of existence. It came to me all at once. This was a game
that I spent very little time contemplating ideas as the one that came to me was
well suited for the task.
A unicorn that vomits rainbows. The vomit is the currency, the cheeks
expand to show build and wait time. Click for player interaction. Buy bigger cheeks
and faster grow time. Simple and done.

For the art direction:

It took several iterations of sketches to find the version I liked best. The
winning image was a surreal mix between cartoon horse and realistic horse. I drew
the final instances in Manga Studio 5 using a tablet. The background is also drawn
in the same fashion.
After fumbling around with the particle system, my professor, professor
Flemming, showed me a few things to try in the unity editor. One of which was the
asset import function as it pertains to textures. After a few tries, I was able to get it
to work in such a way that the particle system I was using would not add a white
background to the vomit droplets. This made for much cleaner look to the rainbow
vomit.
Also, with the particle effect, I nested 2 other particle systems in with the
first. It runs as a two tiered collision emitter. That is, the first emitter is a cone and
pours the particles out. On collision with the invisible plane that was placed on the
ground, the particle system spawns a hemisphere emitter and shoots out a burst.
When those second particles collide with the plane, the new system spawns yet
another new hemisphere emitter. So in other words, rainbow vomit chaos.
The text I used was a random texture I picked up from the internet. It came
from a website that simply hosts random fonts, but its not made by the website
itself. I chose it because, not only is this sort of style very similar to a style used in
a TV cartoon about said horse-types, but the style of the font was a good whimsical
style that works with, well, a video game about a unicorn puking up brightly colored
barf drops.
Audio:
After trying various noises and songs, nothing really seemed to fit. All the
noise just reminded me too much of a bad casino, so I opted to have it silent. Its
very surreal that way, I kind of like it. There is sound in the end credits.
A note on controls:
This game, more so than any of my previous games, would easily be
adaptable to mobile platforms. The controls would be rather simple. You would tap
things instead of click them, using a touch event instead of a mouse down event.
One of the things that I think would be interesting to experiment with, would
be a haptic response. When the unicorn would vomit, you could send a vibrate
command to the phone. It would start when on tap the vomit starts and stop when
the unicorn reverts back to its idling state.
Mechanics:

There are a lot of repeat systems in the game. All the buttons use the same
grow-shrink mouse over-mouse off scripts. All of the labels use the same global GUI
skin and follow object scripts. The camera movement script is a simple iTween
action that eases both translate and focus/point-at motions. Both the points that
the camera translates between and focuses on are invisible objects.
There are 3 screens to the main instance of the game. The first screen is
where the actual game play takes place. You have the unicorn and the clickable
unicorn face. This is where the points are generated. The cheek is handled by two
lerp functions. One that grows as an int is added over time and one that shrinks as
it expels the int into your currency.
This is handled by converting the ints into float values, running the float
values through the lerp functions, and then using the resulting float values for
object scale. From there, the currency amount is ran through a function that
interpolates integer values. The resulting currency display is a rolling value.
Between the growth and shrinking of the unicorns cheeks and the rolling values of
the score/currency, the game is strangely satisfying.
Also satisfying is watching the particle stream. They go EVERYWHERE. The
ground becomes a flood of particles moving every which way. It becomes almost
Zen like, in a way, as they all try to find their place in life.
The animation of the horse is actually two sprites that the game plays
between depending on what state the horse is in, idle or vomit. Due to time, the
brief motion of the head was the only thing I really had time to animate. Given
further development, the whole body could have different motions depending on
what the horse is doing.
The second screen is the store. You buy things and move between the other
two screens. The third screen is the game exit. Upon exiting the game, you are
taken to the credits.
The store:
The values are pretty straight forward. The cheeks get larger in increments
of 5 and the speed at which they fill count down from half a second. Growth is
capped at 500 and speed is capped at .001 of a second. Price increases at a rate of
10-20%. The idea is to make the player grind out values, but still not feel entirely
pointless. In all, the game has over 100 steps required to complete the store. In
future development, achievements and gui toasts could add a wealth of depth to
the game.
Below is a spreadsheet displaying the incremental steps and prices:
Note: Although the spreadsheet shows decimal values, in game, everything but the
fill speed is rounded into a flat int value.

Credits:
Although it is the same prefab of the credits seen in the previous game, several
improvements have been made in this model. For one, explosions now spawn on
the bullets instead of on the blocks they hit. This way, the explosion object is
centered on the point of impact, regardless of how big a target is hit.
A second explosion has been attached as well and the credits now randomly choose
between the two. Both explosions are from Unity 3ds 2D tutorial assets. A basic
GUI has been added as well as buttons to return to the game or exit the stand alone
application entirely.
I chose for the game to not save progress. With the simplified input and controls it
is not really critical for progress to be lost or saved.