先看示例：
// 预处理器指令 - 包含标准库头文件
#include <stdio.h> // 标准输入输出
#include <stdlib.h> // 标准库函数（malloc, free, rand等）
#include <string.h> // 字符串处理函数
#include <time.h> // 时间相关函数
#include <ctype.h> // 字符处理函数
// 预处理器宏定义 - 定义游戏常量
#define MAX_NAME_LENGTH 50 // 最大名称长度
#define MAX_INVENTORY_SIZE 20 // 背包最大容量
#define MAX_SKILLS 10 // 最大技能数量
#define MAX_ENEMIES 5 // 最大敌人数量
#define MAX_AREAS 4 // 最大区域数量
#define SAVE_FILE "game_save.dat" // 存档文件名
// 条件编译 - 调试模式开关
#ifdef DEBUG
#define DEBUG_PRINT(x) printf("DEBUG: %s\n", x)
#else
#define DEBUG_PRINT(x)
#endif
// 枚举类型 - 定义游戏中的各种状态和类型
typedef enum
{
ITEM_WEAPON = 1, // 武器类型
ITEM_ARMOR = 2, // 防具类型
ITEM_POTION = 3, // 药水类型
ITEM_MISC = 4 // 杂项类型
} ItemType;
typedef enum
{
SKILL_ATTACK = 1, // 攻击技能
SKILL_HEAL = 2, // 治疗技能
SKILL_DEFEND = 3, // 防御技能
SKILL_MAGIC = 4 // 魔法技能
} SkillType;
typedef enum
{
AREA_FOREST = 1, // 森林区域
AREA_CAVE = 2, // 洞穴区域
AREA_MOUNTAIN = 3, // 山脉区域
AREA_TOWN = 4 // 城镇区域
} AreaType;
// 联合体 - 用于存储不同类型的游戏数据
typedef union
{
int integer_value; // 整数值
float float_value; // 浮点值
char string_value[20]; // 字符串值
} GameData;
// 结构体定义 - 游戏中的各种对象
// 物品结构体
typedef struct
{
int id; // 物品ID
char name[MAX_NAME_LENGTH]; // 物品名称
ItemType type; // 物品类型
int value; // 物品价值
int effect; // 物品效果值
char description[100]; // 物品描述
} Item;
// 技能结构体
typedef struct
{
int id; // 技能ID
char name[MAX_NAME_LENGTH]; // 技能名称
SkillType type; // 技能类型
int damage; // 伤害值
int mana_cost; // 魔法消耗
int level_required; // 需要等级
} Skill;
// 角色属性结构体（嵌套结构体示例）
typedef struct
{
int health; // 生命值
int max_health; // 最大生命值
int mana; // 魔法值
int max_mana; // 最大魔法值
int attack; // 攻击力
int defense; // 防御力
int speed; // 速度
} Stats;
// 玩家结构体
typedef struct
{
char name[MAX_NAME_LENGTH]; // 玩家姓名
int level; // 等级
int experience; // 经验值
int gold; // 金币
Stats stats; // 角色属性（嵌套结构体）
Item inventory[MAX_INVENTORY_SIZE]; // 背包（结构体数组）
int inventory_count; // 背包物品数量
Skill skills[MAX_SKILLS]; // 技能列表
int skill_count; // 技能数量
Item equipped_weapon; // 装备的武器
Item equipped_armor; // 装备的防具
} Player;
// 敌人结构体
typedef struct
{
char name[MAX_NAME_LENGTH]; // 敌人名称
Stats stats; // 敌人属性
int exp_reward; // 经验奖励
int gold_reward; // 金币奖励
Item drop_item; // 掉落物品
} Enemy;
// 区域结构体
typedef struct
{
char name[MAX_NAME_LENGTH]; // 区域名称
char description[200]; // 区域描述
Enemy enemies[MAX_ENEMIES]; // 区域内的敌人
int enemy_count; // 敌人数量
AreaType type; // 区域类型
} Area;
// 游戏状态结构体
typedef struct
{
Player player; // 玩家数据
Area areas[MAX_AREAS]; // 游戏区域
int current_area; // 当前区域
int game_time; // 游戏时间
unsigned int random_seed; // 随机数种子
} GameState;
// 全局变量声明
static GameState* g_game_state = NULL; // 全局游戏状态指针
static int g_debug_mode = 0; // 调试模式标志
// 函数声明（函数原型）
void init_game(void);
void cleanup_game(void);
Player* create_player(const char* name);
void init_player_stats(Player* player);
void init_items(void);
void init_skills(void);
void init_areas(void);
void init_enemies(void);
// 游戏主循环相关函数
void game_loop(void);
void display_main_menu(void);
void display_player_info(const Player* player);
void display_inventory(const Player* player);
void display_area_info(const Area* area);
// 战斗系统函数
int battle_system(Player* player, Enemy* enemy);
void player_attack(Player* player, Enemy* enemy);
void enemy_attack(const Enemy* enemy, Player* player);
void use_skill(Player* player, Enemy* enemy, int skill_index);
int calculate_damage(int base_attack, int defense);
// 物品和装备系统函数
void add_item_to_inventory(Player* player, const Item* item);
int remove_item_from_inventory(Player* player, int item_index);
void equip_item(Player* player, int item_index);
void unequip_item(Player* player, ItemType type);
void use_potion(Player* player, const Item* potion);
// 经验和等级系统函数
void gain_experience(Player* player, int exp);
void level_up(Player* player);
int calculate_exp_needed(int level);
// 存档系统函数
int save_game(const GameState* state);
int load_game(GameState* state);
void create_backup_save(void);
// 商店系统函数
void shop_menu(Player* player);
void buy_item(Player* player, const Item* item);
void sell_item(Player* player, int item_index);
// 探索系统函数
void explore_area(Player* player, Area* area);
void move_to_area(int area_index);
Enemy* encounter_random_enemy(const Area* area);
// 工具函数
void clear_screen(void);
void wait_for_input(void);
int get_user_choice(int min, int max);
char* get_user_string(char* buffer, int size);
int random_range(int min, int max);
void print_separator(void);
// 位运算相关函数
void set_player_flag(Player* player, int flag);
int check_player_flag(const Player* player, int flag);
void clear_player_flag(Player* player, int flag);
// 函数指针相关
typedef void (*MenuFunction)(void);
typedef int (*BattleFunction)(Player*, Enemy*);
// 递归函数示例
int fibonacci(int n);
void print_level_tree(int level, int max_level);
/*
* ========================================
* 主函数 - 程序入口点
* ========================================
*/
int main(void)
{
// 设置随机数种子
srand((unsigned int)time(NULL));
printf("========================================\n");
printf(" 欢迎来到C语言RPG冒险游戏！\n");
printf("========================================\n\n");
// 初始化游戏
init_game();
// 检查是否有存档
printf("检查存档文件...\n");
if (load_game(g_game_state) == 0)
{
printf("找到存档文件，游戏已加载！\n");
}
else
{
printf("未找到存档，开始新游戏。\n");
// 创建新玩家
char player_name[MAX_NAME_LENGTH];
printf("请输入你的角色名称: ");
get_user_string(player_name, MAX_NAME_LENGTH);
Player* new_player = create_player(player_name);
if (new_player != NULL)
{
g_game_state->player = *new_player;
free(new_player); // 释放动态分配的内存
}
}
// 进入游戏主循环
game_loop();
// 游戏结束，清理资源
cleanup_game();
printf("\n感谢游玩！再见！\n");
return 0; // 程序正常结束
}
/*
* ========================================
* 游戏初始化函数
* ========================================
*/
void init_game(void)
{
DEBUG_PRINT("初始化游戏系统");
// 动态分配游戏状态内存
g_game_state = (GameState*)malloc(sizeof(GameState));
if (g_game_state == NULL)
{
fprintf(stderr, "错误：无法分配内存给游戏状态！\n");
exit(EXIT_FAILURE);
}
// 初始化游戏状态
memset(g_game_state, 0, sizeof(GameState)); // 将内存清零
g_game_state->current_area = 0;
g_game_state->game_time = 0;
g_game_state->random_seed = (unsigned int)time(NULL);
// 初始化游戏数据
init_items();
init_skills();
init_areas();
init_enemies();
printf("游戏系统初始化完成！\n");
}
/*
* ========================================
* 游戏清理函数
* ========================================
*/
void cleanup_game(void)
{
DEBUG_PRINT("清理游戏资源");
// 保存游戏
if (save_game(g_game_state) == 0)
{
printf("游戏已保存！\n");
}
else
{
printf("保存游戏失败！\n");
}
// 释放动态分配的内存
if (g_game_state != NULL)
{
free(g_game_state);
g_game_state = NULL;
}
}
/*
* ========================================
* 创建玩家函数 - 动态内存分配示例
* ========================================
*/
Player* create_player(const char* name)
{
// 动态分配玩家内存
Player* player = (Player*)calloc(1, sizeof(Player)); // 使用calloc自动清零
if (player == NULL)
{
fprintf(stderr, "错误：无法为玩家分配内存！\n");
return NULL;
}
// 字符串复制 - 安全的字符串操作
strncpy(player->name, name, MAX_NAME_LENGTH - 1);
player->name[MAX_NAME_LENGTH - 1] = '\0'; // 确保字符串结束
// 初始化玩家属性
init_player_stats(player);
printf("玩家 '%s' 创建成功！\n", player->name);
return player;
}
/*
* ========================================
* 初始化玩家属性函数
* ========================================
*/
void init_player_stats(Player* player)
{
// 基础属性设置
player->level = 1;
player->experience = 0;
player->gold = 100;
// 角色数值属性
player->stats.max_health = 100;
player->stats.health = player->stats.max_health;
player->stats.max_mana = 50;
player->stats.mana = player->stats.max_mana;
player->stats.attack = 15;
player->stats.defense = 10;
player->stats.speed = 12;
// 初始化背包
player->inventory_count = 0;
// 初始化技能
player->skill_count = 1;
strcpy(player->skills[0].name, "基础攻击");
player->skills[0].type = SKILL_ATTACK;
player->skills[0].damage = 10;
player->skills[0].mana_cost = 0;
player->skills[0].level_required = 1;
// 初始装备（空装备）
memset(&player->equipped_weapon, 0, sizeof(Item));
memset(&player->equipped_armor, 0, sizeof(Item));
// 给玩家一些初始物品
Item starter_potion = { 1, "治疗药水", ITEM_POTION, 50, 30, "恢复30点生命值" };
add_item_to_inventory(player, &starter_potion);
}
/*
* ========================================
* 初始化物品数据
* ========================================
*/
void init_items(void)
{
DEBUG_PRINT("初始化物品数据");
// 这里可以初始化游戏中的所有物品
// 由于篇幅限制，这里只做示例
}
/*
* ========================================
* 初始化技能数据
* ========================================
*/
void init_skills(void)
{
DEBUG_PRINT("初始化技能数据");
// 初始化技能系统
}
/*
* ========================================
* 初始化区域数据
* ========================================
*/
void init_areas(void)
{
DEBUG_PRINT("初始化区域数据");
// 森林区域
strcpy(g_game_state->areas[0].name, "神秘森林");
strcpy(g_game_state->areas[0].description, "一片充满危险的古老森林");
g_game_state->areas[0].type = AREA_FOREST;
g_game_state->areas[0].enemy_count = 2;
// 洞穴区域
strcpy(g_game_state->areas[1].name, "黑暗洞穴");
strcpy(g_game_state->areas[1].description, "深不见底的神秘洞穴");
g_game_state->areas[1].type = AREA_CAVE;
g_game_state->areas[1].enemy_count = 3;
// 山脉区域
strcpy(g_game_state->areas[2].name, "雪山峰顶");
strcpy(g_game_state->areas[2].description, "终年积雪的高山");
g_game_state->areas[2].type = AREA_MOUNTAIN;
g_game_state->areas[2].enemy_count = 2;
// 城镇区域
strcpy(g_game_state->areas[3].name, "和平小镇");
strcpy(g_game_state->areas[3].description, "安全的休息场所");
g_game_state->areas[3].type = AREA_TOWN;
g_game_state->areas[3].enemy_count = 0;
}
/*
* ========================================
* 初始化敌人数据
* ========================================
*/
void init_enemies(void)
{
DEBUG_PRINT("初始化敌人数据");
// 森林区域的敌人
strcpy(g_game_state->areas[0].enemies[0].name, "野狼");
g_game_state->areas[0].enemies[0].stats.health = 40;
g_game_state->areas[0].enemies[0].stats.max_health = 40;
g_game_state->areas[0].enemies[0].stats.attack = 12;
g_game_state->areas[0].enemies[0].stats.defense = 5;
g_game_state->areas[0].enemies[0].exp_reward = 15;
g_game_state->areas[0].enemies[0].gold_reward = 10;
strcpy(g_game_state->areas[0].enemies[1].name, "森林精灵");
g_game_state->areas[0].enemies[1].stats.health = 30;
g_game_state->areas[0].enemies[1].stats.max_health = 30;
g_game_state->areas[0].enemies[1].stats.attack = 15;
g_game_state->areas[0].enemies[1].stats.defense = 8;
g_game_state->areas[0].enemies[1].exp_reward = 20;
g_game_state->areas[0].enemies[1].gold_reward = 15;
// 洞穴区域的敌人
strcpy(g_game_state->areas[1].enemies[0].name, "洞穴蝙蝠");
g_game_state->areas[1].enemies[0].stats.health = 25;
g_game_state->areas[1].enemies[0].stats.max_health = 25;
g_game_state->areas[1].enemies[0].stats.attack = 10;
g_game_state->areas[1].enemies[0].stats.defense = 3;
g_game_state->areas[1].enemies[0].exp_reward = 12;
g_game_state->areas[1].enemies[0].gold_reward = 8;
strcpy(g_game_state->areas[1].enemies[1].name, "石头怪");
g_game_state->areas[1].enemies[1].stats.health = 60;
g_game_state->areas[1].enemies[1].stats.max_health = 60;
g_game_state->areas[1].enemies[1].stats.attack = 18;
g_game_state->areas[1].enemies[1].stats.defense = 12;
g_game_state->areas[1].enemies[1].exp_reward = 25;
g_game_state->areas[1].enemies[1].gold_reward = 20;
strcpy(g_game_state->areas[1].enemies[2].name, "地底蜘蛛");
g_game_state->areas[1].enemies[2].stats.health = 35;
g_game_state->areas[1].enemies[2].stats.max_health = 35;
g_game_state->areas[1].enemies[2].stats.attack = 14;
g_game_state->areas[1].enemies[2].stats.defense = 6;
g_game_state->areas[1].enemies[2].exp_reward = 18;
g_game_state->areas[1].enemies[2].gold_reward = 12;
}
/*
* ========================================
* 游戏主循环函数
* ========================================
*/
void game_loop(void)
{
int choice;
int game_running = 1; // 游戏运行标志
while (game_running)
{ // while循环 - 游戏主循环
clear_screen();
display_main_menu();
choice = get_user_choice(1, 8);
// switch语句 - 处理用户选择
switch (choice)
{
case 1: // 查看角色信息
clear_screen();
display_player_info(&g_game_state->player);
wait_for_input();
break;
case 2: // 查看背包
clear_screen();
display_inventory(&g_game_state->player);
wait_for_input();
break;
case 3: // 探索区域
clear_screen();
printf("选择要探索的区域：\n");
for (int i = 0; i < MAX_AREAS; i++)
{ // for循环 - 遍历区域
printf("%d. %s - %s\n", i + 1,
g_game_state->areas[i].name,
g_game_state->areas[i].description);
}
int area_choice = get_user_choice(1, MAX_AREAS) - 1;
move_to_area(area_choice);
explore_area(&g_game_state->player, &g_game_state->areas[area_choice]);
break;
case 4: // 商店
if (g_game_state->current_area == 3)
{ // if语句 - 检查是否在城镇
shop_menu(&g_game_state->player);
}
else
{
printf("你需要在城镇才能使用商店！\n");
wait_for_input();
}
break;
case 5: // 使用物品
clear_screen();
printf("选择要使用的物品：\n");
display_inventory(&g_game_state->player);
if (g_game_state->player.inventory_count > 0)
{
int item_choice = get_user_choice(1, g_game_state->player.inventory_count) - 1;
Item* selected_item = &g_game_state->player.inventory[item_choice];
if (selected_item->type == ITEM_POTION)
{
use_potion(&g_game_state->player, selected_item);
remove_item_from_inventory(&g_game_state->player, item_choice);
}
else if (selected_item->type == ITEM_WEAPON || selected_item->type == ITEM_ARMOR)
{
equip_item(&g_game_state->player, item_choice);
}
}
wait_for_input();
break;
case 6: // 保存游戏
if (save_game(g_game_state) == 0)
{
printf("游戏保存成功！\n");
}
else
{
printf("游戏保存失败！\n");
}
wait_for_input();
break;
case 7: // 加载游戏
if (load_game(g_game_state) == 0)
{
printf("游戏加载成功！\n");
}
else
{
printf("游戏加载失败！\n");
}
wait_for_input();
break;
case 8: // 退出游戏
printf("确定要退出游戏吗？(y/n): ");
char confirm;
scanf(" %c", &confirm);
if (tolower(confirm) == 'y')
{ // 字符处理函数
game_running = 0;
}
break;
default: // 默认情况
printf("无效的选择！\n");
wait_for_input();
break;
}
g_game_state->game_time++; // 增加游戏时间
}
}
/*
* ========================================
* 显示主菜单
* ========================================
*/
void display_main_menu(void)
{
print_separator();
printf(" 主菜单\n");
print_separator();
printf("当前位置: %s\n", g_game_state->areas[g_game_state->current_area].name);
printf("游戏时间: %d 回合\n\n", g_game_state->game_time);
printf("1. 查看角色信息\n");
printf("2. 查看背包\n");
printf("3. 探索区域\n");
printf("4. 商店 (仅限城镇)\n");
printf("5. 使用物品\n");
printf("6. 保存游戏\n");
printf("7. 加载游戏\n");
printf("8. 退出游戏\n");
print_separator();
printf("请选择 (1-8): ");
}
/*
* ========================================
* 显示玩家信息
* ========================================
*/
void display_player_info(const Player* player)
{
print_separator();
printf(" 角色信息\n");
print_separator();
printf("姓名: %s\n", player->name);
printf("等级: %d\n", player->level);
printf("经验值: %d / %d\n", player->experience, calculate_exp_needed(player->level));
printf("金币: %d\n", player->gold);
printf("\n--- 属性 ---\n");
printf("生命值: %d / %d\n", player->stats.health, player->stats.max_health);
printf("魔法值: %d / %d\n", player->stats.mana, player->stats.max_mana);
printf("攻击力: %d\n", player->stats.attack);
printf("防御力: %d\n", player->stats.defense);
printf("速度: %d\n", player->stats.speed);
printf("\n--- 装备 ---\n");
if (strlen(player->equipped_weapon.name) > 0)
{
printf("武器: %s (攻击力+%d)\n", player->equipped_weapon.name, player->equipped_weapon.effect);
}
else
{
printf("武器: 无\n");
}
if (strlen(player->equipped_armor.name) > 0)
{
printf("防具: %s (防御力+%d)\n", player->equipped_armor.name, player->equipped_armor.effect);
}
else
{
printf("防具: 无\n");
}
printf("\n--- 技能 ---\n");
for (int i = 0; i < player->skill_count; i++)
{
printf("%d. %s (伤害:%d, 魔法消耗:%d)\n",
i + 1, player->skills[i].name,
player->skills[i].damage, player->skills[i].mana_cost);
}
print_separator();
}
/*
* ========================================
* 显示背包内容
* ========================================
*/
void display_inventory(const Player* player)
{
print_separator();
printf(" 背包 (%d/%d)\n", player->inventory_count, MAX_INVENTORY_SIZE);
print_separator();
if (player->inventory_count == 0)
{
printf("背包是空的。\n");
}
else
{
for (int i = 0; i < player->inventory_count; i++)
{
const Item* item = &player->inventory[i];
printf("%d. %s", i + 1, item->name);
// 根据物品类型显示不同信息
switch (item->type)
{
case ITEM_WEAPON:
printf(" (武器, 攻击力+%d)", item->effect);
break;
case ITEM_ARMOR:
printf(" (防具, 防御力+%d)", item->effect);
break;
case ITEM_POTION:
printf(" (药水, 效果+%d)", item->effect);
break;
case ITEM_MISC:
printf(" (杂项)");
break;
}
printf(" - 价值: %d金币\n", item->value);
printf(" %s\n", item->description);
}
}
print_separator();
}
/*
* ========================================
* 战斗系统 - 核心战斗逻辑
* ========================================
*/
int battle_system(Player* player, Enemy* enemy)
{
printf("\n=== 战斗开始！===\n");
printf("你遇到了 %s！\n", enemy->name);
// 战斗循环
while (player->stats.health > 0 && enemy->stats.health > 0)
{
printf("\n--- 你的回合 ---\n");
printf("你的生命值: %d/%d\n", player->stats.health, player->stats.max_health);
printf("%s的生命值: %d/%d\n", enemy->name, enemy->stats.health, enemy->stats.max_health);
printf("\n选择行动：\n");
printf("1. 普通攻击\n");
printf("2. 使用技能\n");
printf("3. 使用物品\n");
printf("4. 逃跑\n");
int action = get_user_choice(1, 4);
switch (action)
{
case 1: // 普通攻击
player_attack(player, enemy);
break;
case 2: // 使用技能
if (player->skill_count > 0)
{
printf("选择技能：\n");
for (int i = 0; i < player->skill_count; i++)
{
printf("%d. %s (魔法消耗:%d)\n", i + 1,
player->skills[i].name, player->skills[i].mana_cost);
}
int skill_choice = get_user_choice(1, player->skill_count) - 1;
use_skill(player, enemy, skill_choice);
}
else
{
printf("你没有可用的技能！\n");
continue; // 跳过敌人回合
}
break;
case 3: // 使用物品
printf("选择要使用的药水：\n");
int potion_found = 0;
for (int i = 0; i < player->inventory_count; i++)
{
if (player->inventory[i].type == ITEM_POTION)
{
printf("%d. %s\n", i + 1, player->inventory[i].name);
potion_found = 1;
}
}
if (potion_found)
{
int item_choice = get_user_choice(1, player->inventory_count) - 1;
if (player->inventory[item_choice].type == ITEM_POTION)
{
use_potion(player, &player->inventory[item_choice]);
remove_item_from_inventory(player, item_choice);
}
}
else
{
printf("你没有可用的药水！\n");
continue;
}
break;
case 4: // 逃跑
if (random_range(1, 100) <= 50)
{ // 50%逃跑成功率
printf("你成功逃跑了！\n");
return -1; // 逃跑成功
}
else
{
printf("逃跑失败！\n");
}
break;
}
// 检查敌人是否死亡
if (enemy->stats.health <= 0)
{
printf("\n%s 被击败了！\n", enemy->name);
printf("获得经验值: %d\n", enemy->exp_reward);
printf("获得金币: %d\n", enemy->gold_reward);
gain_experience(player, enemy->exp_reward);
player->gold += enemy->gold_reward;
// 随机掉落物品
if (random_range(1, 100) <= 30)
{ // 30%掉落率
printf("获得物品: %s\n", enemy->drop_item.name);
add_item_to_inventory(player, &enemy->drop_item);
}
return 1; // 战斗胜利
}
// 敌人回合
printf("\n--- %s的回合 ---\n", enemy->name);
enemy_attack(enemy, player);
// 检查玩家是否死亡
if (player->stats.health <= 0)
{
printf("\n你被击败了！\n");
printf("你失去了一些金币...\n");
player->gold = (int)(player->gold * 0.8); // 失去20%金币
player->stats.health = 1; // 保留1点生命值
return 0; // 战斗失败
}
wait_for_input();
}
return 0;
}
/*
* ========================================
* 玩家攻击函数
* ========================================
*/
void player_attack(Player* player, Enemy* enemy)
{
int base_damage = player->stats.attack;
// 如果装备了武器，增加攻击力
if (strlen(player->equipped_weapon.name) > 0)
{
base_damage += player->equipped_weapon.effect;
}
int damage = calculate_damage(base_damage, enemy->stats.defense);
// 随机暴击 (10%几率)
if (random_range(1, 100) <= 10)
{
damage *= 2;
printf("暴击！");
}
enemy->stats.health -= damage;
if (enemy->stats.health < 0) enemy->stats.health = 0;
printf("你对 %s 造成了 %d 点伤害！\n", enemy->name, damage);
}
/*
* ========================================
* 敌人攻击函数
* ========================================
*/
void enemy_attack(const Enemy* enemy, Player* player)
{
int base_damage = enemy->stats.attack;
int defense = player->stats.defense;
// 如果装备了防具，增加防御力
if (strlen(player->equipped_armor.name) > 0)
{
defense += player->equipped_armor.effect;
}
int damage = calculate_damage(base_damage, defense);
player->stats.health -= damage;
if (player->stats.health < 0) player->stats.health = 0;
printf("%s 对你造成了 %d 点伤害！\n", enemy->name, damage);
}
/*
* ========================================
* 使用技能函数
* ========================================
*/
void use_skill(Player* player, Enemy* enemy, int skill_index)
{
if (skill_index < 0 || skill_index >= player->skill_count)
{
printf("无效的技能选择！\n");
return;
}
Skill* skill = &player->skills[skill_index];
// 检查魔法值是否足够
if (player->stats.mana < skill->mana_cost)
{
printf("魔法值不足！\n");
return;
}
player->stats.mana -= skill->mana_cost;
switch (skill->type)
{
case SKILL_ATTACK:
{
int damage = calculate_damage(skill->damage + player->stats.attack, enemy->stats.defense);
enemy->stats.health -= damage;
if (enemy->stats.health < 0) enemy->stats.health = 0;
printf("你使用了 %s，对 %s 造成了 %d 点伤害！\n",
skill->name, enemy->name, damage);
}
break;
case SKILL_HEAL:
{
int heal_amount = skill->damage;
player->stats.health += heal_amount;
if (player->stats.health > player->stats.max_health)
{
player->stats.health = player->stats.max_health;
}
printf("你使用了 %s，恢复了 %d 点生命值！\n", skill->name, heal_amount);
}
break;
case SKILL_DEFEND:
printf("你使用了 %s，提高了防御力！\n", skill->name);
// 临时提高防御力的逻辑可以在这里实现
break;
case SKILL_MAGIC:
{
int magic_damage = skill->damage * 2; // 魔法伤害更高但消耗魔法
enemy->stats.health -= magic_damage;
if (enemy->stats.health < 0) enemy->stats.health = 0;
printf("你使用了 %s，对 %s 造成了 %d 点魔法伤害！\n",
skill->name, enemy->name, magic_damage);
}
break;
}
}
/*
* ========================================
* 计算伤害函数 - 考虑防御力
* ========================================
*/
int calculate_damage(int base_attack, int defense)
{
int damage = base_attack - (defense / 2);
if (damage < 1) damage = 1; // 最少造成1点伤害
// 添加随机因素 (±20%)
int variance = (int)(damage * 0.2);
damage += random_range(-variance, variance);
if (damage < 1) damage = 1;
return damage;
}
/*
* ========================================
* 添加物品到背包
* ========================================
*/
void add_item_to_inventory(Player* player, const Item* item)
{
if (player->inventory_count >= MAX_INVENTORY_SIZE)
{
printf("背包已满！无法添加物品。\n");
return;
}
// 复制物品到背包
player->inventory[player->inventory_count] = *item;
player->inventory_count++;
printf("获得物品: %s\n", item->name);
}
/*
* ========================================
* 从背包移除物品
* ========================================
*/
int remove_item_from_inventory(Player* player, int item_index)
{
if (item_index < 0 || item_index >= player->inventory_count)
{
return -1; // 无效索引
}
// 将后面的物品前移
for (int i = item_index; i < player->inventory_count - 1; i++)
{
player->inventory[i] = player->inventory[i + 1];
}
player->inventory_count--;
return 0; // 成功移除
}
/*
* ========================================
* 装备物品函数
* ========================================
*/
void equip_item(Player* player, int item_index)
{
if (item_index < 0 || item_index >= player->inventory_count)
{
printf("无效的物品选择！\n");
return;
}
Item* item = &player->inventory[item_index];
if (item->type == ITEM_WEAPON)
{
// 如果已经装备了武器，先卸下
if (strlen(player->equipped_weapon.name) > 0)
{
add_item_to_inventory(player, &player->equipped_weapon);
}
player->equipped_weapon = *item;
printf("装备了武器: %s\n", item->name);
}
else if (item->type == ITEM_ARMOR)
{
// 如果已经装备了防具，先卸下
if (strlen(player->equipped_armor.name) > 0)
{
add_item_to_inventory(player, &player->equipped_armor);
}
player->equipped_armor = *item;
printf("装备了防具: %s\n", item->name);
}
else
{
printf("这个物品无法装备！\n");
return;
}
// 从背包中移除已装备的物品
remove_item_from_inventory(player, item_index);
}
/*
* ========================================
* 使用药水函数
* ========================================
*/
void use_potion(Player* player, const Item* potion)
{
if (potion->type != ITEM_POTION)
{
printf("这不是药水！\n");
return;
}
// 根据药水名称判断效果
if (strstr(potion->name, "治疗") != NULL)
{
player->stats.health += potion->effect;
if (player->stats.health > player->stats.max_health)
{
player->stats.health = player->stats.max_health;
}
printf("使用了 %s，恢复了 %d 点生命值！\n", potion->name, potion->effect);
}
else if (strstr(potion->name, "魔法") != NULL)
{
player->stats.mana += potion->effect;
if (player->stats.mana > player->stats.max_mana)
{
player->stats.mana = player->stats.max_mana;
}
printf("使用了 %s，恢复了 %d 点魔法值！\n", potion->name, potion->effect);
}
}
/*
* ========================================
* 获得经验值函数
* ========================================
*/
void gain_experience(Player* player, int exp)
{
player->experience += exp;
// 检查是否升级
int exp_needed = calculate_exp_needed(player->level);
while (player->experience >= exp_needed)
{
level_up(player);
exp_needed = calculate_exp_needed(player->level);
}
}
/*
* ========================================
* 升级函数
* ========================================
*/
void level_up(Player* player)
{
player->level++;
player->experience -= calculate_exp_needed(player->level - 1);
// 提升属性
int health_increase = random_range(8, 15);
int mana_increase = random_range(3, 8);
int attack_increase = random_range(2, 5);
int defense_increase = random_range(1, 4);
int speed_increase = random_range(1, 3);
player->stats.max_health += health_increase;
player->stats.health = player->stats.max_health; // 升级时完全恢复生命值
player->stats.max_mana += mana_increase;
player->stats.mana = player->stats.max_mana; // 升级时完全恢复魔法值
player->stats.attack += attack_increase;
player->stats.defense += defense_increase;
player->stats.speed += speed_increase;
printf("\n=== 升级了！===\n");
printf("等级提升到 %d！\n", player->level);
printf("生命值 +%d (最大值: %d)\n", health_increase, player->stats.max_health);
printf("魔法值 +%d (最大值: %d)\n", mana_increase, player->stats.max_mana);
printf("攻击力 +%d (当前: %d)\n", attack_increase, player->stats.attack);
printf("防御力 +%d (当前: %d)\n", defense_increase, player->stats.defense);
printf("速度 +%d (当前: %d)\n", speed_increase, player->stats.speed);
// 学习新技能
if (player->level == 3 && player->skill_count < MAX_SKILLS)
{
strcpy(player->skills[player->skill_count].name, "治疗术");
player->skills[player->skill_count].type = SKILL_HEAL;
player->skills[player->skill_count].damage = 25;
player->skills[player->skill_count].mana_cost = 10;
player->skills[player->skill_count].level_required = 3;
player->skill_count++;
printf("学会了新技能: 治疗术！\n");
}
if (player->level == 5 && player->skill_count < MAX_SKILLS)
{
strcpy(player->skills[player->skill_count].name, "火球术");
player->skills[player->skill_count].type = SKILL_MAGIC;
player->skills[player->skill_count].damage = 20;
player->skills[player->skill_count].mana_cost = 15;
player->skills[player->skill_count].level_required = 5;
player->skill_count++;
printf("学会了新技能: 火球术！\n");
}
wait_for_input();
}
/*
* ========================================
* 计算升级所需经验值
* ========================================
*/
int calculate_exp_needed(int level)
{
// 使用递归函数计算经验值需求
if (level <= 1)
{
return 100;
}
return (int)(calculate_exp_needed(level - 1) * 1.5);
}
/*
* ========================================
* 保存游戏函数 - 文件操作示例
* ========================================
*/
int save_game(const GameState* state)
{
FILE* save_file = fopen(SAVE_FILE, "wb"); // 以二进制写模式打开文件
if (save_file == NULL)
{
fprintf(stderr, "无法创建存档文件！\n");
return -1;
}
// 写入游戏状态到文件
size_t written = fwrite(state, sizeof(GameState), 1, save_file);
if (written != 1)
{
fprintf(stderr, "写入存档文件失败！\n");
fclose(save_file);
return -1;
}
fclose(save_file);
return 0; // 保存成功
}
/*
* ========================================
* 加载游戏函数 - 文件操作示例
* ========================================
*/
int load_game(GameState* state)
{
FILE* save_file = fopen(SAVE_FILE, "rb"); // 以二进制读模式打开文件
if (save_file == NULL)
{
return -1; // 文件不存在
}
// 从文件读取游戏状态
size_t read = fread(state, sizeof(GameState), 1, save_file);
if (read != 1)
{
fprintf(stderr, "读取存档文件失败！\n");
fclose(save_file);
return -1;
}
fclose(save_file);
return 0; // 加载成功
}
/*
* ========================================
* 商店系统函数
* ========================================
*/
void shop_menu(Player* player)
{
// 商店物品数组
Item shop_items[] =
{
{101, "铁剑", ITEM_WEAPON, 150, 8, "一把锋利的铁制长剑"},
{102, "皮甲", ITEM_ARMOR, 120, 5, "轻便的皮制护甲"},
{103, "治疗药水", ITEM_POTION, 50, 30, "恢复30点生命值"},
{104, "魔法药水", ITEM_POTION, 80, 20, "恢复20点魔法值"},
{105, "钢剑", ITEM_WEAPON, 300, 15, "坚固的钢制长剑"},
{106, "链甲", ITEM_ARMOR, 250, 10, "防护性能优秀的链甲"}
};
int shop_item_count = sizeof(shop_items) / sizeof(Item);
int shopping = 1;
while (shopping)
{
clear_screen();
printf("=== 武器商店 ===\n");
printf("你的金币: %d\n\n", player->gold);
printf("商品列表：\n");
for (int i = 0; i < shop_item_count; i++)
{
printf("%d. %s - %d金币", i + 1, shop_items[i].name, shop_items[i].value);
if (shop_items[i].type == ITEM_WEAPON)
{
printf(" (攻击力+%d)", shop_items[i].effect);
}
else if (shop_items[i].type == ITEM_ARMOR)
{
printf(" (防御力+%d)", shop_items[i].effect);
}
else if (shop_items[i].type == ITEM_POTION)
{
printf(" (效果+%d)", shop_items[i].effect);
}
printf("\n %s\n", shop_items[i].description);
}
printf("\n%d. 出售物品\n", shop_item_count + 1);
printf("%d. 离开商店\n", shop_item_count + 2);
int choice = get_user_choice(1, shop_item_count + 2);
if (choice <= shop_item_count)
{
// 购买物品
buy_item(player, &shop_items[choice - 1]);
}
else if (choice == shop_item_count + 1)
{
// 出售物品
if (player->inventory_count > 0)
{
printf("选择要出售的物品：\n");
display_inventory(player);
int sell_choice = get_user_choice(1, player->inventory_count) - 1;
sell_item(player, sell_choice);
}
else
{
printf("你没有可以出售的物品。\n");
wait_for_input();
}
}
else
{
shopping = 0; // 离开商店
}
}
}
/*
* ========================================
* 购买物品函数
* ========================================
*/
void buy_item(Player* player, const Item* item)
{
if (player->gold < item->value)
{
printf("金币不足！你需要 %d 金币。\n", item->value);
wait_for_input();
return;
}
if (player->inventory_count >= MAX_INVENTORY_SIZE)
{
printf("背包已满！\n");
wait_for_input();
return;
}
player->gold -= item->value;
add_item_to_inventory(player, item);
printf("购买成功！花费了 %d 金币。\n", item->value);
wait_for_input();
}
/*
* ========================================
* 出售物品函数
* ========================================
*/
void sell_item(Player* player, int item_index)
{
if (item_index < 0 || item_index >= player->inventory_count)
{
printf("无效的物品选择！\n");
wait_for_input();
return;
}
Item* item = &player->inventory[item_index];
int sell_price = item->value / 2; // 出售价格是购买价格的一半
printf("确定要出售 %s 吗？可以获得 %d 金币。(y/n): ", item->name, sell_price);
char confirm;
scanf(" %c", &confirm);
if (tolower(confirm) == 'y')
{
player->gold += sell_price;
printf("出售成功！获得了 %d 金币。\n", sell_price);
remove_item_from_inventory(player, item_index);
}
else
{
printf("取消出售。\n");
}
wait_for_input();
}
/*
* ========================================
* 探索区域函数
* ========================================
*/
void explore_area(Player* player, Area* area)
{
printf("\n你来到了 %s\n", area->name);
printf("%s\n", area->description);
if (area->enemy_count == 0)
{
printf("这里很安全，你可以休息恢复体力。\n");
player->stats.health = player->stats.max_health;
player->stats.mana = player->stats.max_mana;
printf("生命值和魔法值已完全恢复！\n");
wait_for_input();
return;
}
// 随机遇敌
if (random_range(1, 100) <= 70)
{ // 70%遇敌概率
Enemy* enemy = encounter_random_enemy(area);
if (enemy != NULL)
{
// 复制敌人数据（避免修改原始数据）
Enemy battle_enemy = *enemy;
int battle_result = battle_system(player, &battle_enemy);
if (battle_result == 1)
{
printf("你在这个区域获得了胜利！\n");
}
else if (battle_result == 0)
{
printf("你被击败了，但设法逃脱了。\n");
}
else
{
printf("你成功逃脱了战斗。\n");
}
}
}
else
{
printf("你在这个区域没有遇到敌人。\n");
// 随机发现物品
if (random_range(1, 100) <= 20)
{ // 20%发现物品概率
Item found_items[] =
{
{201, "生锈的剑", ITEM_WEAPON, 80, 5, "一把生锈但还能用的剑"},
{202, "破旧的盾", ITEM_ARMOR, 60, 3, "破旧但还有防护作用的盾牌"},
{203, "小治疗药水", ITEM_POTION, 30, 15, "恢复15点生命值"}
};
int random_item = random_range(0, 2);
printf("你发现了一个物品！\n");
add_item_to_inventory(player, &found_items[random_item]);
}
}
wait_for_input();
}
/*
* ========================================
* 移动到指定区域
* ========================================
*/
void move_to_area(int area_index)
{
if (area_index >= 0 && area_index < MAX_AREAS)
{
g_game_state->current_area = area_index;
printf("你移动到了 %s\n", g_game_state->areas[area_index].name);
}
}
/*
* ========================================
* 随机遇到敌人
* ========================================
*/
Enemy* encounter_random_enemy(const Area* area)
{
if (area->enemy_count == 0)
{
return NULL;
}
int random_enemy_index = random_range(0, area->enemy_count - 1);
return (Enemy*)&area->enemies[random_enemy_index]; // 强制类型转换
}
/*
* ========================================
* 工具函数实现
* ========================================
*/
// 清屏函数
void clear_screen(void)
{
#ifdef _WIN32
system("cls");
#else
system("clear");
#endif
}
// 等待用户输入
void wait_for_input(void)
{
printf("\n按回车键继续...");
while (getchar() != '\n'); // 清除输入缓冲区
getchar(); // 等待回车
}
// 获取用户选择（带范围检查）
int get_user_choice(int min, int max)
{
int choice;
char input[10];
do
{
printf("请选择 (%d-%d): ", min, max);
if (fgets(input, sizeof(input), stdin) != NULL)
{
choice = atoi(input); // 字符串转整数
if (choice >= min && choice <= max)
{
return choice;
}
}
printf("无效输入！请输入 %d 到 %d 之间的数字。\n", min, max);
} while (1); // do-while循环
}
// 获取用户输入的字符串
char* get_user_string(char* buffer, int size)
{
if (fgets(buffer, size, stdin) != NULL)
{
// 移除换行符
size_t len = strlen(buffer);
if (len > 0 && buffer[len - 1] == '\n')
{
buffer[len - 1] = '\0';
}
return buffer;
}
return NULL;
}
// 生成指定范围的随机数
int random_range(int min, int max)
{
if (min > max)
{
int temp = min;
min = max;
max = temp;
}
return min + rand() % (max - min + 1);
}
// 打印分隔线
void print_separator(void)
{
printf("========================================\n");
}
/*
* ========================================
* 位运算相关函数示例
* ========================================
*/
// 设置玩家标志位
void set_player_flag(Player* player, int flag)
{
// 使用位运算设置标志
// 这里可以用一个整数来存储多个布尔标志
// 例如：player->flags |= (1 << flag);
// 由于Player结构体中没有flags字段，这里只是示例
(void)player; // 避免未使用参数警告
(void)flag;
}
// 检查玩家标志位
int check_player_flag(const Player* player, int flag)
{
// 使用位运算检查标志
// 例如：return (player->flags & (1 << flag)) != 0;
(void)player;
(void)flag;
return 0;
}
// 清除玩家标志位
void clear_player_flag(Player* player, int flag)
{
// 使用位运算清除标志
// 例如：player->flags &= ~(1 << flag);
(void)player;
(void)flag;
}
/*
* ========================================
* 递归函数示例
* ========================================
*/
// 斐波那契数列（递归实现）
int fibonacci(int n)
{
if (n <= 1)
{
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
// 打印等级树（递归实现）
void print_level_tree(int level, int max_level)
{
if (level > max_level)
{
return;
}
// 打印当前等级
for (int i = 0; i < level; i++)
{
printf(" "); // 缩进
}
printf("等级 %d\n", level);
// 递归打印下一级
print_level_tree(level + 1, max_level);
}
/*
* ========================================
* 函数指针使用示例
* ========================================
*/
// 菜单函数数组（函数指针数组）
void menu_display_stats(void)
{
display_player_info(&g_game_state->player);
}
void menu_display_inventory(void)
{
display_inventory(&g_game_state->player);
}
// 函数指针数组示例
MenuFunction menu_functions[] =
{
menu_display_stats,
menu_display_inventory,
NULL // 数组结束标志
};
/*
* ========================================
* 高级功能示例
* ========================================
*/
// 创建备份存档
void create_backup_save(void)
{
FILE* original = fopen(SAVE_FILE, "rb");
if (original == NULL)
{
return;
}
FILE* backup = fopen("game_save_backup.dat", "wb");
if (backup == NULL)
{
fclose(original);
return;
}
// 复制文件内容
char buffer[1024];
size_t bytes;
while ((bytes = fread(buffer, 1, sizeof(buffer), original)) > 0)
{
fwrite(buffer, 1, bytes, backup);
}
fclose(original);
fclose(backup);
printf("备份存档已创建。\n");
}
上面是一个完整的RPG小游戏，因为博主比较懒，所以就将原本所有的.c .h文件都整合到一起粘贴到这里面QAQ。看似写了很多，但是你不要害怕，其实你把每一个部分拆开来看就是你学C语言的基础知识，只不过我把他们汇总在一起，又加了一些自己的东西罢了。
这个小游戏涵盖了以下C语言的知识点：
* 1. 基本数据类型：int, float, char, double等
* 2. 运算符：算术(+,-,*,/,%)、逻辑(&&,||,!)、关系(<,>,==,!=)、位运算(&,|,^,~,<<,>>)
* 3. 控制结构：if-else, switch-case, for, while, do-while
* 4. 函数：函数定义、参数传递、返回值、递归函数
* 5. 数组：一维数组、多维数组、字符数组、结构体数组
* 6. 指针：指针声明、指针运算、指针与数组、函数指针
* 7. 结构体：结构体定义、嵌套结构体、结构体指针、结构体数组
* 8. 联合体：union的使用
* 9. 枚举：enum类型定义和使用
* 10. 文件操作：fopen, fread, fwrite, fclose等
* 11. 动态内存分配：malloc, calloc, free
* 12. 预处理器：#include, #define, #ifdef等
* 13. 字符串处理：strcpy, strlen, strstr等
* 14. 标准库函数：printf, scanf, rand, time等
* 15. 类型转换：强制类型转换、隐式转换
* 16. 作用域和存储类：static, extern, auto等
* 17. 错误处理：返回值检查、错误输出
* 18. 内存管理：内存分配、释放、内存泄漏防护
下面我将用盖房子的例子来解释我是怎么写出来这样一个复杂而又不好玩的小游戏的：
第一步：画图纸（设计阶段）
建筑图纸 = 代码架构设计
// 1. 确定"房子"要有什么房间（游戏系统）
- 主卧室：玩家系统
- 厨房：物品系统
- 浴室：战斗系统
- 客厅：主菜单系统
- 车库：存档系统
// 2. 画平面图（数据结构设计）
typedef struct
{ // 每个房间的尺寸和功能
int health; // 卧室面积
int attack; // 厨房设备
// ... 其他属性
} Player;
// 3. 确定房间关系（系统交互）
// 卧室→浴室：玩家战斗后需要恢复
// 厨房→客厅：物品可以在菜单使用
先想清楚要建什么房子，有多少房间，房间怎么连接。
第二步：打地基（基础架构）
地基 = 核心数据结构和头文件
// 1. 准备建筑材料（头文件）
#include <stdio.h> // 水泥、砖块
#include <stdlib.h> // 钢筋、木材
#include <string.h> // 管线材料
// 2. 定义房屋结构（结构体）
#define MAX_ROOMS 10 // 房子最多10个房间
typedef enum
{ // 房间类型枚举
BEDROOM = 1, // 卧室
KITCHEN = 2 // 厨房
} RoomType;
// 3. 建立地基（全局变量）
static GameState *house_foundation = NULL; // 整个房子的地基
先把最基础的结构确定好，确保地基牢固。
第三步：搭建主体框架（主循环和核心函数）
房屋框架 = 游戏主循环和核心函数
// 1. 建立承重墙（主函数）
int main(void)
{
build_foundation(); // 打地基
setup_framework(); // 搭框架
live_in_house(); // 入住使用
return 0;
}
// 2. 搭建楼层框架（游戏主循环）
void game_loop(void)
{
while (living_in_house)
{ // 只要还住在这房子
show_house_menu(); // 显示房间导航
room_choice = choose_room(); // 选择去哪个房间
switch (room_choice)
{
case 1: enter_bedroom(); break; // 进入卧室
case 2: enter_kitchen(); break; // 进入厨房
// ... 其他房间
}
}
}
先建立房子的整体结构，确定怎么在各个房间之间移动。
第四步：砌墙分隔房间（实现各个系统）
砌墙 = 实现各个游戏模块
卧室墙面（玩家系统）
void build_bedroom(void)
{ // 建造卧室
// 墙面1：玩家属性
player->health = 100; // 床的尺寸
player->level = 1; // 卧室等级
// 墙面2：装备系统
equip_item(player, sword); // 放置家具
// ... 其他卧室功能
}
厨房墙面（物品系统）
void build_kitchen(void)
{ // 建造厨房
// 墙面1：背包系统
add_item(potion); // 放置厨具
// 墙面2：使用物品
use_potion(player); // 使用厨房设备
}
浴室墙面（战斗系统）
void build_bathroom(void)
{ // 建造浴室
// 墙面1：战斗流程
start_battle(player, enemy); // 进入淋浴间
// 墙面2：伤害计算
calculate_damage(attack, defense); // 调节水温
}
一个房间一个房间地建造，确保每个房间功能完整。
第五步：安装水电管线（系统间连接）
水电管线 = 系统间的数据流动
// 1. 卧室→浴室的水管（战斗→经验连接）
void battle_to_experience_pipe(void)
{
if (battle_won)
{ // 战斗胜利
gain_experience(player, exp); // 经验流向玩家
if (enough_experience)
{ // 经验积累到一定程度
level_up(player); // 触发升级
}
}
}
// 2. 厨房→卧室的电路（物品→属性连接）
void item_to_stat_wiring(void)
{
use_potion(player, health_potion); // 使用药水
player->health += healing_amount; // 生命值增加
// 这影响了卧室的状态（玩家属性）
}
// 3. 客厅→所有房间的中央空调（主菜单→各系统）
void main_menu_central_system(void)
{
switch (user_choice)
{
case 1: go_to_bedroom(); break; // 控制通往卧室
case 2: go_to_kitchen(); break; // 控制通往厨房
}
}
确保各个房间的水电都能正常使用，数据能正确流动。
第六步：装修装饰（完善用户体验）
装修 = 优化界面和体验
// 1. 墙面刷漆（界面美化）
void paint_walls(void)
{
print_separator(); // 漂亮的边框
printf("=== 豪华卧室 ===\n"); // 好看的标题
display_player_info(player); // 整洁的信息展示
}
// 2. 安装灯具（交互优化）
void install_lighting(void)
{
clear_screen(); // 让界面清晰
wait_for_input(); // 给用户反应时间
get_user_choice(1, 5); // 明确的选项指引
}
// 3. 布置家具（功能完善）
void arrange_furniture(void)
{
create_backup_save(); // 安全措施
debug_mode_print(); // 调试工具
}
让房子不仅功能齐全，还要住得舒服。
第七步：验收检查（测试调试）
验收 = 测试游戏功能
// 1. 检查每个房间门是否能开
test_battle_system(); // 战斗系统测试
test_inventory_system(); // 背包系统测试
// 2. 检查水电是否正常
test_experience_flow(); // 经验流动测试
test_item_usage(); // 物品使用测试
// 3. 压力测试（多人同时使用）
stress_test_game(); // 性能测试
第八步：入住使用（玩家体验）
入住 = 开玩
最终成果：
//一栋功能完整的"游戏房子"：
//- 主卧室（玩家系统）：休息、查看状态
//- 厨房（物品系统）：整理、使用道具
//- 浴室（战斗系统）：战斗、升级
//- 客厅（主菜单）：导航到各个房间
//- 车库（存档系统）：保存游戏进度
你的实际操作步骤：
-
今天：画图纸（设计数据结构）
-
明天：打地基（写头文件和定义）
-
后天：搭框架（实现主循环）
-
每天砌一面墙（逐个实现系统）
-
周末安装水电（连接系统）
-
下周末装修（优化界面）
-
验收：自己玩一遍找问题
-
邀请朋友入住：让其他人测试
关键心态： 不要试图一天建成整个房子！一天砌一面墙，慢慢来，确保每面墙都结实。我相信各位未来的大牛们有一天也会写出来更厉害的程序！
扫一扫
7332
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
