initial monopoly test
This commit is contained in:
Adolfo Reyna
632
games/monopoly/monopoly.cpp
Normal file
632
games/monopoly/monopoly.cpp
Normal file
@@ -0,0 +1,632 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
#include "monopoly_board.h"
|
||||
#include "player.h"
|
||||
#include "chance.h"
|
||||
#include "community_chest.h"
|
||||
|
||||
// Forward Declarations
|
||||
void handle_roll(Player *p, bool *has_rolled, int *double_rolls);
|
||||
void handle_buy(Player *p, bool has_rolled);
|
||||
void handle_trade(Player *p);
|
||||
void handle_build(Player *p);
|
||||
void process_landing(Player *p);
|
||||
void handle_property_landing(Player *p, const BoardTile *tile);
|
||||
void handle_chance(Player* p);
|
||||
void find_properties_on_group_from_position(int position, int positions_found[4], int *count);
|
||||
void handle_community_chest(Player* p);
|
||||
void handle_jail_options(Player *p);
|
||||
bool attempt_jail_escape(Player *p);
|
||||
|
||||
// Global State
|
||||
Player players[MAX_PLAYERS];
|
||||
int players_count = 2;
|
||||
|
||||
int current_player_idx = 0;
|
||||
bool just_sent_to_jail = false; // Flag to end turn when sent to jail
|
||||
|
||||
int main()
|
||||
{
|
||||
srand(time(NULL));
|
||||
|
||||
// Initialize hardcoded players
|
||||
init_player(&players[0], 0, "Elias", "Top Hat");
|
||||
init_player(&players[1], 1, "Adolfo", "Racecar");
|
||||
init_player(&players[2], 2, "Grace", "Thimble");
|
||||
init_player(&players[3], 3, "Alicia", "Dog");
|
||||
|
||||
printf("\n╔════════════════════════════════════════╗\n");
|
||||
printf("║ Welcome to C-Monopoly! ║\n");
|
||||
printf("╚════════════════════════════════════════╝\n\n");
|
||||
|
||||
bool running = true;
|
||||
bool has_rolled = false; // Turn state tracker
|
||||
int double_rolls = 0;
|
||||
current_player_idx = 0;
|
||||
while (running)
|
||||
{
|
||||
Player *p = &players[current_player_idx];
|
||||
printf("\n╔═════════════════════════════════════════╗\n");
|
||||
printf("║ %s's Turn (%s)\n", p->name, p->token);
|
||||
printf("║ 💰 Balance: $%d | 📍 %s\n", p->balance, MONOPOLY_BOARD[p->position].name);
|
||||
printf("╚═════════════════════════════════════════╝\n\n");
|
||||
// Handle jail status at start of turn
|
||||
if (p->is_in_jail)
|
||||
{
|
||||
if (just_sent_to_jail)
|
||||
{
|
||||
// Player was just sent to jail this turn, end their turn
|
||||
printf("\n🚨 You have been sent to Jail! Your turn ends.\n");
|
||||
current_player_idx = (current_player_idx + 1) % players_count;
|
||||
has_rolled = false;
|
||||
just_sent_to_jail = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
printf("\n🚨 YOU ARE IN JAIL!\n");
|
||||
printf(" Turns in jail: %d/3\n", p->jail_turns);
|
||||
handle_jail_options(p);
|
||||
|
||||
if (!p->is_in_jail)
|
||||
{
|
||||
// Player escaped jail, now they can roll
|
||||
printf("\n📋 %s escaped jail!\n\n", p->name);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Player remains in jail, end turn
|
||||
printf("\n📋 %s remains in jail.\n", p->name);
|
||||
current_player_idx = (current_player_idx + 1) % players_count;
|
||||
has_rolled = false;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (!has_rolled)
|
||||
printf("⚠️ You must roll the dice first!\n\n");
|
||||
|
||||
printf("╔─ Available Actions ──────────────────────╗\n");
|
||||
printf("║ 1. 🎲 Roll Dice\n");
|
||||
printf("║ 2. 🏠 Buy Property\n");
|
||||
printf("║ 3. 🏗️ Build Houses/Hotels\n");
|
||||
printf("║ 4. 🤝 Trade (Empty)\n");
|
||||
printf("║ 5. ⏭️ End Turn\n");
|
||||
printf("║ 6. ❌ Exit Game\n");
|
||||
printf("╚═════════════════════════════════════════╝\n");
|
||||
printf("\nChoose action (1-6): ");
|
||||
|
||||
int choice;
|
||||
scanf("%d", &choice);
|
||||
|
||||
switch (choice)
|
||||
{
|
||||
case 1:
|
||||
handle_roll(p, &has_rolled, &double_rolls);
|
||||
break;
|
||||
case 2:
|
||||
handle_buy(p, has_rolled);
|
||||
break;
|
||||
case 3:
|
||||
handle_build(p);
|
||||
break;
|
||||
case 4:
|
||||
handle_trade(p);
|
||||
break;
|
||||
case 5:
|
||||
if (has_rolled)
|
||||
{
|
||||
current_player_idx = (current_player_idx + 1) % players_count;
|
||||
has_rolled = false; // Reset for next player
|
||||
just_sent_to_jail = false; // Reset jail flag
|
||||
printf("✓ Turn ended.\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("❌ You must roll before ending your turn!\n");
|
||||
}
|
||||
break;
|
||||
case 6:
|
||||
running = false;
|
||||
break;
|
||||
default:
|
||||
printf("❌ Invalid choice! Please enter 1-6.\n");
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void find_properties_on_group_from_position(int position, int positions_found[4], int *count)
|
||||
{
|
||||
const BoardTile *tile = &MONOPOLY_BOARD[position];
|
||||
if (tile->type == TILE_PROPERTY || tile->type == TILE_RAILROAD || tile->type == TILE_UTILITY)
|
||||
{
|
||||
int group_id = tile->group[0];
|
||||
*count = 0;
|
||||
for (int i = 0; i < BOARD_SIZE; i++)
|
||||
{
|
||||
if (i == position)
|
||||
continue;
|
||||
const BoardTile *t = &MONOPOLY_BOARD[i];
|
||||
if (t->group[0] == group_id)
|
||||
{
|
||||
positions_found[(*count)++] = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool handle_if_owned(Player *p, const BoardTile *tile){
|
||||
if (tile->type == TILE_PROPERTY || tile->type == TILE_RAILROAD || tile->type == TILE_UTILITY){
|
||||
bool is_owned = false;
|
||||
int i = 0;
|
||||
for (i = 0; i < MAX_PLAYERS; i++)
|
||||
{
|
||||
for (int j = 0; j < players[i].property_count; j++)
|
||||
{
|
||||
if (players[i].properties_owned[j] == p->position)
|
||||
{
|
||||
is_owned = true;
|
||||
printf("🏠 This property is owned by %s.\n", players[i].name);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (is_owned)
|
||||
break;
|
||||
}
|
||||
if(is_owned)
|
||||
{
|
||||
if(players[i].id == p->id)
|
||||
{
|
||||
printf("✓ You own this property.\n");
|
||||
return true;
|
||||
}
|
||||
// pay rent logic would go here
|
||||
p->balance -= tile->rent[0]; // Simplistic: always pay base rent
|
||||
players[i].balance += tile->rent[0];
|
||||
printf("💰 Paid $%d in rent to the owner.\n", tile->rent[0]);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void handle_roll(Player *p, bool *has_rolled, int *double_rolls)
|
||||
{
|
||||
if (*has_rolled)
|
||||
{
|
||||
printf("❌ You have already moved this turn!\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if player is in jail and trying to escape
|
||||
if (p->is_in_jail)
|
||||
{
|
||||
printf("❌ You are in jail! Use the jail menu to escape first.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
int dice1 = (rand() % 6) + 1;
|
||||
int dice2 = (rand() % 6) + 1;
|
||||
printf("\n🎲 Rolled: [%d] + [%d] = %d\n", dice1, dice2, dice1 + dice2);
|
||||
int total = dice1 + dice2;
|
||||
p->position = (p->position + total) % BOARD_SIZE;
|
||||
|
||||
if(dice1 == dice2)
|
||||
{
|
||||
(*double_rolls)++;
|
||||
if(*double_rolls >= 3)
|
||||
{
|
||||
printf("🚨 Three doubles in a row! Sent directly to JAIL!\n");
|
||||
p->position = 10; // Jail position
|
||||
p->jail_turns = 0;
|
||||
p->is_in_jail = true;
|
||||
*double_rolls = 0;
|
||||
*has_rolled = true;
|
||||
just_sent_to_jail = true;
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("✨ Doubles! You get another turn!\n");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*double_rolls = 0; // Reset double rolls count
|
||||
}
|
||||
|
||||
*has_rolled = true;
|
||||
|
||||
// Check for passing GO
|
||||
if (p->position < (p->position - total))
|
||||
{ // Simplistic wrap-around check
|
||||
p->balance += 200;
|
||||
printf("Passed GO! Collected $200.\n");
|
||||
}
|
||||
|
||||
printf("➜ Moved %d spaces to: %s\n\n", total, MONOPOLY_BOARD[p->position].name);
|
||||
process_landing(p);
|
||||
}
|
||||
|
||||
void handle_buy(Player *p, bool has_rolled)
|
||||
{
|
||||
if (!has_rolled)
|
||||
{
|
||||
printf("❌ You can't buy anything until you roll and land on a tile!\n");
|
||||
return;
|
||||
}
|
||||
|
||||
const BoardTile *tile = &MONOPOLY_BOARD[p->position];
|
||||
|
||||
// Check if it's even a purchasable type
|
||||
if (tile->type != TILE_PROPERTY && tile->type != TILE_RAILROAD && tile->type != TILE_UTILITY)
|
||||
{
|
||||
printf("❌ This location (%s) cannot be purchased.\n", tile->name);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if someone already owns it (basic check)
|
||||
// In a full game, we'd iterate through all players' properties_owned arrays
|
||||
for (int i = 0; i < MAX_PLAYERS; i++)
|
||||
{
|
||||
for (int j = 0; j < players[i].property_count; j++)
|
||||
{
|
||||
if (players[i].properties_owned[j] == p->position)
|
||||
{
|
||||
printf("❌ This property is already owned by %s.\n", players[i].name);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (p->balance >= tile->cost)
|
||||
{
|
||||
p->balance -= tile->cost;
|
||||
p->properties_owned[p->property_count++] = p->position;
|
||||
printf("✓ Bought %s for $%d! (Balance: $%d)\n", tile->name, tile->cost, p->balance);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("❌ Insufficient funds! Cost: $%d | Your Balance: $%d\n", tile->cost, p->balance);
|
||||
}
|
||||
}
|
||||
|
||||
void process_landing(Player *p)
|
||||
{
|
||||
const BoardTile *tile = &MONOPOLY_BOARD[p->position];
|
||||
|
||||
printf("\n─────────────────────────────────────────\n");
|
||||
printf("📍 Landed on: %s\n", tile->name);
|
||||
printf("─────────────────────────────────────────\n");
|
||||
|
||||
switch (tile->type)
|
||||
{
|
||||
case TILE_PROPERTY:
|
||||
case TILE_RAILROAD:
|
||||
case TILE_UTILITY:
|
||||
handle_property_landing(p, tile);
|
||||
break;
|
||||
|
||||
case TILE_TAX:
|
||||
p->balance -= tile->cost;
|
||||
printf("💸 Tax payment: $%d (Balance: $%d)\n", tile->cost, p->balance);
|
||||
break;
|
||||
|
||||
case TILE_CHANCE:
|
||||
printf("\n⚡ CHANCE CARD! ⚡\n");
|
||||
handle_chance(p);
|
||||
break;
|
||||
|
||||
case TILE_COMMUNITY_CHEST:
|
||||
printf("\n📦 COMMUNITY CHEST CARD! 📦\n");
|
||||
handle_community_chest(p);
|
||||
break;
|
||||
|
||||
case TILE_FREE_PARKING:
|
||||
case TILE_GO:
|
||||
case TILE_JAIL:
|
||||
// Corner tiles (GO, Free Parking, Go to Jail, Just Visiting)
|
||||
printf("📌 You're at: %s\n", tile->name);
|
||||
break;
|
||||
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void handle_property_landing(Player *p, const BoardTile *tile)
|
||||
{
|
||||
bool is_owned = handle_if_owned(p, tile);
|
||||
if (is_owned)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
printf("\n💰 Purchase Price: $%d\n", tile->cost);
|
||||
if (tile->type == TILE_PROPERTY)
|
||||
{
|
||||
// rent data
|
||||
printf("\n📋 Rent Schedule:\n");
|
||||
printf(" Vacant.....................$%d\n", tile->rent[0]);
|
||||
printf(" 1 House.....................$%d\n", tile->rent[1]);
|
||||
printf(" 2 Houses.....................$%d\n", tile->rent[2]);
|
||||
printf(" 3 Houses.....................$%d\n", tile->rent[3]);
|
||||
printf(" 4 Houses.....................$%d\n", tile->rent[4]);
|
||||
printf(" Hotel.......................$%d\n", tile->rent[5]);
|
||||
printf("\n🏗️ House Cost: $%d\n", tile->house_cost);
|
||||
}
|
||||
|
||||
// show if the other properties in the group are owned
|
||||
printf("\n🏘️ Property Group: %d | Position %d/%d in group\n",
|
||||
tile->group[0], tile->group[1], tile->group[2]);
|
||||
int group_positions[4];
|
||||
int group_count = 0;
|
||||
find_properties_on_group_from_position(p->position, group_positions, &group_count);
|
||||
if (group_count > 0)
|
||||
{
|
||||
printf("\n Related properties:\n");
|
||||
for (int i = 0; i < group_count; i++)
|
||||
{
|
||||
const BoardTile *gtile = &MONOPOLY_BOARD[group_positions[i]];
|
||||
// Check if owned by any player
|
||||
bool is_owned_in_group = false;
|
||||
for (int j = 0; j < MAX_PLAYERS; j++)
|
||||
{
|
||||
for (int k = 0; k < players[j].property_count; k++)
|
||||
{
|
||||
if (players[j].properties_owned[k] == group_positions[i])
|
||||
{
|
||||
is_owned_in_group = true;
|
||||
printf(" 🔒 %s (Owned by %s)\n", gtile->name, players[j].name);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (is_owned_in_group)
|
||||
break;
|
||||
}
|
||||
if (!is_owned_in_group)
|
||||
{
|
||||
printf(" 🔓 %s - $%d (available)\n", gtile->name, gtile->cost);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void handle_trade(Player *p)
|
||||
{
|
||||
printf("⚙️ Trade functionality is not yet implemented.\n");
|
||||
}
|
||||
|
||||
void handle_jail_options(Player *p)
|
||||
{
|
||||
bool escaped = false;
|
||||
|
||||
printf("\n╔─ Jail Options ──────────────────────────────╗\n");
|
||||
printf("║ 1. 🎲 Roll Doubles to Escape\n");
|
||||
printf("║ 2. 💰 Pay $50 Bail\n");
|
||||
if (p->jail_free_cards > 0)
|
||||
printf("║ 3. 🔑 Use Get Out of Jail Free Card\n");
|
||||
printf("╚─────────────────────────────────────────────╝\n");
|
||||
printf("Choose option: ");
|
||||
|
||||
int choice;
|
||||
scanf("%d", &choice);
|
||||
|
||||
switch(choice)
|
||||
{
|
||||
case 1:
|
||||
// Try to roll doubles
|
||||
escaped = attempt_jail_escape(p);
|
||||
break;
|
||||
case 2:
|
||||
// Pay bail
|
||||
if (p->balance >= 50)
|
||||
{
|
||||
p->balance -= 50;
|
||||
p->is_in_jail = false;
|
||||
p->jail_turns = 0;
|
||||
escaped = true;
|
||||
printf("\n✓ Paid $50 bail! You are now free.\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\n❌ Insufficient funds! You need $50.\n");
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
if (p->jail_free_cards > 0)
|
||||
{
|
||||
p->jail_free_cards--;
|
||||
p->is_in_jail = false;
|
||||
p->jail_turns = 0;
|
||||
escaped = true;
|
||||
printf("\n✓ Used a Get Out of Jail Free card! You are now free.\n");
|
||||
printf(" Cards remaining: %d\n", p->jail_free_cards);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\n❌ You don't have any Get Out of Jail Free cards!\n");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
printf("\n❌ Invalid choice!\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (!escaped)
|
||||
{
|
||||
p->jail_turns++;
|
||||
if (p->jail_turns >= 3)
|
||||
{
|
||||
// Force payment after 3 turns
|
||||
printf("\n⏰ You've been in jail for 3 turns. You must pay $50 bail!\n");
|
||||
p->balance -= 50;
|
||||
p->is_in_jail = false;
|
||||
p->jail_turns = 0;
|
||||
printf(" Balance: $%d\n", p->balance);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool attempt_jail_escape(Player *p)
|
||||
{
|
||||
int dice1 = (rand() % 6) + 1;
|
||||
int dice2 = (rand() % 6) + 1;
|
||||
printf("\n🎲 Rolling to escape...\n");
|
||||
printf(" Rolled: [%d] + [%d]\n", dice1, dice2);
|
||||
|
||||
if (dice1 == dice2)
|
||||
{
|
||||
printf("\n✨ DOUBLES! You escaped jail!\n");
|
||||
p->is_in_jail = false;
|
||||
p->jail_turns = 0;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("\n❌ No doubles. You remain in jail.\n");
|
||||
p->jail_turns++;
|
||||
if (p->jail_turns >= 3)
|
||||
{
|
||||
printf("\n⏰ You've been in jail for 3 turns. You must pay $50 bail!\n");
|
||||
p->balance -= 50;
|
||||
p->is_in_jail = false;
|
||||
p->jail_turns = 0;
|
||||
printf(" Balance: $%d\n", p->balance);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void handle_build(Player *p)
|
||||
{
|
||||
printf("⚙️ Build functionality is not yet implemented.\n");
|
||||
}
|
||||
|
||||
void handle_chance(Player* p) {
|
||||
// In a real game, you'd pull from a shuffled deck of indices
|
||||
int card_idx = rand() % CHANCE_DECK_SIZE;
|
||||
const ChanceCard* card = &CHANCE_DECK[card_idx];
|
||||
|
||||
printf("\n✨ %s\n", card->description);
|
||||
|
||||
switch (card->type) {
|
||||
case CHANCE_ADVANCE: {
|
||||
int target = card->value;
|
||||
|
||||
// Handle special "Nearest" logic
|
||||
if (target == TARGET_NEAREST_UTILITY) {
|
||||
while (MONOPOLY_BOARD[p->position].type != TILE_UTILITY) {
|
||||
p->position = (p->position + 1) % BOARD_SIZE;
|
||||
}
|
||||
} else if (target == TARGET_NEAREST_RAILROAD) {
|
||||
while (MONOPOLY_BOARD[p->position].type != TILE_RAILROAD) {
|
||||
p->position = (p->position + 1) % BOARD_SIZE;
|
||||
}
|
||||
} else {
|
||||
// Check for passing GO during standard advance
|
||||
if (target < p->position) {
|
||||
p->balance += 200;
|
||||
printf("🎉 Passed GO! Collected $200.\n");
|
||||
}
|
||||
p->position = target;
|
||||
}
|
||||
printf("➜ Moved to: %s\n", MONOPOLY_BOARD[p->position].name);
|
||||
process_landing(p); // Re-evaluate logic for new square
|
||||
break;
|
||||
}
|
||||
|
||||
case CHANCE_EARN:
|
||||
p->balance += card->value;
|
||||
break;
|
||||
|
||||
case CHANCE_SPEND:
|
||||
p->balance -= card->value;
|
||||
break;
|
||||
|
||||
case CHANCE_BACK:
|
||||
p->position = (p->position - card->value + BOARD_SIZE) % BOARD_SIZE;
|
||||
printf("⬅️ Moved back to: %s\n", MONOPOLY_BOARD[p->position].name);
|
||||
process_landing(p);
|
||||
break;
|
||||
|
||||
case CHANCE_JAIL:
|
||||
p->position = 10; // Index of Jail
|
||||
p->jail_turns = 0;
|
||||
p->is_in_jail = true;
|
||||
just_sent_to_jail = true;
|
||||
printf("🚨 Sent directly to JAIL!\n");
|
||||
break;
|
||||
|
||||
case CHANCE_SPEND_EACH_PLAYER:
|
||||
for (int i = 0; i < MAX_PLAYERS; i++) {
|
||||
if (players[i].id != p->id && !players[i].is_bankrupt) {
|
||||
p->balance -= card->value;
|
||||
players[i].balance += card->value;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case CHANCE_JAIL_FREE:
|
||||
p->jail_free_cards++;
|
||||
printf("🔑 You received a 'Get Out of Jail Free' card! (Total: %d)\n", p->jail_free_cards);
|
||||
break;
|
||||
|
||||
case CHANCE_REPAIRS:
|
||||
// TODO: Logic placeholder: calculate based on houses/hotels owned
|
||||
printf("🔧 Repairs calculated based on your property development.\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void handle_community_chest(Player* p) {
|
||||
int card_idx = rand() % COMMUNITY_DECK_SIZE;
|
||||
const CommunityCard* card = &COMMUNITY_DECK[card_idx];
|
||||
|
||||
printf("\n📦 %s\n", card->description);
|
||||
|
||||
switch (card->type) {
|
||||
case COMMUNITY_ADVANCE:
|
||||
p->position = card->value;
|
||||
p->balance += 200; // Always Go in this set
|
||||
printf("➜ Moved to Go! Balance: $%d\n", p->balance);
|
||||
break;
|
||||
|
||||
case COMMUNITY_EARN:
|
||||
p->balance += card->value;
|
||||
break;
|
||||
|
||||
case COMMUNITY_SPEND:
|
||||
p->balance -= card->value;
|
||||
break;
|
||||
|
||||
case COMMUNITY_EARN_EACH_PLAYER:
|
||||
for (int i = 0; i < MAX_PLAYERS; i++) {
|
||||
if (players[i].id != p->id && !players[i].is_bankrupt) {
|
||||
players[i].balance -= card->value;
|
||||
p->balance += card->value;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case COMMUNITY_JAIL:
|
||||
p->position = 10;
|
||||
p->jail_turns = 0;
|
||||
p->is_in_jail = true;
|
||||
just_sent_to_jail = true;
|
||||
printf("🚨 Go to Jail! (Do not pass Go, do not collect $200)\n");
|
||||
break;
|
||||
|
||||
case COMMUNITY_REPAIRS:
|
||||
// logic for $40/house and $115/hotel
|
||||
printf("🔧 Repairs assessed.\n");
|
||||
break;
|
||||
|
||||
case COMMUNITY_JAIL_FREE:
|
||||
p->jail_free_cards++;
|
||||
printf("🔑 Card stored. (Total: %d)\n", p->jail_free_cards);
|
||||
break;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user