A Step-by-Step Guide to Building a C# Text Adventure Game

Crafting a C# Text-Based Dungeon Adventure

Explore creating-a-text-based-dungeon-game-in-csharp to help your C# assignment. This comprehensive guide provides step-by-step insights into game development and software architecture, making it an invaluable resource for aspiring programmers. Delve into the intricacies of coding a captivating text-based dungeon game, learn how to structure game elements, and acquire practical knowledge that can enhance your C# programming skills. Whether you're a beginner seeking hands-on experience or a game development enthusiast, this guide opens the doors to endless creative possibilities in the world of C# game development.

Block 1: Namespace and Class Declaration

```csharp
using System;
using System.Linq;
using System.IO;
using System.Collections.Generic;
using static GameDev.Game;
namespace GameDev
{
// Main class definition for the Dungeon Game Application
public class Game
{
// ...
}
}
```

This block includes necessary C# `using` directives for the required libraries.
It defines a `Game` class within the `GameDev` namespace.

Block 2: Game Class Variables and Enums

```csharp
using System;
namespace GameDev
{
public class Game
{
public enum PlayerActions
{
NOTHING,
NORTH,
EAST,
SOUTH,
WEST,
PICKUP,
ATTACK,
DROP,
QUIT
}
private PlayerActions action = PlayerActions.NOTHING;
private int playerX;
private int playerY;
public enum GameState
{
UNKNOWN,
STOP,
RUN,
START,
INIT
}
private GameState status = GameState.INIT;
private char[][] originalMap = new char[0][];
private char[][] workingMap = new char[0][];
private bool advanced = false;
private string currentMap;
private int coins;
private int kills;
public string ReadUserInput()
{
return Console.ReadLine() ?? string.Empty;
}
public int GetStepCounter()
{
return counter;
}
public void ProcessUserInput(string input)
{
var inputSplit = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);
var command = inputSplit.FirstOrDefault()?.ToLower().Trim();
var args = inputSplit.Skip(1).Select(x => x.Trim()).ToArray();
switch (command)
{
case "load":
var mapName = args.FirstOrDefault();
LoadMapFromFile(mapName ?? string.Empty);
break;
case "begin":
if (GameIsRunning() == GameState.RUN)
{
action = PlayerActions.NOTHING;
}
else
{
status = GameState.RUN;
counter = 0;
var removedS = false;
foreach (var tilesY in workingMap)
{
for (var i = 0; i < tilesY.Length; i++)
{
var tile = tilesY[i];
if (tile != 'S') continue;
removedS = true;
tilesY[i] = '_';
break;
}
if (removedS) break;
}
var placedPlayer = false;
for (var y = 0; y < workingMap.Length; y++)
{
var tilesY = workingMap[y];
for (var x = 0; x < tilesY.Length; x++)
{
var tile = tilesY[x];
if (tile != 'S') continue;
playerX = x;
playerY = y;
placedPlayer = true;
workingMap[y][x] = '_';
break;
}
if (placedPlayer) break;
}
}
break;
case "w":
MovementAction(PlayerActions.NORTH);
break;
case "a":
MovementAction(PlayerActions.WEST);
break;
case "s":
MovementAction(PlayerActions.SOUTH);
break;
case "d":
MovementAction(PlayerActions.EAST);
break;
case "z":
action = PlayerActions.PICKUP;
break;
case "q":
action = PlayerActions.ATTACK;
break;
}
}
// Other methods and logic for game functionality
public GameState GameIsRunning()
{
return status;
}
private void InitializeMap()
{
status = GameState.START;
action = PlayerActions.NOTHING;
coins = 0;
var placedPlayer = false;
for (var y = 0; y < workingMap.Length; y++)
{
var tilesY = workingMap[y];
for (var x = 0; x < tilesY.Length; x++)
{
var tile = tilesY[x];
if (tile != 'S') continue;
playerX = x;
playerY = y;
placedPlayer = true;
break;
}
if (placedPlayer) break;
}
}
}
}

In this block, various class variables and enums are defined.
`PlayerActions` is an enum representing player actions.
`GameState` is an enum representing game states.
Several private variables are used to store player and game state information.

Block 3: ReadUserInput Method

```csharp
private string ReadUserInput()
{
// Read user input from the console, returning an empty string if null
return Console.ReadLine() ?? string.Empty;
}
```

This block defines a private method for reading user input from the console.

Block 4: GetStepCounter Method

```csharp
public int GetStepCounter()
{
return counter;
}
```

This method returns the number of steps a player has taken on the current map. It increments with each player move.

Block 5: ProcessUserInput Method

```csharp
public void ProcessUserInput(string input)
{
// Split input by space, we get command and args
var inputSplit = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);
// Command is processed in lowercase to make things easier
var command = inputSplit.FirstOrDefault()?.ToLower().Trim();
// Arguments are all trimmed
// Also skip the first element as that's the command
var args = inputSplit.Skip(1).Select(x => x.Trim()).ToArray();
switch (command)
{
case "load":
// Load map
var mapName = args.FirstOrDefault();
LoadMapFromFile(mapName ?? string.Empty);
break;
case "begin":
if (GameIsRunning() == GameState.RUN)
{
// Game already running, do nothing
action = PlayerActions.NOTHING;
}
else
{
status = GameState.RUN;
counter = 0;
var removedS = false;
foreach (var tilesY in workingMap)
{
for (var i = 0; i < tilesY.Length; i++)
{
var tile = tilesY[i];
if (tile != 'S') continue;
removedS = true;
tilesY[i] = '_';
break;
}
if (removedS) break;
}
var placedPlayer = false;
for (var y = 0; y < workingMap.Length; y++)
{
var tilesY = workingMap[y];
for (var x = 0; x < tilesY.Length; x++)
{
var tile = tilesY[x];
if (tile != 'S') continue;
playerX = x;
playerY = y;
placedPlayer = true;
workingMap[y][x] = '_';
break;
}
if (placedPlayer) break;
}
}
break;
case "w":
MovementAction(PlayerActions.NORTH);
break;
case "a":
MovementAction(PlayerActions.WEST);
break;
case "s":
MovementAction(PlayerActions.SOUTH);
break;
case "d":
MovementAction(PlayerActions.EAST);
break;
case "z":
action = PlayerActions.PICKUP;
break;
case "q":
action = PlayerActions.ATTACK;
break;
}
}
```

The `ProcessUserInput` method parses user input, interprets commands, and updates the game state accordingly.

Block 6: MovementAction Method

```csharp
private void MovementAction(PlayerActions playerAction)
{
if (GameIsRunning() != GameState.RUN) return;
action = playerAction;
counter++;
}
```

This method handles movement-related actions (North, East, South, West).

Block 7: Update Method

```csharp
public bool Update(GameState status)
{
this.status = status;
if (status != GameState.RUN)
{
// If not running, there's no need to update, return false
return false;
}
var pos = GetPlayerPosition();
var currentTile = workingMap[pos[0]][pos[1]];
switch (GetPlayerAction())
{
case PlayerActions.NOTHING:
break;
case PlayerActions.NORTH:
playerY--;
if (!ValidPlayerMove())
playerY++;
break;
case PlayerActions.EAST:
playerX++;
if (!ValidPlayerMove())
playerX--;
break;
case PlayerActions.SOUTH:
playerY++;
if (!ValidPlayerMove())
playerY--;
break;
case PlayerActions.WEST:
playerX--;
if (!ValidPlayerMove())
playerX++;
break;
case PlayerActions.PICKUP:
if (currentTile == 'C')
{
// We can pick up a coin
coins++;
workingMap[pos[0]][pos[1]] = '_';
}
break;
case PlayerActions.ATTACK:
if (currentTile == 'M')
{
// We can slay the monster
kills++;
workingMap[pos[0]][pos[1]] = '_';
}
break;
case PlayerActions.DROP:
// Handle dropping an item
// ...
break;
case PlayerActions.QUIT:
this.status = GameState.STOP;
return false;
default:
throw new ArgumentOutOfRangeException();
}
// The tile could be updated as the player has moved
pos = GetPlayerPosition();
currentTile = workingMap[pos[0]][pos[1]];
if (currentTile == 'D')
{
// Exit, game stops here
this.status = GameState.STOP;
}
return true;
}
```

The `Update` method updates the game state, handles player actions, and checks game conditions to determine if the game continues.

Block 8: ValidPlayerMove Method

```csharp
private bool ValidPlayerMove()
{
var pos = GetPlayerPosition();
// Check collision
return workingMap[pos[0]][pos[1]] != '#';
}

