DEV Community: Chad

Tetris Development #6 - Risk and Reward

Chad — Tue, 07 May 2024 17:50:03 +0000

In this post, I will talk about the implementation for the varied reward functions in implementing the Tetris game.

Intro to Tetris Scoring

After digging into Tetris documentations, I found a lot of resources on how each move in Tetris is scored. It is A LOT more in-depth than what I knew about Tetris.

It's like, have I really been playing the same game as them? I only knew that clearing more = better scores...

Implementation

Overall, I took the same scoring system from this Tetris Wikipedia, as I want my game to behave as similarly to a real Tetris game as possible, so that my Tetris bot can extrapolate to the real game well.

I implemented the normal scores (single, double, triple and quad) as well as combo scores pretty easily -- All they required was some variables to keep track of rows cleared and combo so far.

To adhere to SWE principles, I also made sure to encapsulate the score calculation in a separate RewardManager class, and my game logic will call the API from this class to update the score.

Once that's done, it is time to move on to the boss of the section:

T-spins

T-SPINS!!

I have to say that this is the first time I had read a documentation on the formal definition of a T-spin. In essence, it is when the player is controlling a T-block, and rotates into a slot where 3 out of 4 corners in the 3x3 surrounding area are filled.

To check for this, I implemented an additional function when I land a T-block to check whether this action is eligible for a T-spin. Since I need to check the 4 corners, I hardcoded the corner values from the center, and counted how many corners were filled. I then adjusted the RewardManager to award T-spin score if a T-spin was done.

However, there is another move called T-spin Minis, and I didn't even know they existed! From what I read, they are kind of like an easier version of the T-spin, where you have to slot the T-block into a hard-to-reach, yet not incredibly hard-to-reach space. Sounds complicated, right? It did for me, at least, and I am not confident that I can successfully and reliably pull T-spin Minis off to test the functionality. Therefore, I decided to put T-spin Minis on hold for potential future addition, and only consider the regular and more difficult T-spin.

Conclusion

With that, the Tetris game clone is looking good! I am planning to pause the development here, and look into building the AI bot for this Tetris game. Stay tuned for the next post!

Tetris Development #5 - The HOLD Piece

Chad — Sun, 28 Apr 2024 18:18:51 +0000

In this post, I will talk about the implementation of the HOLD piece in our Tetris game.

First, what is a HOLD piece? In Tetris, there is a HOLD slot, which is empty at the start of the game, and the player can press a button to put the currently controlled piece into the HOLD slot to be used later. The game then continues as if the hold piece vanished. When the player thinks it is time to use the HOLD piece, they can press the same button again to swap the HOLD piece with the currently controlled piece and continue the game.

This allows for strategic planning and setup, where players can HOLD a useful piece to be used later in the game.

"Ok but how do we implement it?"

Logic

I started by adding a new variable for HOLD piece, and it is empty at the start of the game.

When the HOLD button (spacebar) is pressed, the game logic will check if there exists a piece being held. If there isn't, the HOLD piece will clone the current active piece, and the active piece will be replaced by the next piece in line.

If there is already a piece being held, then pressing the HOLD button will swap the held piece with the active piece.

Details

There are two important details in the HOLD implementation.
Firstly, when the active piece is replaced by the HOLD piece, the drop indicator will need to change as well. Without it, the drop indicator will still show where the original block (now in HOLD) will drop, instead of the newly swapped piece. Therefore, extra logic on the drop indicator piece was implemented to correct the behavior.

Next, to ensure consistency, I made it so that when a piece is put into HOLD, its orientation (i.e. rotation) is reverted back to upright. This means that every time the player swap a piece out of HOLD, the piece will be in an upright position, instead of whatever position it was when the player pressed HOLD. Since there are 4 possible orientations, if the player has to remember which orientation the HOLD piece was in, it is a huge burden especially if the player is swapping between different HOLD pieces. Thus, by reverting to always being upright, it adds more consistency to the outcome when using the HOLD functionality.

UI updates

But the HOLD piece won't work if the player can't see it!
Thus, the HUD must now have space for the HOLD slot, and the player should be able to see what piece is being held right now. I updated the UI to free up some space on the top-right in order to show the HOLD slot.

