1. Homepage
2. Programming
3. DPST1091 Programming Fundamentals - Assignment 1 - CS Defence

# DPST1091 Programming Fundamentals - Assignment 1 - CS Defence

CProgramming FundamentalsCS DefenceAustraliaUNSWDPST1091

# Assignment 1 - CS Defence

Tower Defence is a specific genre of games that boomed in the late 2000s. Many innovative games were created under this genre that pushed new and exciting ideas!

The core mechanics of these types of games are actually very simple! Waves of enemies continuously spawn (often forever!) and the player has the task of placing towers that will automatically fight these enemies. Both the player and enemies increase in strength over time and the defences need to be upgraded and improved to avoid enemies reaching a particular destination that could end the game!

CS Defence is heavily inspired by this genre, and specifically, one of the more famous games under its belt - Bloons Tower Defense. In this game, as well as CS Defence, enemies spawn from some start position and try to move to some end position via a path on the map. The player's goal is to place down towers that attack these enemies as they move. As towers destroy enemies, the player earns money that they can use to either upgrade or place down new towers.

# Overview

## Assignment Structure

This assignment will test your ability to create, use and manipulate 2D arrays and structs to solve problems. To do this, the map used in the game has been implemented as a 2D array of tiles. These tiles are each represented by a `struct tile`, which is outlined below:

`struct tile`

• Purpose:
• To store information about the tiles of the map.
• Contains:
• `enum land land_type`
• The type of land this tile has.
• All land types are found in the `enum land` definition.
• `enum entity entity`
• The type of entity that exists on top of the land for this tile.
• All entity types are found in the `enum entity` definition.
• `int n_enemies`
• Represents the number of enemies at this tile in the map.

The provided enums are quite extensive. Definitions of each are provided below:

`enum land`

• Purpose:
• Represent the type of land.
• Possible values:
• `GRASS`
• Represents a piece of grass. It is notable that towers can be placed on this land.
• `WATER`
• Represents a block of water. It is notable that towers cannot be placed on this land, with an exception mentioned in later stages.
• `PATH_START`
• Represents the start of the path on the map. It is notable that this is where enemies will spawn.
• `PATH_END`
• Represents the end of the path on the map. It is notable that enemies move to this location, and when reached, the player loses lives.
• `PATH_UP``PATH_RIGHT``PATH_DOWN``PATH_LEFT`
• Represents the “flow” of a path on this piece of land. Each of these types indicates the direction that the path is heading.
• `TELEPORTER`
• Represents a teleporter on the path that links to another teleporter. Similar use case as the path tiles mentioned, but allows for more complex path flow.

`enum entity`

• Purpose:
• Represent the kind of entity.
• Possible values:
• `EMPTY`
• Represents no entity. Some tiles will only have land and no entity, this allows us to represent that.
• `ENEMY`
• Represents single or multiple enemies. Used when enemies are spawned and will move along the path.
• `BASIC_TOWER``POWER_TOWER``FORTIFIED_TOWER`
• Represents all the different types of towers that exist. Each tower has different abilities, specified in Stage 3.

### Mental Model

A tile can always be thought of as a piece of land with an entity on top of it. Click through the different combination of land + entities below to build up this mental model of what a tile is!

In this assignment, you will have a 2D array of these tiles. This could represent a map like the one below:

### Implementation Model

Although the mental model mentioned above is a great way to understand how the map works in this assignment, it is also important to understand how it works in the code itself.

In this assignment, you will be need to manipulate a map provided which is defined as

`struct tile map[MAP_ROWS][MAP_COLUMNS];`,

where `MAP_ROWS` is 6 and `MAP_COLUMNS` is 12.

This means that we have a 2D array of `struct tile`s, which themselves have both entity + land enums associated with them. Change attributes in the interactive below to get an understanding of how you should access each part of this `map`.

Note that the indices indicate which struct in the array you are accessing, and the word after the `.` indicates which member of that struct that you are accessing.

`map[ 0 1 2 3 4 5 ][ 0 1 2 3 4 5 6 7 8 9 10 11 ]. land entity n_enemies `
struct tile
enum land_type land = GRASS
enum entity entity = EMPTY
int n_enemies = 0
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile
struct tile

## How To Get Started

There are a few steps to getting started with CS Defence.

1. Create a new folder for your assignment work and move into it.

```mkdir ass1
cd ass1```

2. Download the starter code (cs_defence.c) here or use this command on your CSE account to copy the file into your current directory:

`cp -n /web/cs1511/23T1/activities/cs_defence/cs_defence.c .`

3. Run `1511 autotest cs_defence` to make sure you have correctly downloaded the file.

```    1511 autotest cs_defence
```

2. Spend a few minutes playing with the reference solution -- get a feel for how the assignment works.

`1511 cs_defence`

1. Start coding!

The provided starter code has done some setup for you. This is explained below.

Before the main function, the starter code has:

1. Imported the standard input/output library.
2. Defined some initial `#define`'s and enums.
3. Defined the struct described above.

In the main function, the starter code:

1. Creates a 2D array of `struct tile`s called `map`.
2. Initialises this `map` with some default values.
3. Prompts you to write your own code!

This assignment consists of four stages. Each stage builds on the work of the previous stage, and each stage has a higher complexity than its predecessor. You should complete the stages in order

