Treasure Quest is an adventure game where the character, called the hero, is called upon to rid the land of flying bat-like creatures (called Flyers) and is promised a treasure chest as a reward. The hero has two methods of attacking and destroying the Flyers : swinging a sword and shooting arrows (the hero begins with three). Contact with either of these weapons will destroy a Flyer in a single hit. The hero begins with three health points . Colliding with a Flyer reduces the health of the hero by one point, and if the hero’s health reaches zero, then the hero is destroyed, and the game is over. When each Flyer is destroyed, they drop a coin, which can be collected by the hero and used to purchase additional health or arrows from an item shop. There are a pair of NPCs in the game: the Shopkeeper, who informs you of the prices and quantities of items in the shop (1 health for 3 coins, 3 arrows for 4 coins), and the Gatekeeper, who guards the treasure and tells you how many Flyers remain to be defeated.

The player uses the arrow keys to move the hero, and the S and A keys to swing the sword and shoot arrows, respectively. Arrows travel in a straight line in whatever direction the player is facing. The amount of health and the numbers of coins and arrows are displayed along the top of the screen. When the player wins or loses the game, a large message will be displayed in the center of the screen. NPC messages are displayed automatically on the bottom of the screen (as seen in Figure 12-2) when the hero is within four pixels of the NPC and automatically disappear when the hero moves away.

The graphics for this game are colorful and cartoonish. Only a few animations are implemented in this project: the hero walking, the sword swinging, the enemies flying, and fading smoke that appears when an enemy is destroyed. Adding additional animations and sound effects to enhance the interaction with game-world objects would be an important and worthwhile addition to this project.

This chapter assumes that you are familiar with the material on tilemaps from Chapters 10 and 11, and that you have installed the Tiled map-editor software. In addition, you will need to be familiar with the material on dialog boxes and sign mechanics from Chapter 5, which is necessary to set up interactions with the NPCs.

Beginning this project requires the same steps as in previous projects: creating a new project, creating an assets folder and a +libs folder (the latter not being necessary if you have set up the userlib directory), copying the custom framework files you created in the first part of this book (BaseGame.java, BaseScreen.java, BaseActor.java), as well as the TilemapActor.java class you developed in Chapter 10 and the DialogBox.java class you developed in Chapter 5, and copying the graphics and audio for this project into your assets folder. As described previously, a BlueJ project named Framework has been created for your convenience and contains the necessary source code files to provide a convenient starting point. To begin the first project:

To begin, start the Tiled map-editor software . Create a new map with a map size that has a width of 40 tiles and a height of 40 tiles, and a tile size with the width and height both set to 32 pixels. The resulting map will be 1280 by 1280 pixels. Click the Save As . . . button and save the file to your assets directory with the filename map.tmx.

Next, add an object layer to your map. Then, in the Tileset panel , add a new tileset using the image adventure-tiles.png (shown on the left side of Figure 12-3), set the tile size to 32 by 32, and check the box to embed the tileset in the map. Add another new tileset to the map, this time using the image object-tiles.png (shown on the right side of Figure 12-3), in the same way. Since the object tiles will be used to indicate where game-world objects should be spawned, you will need to specify the corresponding Java classes (which you will create later). In the Tileset panel , select object-tiles and click on the icon to edit the tileset. In the tab that appears, you will need to click on each tile (one at a time) and add a new custom property to each. The property should be called name; the corresponding values for the tiles (from left to right) are Bush, Rock, Coin, Treasure, Flyer, NPC, ShopHeart, and ShopArrow. In addition, for the NPC tile, add a second custom property called id with a value of default, and a third custom property called text with a value of Hello, World!. (These default values will be overridden for specific instances later on in the tilemap editor).

Return to the tab featuring the tilemap. In the Layers panel, select Tile Layer 1. In the Tileset panel, select adventure-tiles , and then press the B key to activate the Stamp Brush tool . Add grass tiles across the entire map (which can be greatly accelerated using the Bucket Fill tool ), then add the wooden fence tiles along the edges. Also, add two large fenced-in areas near the center of the map, each with a two-tile-wide entrance so that the hero can move through; the bottom half of the tilemap is shown in Figure 12-4.

