• Advertisement
  • entries
    6
  • comments
    32
  • views
    8616

Entries in this blog

This journal has been quiet lately, for a number of reasons. But before we get to that, here's the last video update (for now):

I grabbed various images from Google image search, and replaced most of my textures. This wouldn't be close to final in a proper game (even if we ignore the fact that I do not own commercial licenses for these images), but at least I think it looks better than what I had.

As some of the keen readers might have noticed, this journal became very quiet the last weeks compared to the initial ones. There's a number of reasons for that. Firstly, there were birthdays to attend (both my own and a friend's) and other social activities needing to be done. Additionally, there were some developments pertaining to other things I can't talk about yet, but which I might elaborate on in the future. I should know a bit more before the end of the month, so I might post something at that time... Combined, this does mean I couldn't invest as much time as originally planned, but the shift in focus from my side feels worth it going forward.

So, where does that leave this project?

For now, it will remain in its current state until further notice. I still want to come back to it and finish it off, as I think it could be quite a fun little bite-sized game with a fairly contained scope, but for now other things and potentially other projects will have to take priority.

I definitely gained some valuable experience with using Unity, and it's highly likely there will be more Unity related work/posts/projects coming.

Thanks for reading, and stay tuned... :)

For this update, I improved the enemy AI. Let's see it in action:

The enemies now fire back at the player. This also meant storing more information when firing a projectile, to prevent enemies from suiciding by shooting themselves.

Additionally, I made the enemies sometimes change direction instead of only moving in a straight line. This could do with a bit more work, to make it all more fluid and nice.

Lastly, I added a mechanic that, if an enemy leaves the bottom of the screen, the player takes a small amount of damage. This means the player is forced to deal with the enemies in order to survive.

Oh, and I also added a new item in the shop, a health refill.

I'm really unsure about what I should do next. Like I mentioned last time, I could either focus on polishing up a few areas by tweaking bits and pieces, or leaving things slightly more rough. The latter option would allow me to try my hand at different features to implement.

Thoughts?

...and I'm all out of bubble gum.

Last time I said my plan was to fix a few things, then take stock and see where I'm at -- hence, this journal entry.

I fixed the visual issue I had on the button, where it would fade instead of starting directly at the correct graphic when opening the shop. The fix was to just set the fade duration to 0 except for when I wanted a fade duration.

Object pools were also added, for currency, projectiles and enemies. In the process I lost the ability to spawn different types of enemy, but since I only have 1 for now that's fine. If I add more enemies, I have a plan for getting that functionality in again, fairly trivial.

Restarting the level was a bit more finicky than I had anticipated. Since I have several systems and scripts that communicate/are aware of each other's existence, I had to shuffle things around to make more sense.

It ended up working nicely, with my setup being multiple scenes, and unloading/reloading the gameplay/level scene in order to restart it. It didn't take a lot of time, but there was more Unity fiddling here than a lot of the other things I've implemented.

Sooooo... taking stock! I figured a decent starting point would be simply copying my initial scoping bullet points, and comment them as I go along. Here we go!


  • Intro and outro "cutscenes" (very simple).

    • Nothing done here yet. I'm still wanting something for the intro... Outro might not be all that important (since I have no end-point as it currently stands), but my intro plan I still like.

    • Animated characters (player & enemies). Likely horrible and/or clip-art, 2D. Potentially replaced with bought (3D?) assets as development continues.

      • Not yet animated, but player & enemies are in. Horrible graphics also included (very prominently).

      • Scrolling scenery.

        • Check. Might want to upgrade this slightly with some more layers/parallax effect.

        • Collision detection.

          • Check. Enemies are hit by projectiles and player. Enemies and projectiles also intersect level boundary and die.

          • Simple enemy AI.

            • Check, although too simple. Currently they just move straight ahead. Not sure what I want to do here... make them shoot? Make them go adjust their direction after a certain amount of time?

            • Multiple weapon behaviors (ballistic movement, homing, line-of-sight).

              • Currently only 1 projectile type, the "straight ahead" bullet.

              • HUD/GUI for various bits and pieces (tracking game progress, health, currency, upgrade shop, etc). Text, icons, buttons.

                • Most of this is up and running. If more is needed for more functionality, the UI part is the simple part.

                • Player/weapon stats, affected by upgrades.

                  • Partly. There is a shop, and you can buy some upgrades. Can't currently buy new weapons/projectiles, because they don't exist.

                  • Save/load (with support for multiple profiles).

                    • Nope. Will most likely scrap this.

                    • Simple input system.

                      • Check.

                      • Deploy mainly to PC during development, mobile (Android) near completion.

                        • Currently deploys to PC. Might try Android deployment just to see how painful it is with such a simple project.

                        • Enemy spawn system/ruleset. Possibly some sort of wave editor if needed.

                          • Very simple spawning included, but not robust/good enough by far. Unsure how I want this to behave. No wave editor.

                          • Various effects (sounds, music, particles, etc.).

                            • No work done here yet.


                              All in all, it feels like I've done quite a lot of what I set out to do in terms of systems and mechanics. There's a few things missing and needing more work (different weapons, better/more interesting enemy behavior, etc.), but the systems side of things feel fairly solid.

                              What does not feel good at all, though, is the art side and the actual gameplay side of things. Art-wise, I could try to whip up some slightly better textures (still horrible), and at least make them animate a bit.

                              When it comes to gameplay, I'm not sure... my main objective with this project was to get a better grasp of Unity. I could invest a large chunk of time trying to improve the gameplay, which for a lot of this will mean tweaking values and such, or I could invest that time into new systems/mechanics instead.

                              I'm a bit torn here on what to do.

                              What does the keen reader suggest/think?

