Adolfo Reyna
632 lines
20 KiB
C++
632 lines
20 KiB
C++
#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;
|
|
}
|
|
} |