That is the end of the HOLD piece implementation. Personally, I feel that similar to the Next Piece Indicators, the HOLD piece adds another level of depth to the game and more rewards to carefully planned gameplay by strategic players. This also makes the training of an AI to play the game later more interesting.

Tetris Development #4 - Stop, Drop (and Roll?)

Chad — Sat, 27 Apr 2024 13:50:43 +0000

Continuing my development from the basic Tetris game, I added some new features that will make the game more player-friendly and fun: "Next Piece" indicators, Ability to drop the block instantly, and a Drop Indicator that tells you where the block will fall to.

Next Piece Indicators (NPIs)

I built the basic version of the Tetris game with 1 Next Piece Indicator (NPI), meaning that the player can see what will be the next ONE Tetris block coming up.

However, one block seems pretty limited in allowing the player to plan ahead -- c'mon, with only one NPI, when I see that the next block is an I-block (the straight linear Tetris), most of the time it's already too late to set up for a satisfying clear with that block. But if I can see THREE steps in advance, and know that the I-block is coming in THREE turns, as a player I can (or hope I can) definitely cook up some strategies!

Moreover, considering that I am planning to build an AI for this game (remember this is a Game & AI development!), looking 3 steps into the future makes the AI development much more interesting.

Therefore, I added more NPIs to the game, allowing players to see up to 3 upcoming pieces. Here's how it looks like in the game:

Instant Drop

I'm pretty impatient when it comes to Tetris, so if I'm sure that I want the block to drop directly down, I want a way to make it drop instantly instead of waiting for it to slowly make its way down.

With that thought in mind, I implemented a function where if the player taps the DOWN arrow key twice in quick succession, the block falls immediately. I did this by tracking the time delta since the last time the DOWN key was pressed. Using the process function, I can keep track of the time between two DOWN key taps, and if they are within 0.5 seconds, the block will be immediately dropped.

Drop Indicator

After implementing the instant drop, I tested the game, and found that sometimes when I drop the block instantly, it falls to the left or right of where I intended it to fall. This is due to my bad visual perception. Not the game.

In any case, it turns out that identifying which slot at the bottom of the board the block is going to fall into, when the block is at the top of the screen, is a not an easy task. Therefore, to help the players, I implemented a Drop Indicator to show where the block will fall to.

To implement this, I added a new variable: the indicator piece, which is different from the active piece which is the actual piece the player is controlling. Whenever the active piece moves, the indicator piece will instantiate at the same location, fall to the bottom, and stay there.

With the new Drop Indicator, it became a lot easier to see where my Tetris pieces were falling, and made the game less frustrating as I wouldn't accidentally drop a piece somewhere I didn't intend to.

Software Engineering Principles

During this part of the development, I realised again that I overlooked some Software Engineering principles in my development due to the lack of planning.

Don't Repeat Yourself (DRY)
As I implemented the indicator piece to show the Tetris drop location, I realized that it also uses the drop block function used by the active piece controlled by the player. The only different is that the indicator piece uses it to see where it will drop to, while the active piece uses it when the player actively double taps DOWN to get an instant drop. There are also a few other functions that are used by both pieces, indicating a possibility for a Game Piece class as an abstraction. However, as I did not think of the indicator piece idea until I implemented the instant drop, I had to add some code refactoring and repeat some code to achieve the functionality.
God Class
With more functionalities coming along, the Game script is getting longer and longer, making it difficult to locate specific functions within the script. During this phase of the development, I found myself using Ctrl+F to locate functions at times, simply because of the sheer size of the script file. I did not think a game like Tetris would have so many functions, and would have to take note to separate the game into components in the future.

Next Steps

Up next, I will continue to implement the expected features of the Tetris game!

Tetris Development #3 - Simple Tetris Game in Godot

Chad — Thu, 25 Apr 2024 14:36:06 +0000

Following the tutorial video in my previous post, I have implemented the basic components of the Tetris game.

Here are what the tutorial covered:

Game Layers There are two layers of the game, one being the active layer, which contains only the Tetris block that the player is currently possessing, and the other is the board layer, which contains the Tetris board as well as all blocks that have been set in place. The general flow is to instantiate a random block in the active layer, let the player control it until the block can't fall any further, then send that block to the board layer and create a new block in the active layer.