This method checks if the player's move is valid by detecting collisions with obstacles in the game map.

Block 9: PrintMapToConsole Method

```csharp
public bool PrintMapToConsole()
{
// Check game status before printing
if (status != GameState.RUN)
{
return false;
}
Console.Clear();
var map = GetCurrentMapState();
foreach (var yTiles in map)
{
foreach (var tile in yTiles)
{
Console.Write(tile);
}
Console.WriteLine();
}
return true;
}
```

The `PrintMapToConsole` method clears the console and displays the current state of the game map.

Block 10: PrintExtraInfo Method


```csharp
public bool PrintExtraInfo()
{
if (GameIsRunning() != GameState.RUN)
return false;
Console.WriteLine($"Coins: {coins}, moves: {counter}, kills: {kills}");
return true;
}
```

This method prints additional information, such as the number of coins collected, moves made, and monsters killed.

Block 11: LoadMapFromFile Method

```csharp
public bool LoadMapFromFile(string mapName)
{
var mapPath = Path.Combine(Environment.CurrentDirectory, mapName);
string[] map;
try
{
map = File.ReadAllLines(mapPath);
}
catch (Exception)
{
// Couldn't load map file
return false;
}
var mapHeight = map.Length;
originalMap = new char[mapHeight][];
workingMap = new char[mapHeight][];
for (var y = 0; y < mapHeight; y++)
{
var width = map[y].Length;
originalMap[y] = new char[width];
for (var x = 0; x < width; x++)
{
// Pick the correct tile from the map string
originalMap[y][x] = map[y][x];
}
}
// Copy original to working
CloneCharArray2D(originalMap, workingMap);
InitializeMap();
return true;
}
// Helper method to clone a 2D char array
private static void CloneCharArray2D(char[][] original, char[][] dest)
{
var height = original.Length;
for (var y = 0; y < height; y++)
{
var line = original[y];
var width = line.Length;
dest[y] = new char[width];
Array.Copy(line, dest[y], width);
}
}
```