# Stage 1

## Stage 1.1 - Setup

To start off the assignment, you will need to initialise some basic information for the game. The starter code currently creates a 2D array of `struct tile`s and initialises them using the `initialise_map()` function that we’ve provided.

Your job is to take input from the user, asking them for their initial lives and money. An example of this is shown below:

```dcc cs_defence.c -o cs_defence
./cs_defence
Starting Lives: 100
Starting Money(\$): 500
```

Once you have the above working, you will need to scan in the “starting” point on the map and the “ending” point on the map. We describe a point as 2 integers, indicating a row then column. The starting and ending points will indicate where enemies will spawn from, and where they need to get to respectively. Implementing this, your program should behave in the same manner as below:

```dcc cs_defence.c -o cs_defence
./cs_defence
Starting Lives: 100
Starting Money(\$): 500
Start Point: 1 2
End Point: 4 10
```

In the example above, the start point is at row 1, column 2 and the ending point is at row 4, column 10.

These points can be visualised on the map like so:

You will need to modify the given 2D array, `map`, to account for these points.

Make sure to read through the overview of the given structs/enums to understand how they work before continuing.

Once you understand how each struct/enum works, it is important to know that the `map` variable in the code is a 2D array of `struct tile`s. Alternatively, it can also be thought of as a 2D array of land with optional entities on top of it, since this is what each tile represents.

Currently, all the land is simply grass. However, given the starting/ending point that was just scanned in, you should update the relevant tiles such that their land is now `PATH_START` and `PATH_END` respectively.

After this, you should print out the map using the provided `print_map()` function. When printing out the map, the start point will be printed as `S` and the ending point will be printed as `E`, assuming you’ve updated the land correctly!

### Assumptions/Restrictions/Clarifications

• Starting lives and money will always be given as numbers greater than 0.
• Start/End points will always be valid indexes in the `map` array. They will never be out of bounds.
• Start/End points will never be the same point.

## Stage 1.2 - Initial Enemies

Tower defence games aren’t quite so fun when enemies don’t exist! For Stage 1.2, you will add some initial enemies to the starting point on the map. After printing out the map in the previous section, you should scan in how many enemies to put at the starting point:

```Initial Enemies: [num]
```

To add enemies to the starting tile, you need to do two things:

• Set the `entity` component at that tile to `ENEMY`.
• Set the `n_enemies` component of that tile to the number scanned in.

In the case where `num` is 0 or negative, the starting tile should not change.

After scanning in the enemies, you will need to print out the map again. If done correctly, the map will now show a number above the 'S' on the starting tile!

### Assumptions/Restrictions/Clarifications

• You can assume that the initial enemies will never be greater than 999.

## Stage 1.3 - Lake

A common way to increase the difficulty of Tower Defence games is to add environmental obstacles, rather than just bombarding the player with more enemies. For Stage 1.3, you will add the ability to create a lake on the map! Lakes restrict the types of towers that can be placed on them.

After printing out the map in the previous section, you should scan in information about this lake:

```Enter Lake: [row] [column] [height] [width]
```

The row and column that are scanned in indicate where the lake starts. The height and width indicate how far the lake stretches out in both dimensions. The lake always stretches down and to the right with these dimensions.

For every tile that appears in the lake on the map, their `land` component should be set to `WATER`.

After filling in the lake, the map should be printed again.

As an example, assume we give the program the following input:

```Enter Lake: 1 2 4 6
```

The map would then look like this (ignoring start/ending tiles and initial enemies):

### Error Handling

If the `row` and `column` provided is outside the map, or the `height` or `width` would stretch the lake outside the map, the message below should be printed and no lake should be added.

"Error: Lake out of bounds, ignoring...".

### Assumptions/Restrictions/Clarifications

• The given lake will never overlap with the start/end points.
• The height and width entered will always be positive integers.
• When handling the lake out-of-bounds error mentioned, the program should still continue normally. This error should only cause the lake to be ignored, and no water to be added to the map.
• The map should still be printed even if the lake out-of-bounds error occurs.

## Get in Touch with Our Experts

WeChat
WhatsApp
C代写,Programming Fundamentals代写,CS Defence代写,Australia代写,UNSW代写,DPST1091代写,C代编,Programming Fundamentals代编,CS Defence代编,Australia代编,UNSW代编,DPST1091代编,C代考,Programming Fundamentals代考,CS Defence代考,Australia代考,UNSW代考,DPST1091代考,Chelp,Programming Fundamentalshelp,CS Defencehelp,Australiahelp,UNSWhelp,DPST1091help,C作业代写,Programming Fundamentals作业代写,CS Defence作业代写,Australia作业代写,UNSW作业代写,DPST1091作业代写,C编程代写,Programming Fundamentals编程代写,CS Defence编程代写,Australia编程代写,UNSW编程代写,DPST1091编程代写,Cprogramming help,Programming Fundamentalsprogramming help,CS Defenceprogramming help,Australiaprogramming help,UNSWprogramming help,DPST1091programming help,Cassignment help,Programming Fundamentalsassignment help,CS Defenceassignment help,Australiaassignment help,UNSWassignment help,DPST1091assignment help,Csolution,Programming Fundamentalssolution,CS Defencesolution,Australiasolution,UNSWsolution,DPST1091solution,