Player Input Movement
With player input, the currently possessed Tetris block can perform 4 actions: move left, move right, accelerate downwards, as well as rotate. There are also logic checks implemented for each of them, to prevent the block from going out of the game board or overlapping with existing blocks.
Next Piece Preview
Like every Tetris game, there is a preview for the player to see what the upcoming piece is, so that they can strategise accordingly.
Score Calculation
A flat amount is added to the score each time a row is cleared.

And with that, I now have a functioning Tetris game, albeit simplistic and lacking some features. The next step is to look back at the required features I set for the game in the first development post, and implement those additional features in the game.

What are left?

The Ability to Drop the Block Immediately
I want to implement an action, potentially a quick double-tap on the DOWN arrow key, that allows the player to drop the block immediately. This is needed for player satisfaction so players don't have to wait for the blocks to drop.
More Varied Rewards and Tracking
In the tutorial, clearing a row always grants a flat amount of reward points. I want to implement it so that clearing consecutive rows, or clearing multiple rows at once, are rewarded more, since they require more planning on the player's side. This encourages more tactical playstyles. To do this, I will need some kind of variable to track the player's "combo" at the moment.

A stretch goal for this would be to implement a reward for T-Spin, an advanced technique where the player can spin the T-block into hard-to-reach places. (Here is a video where T-spin is used, at around the 10 seconds mark.)

As you can see from the video, T-spin requires a very specific setup and thus careful planning, which is why I would want to include it in the game to reward highly-skilled players. There are two variations, the double T-spin (spin and clear 2 rows) and the triple T-spin (spin twice and clear 3 rows), and I will have to look more into how I can track these.

Simulating Multiplayer by Adding Obstacle Rows
In a multiplayer Tetris game, if one player receives a lot of points in a short period of time, for example by clearing many rows, the other player will be punished by having a few "zombie" obstacle rows added to the bottom of their board. These rows have random openings in them, so the other player will have to clear those rows strategically. This is a good way to spice up the game and add some element of randomness, so I would want to simulate this effect by adding obstacle rows at random time.
More Next Block Indicators
The tutorial implements one Next Block indicator, which tells the player what is the next block. I want to increase the number to three, so that the player can plan ahead even further. This should be doable by extending the existing functionality.
HOLD Functionality
I want to implement a HOLD functionality to allow the player to hold one block in a HOLD slot. This block can then be used to replace the active block at anytime. This allows the player to strategize which block to use and which to hold. For example, the player may hold a I-block (the long linear block) and then proceed to prepare 4 almost full rows, then take out the I-block from the hold slot and get 4 rows cleared at once. This is also to make the game more fun and encourage strategic planning.

So these are some of the next features I intend to implement in the Tetris game. During this post's development, I have also setup source control using Git, just for good practice. With that, it is time to push these updates to GitHub and work on the above features!

Tetris Development #2 - Intro to Godot and Basic Tetris Setup

Chad — Wed, 24 Apr 2024 18:15:08 +0000

Time to start developing in Godot!

Having watched a few quick tutorial videos on how Godot worked, I began setting up my first scene.

Since the Tetris game is played in a grid, my scene began with a TileMap, which allows me to set a 10x20 tilemap (essentially a grid) for the game. I followed a beginner's guide to Tetris in Godot video to complete this step.

The tutorial video then proceeded to create Tetris blocks for the game. In the video, the developer used individual variables for the vertex positions for each of the 7 different blocks, and the code looks something like this:

And this piece of code is repeated 7 times with minimal changes! ("How horrendous!" is what my software engineering module professors would say, if they ever see this coding style)

Therefore, as something of a Software Engineer myself, I decided to embrace the Object Oriented Programming Principles, and re-implement this code using inheritance and polymorphism. Thus began the long research into OOP in Godot...

OOP for Tetris in Godot

First of all, there has to be a Base Tetris class. This class declares (only the names, without values) a few variables, including the current vertice positions of the Tetris block, the 4 possible orientations of this block, as well as the current rotation angle. Each child class (e.g. Tetris_L for L-shaped Tetris blocks) will then define their own values for these variables when they are instantiated with _ready().

The base class also has a function rotate(), which rotates the Tetris block clockwise by updating its vertices and angle accordingly.