This method loads a game map from a file, initializes the game state, and handles map-related operations.

Block 12: CloneCharArray2D Method

```csharp
private static void CloneCharArray2D(char[][] original, char[][] dest)
{
var height = original.Length;
for (var y = 0; y < height; y++)
{
var line = original[y];
var width = line.Length;
dest[y] = new char[width];
Array.Copy(line, dest[y], width);
}
}
```

This method is a utility function to clone a 2D character array.

Block 13: GetOriginalMap Method

```csharp
public char[][] GetOriginalMap()
{
return originalMap;
}
```

This method returns the original game map, which doesn't change as the player moves.

Block 14: GetCurrentMapState Method

```csharp
public char[][] GetCurrentMapState()
{
// Don't alter the original, clone it for showing
var returningMap = new char[workingMap.Length][];
CloneCharArray2D(workingMap, returningMap);
// Only place the player in the map if the game is running
if (GameIsRunning() == GameState.RUN)
{
var pos = GetPlayerPosition();
// Show the player's position
returningMap[pos[0]][pos[1]] = '1';
}
return returningMap;
}

This method returns the current state of the game map with the player's position.

Block 15: GetPlayerPosition and GetPlayerAction Methods

```csharp
public int[] GetPlayerPosition()
{
return new[] { playerY, playerX };
}
public PlayerActions GetPlayerAction()
{
return action;
}
```

These methods return the player's current position and the next player action, respectively.

Block 16: GameIsRunning Method

```csharp
public GameState GameIsRunning()
{
return status;
}
```

This method returns the current game state (whether the game is running, stopped, etc.).

Block 17: InitializeMap Method

```csharp
private void InitializeMap()
{
status = GameState.START;
action = PlayerActions.NOTHING;
coins = 0;
// Place the player at a valid empty position
var placedPlayer = false;
for (var y = 0; y < workingMap.Length; y++)
{
var tilesY = workingMap[y];
for (var x = 0; x < tilesY.Length; x++)
{
var tile = tilesY[x];
if (tile != 'S') continue;
// Found the starting position, move the player there
playerX = x;
playerY = y;
placedPlayer = true;
break;
}
if (placedPlayer) break;
}
}
```

This method initializes the game map and places the player in the starting position.

Block 18: Main Method

```csharp
static void Main(string[] args)
{
Game crawler = new Game();
string input = string.Empty;
Console.WriteLine("Welcome to the Commandline Dungeon!" + Environment.NewLine +
"May your Quest be filled with riches!" + Environment.NewLine);
// Loops through the input and determines when the game should quit
while (crawler.GameIsRunning() != GameState.STOP && crawler.GameIsRunning() != GameState.UNKNOWN)
{
Console.Write("Your Command: ");
input = crawler.ReadUserInput();
Console.WriteLine(Environment.NewLine);
crawler.ProcessUserInput(input);
crawler.Update(crawler.GameIsRunning());
crawler.PrintMapToConsole();
crawler.PrintExtraInfo();
}
Console.WriteLine("See you again" + Environment.NewLine +
"In the CMD Dungeon! ");
}
```

This is the main entry point of the program, which sets up and runs the game loop, processes user input, and updates the game state based on user commands.

Conclusion

By breaking down the code into these manageable sections, you gain a better understanding of how the text-based dungeon game is structured and how different components interact to create an engaging gameplay experience. This code serves as a valuable reference for anyone interested in game development, C# programming, or software architecture. Furthermore, the knowledge and skills acquired from this guide can be a stepping stone for your game development journey, enabling you to embark on exciting projects, explore advanced game mechanics, and even create your own unique gaming experiences. As you dive deeper into the world of programming and game design, you'll find that the possibilities are virtually limitless. So, roll up your sleeves, unleash your creativity, and start crafting your very own digital adventures today. The dungeon's gates are open—venture forth and code your way to gaming greatness!

How to Creating a Text-Based Dungeon Game in C#