Last time, I posted a quick video of various UI/HUD elements in action, and said that the Turtle Shopa"c was up next.

Well... here it is, in all its splendor!

Amazing, isn't it?

Upon entering or exiting the shop, I simply enable and disable (as appropriate) the ingame HUD and the shop HUD -- I did this by placing the contents of each in a empty GameObject "folder", and enabling/disabling those folders.

Currently, you can upgrade your default projectile's fire rate and damage per hit. There are 3 levels to each (including the starting level). I had to shift some data around and put them on the actual projectile instead of more globally, but it was an easy & expected change.

While in the shop, the game is paused. I did this by setting the Time.timeScale value to 0.0f when entering the shop, and back to 1.0f again when exiting the shop.

The shop buttons change color to indicate whether or not you can afford the next level, as well as whether or not the selected upgrade has been maxed out. I did this by setting the disabled color, and toggling the interactable flag of the button. There's a tiny bug here where the colors aren't set directly when the shop is opened, so it will fade from "too expensive" to "can buy" instead just being the correct color immediately. This will be fixed before the next update.

I display the currency cost associated with each upgrade level, as well as your current currency.

Next I'll be wanting to add some "restart level" functionality (while keeping upgrade levels/currency intact). I've been holding off on doing this for no reason in particular, and I should just get it done.

Once that's out of the way, I think I'll implement some object pooling for enemies, currency and projectiles -- again mainly to just get it done. Once complete, I think I'll take stock of what I have and make some sort of rough plan for moving forwards. I think it's looking not-too-horrible compared to my initial scoping, which is always nice, but I wouldn't be too surprised if some of the more ambitious features will have to be cut.

Thoughts, comments, feedback, questions?

Last time, I mentioned I had done some UI updates, but I didn't include anything to actually show what I had done.

Based on feedback, it seems like I should include some more visuals when it's appropriate, so here goes :)

This video shows a couple of different things:


  1. Currency and player health displayed as HUD elements.
  2. HUD elements updating in a "ticker" fashion -- quickly counting to the target value instead of snapping directly.
  3. Enemy healthbar.
  4. The enemy healthbar has an effect when damaged. It immediately displays the actual health, and additionally displays a depleting health indicator, where it (after a delay) gradually depletes from the previous health value to the new health value.
  5. Currency amount chosen at random, chosen from pre-defined min and max.


I spent more time implementing the tick functionality than I had wanted. Initially, I wanted something that worked for both ints and floats, but using C# in Unity, I couldn't get a single class to do what I wanted.

In C++ I would just have used a template class, but C#'s generic classes do not support arithmetic, which I would need.

In the end, I ended up creating just a single class for ints. If I need floats later on, I'll deal with that then, even if it means just duplicating the int class.

The same tick class drives both the currency/player health and the enemy healthbar drawing. For the HUD elements, I just use the ticking value directly, while on the enemy healthbars I use both the actual/target value and the currently ticking value.

The enemy healthbars are made up of 3 elements -- a black background/frame, a light green "filled" color, and a darker green used for "depleting" health.

It looked exactly like what I was aiming for, so happy with that. Given an eventual art pass, I might replace the single color with textures instead.

Next up: Turtle Shopa"c!