As was mentioned in the previous chapter, the tile layer is being used only to simplify creating an image from a tileset. The fence tiles should be solid barriers in the actual game, and so you will add rectangles in the object layer to store the data corresponding to those regions. In the Layers panel, select Object Layer 1 and press R to activate the Rectangle tool . Draw rectangles around all the regions containing solid tiles; for simplicity, rectangles can be drawn that surround multiple tiles at once. Each time you add one of these rectangles, you must also add a custom property called name with a value of Solid (which will be used to initialize corresponding actors later). To accelerate this process, when a rectangle is selected and the Select Object tool is active, you can use the shortcut key combination Ctrl+D to duplicate the object (including the custom property) and simply reposition and resize the new object (which appears directly on top of the original object). Once you have added rectangles corresponding to all the regions containing solid tiles, add one final rectangle in the bottom center of the map to indicate the starting position of the hero; add the custom property name with a value of Start.

Next, you will add the game objects, aiming for a design similar to that seen in Figure 12-5. Press T to activate the Insert Tile tool. Add Bush and Rock tiles (from the object-tiles tileset) to wall off a region that includes the hero’s starting position and the entrances to the two fenced-in areas you created earlier; this will be used to block enemies from reaching the hero until the player decides they are ready and uses the sword to remove the bushes. In the left fenced area, place a Treasure tile in the center and an NPC tile in the middle of the entrance. It may be useful during this process to hold down the Ctrl key while positioning a tile, which allows a tile to be placed in-between grid squares . For that NPC tile, temporarily switch to the Select tool and change the custom property id value to Gatekeeper . (The text that this NPC will display will be set via code later, and so you do not need to change this property.) In the right fenced area, add an NPC tile in the top center, changing id to Shopkeeper and text to 1 heart for 3 coins! 3 arrows for 4 coins! (This will produce the message seen in Figure 12-2 .) Also add a ShopHeart tile and a ShopArrow tile in the middle, at least one grid square apart from each other. Add a Coin tile somewhere in this area for later testing purposes. Finally, outside of the closed-in area you created, add a bunch of Flyer tiles and some more scattered Bush and Rock tiles.

When you are finished, save the tilemap, close the Tiled map editor if you wish, and open the Treasure Quest project in BlueJ (if it isn’t already open). First, to represent the solid objects with which the hero and other game entities will collide, similar to the process from Chapter 11, create a class named Solid containing the following code:

Next, in the LevelScreen class , add the following import statements:

Then, add the following code to the initialize method to load the tilemap and generate the Solid objects corresponding to the rectangles in the tilemap:

At this point, you can test your project, although you will only see a small part of the level, and you have yet to write the code that creates the game entities represented by the object tiles. Your first task will be to add the hero character, as will be explained in the next section.

In this section, you will create the code for the hero character. Since this game features a top-down perspective, the hero will have four different animations corresponding to walking in each of the four compass directions (north, south, east, and west). The main responsibilities of this class are to initialize the animations and display the correct animation depending on the actual angle of motion. It will also be important for this class to be able to determine the angle at which the character is currently facing (which will be a multiple of 90 degrees).

For adventure games or role-playing games, many spritesheets containing top-down character-walking animations typically contain the animation frames for all four directions in a single spritesheet, one direction per row, as illustrated in Figure 12-6. This layout standard has been popularized in particular by the game engine software RPG Maker. To extract the animation frames from the individual rows and create the corresponding animation will require the use of the TextureRegion class split method, as you will see.

To begin, create a class called Hero with the following code:

Next, you need to select the correct animation according to the direction of movement . This is a straightforward calculation, as visualized in Figure 12-7. For example, if the angle of motion is between 45 and 135 degrees, then the player’s movement is mainly to the north, and the hero is facing in the 90-degree direction. The eastern direction is slightly more complicated, as it corresponds to an angle that is either between 0 and 45 degrees or between 315 and 360 degrees, and so this case is left until last in the corresponding set of if-else statements.

Next, you will add the hero to the game as well as keyboard controls for moving the hero.

In the LevelScreen class, add the following import statements:

Then, add the following variable declaration:

In the initialize method , add the following code, which determines the starting position of the hero from the tilemap data and initializes the object:

Finally, in the update method , to move the hero with the arrow keys and stop the hero from moving through solid objects, add the following:

This is a good point at which to test your project to make sure that the hero moves as intended.

Next, you will add a sword to the game; pressing the S key will make the sword appear. The hero will appear to swing the sword in an arc, and then the sword will disappear. The first challenge in this process is making the sword appear in the correct location, consistent with the animation currently being displayed. In this game, you will assume the hero is right handed, and so the hilt of the sword should appear at the location of the hero’s right hand , as shown in Figure 12-8. This position, relative to the bottom-left corner of the hero image, will be stored as a percentage of the width and height of the hero graphic.

In addition, once the sword has been placed correctly, it will be swung through a 90-degree arc, as illustrated in Figure 12-9 . This can be accomplished by setting the initial rotation to 45 degrees less than the angle at which the hero is facing, then using an action to rotate the sword by 90 degrees (counter-clockwise). Since the sword should rotate around its hilt (not the center), the x-coordinate of the origin should be set to 0.

Next, in the LevelScreen class , add the following import statements:

Then, add the following variable declaration:

In the initialize method , set up the sword as follows:

In the update method , to stop the hero from moving during a sword swing, locate the if statements corresponding to hero acceleration and enclose them in a conditional statement as follows:

To handle the actual swinging of the sword, add the following method to the LevelScreen class:

Finally, to enable the player to swing the sword, as this is a discrete action, you need to add a keyDown method to the LevelScreen class:

At this point, your code is ready to test again. Walk around the screen and try swinging the sword in each direction. However, there is nothing to swing at yet; this will be remedied in the next section.

Then, create a class named Rock with the following code:

To create these objects from the tilemap data, in the LevelScreen class, add the following code to the initialize method:

Since the Bush and Rock classes extend the Solid class, overlap with these objects is already prevented in the update method by the for loop that iterates over the list of Solid objects. For the sword to destroy the bushes, add the following code to the update method:

At this point, you can test your code again, slashing bushes with the hero’s sword to your heart’s content.

Next, you will set up the user interface, which displays the amount of health remaining and the number of coins and arrows currently being held by the player. To keep the interface simple and minimal, images will be used rather than words, as shown in Figure 12-10 . The user interface will also contain a label that displays a “Game Over” message when appropriate, as well as a dialog box for discussions with NPCs (although this will not be used until later).

To begin, add the following import statements to the LevelScreen class:

Then, add the following variables to the class:

Next, to set up all these variables , add the following code to the initialize method:

To create the icons used in the interface, add these statements:

To arrange all these items in the uiTable , add the following code as well:

To keep the labels updated with the correct values of the variables, add the following code to the update method :

In addition, when the game is over, you will no longer want to move the player or swing the sword, so add the following code at the beginning of the update method:

Similarly, at the beginning of the keyDown method , add the following:

This is a good point at which to add a few more game objects: the coins that can be collected and the treasure chest that you find to win the game. First, create a new class named Coin with the following code:

To create the objects from the map data, add the following to the initialize method :

To handle overlap with these objects, in the update method , add the following code:

In addition, this is a good time to add the code that handles losing the game, which happens when the hero runs out of health (even though this is not possible yet), so also add the following:

Once again, you are ready to test your game. Collect coins (if you have added any) and collect the treasure to see the “You win!” message appear on the screen.

Every game should have an obstacle that makes it difficult to reach or achieve the goal. In Treasure Quest, you must use your weapons to destroy the enemies that fly around the screen, which are named Flyers. Flyers are somewhat random: each has a random speed, and at random times they change their direction of motion to a random angle. Create a new class called Flyer that contains the following code:

When a Flyer is destroyed, it will disappear in a puff of smoke. To this end, create a new class called Smoke that contains the following code, which creates an image that fades out and then removes itself from the game:

As usual, you need to create these new objects in the LevelScreen class initialize method, as follows:

Flyers will also be blocked by solid objects and change their direction on collision, so in the update method, locate the for loop that iterates over the Solid objects and in the corresponding block of code add the following:

The sword can destroy enemies when it is visible (which indicates it is in the process of being swung). In this case, if the sword overlaps an enemy, smoke will be created and a coin will be spawned (rewarding the player for their victory). In the update method, locate the conditional statement that checks if the sword is visible, and in the corresponding block of code add the following:

Finally, the hero should lose health when he comes into contact with a Flyer. Checking for overlap is straightforward, but there is a subtle point that needs to be addressed: the hero and the Flyer should be “pushed apart” as much as possible because otherwise the hero could overlap the Flyer multiple times in rapid succession, and the player would quickly lose the game. Therefore, after a collision occurs, the Flyer will start moving in the opposite direction, and the hero will be pushed away from the enemy, which is also sometimes called knockback. To calculate the angle of motion, you calculate the vector from the hero to the Flyer by subtracting their positions and then use the angle method of the Vector2 class. To implement these features , add the following code to the update method:

At this point, you have finished implementing the Flyer enemies. Test your project, slash the enemies with your sword, and collect the coins they drop.

Shooting arrows will be handled by the following method, which should be added to the LevelScreen class:

Finally, to specify how the arrows interact with the Flyers and with solid objects, add the following code to the update method:

This completes the arrow-shooting mechanic . Test your game and make sure that arrows destroy Flyer enemies, arrows stop when colliding with a solid, the number of arrows decreases when they are shot, and once the number of arrows reaches 0, no more arrows can be shot.

The next feature you will implement is the addition of non-player characters (NPCs). They are very closely related to the sign objects introduced in Chapter 5; you may want to reread the corresponding section before continuing. Similar to signs, approaching an NPC causes the dialog box in the user interface to display an associated message. Unlike signs, however, each NPC will have a distinct appearance, using the identification (id) data set in the tilemap. In addition, each NPC’s ID will be checked before displaying the associated message, which gives you the opportunity to display different messages depending on the state of the game. In particular, the game designed in this chapter features two NPCs, one called the Gatekeeper, the other called the Shopkeeper. The Gatekeeper initially blocks access to the treasure, provides instructions to the player (destroy all the Flyers to get the treasure!), informs you how many Flyers remain, and fades out and disappears once you have destroyed them all, thus enabling you to collect the treasure. The Shopkeeper does not feature dynamic text; they simply inform the hero of the prices and quantities of items available for sale in the item shop (which will be created in the next section).

To set up the NPCs, in the initialize method of the LevelScreen class, add the following code; note that you need to also retrieve the properties named id and text that you created when designing the tilemap. Note that the NPC position will be slightly offset from where it was placed in the Tiled map editor, because the NPC size is larger than the icon used to represent it in the tileset. You may find that you wish to adjust the NPC positions in Tiled later.

At this point, the NPCs are fully functional. Test your game and talk to each of the NPCs. Try to destroy the Flyers, and then make sure that the Gatekeeper vanishes as expected.

The final mechanic you will implement in the Treasure Quest game is the item shop, which consists of two tiles that the hero can stand on, and if the player presses the B key (to buy) and has enough coins, the player will receive the quantity of items stated by the Shopkeeper. This gives value to the coins collected by the player, rather than their just being an abstract number of points or measure of progress. To begin, create a new class named ShopHeart with the following code:

Also create a class named ShopArrow as follows:

To create these objects , add the following to the initialize method:

That’s all there is to it! Try out your game again, destroy some Flyers , and spend your hard-earned coins.

Once you have reached this point, congratulations are in order, as you have completed the longest project in this book!

As always, you should add features such as menus and sounds. If you wish, you could add new types of weapons, such as bombs, that create explosions that destroy both rocks and enemies. Bombs would likely be a limited resource, similar to arrows, and could perhaps be purchased at the item shop as well. Additionally, you could create a new kind of enemy that follows the player for added difficulty. You could change the goal of the game: instead of destroying Flyers, perhaps you have to collect a certain number of coins to proceed. You could remove the sword from the game, or even remove weapons entirely, making the game about dodging and avoiding enemies. The possibilities are endless!

At this point, you have completed the second part of the book. The final part of this book contains advanced techniques and algorithms that explain how to use gamepad controllers, advanced graphics, and more, which can be used to improve all of the games you have worked on up to this point.