fernando-j-scherf-blog

[fernando-j-scherf-blog]

Planet Lander - This is a Postmortem

The game is available to download on itch.io and you can also download it as a snap, an Universal Linux Package. In this post I give you the necessary instructions.

This is my first postmortem. I know this is only a small game that I made in one month. Nevertheless, I think it’s a good idea to make a retrospective of the development to see what was learned. But let’s start with some context:

THE CONTEXT:

Last year (2016) was a completely different year for me. In 2015 I was studying Electronic Engineering. I was already an Electronic Technician and I had the opportunity to continue my studies, so I took that opportunity.

After a year and some months of having, well, pretty good grades, I started to get stuck. I was beginning to lose interest and feeling I wasn’t studying engineering because I really loved it, but because it was the safest option. And it’s not that I didn’t like what I was doing; I was experiencing life in a new town, being more independent, and getting new, interesting friends. But the classes seemed to me every day more and more tedious, and I was losing focus. That idea of “You are only here because it is the easier choice.” was every day more and more present in my mind. I knew I was postponing what I really wanted to do. And you know what that is. Don’t you?

I suppose this is kind of cliché. One day I decided, after failing some tests because my head was completely saturated with those ideas, that I needed a break.

After a bus back home and a couple of days of thinking I decided to take some months to make a small game.

My family was very supportive. They helped me, but were worried about my future. Luckily, I already had a peace of paper that said I was a Technician and If anything went wrong, I could get a job in that area, so they weren’t too worried.

After five or six months, I finished Rita, a small adventure game. I am proud of this game, regardless of the fact that I know it’s not perfect. I wrote the dialogs, designed the puzzles, made the graphics, and tested it with some friends. My friends liked it and laughed at the jokes! While testing this game I discovered that playing adventure games with good company can be very fun.

The big problem with Rita is that it’s only in Spanish, so I could only get it to be known in circles that spoke that language. Also, I was quite naive and unexperienced in game promotion. I still am, but to a lesser extent, I hope.

Maybe some day I will translate it.

I charged $1.50 for the game, and…

The analytics for that game on itch.io, to this day, are:

Yes, I wanted to make a little bit of money with Rita, just to prove to myself that I could in fact live by doing this. I thought that If my first game made just, maybe $50, $100, my second game would be even more commercially successful, because people would already know me and follow my work. I wanted to put my family at ease, showing them “Hey, I made some money with this, and this is only the beginning!”.

It was the result of my own inexperience. Not enough people knew about Rita, and even just asking $1.50 put a barrier to anyone who wanted to play the game and didn’t have a credit card, so nobody downloaded until I made it free.

So, first advise: Make sure your game is long and good enough, and is known by different communities before putting a price to it, or nobody will download it. And I’m not saying that it’s impossible to make money with your first game, but you will need to make it really impressive and advertise it well. Maybe the best idea for your first game is to keep it small and simple, to learn.

After some weeks, I made the game free, with optional payment, and some people downloaded it.

And I started my search for a job. 2016 was the first time I had a “real” job, in which someone payed me with real money. I also kept studying, doing some on-line courses about entrepreneurship, programming and etc.

To tell you the truth, my experience in the world of (more traditional) work was… let’s say… messy. But that’s another story.

Now, I’m mostly searching for a part-time job. I want to have at least half of the day free to work on my games.

THE GAME:

One day I was browsing the future jams on itch.io and found the “Finally Finish Something” Game Jam. I thought to myself “This sounds perfect”. I wanted to take this opportunity to get more familiarized with the LOVE framework, and to get more in touch with the itch.io community of developers.

I started to organize myself. I knew I had little more than a month to start and finish a game, and I was going to be working alone, so I chose realistic and doable objectives for the time that I had:

Simple graphics.

Simple game design (Simple player objectives, story, gameplay, levels)

Reduce text to a minimum.