[Questions at the end of post]

Last time, I had just introduced the concept of player & enemy health, as well as currency (and I showed off my amazing art skills in a breath-taking video). However, player health & currency was only ever displayed in Unity's console as debug output.

So, wIth that in mind, I added some HUD/GUI to display the player's health and currency.

I made it ever so slightly more fancy than just displaying the raw data -- I tick the value from the currently displayed value to the actual value in a fraction of a second. I think it looks a bit cooler than just snapping between values, and it's a quick effect that doesn't inconvenience the player. Currently, there is a lot of duplicated code both currency and health, so I'm going to extract the common functionality and refactor this so I can reuse it more easily.

Related to all of this is one of the next things I'll be adding -- a health bar above each enemy. I'll be wanting to use the same logic for updating/ticking the value to display (hence the refactor), but I want it to feed into a health bar drawing instead of just a number print. I have a plan that I think will work fine, and then we'll see if Unity agrees with me or not :)

Another feature I'm adding sooner rather than later is to restart the level, while keeping progress (i.e. currency). This might mean I have to split things into multiple scenes, one that's a persistent scene, while the game/level scene can just be reloaded as needed to restart.

After that, the main thing is adding a shop, allowing you to fork over your hard-earned currency. Initially, this will be probably just be accessed by a keypress and have some basic health refill item. More involved upgrades and unlocks to come at a later point.

---

QUESTION TIME:


  1. Is any of this interesting to you?
  2. Would you be more interested in a different type of journal entry?
  3. Journal entry length -- too long, too short or just right?
  4. Is there anything you feel is missing or could be added to my journal entries? Or something you don't like/care about at all that could be removed?
  5. Do you like short videos showing the functionality I describe, even in its currently incredibly rudimentary form (refer to the previous post for an example here)?

I got a chunk of stuff out of the way today, even with some unscheduled "fall asleep on couch with cat on chest" time.

A brief video (of the project, not the cat-on-chest sleeping) should be included below, if my journal entry skills are up to scratch.

---

Like I mentioned in the previous update, I started with doing some project updates and refactoring, after which it was on to making a rudimentary enemy prototype (red quad!).

Enemies spawn in waves, each wave with a randomly chosen number of enemies (pre-define min and max). The system also allows choosing different enemies, but we'll see how all that'll work once more enemy types are actually added in. Later on all this enemy stuff will have to be reworked quite extensively, but for now it at least gives me an unending amount of enemies to shoot at.

Enemies have health, and take damage when hit by a projectile. If killed by a projectile, they drop currency. If death occurs due to colliding with the player (which also damages the player), no currency is spawned.

Currency, when spawned, waits for a little while before starting their descent. They also time-out after a while, indicating by 2 different flash speeds. When collected, currency is added to the player's total.

Next up will be displaying player health and currency somewhere. After that, the next thing I want to do is some shop interface, where you can buy new weapons/upgrades. At that point, I'll need to do my weapon firing logic better -- checking which weapon is the currently equipped, grabbing stats from it, etc. I might also do some sort of enemy health bar above the enemy, and do the object pooling for the various objects I currently instantiate and destroy.


VIDEO TIME!

Due to some unforeseen apartment maintenance, I didn't have as much time to invest today as I had hoped.

That said, I had made some progress anyway :)

I made a quad, slapped a tiling texture on it, and made it UV scroll from code. Presto, simple scrolling background. I might come back to this later and do something more fancy, e.g. add some more layers and do some simple parallax effect, but for now it's good enough.

I made another textured quad that I move around based on input, constrained within a movement area (defined via 2 corners I placed in the world). This is my player object. It fires a projectile based on input. My player needs a lot more work later on, but I have something moving, at least. One of many things to do is make this an animated thing, instead of a static texture. Apart from that, what I need to add will become apparent once I add in other features.

Yet another textured quad was made - this time it's a projectile. When spawned, it moves forward until it times out and is removed. I'll need to add collision detection here (once I have something to collide with), and I'll probably want to remove it if it exits the screen. I'll want to come back to this later on an use an object pool instead of instantiating and destroying objects all the time, but mainly for my own sake -- I doubt this project will run into performance issues given the simplicity of it all.

---

Before going further, I'll probably redo a few things -- shifting my camera from top-down to side-view, making the game window portrait instead of landscape (so it makes sense if I get it on a mobile device later on), and other small stuff like that.