With the classes set up, I implemented a function to draw Tetris blocks on the tilemap. It is surprisingly simple: Simply instantiate a Tetris child class, grab its coordinates variable, and set the corresponding coordinates on the TileMap to a random color!

With the blocks ready, the next step is to make them start moving!

Lessons Learned

Instantiating a class in Godot: I have encountered two types of files in Godot so far. One is the .tscn files, which are for scenes, and another is the .gd files, which are for GD scripts. The classes are in .gd files, which must be instantiated with .new(), instead of with .load() and instantiate() which is for scenes.
The _ready() function: In the GDScript, there exists a _ready() function. Initially, I treated it as an equivalent function to __init__() in Python and Java, though after some debugging I found that there exist some subtle differences. In Python for instance, the init() functions for classes are called immediately when the class objects are instantiated. On the other hand, for GDScript objects, _ready() is only called when the object enters the scene tree, so you have to get the scene tree and add_child() to it before your instantiated object is fully instanced. I was stuck on this for a while wondering why my instanced objects did not have the updated variable values I defined in their _ready() functions, but now we know!

Tetris Development #1 - Setting Up

Chad — Wed, 24 Apr 2024 16:59:13 +0000

The first game that I would like to recreate is the game of Tetris. While it is a childhood game, it has also gained traction recently with the increase in popularity for the Puyopuyo-Tetris game in Japan.

This setup post has two areas to tackle: Game Specifications and Software.

Game Specification

Before diving into the implementation, the rules of the Tetris game must be clear. This is so that the implementation can be as efficient as possible, and does not obstruct future additions when implementing early features.

While there may be many versions of Tetris games online, I will go with the ruleset of one that I am familiar with.

The Tetris game is played in a 20*10 (Height*Width) grid.
There are 7 different Tetris blocks.

At one time, one Tetris block will fall slowly from the top of the screen, and the player can move it left, move right, or rotate it clockwise, as well as drop the block immediately.
The player can see the next 3 Tetris blocks coming up.
The player has a "Store" slot, which is empty at the start of the game. They can store the current block (block A) into the "Store" slot anytime they want to. If there is a block (block B) in the slot already, that block (B) will be popped out, and replace block A at block A's location on the grid.
When the player fill any row with 10 Tetris blocks, the row disappears and rows above it will drop down.
Clearing one-row awards points.
These actions award more points: Clearing more than one-row at once, Clearing rows in consecutive actions, Clearing 4 rows at once (a lot of points!), and possibly a T-spin (an advanced technique where the T block is spun as it falls so it goes into hard-to-reach spaces).
Most modern Tetris games are multiplayer, and when one player does well and receives a certain amount of points, the other player will be punished by having rows added to the bottom of their screen. Since multiplayer games are a whole new can of worms, I will simulate this effect by adding rows to the bottom of the screen at random intervals.
If the next Tetris cannot enter the screen, that is, the center of the screen reaches the full 20 rows height, the game is over.
As time progresses, the Tetris blocks will fall faster to increase the difficulty and give the players less time to react.

These are the rules I can think of currently for the Tetris game.

Software

Moving on to the software used for development, I will need a simple lightweight 2D game development environment.

While I am proficient in Unreal Engine from a previous game, I feel that it is more suited for 3D games. I also have some brief experience making games in Unity, which is equally popular, but I am not as proficient in Unity.

Instead, I was recommended Godot by a fellow developer. It is an easy-to-pickup and beginner-friendly open-source engine, which I will use to develop the Tetris game.

In the next post, I will be starting my Tetris development in Godot, so stay tuned!

Beginner Dev Takes On AI and Games!

Chad — Tue, 23 Apr 2024 13:20:41 +0000

Hey! I'm Chad, a beginner developer on the way to learning more about AI and Games, and I'm starting this blog to document my progress and findings.

Some of the game AIs that inspired me to dive deeper include the enemies in The Legend of Zelda: BOTW and the Last of Us, as well as characters in Skyrim and Sims. However, as a beginner dev, I'm going to start with something simpler:
Recreate Classic Games, then Build AIs to play them.

With this in mind, the project will be split into a few sections:

Game Development
Game Information Extraction
AI Training

And now, it's time to start developing!