Based on those constraints, I designed Planet Lander to be reminiscent of old arcade games that had simple vector graphics, simple objectives, and didn’t need a lot of text, because their stories were very straight-forward.

I also eliminated the problem that I had with Rita’s Game, where I had lots and lots of text, but only in one language, and this limited the game to be available only for people that understood that language; In contrast, with a game that has very little words, if they are in English, you know that most players will be able to play it and understand it, even if they really aren’t English speakers. Anyone who plays knows what “Start”, “Game Over”, and “High-Score” means, without the need of a translation.

This is one of the things that I got right: Design the game from the beginning considering the limited time that you have. If you don’t have much time and resources, apply the KISS principle:

Keep It Simple,

Stupid.

In Asteroids, for example, it’s graphics are simple vectors, the player’s objective is to survive long enough while destroying asteroids to get a high score, and the story is practically just made by the player. Planet Lander was built on those ideas.

I began programming in the last days of December. My first task consisted in taking the Newton's law of universal gravitation and apply it to every basic object in the game. I made a super class that was accelerated towards the center of the screen (Where the planet is) and the ship, particles and asteroids inherited this property. The acceleration depends on the distance to the center and the mass of the planet. The result is what you see in my first post about the game:

“After much effort, (And thanks, in part, to this video: https://youtu.be/EhDtJxX0sCA) I finally finished implementing gravity. Also, as the idea is to not use sprites, but only the functions provided by the LÖVE framework to draw lines, points, circles, etc, those little ships (3 of them should be asteroids, really, but I still haven’t implemented them) are polygons, and I had to write a function to rotate every point that defines them around their centers, too.”

I managed to understand how to work with classes and inheritance well enough to make every small object that exists in the game to be realistically attracted to the planet in the center. Later in development, I would even calculate the mass of the planet based on its radius, to make it even more realistic (Instead of having always the same mass independently of the planet size).

It worked, and it was super exciting!

Then I had to add the asteroids, or as I called them in the code “Space Rocks”. As they are polygons, you have to pass a table containing the vertices to the function love.graphics.polygon( mode, vertices ) to draw one, and my first idea was to create a table containing different sets of vertices, and give those vertices to that function at random. This would result in some variation in the shapes of the rocks.

I took a couple of days to work on a “Polygon Editor”, a tool to create the shapes of the polygons more easily, saving me from the process of drawing an asteroid on a piece of paper, taking the coordinates of the points and writing them on a table by hand (This is how I made the ship). I could as well use this editor to create other graphics, like big letters for the logo of the game, or maybe even alternative designs for the ship.

With this tool I could place the vertices anywhere I needed with the mouse and export them to a txt file containing a lua table, that then I would copy and paste to the game’s code.

But this idea presented a couple of problems:

The number of shapes for the rocks I could create was still finite, and eventually they would repeat, like in the original Asteroids.

The editor wasn’t very practical, and at the end, I really didn’t have much graphics to make aside from the asteroids to justify its creation.

Why not just randomize the position of the vertices? This would give me infinite possible shapes.

I worked on it and made my second post about the game:

“Now, we have asteroids. All of them are polygons, defined with points that are placed semi-randomly around a circle, so every space rock looks different from the others. The asteroids can be made bigger or smaller through a “radius” variable, that also affects the number of vertices that the polygon’s asteroid will have. Bigger radius => Asteroids with more vertices.”

This is one of the things that maybe wasn’t a good idea: Don’t create unnecessary tools that you are not even going to use at the end. Don’t waste your time and think of other alternatives first.

Another thing that I changed around this time, and you can see in the video, is the default “graphics mode” of the game. Every shape is filled instead of being just lines. You can switch the styles with “Ctrl – L” in the final game.

The development continued without too much trouble and the weeks passed: The player now could control the ship, the collision detection worked, and landing was implemented. Collisions and specially landing were kind of difficult to get done, but they seemed to work well. Difficulty progression was done; In every new planet the player has to destroy more asteroids, and the number of asteroids doesn’t grow in a linear way, to make the game less monotonous:

And I was getting close to the deadline.

I was the only one to test the game and you should always have your games tested by everyone you can: friends, family, etc. Study what they do. Learn from how they play. They probably will find bugs and things to adjust that you won’t. Don’t be the only one to test your own game.

I decided to release at least 24 hours before the jam ended, just to have some extra time in case anything unexpected happened.

This was a good idea: Always give yourself more time that the one you think you will need. We never know what problem that we did not expect might appear.

The problem that presented itself was related to the sound.

I had the self imposed objective of making the game’s size the smallest possible, and that’s why I generated the sound effects in sfxr, a really cool program that gives you randomized sounds inside of certain parameters, always similar to the sound effects usually heard in old video game systems, instead of using pre-recorded audio.

I played around with the parameters and made the program generate new sounds until I got the ones that I liked, and then I saved them in that program’s special format (That was only the information to re-generate the sounds later, exactly as they sounded when I saved them. Only 105 bytes), loaded them to the game and and re-generated them when the game was started with the library sfxr.lua.

I still don’t know why, but it appears like that library worked only on my Linux System (I was developing the game on a netbook with Lubuntu). When I packaged the game and tested it on Windows, the game stopped execution to give me an error when the first sound effect should have been re-generated.

Probably I should write to the author about this, now that I have the time. Maybe I will make him aware of a bug, or he will just explain me how this is really all my fault and what I did wrong.

When I encountered this problem, the only solution that I found in that very limited space of time was to re-load the files of the sounds in the sfxr program, export them as wavs, and load them to the game directly, instead of generating them with the sfxr.lua library before the game started. This made the game size bigger (Instead of having files of 105 bytes, I had .wavs that ranged from 1.9 kB to 74.2 kB), but still, 126 kB for the .love file and 2mB for the windows package is ridiculously small.

The next steps were to record some footage of the game, make gifs, make the itch.io page, and submit the game to the jam.

THE RESULTS:

One of the moderators of the subreddit “playmygame” was nice enough to record himself playing to give me his feedback.

The common opinion given is that it’s difficult to grasp the controls of the ship the first time you play.

This is why I said that It’s very important to test with other people. They will give you important feedback of elements of your design that you didn’t consider would be problematic for players to understand.

In my case, I considered that some mechanics were difficult to understand the first time you played, and evaluated the possibility of including some optional tutorial levels, that served as sandboxes where the player could practice landing, shooting, rotating and etc. in a safe environment. But this would have taken time that I didn’t have.

Regardless, now part of the fun is to learn how to control the ship. And I super enjoy watching all my fiends crash the ship again and again the first minutes they try the game.

I’m very happy with the final game. The players even gave it a really nice score!

It ranked #12 Overall, of 57 entries. For my first jam, I will consider this as a total success.

This was an awesome experience.

Thanks to everyone that in some way or another helped me with their libraries, opinion, motivation or tutorials.

Fer.

[fernando-j-scherf-blog]

Planet Lander - Distribution

Hey, hello, quick update!

Sorry for not posting anything for the last couple of weeks. I’ve been busy/distracted.

The game has been available to download here on itch.io since January 31st and in the Snappy Store since yesterday! I’m very happy.

In the itch.io page you can download a Windows executable that you can just double-click to start playing, or the .love file for Linux and MacOS, but you will need to have LOVE installed in this case.

Whereas snaps are universal Linux Packages; You won’t need to have LOVE installed in your system, as almost everything needed is packaged inside the snap.

I was contacted by Canonical’s Alan Pope, who was super nice and guided me through the process of making the snap and publishing it in the Ubuntu Snappy Store.

To install the game in Ubuntu 16.04 LTS or above, you can just search it in the Ubuntu Software App or open your terminal and write:

sudo snap install planetlander

Or go to https://uappexplorer.com/app/planetlander.fernando-j-scherf

If you are using Lubuntu and have no sound, install PulseAudio and it should work.

Well, that’s all you need to know, I believe. So, just go play it! It’s free! Well, on itch.io you can pay for the game as a contribution to my personal economy, which would be super nice and I would love you forever, and I would be able to make more games more often.

Ah! And if you get a high score you can take an screenshot and tweet it to me!

https://twitter.com/FernandoJScherf

Thank you, love you.

Fer.

[fernando-j-scherf-blog]

Planet Lander - Landing

After the last post I’ve been working on the mechanic that gives name to the project: Landing. It took me some time to get it right, but finally it is implemented!

Here is how it works:

After a collision of the ship against the planet is detected, the game checks if the speed of the ship is higher than the maximum value that it should have while landing, and if its higher than that, the ship is destroyed.

Now, if the ship’s speed is lower than this maximum value, the ship lands and is not destroyed. This means:

Until now, the ship was in it’s state 1, “Flying”:

Only in this state, the ship is affected by gravity, can be accelerated forward and rotated by the player and can be considered or not as a “collidable” object. (A collision can be detected against the planet or not).

Now the ship transitions to state 2, “Landing”:

In this state, the length and the angle of the line that goes from the center of the planet (The center of the screen) to the center of the ship are calculated, and the ship is moved to an specific distance from the center of the planet. I did this because in my first experiments with landing, the ship always ended being more or less “inside” of the planet after a collision, depending on the speed that the ship had when the collision happened. Now I make sure that the ship is always at the exact same distance from the center of the planet, independently of any variable. The speed of translation and the speed of rotation are made 0 and we…

Go to state 3, “Rotating”:

This part took me some time to complete. After the ship lands, it should be at a certain angle, depending on the point on the surface where it landed, so the ship is always “pointing” outwards the planet.

The problem is that the landings wont always be perfect. I could punish the player and destroy the ship if it lands at a weird angle, but I thought that doing that would make the game unnecessarily frustrating. I decided that the ship should slowly rotate to its right position.

The rotation itself wasn’t the difficult part, but making the program being able to decide if the rotation should be clockwise or anti-clockwise, depending on which one would take less time to complete, took me some time and effort.

After a while, I came up with this:

We have that:

self.rotation is the angle of rotation of the ship.

self.angleC is the angle of the line that goes from the center of the planet (The center of the screen) to the center of the ship.

yS is the “y” coordinate of the center of the ship, relative to the center of the planet.

And the reference system:

Notice how the positive values of “y” are under the “x” axis.

In the quadrants I and II the angles take positive values (From 0 to Pi, right to left), and in quadrants III and IV, negative values (From -Pi to 0, left to right).

Well, after observation of all the different possible positions of the angles in all the different quadrants, I discovered that:

If the ship’s “yS” is positive, we have that if the difference self.rotation – self.angleC is negative (self.angleC > self.rotation) AND the absolute value of that same difference is less than pi (One angle is not more than 180 degrees away from the other), the rotation should be Clockwise.

If the ship’s “yS” is negative, we have that if self.rotation – self.angleC is now positive (self.rotation >  self.angleC) AND the absolute value of that same difference is less than pi, the rotation should be ANTI-Clockwise.

With this information I wrote the algorithm:

 elseif self.state == 3 then--IF IN ROTATING STATE.    local angleSSubC = self.rotation - self.angleC    local maxDif = pi / 32    --If there is too much difference between angles.    if math.abs(angleSSubC) > maxDif then        --Determine if ship should rotate clockwise or anti-clockwise:      if yS >= 0 then        if angleSSubC < 0 and math.abs(angleSSubC) < pi then          self:rotate(dt, 3) --Clockwise        else          self:rotate(dt, -3) --Anti-Clockwise        end      else        if angleSSubC > 0 and math.abs(angleSSubC) < pi then          self:rotate(dt, -3) --Anti-Clockwise        else          self:rotate(dt, 3) --Clockwise        end      end    else --If the ship is already in the correct angle.      self.state = 4 --TO TAKING-OFF STATE.    end

"self:rotate(...)” will be called until the absolute value of the difference “self.rotation - self.angleC” is smaller than the maximum difference of “pi / 32″. After the rotation is done, the game switches to the...

State 4, “Taking-off”:

Here the ship just waits for input. If the player presses the “accelerate” key, the ship becomes “non-collidable” (A collision against the planet wont be detected) and goes back to state 1, where it accelerates (As long as the player keeps pressing the button associated to the acceleration) its way out of the surface of the planet and becomes “collidable” again when it stops being in contact with it.

Well, I hope some of this made sense for you. Now, I am working on the sound effect “engine”.

...Is “collidable” even a real word?

[fernando-j-scherf-blog]

Planet Lander - EXPLOSIONS

During the last few days I’ve been implementing more complex collisions, cooler explosions, and the ability to shoot highly destructive lasers.

For the collisions, I wanted different behaviors for different cases:

Planet vs Anything:

If something collides against the planet, it is destroyed an in its place an explosion is created.

In the final game, if the collision is against an asteroid, the player will lose some points, because his job was to defend the planet and he let millions of its inhabitants die. If the collision is against the ship, the player will lose a life.

Asteroids vs Asteroids:

For this type, I programmed elastic collisions. This means, that the total kinetic energy (The sum of the energies that the objects have due to their motion) and the total momentum (The sum of the products of the mass and velocity of each object) that the two Spacial Rocks have before the collision, must be the same after the collision. This means, that the asteroids will bounce off each other as if they were balls on a pool table.

Asteroids vs Space Dust:

The “Space Dust” are the little particles that you see flying around the screen. They serve an aesthetic purpose, and nothing more. These particles are created when:

Each game starts. They are supposed to represent very little, insignificant rocks that are just going around the planet.

The player gives impulse to the ship to move it forward or rotate it.

An explosion is created.

And when they get in contact with an asteroid, they are simply eliminated. My idea is that they just become part of the asteroid.

Asteroid vs Ship:

The ship is destroyed, an explosion is created, and the player loses a life. This is more of a perfectly inelastic collision, where the colliding objects are bound together, instead of bouncing off each other, and kinetic energy is lost. Imagine that the pieces of the ships get stuck into the asteroid. The same could be said about the Space Dust: They get into the asteroid, and after the collision they both keep moving with the same speed and direction. Perfectly Inelastic Collision.

Asteroid vs Laser:

Again, I use elastic collisions. When the laser hits a rock, the program first calculates the new velocities for the asteroid and the laser, as if they were to bounce off each other (Again: Like balls on a pool table). But instead, the laser is eliminated and the rock is destroyed, and an explosion and two smaller rocks (These two smaller rocks each have half of the total surface of the original, bigger rock) are created, and the new velocity that was calculated for the big asteroid is given to them, so after the impact, the big asteroid not only becomes two smaller asteroids, but also they change directions realistically. And, yes, I know that technically this should not be an elastic collision, because after an explosion energy is lost from the system, but for what I want, this is working perfectly.

This is all for now! I hope you find some of this interesting. I hope I didn’t commit any mistake while writing. English is not my original language!

[fernando-j-scherf-blog]

Planet Lander - Ship’s Movement

Now, the ship is controllable! The player controls it using three propulsors; two of them control its rotation and one accelerates it towards the direction it’s facing.

Next, I will probably continue working on the collision detection.

[fernando-j-scherf-blog]

Planet Lander - Adding Asteroids

After some days of vacations and a battle against procrastination (that I was losing), I am continuing to work on Planet Lander, my game for the Finally Finish Something Game Jam.

Now, we have asteroids. All of them are polygons, defined with points that are placed semi-randomly around a circle, so every space rock looks different from the others. The asteroids can be made bigger or smaller through a "radius" variable, that also affects the number of vertices that the polygon’s asteroid will have. Bigger radius => Asteroids with more vertices.

I also added little particles; "Space Dust". They won't affect the gameplay, but look nice.

I’m also working on the collision detection system. For now, it’s very limited: If something “touches” the planet, it only disappears.

I still have much work to do, But I’m liking the results so far.

[fernando-j-scherf-blog]

I am working on a new game

Defend your planet from spacial rocks and killer aliens! Last all you can before your inevitable demise! How long can you survive before you are overwhelmed by asteroids and you and all the population of your planet dies!? Find out by playing Planet Lander!

What you are seeing is the game I am working on right now: Planet Lander.

I am working on this game to present it on the Finally Finish Something Game Jam (https://itch.io/jam/finally-finish-something) next January.

Taking inspiration from the old classics Lunar Lander and Asteroids, the game will have graphics influenced by those vectorial games.

After much effort, (And thanks, in part, to this video: https://youtu.be/EhDtJxX0sCA) I finally finished implementing gravity. Also, as the idea is to not use sprites, but only the functions provided by the LÖVE framework to draw lines, points, circles, etc, those little ships (3 of them should be asteroids, really, but I still haven’t implemented them) are polygons, and I had to write a function to rotate every point that defines them around their centers, too.

I will continue working. The basic idea is to have a game in which the objective is to survive as long as possible and get a High Score. By destroying the Asteroids you gain minerals, and landing back to your planet with those minerals, you give the population extra materials to build you extra ships (That, of course, represent “lives”). So there will be (Hopefully) a mechanic of destroying the spacial rocks, retrieving the precious metals that they leave behind, and taking them back to your planet whenever you can.

I hope you are interested in this little game! Thank you so much for taking your time to read this!

[fernando-j-scherf-blog]

“Dancing Skeleton”

Get ready to move your bones.

If you want you can buy shirts, stickers, and other stuff with this design printed on them: www.redbubble.com/people/fernandojs/works/24340172-dancing-skeleton

Thank you so much and sorry for the shameless self-promotion.

[fernando-j-scherf-blog]

“Happy Ghost”

The happy ghost is happy to see you!

Please consider buying, if you want, this little ghost on a shirt, or mug, or poster, or sticker, or any other thing from my shop! http://www.redbubble.com/people/fernandojs/works/24176173-happy-ghost?asc=u&ref=recent-owner

[fernando-j-scherf-blog]

“Attack of the Submarine Tin Robot“

After many years it has been reactivated. Now it seeks only the destruction of humanity.

Also, If you want, you can buy different products (Like shirts, posters, stickers, mugs and more) with this work here: http://www.redbubble.com/people/fernandojs/works/24175015-attack-of-the-submarine-tin-robot?asc=u&ref=recent-owner

[fernando-j-scherf-blog]

“Full moon”

[fernando-j-scherf-blog]

Another test character.

[fernando-j-scherf-blog]

A test character.

[fernando-j-scherf-blog]

“Space Cat”

[fernando-j-scherf-blog]

“Animated Again”

This is what happens when you build a cemetery where a nuclear waste disposal facility used to be.

[fernando-j-scherf-blog]

My first post

Hello and welcome to my blog.

I am Fernando José Scherf, a pixel artist and game developer from Argentina.

Here you will find my pixel art and posts about the development of my own games. I don’t consider myself an expert developer; Here you won’t find articles written by someone with years and years of experience, but by someone who is discovering his path to make interesting games.

I want to let you see how I conceive projects, and how them, and I, grow together, hopefully ending with an interesting game and me being a better programmer, designer and artist.

That being said, I do have one finished game. Una noche de panico con Rita Garcia, A retro point-and-click adventure game. I am very proud of this game, but sadly it’s only in Spanish. Maybe someday I will translate it, if some of you show enough interest in a comical small adventure where you must find different gifts to give to your boyfriend in your anniversary night.

Thank you so much for your time!

One last thing: I have an Upwork Profile, so if you want me to provide pixel art for your project, please consider contacting me!