Next will be an enemy that moves in some fashion and that you can defeat. Upon defeat, it will spawn some currency that the player can collect. Once that's up and running, a system for spawning the enemies in waves (first iteration probably just timed/formula based). Other than that, their behaviour is undefined at the moment. Maybe some firing back at the player. At some point later on there will also be an object pool for this (like with the projectiles).

Once I have a basic enemy that moves around, the plan is to deal with health somehow (instead of hit = death), both for the player and the enemies.

This will also mean I'll do some GUI/HUD stuff to keep track of currency, health, and other related bits and pieces.

After that I'll probably want to do something with the shop/upgrade system.

Past that, it's a bit fuzzy, but I'll have a clearer picture once I've started on the above.

Let's try scoping some features and design, so I have something to compare & learn from come deadline. As mentioned, I will be using Unity for this, and the deadline is roughly 1 month from now (June 7th). What follows is a rough feature list and basic design of the game.

Game concept: As a flying turtle, use various weapons to shoot down eagles to get currency. Spend currency on better weaponry in order to shoot down eagles more efficiently. Increasingly difficult eagle enemy types, culminating with a boss eagle.

Various features I want/need to include:


  • Intro and outro "cutscenes" (very simple).
  • Animated characters (player & enemies). Likely horrible and/or clip-art, 2D. Potentially replaced with bought (3D?) assets as development continues.
  • Scrolling scenery.
  • Collision detection.
  • Simple enemy AI.
  • Multiple weapon behaviors (ballistic movement, homing, line-of-sight).
  • HUD/GUI for various bits and pieces (tracking game progress, health, currency, upgrade shop, etc). Text, icons, buttons.
  • Player/weapon stats, affected by upgrades.
  • Save/load (with support for multiple profiles).
  • Simple input system.
  • Deploy mainly to PC during development, mobile (Android) near completion.
  • Enemy spawn system/ruleset. Possibly some sort of wave editor if needed.
  • Various effects (sounds, music, particles, etc.).


    There's probably a lot more as well, but that's the main things I can think of right now.

    I don't know how to do all these things properly in Unity as it stands, but that's kinda the point. This will be a learning process.

    Thoughts? =)

Right.

So, for a number of reasons, I'm going to be trying something new. I've dabbled with Unity before (notably the Week of Awesome gamejam here on GameDev.net), but I've been wanting to learn it better for a while now.

Thus, I'm setting myself a goal - try to create a small project in a single month (outside of normal full-time job).

Why a month? Well, why not? It's long enough to make it past the "just a simple prototype with some boxes" stage, but not long enough where I feel like i have all the time in the world. I need to keep going, and work towards the ever-looming deadline.

Also, it'll coincide nicely with my birthday which is almost exactly 1 month from now -- I should have thought of this yesterday, drats!

I'm not quite sure how often I'll be posting updates, it'll most likely depend on when I feel I have any noteworthy progress to jot down.

Tomorrow will be focused on trying to nail down a set of features I want to implement,, a basic design framework, etc.

Until next time!

Just a brief update regarding the on-going radio silence.

Amongst other things, I'm currently in the middle of moving. Once that's done (early this week), I'm a bit unsure about the internet status in the immediate future.

Hopefully project work and updates will return to a normal(ish) schedule soon! :)
Another YouTube update, showing off some of the new animations and movement improvements we've done.


As you might notice compared to the previous video, we're now using a higher framerate for the animations, giving it a much more fluid look. This is also more representative for how the finished game will end up being, when we transition to using proper 3D models and animation data directly, instead of pre-rendered to 2D sprites.

There's a whole bunch of animations in the video, and I've annotated them to show what they are meant, in case it isn't obvious.

Some keen observers might, well, observe some graphical glitches on a few of the animations (mainly that some of them start a bit abruptly). This is due to me recording with a laptop which wasn't connected to a power source -- power saving + recording = what you see.

Updates have been a bit scarce lately, as I'm currently looking for a new place to live, which takes up a lot of time.

In the next update, I'll shine a light on what we think of the current status of the game, and what we plan to do moving forward.

As always, comments, questions and any other feedback is appreciated!

smile.png
So, what's happened since the last journal entry?
With a rough and basic framework in place for drawing and moving some characters around, we continued adding and testing new animations, combat mechanics, etc. Even with time being limited due to our normal work, we (the artist and myself) still made some progress.

After trying out, discarding and keeping various ideas, we decided to try make something playable for a game dev convention that was not too far off in the future.
However, the night before the convention, we ran into an issue we thought we could ignore until later:
OUT OF MEMORY (crash).

While probably obvious if we had tried working out the memory requirements (which we didn't), the amount of animations we had blew through any available memory. We had 12 animations, rendered at 30 frames per second, in 16 directions. The largest sprite (containing 1 full animation, in all directions) had the massive size of 12800 * 4096 pixels. Yikes!

After some slight and minor panic, we decided to scale all the textures down, and hope for the best. Luckily, scaling down by 50%, and then drawing everything at double scale worked fine. It wasn't as crisp as we'd have wanted it, but "slightly blurry" beats "does not start", so it was an easy decision to make.
After some further work into the night (and during breaks between talks), we get the final things up and running.
---
At this point, what we have is a really basic 2 player competitive isometric fighter/brawler game. The goal in is to defeat the other guy, after which you can restart and try again. Pure and simple.

We latched onto some people and got them to try our game. They played it. They kept playing it. They reset and tried again, after victory and after defeat. Most of them played for far longer than just courtesy would dictate. Awesome.
As they played it, others walking past stopped to watch, comment and try it as well, swapping with the other players, or just discussing it between themselves.

In total, I'd estimate about roughly 20 - 25% of the convention participants either tried or observed the game (roughly 100 people were signed up for the event). We also got some positive feedback related to us being as open as we were, especially this early in the project.

Now, obviously, the game is still ways off from being totally super amazing. We repeatedly got comments about "seeing the potential". We're far from where we need to be, even for a prototype.
We know that a lot of the issues that were flagged need to be dealt with. While we think we would have noticed most of these issues ourselves easily enough, it was still very cool seeing how other people approached and played the game.

Looking ahead, that's the next thing to do. We're going to be going through all the feedback we collected, and decide which things to fix, which to ignore, and in what direction we'll be heading next.

As a personal look back on the event, my main disappointment is that we didn't manage to do some recording of the people playing. I just didn't have enough time to set up and test a system, which is something I'll definitely want to have sorted before we bring/show the game anywhere else.
It would also have been very beneficial if there had been enough time to test and tweak the game more before it was shown to other people, but I think it went well with the time available.
Other than that, I feel the criticism and comments helped enforce my belief in the game; what they were seeing was the same game we're discussing and making. There doesn't seem to be any dissonance going on. It doesn't seem like we're heading down a totally silly route. Phew.
---
And that concludes the journal update, I hope you found it interesting. Comments and feedback welcome! smile.png
After some weekends and afternoons busy with other things (i.e. friends and Dark Souls 2), there has been some progress on the project.



While some of the initial gameplay mechanic concepts seem to have been shelved for now, we're seeing quite a lot of interesting paths this could take. We might also revisit them again once we've played around with some new ideas. I guess that's what prototyping is for, eh?
[size=2]That, and for making horrible horrible code that can barely support itself, and is itching to get made somewhat more proper once we know which mechanics we want to support, etc.

For now, what we have is fairly rudimentary and rough, but that's par for the course.

  • Background image, larger than a screen.
  • Camera, can scroll around to extent of background image.
  • Camera can track entities (centering on average position), or just look at a specific point.
  • Some sprites with parenting and basic sprite sorting.
  • Some character system, supporting multiple animations and multiple directions.
  • Gamepad support.
  • Local multiplayer using 2x gamepads.
  • Various animations -- idle, walk, run, attack (x2).
  • Super basic hit detection.
  • Probably other stuff I can't remember.

    The character is modeled in 3D and animated. The animation is then rendered out to however many directions we decide we want to have, and loaded into the game. Each animation is its own spritesheet image, with frames in the x-axis and directions in the y-axis.

    The current focus is trying out various combat mechanics. This will involve quite a lot of brain storming and mocking up some quick & dirty animations, test and iterate.
    The plan is trying to get something which is fun when we control both characters, and then try to use that knowledge when creating some sort of AI.

    As always, I hope you've enjoyed this status update!

Test level image

Right, let's try a slightly more interesting journal entry than the last one, shall we?
One with something more than just boring text?

xy4B9RI.jpg

This piece of level test art is mainly for my own use as a testbed for implementing my various mechanics and effects. Obviously, a final product will look way better than this (as this is just a rough sketch), but it might be interesting to look at regardless.

As some sort of status update, I'm currently working towards a somewhat decent (hopefully!) prototype of my game's main game mechanics and effects. .Details coming in future journal entries.

Enjoy!
  • Advertisement