生化小游戏 v1227版本（上半部分）

//-std=c++14
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <cstdint>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <chrono>
#include <conio.h>
#include <windows.h>
using namespace std;

// 全局变量

// 游戏状态变量
bool gameClear = false;   // 基础剧情通关标记
bool advanced = false;    // 进阶剧情通关标记
int deathCount = 0;       // 死亡次数
bool specialItem = false; // 是否持有特殊物品
bool saveExists = false;  // 是否存在存档
int clueCount = 0;        // 已收集线索数
int exitTry = 0;          // 尝试退出次数
int theLoops = 1;         // 周目次数

// 存档变量
const string SAVE_FILE = "save.ans";
// 存档错误类型
enum class SaveErrorType {
	FILE_OPEN_FAILED,
	FILE_WRITE_FAILED,
	FILE_READ_FAILED,
	CHECKSUM_MISMATCH,
	VERSION_MISMATCH,
	INVALID_DATA
};
// 版本号
const int VERSION = 1227;

// 资源变量
int bullets; // 子弹数量
int food;    // 食物数量

// 人物关系变量
int girlFavor = 0;         // 少女好感度（-1=敌对，0=中立，1=友好）
int girlBullet = 0;        // 少女子弹数
bool hasBoy = false;       // 少年是否入队
bool boyInfected = false;  // 少年是否被感染
int savedGirl = 3;         // 少女关系
int savedBoy = 3;          // 少年关系

// 道具/状态标记
int boyWeapon = 0;         // 少年武器（0=无，1=枪，2=水管）
bool zombieKing = false;   // 尸王线标记
bool triggerWeird = false; // 违和感触发标记
int adminLog = 0;          // 管理员日志数量

bool badEnd[30] = {false};
const vector<string> badEndNames = {
	"0-未用",
	"1-饥馑殒命", "2-破密无门", "3-神智崩摧", "4-独往基覆", "5-基地沦亡",
	"6-变异失智", "7-作者裁决", "8-异女噬身", "9-阅记遭噬",
	"10-麻木度世", "11-轻敌丧身", "12-崩解遭毙", "13-崩解猎援",
	"14-出界无讯", "15-熟迹反灭", "16-杀女被诛", "17-女反杀之",
	"18-弹尽群噬", "19-孤存终亡", "20-精英丧噬", "21-途竭而终",
	"22-少叛遭祸", "23-安离反目", "24-杀少成魔", "25-携少饥终",
	"26-异少噬身", "27-首领诛知", "28-空城孤王"
};
bool happyEnd[10] = {false};
const vector<string> happyEndNames = {
	"0-未用",
	"1-终睹晨曦", "2-仙侣偕行", "3-英名长存", "4-真我觉醒", "5-异途相恋", "6-或敌或友"
};
bool trueEnd[10] = {false};
const vector<string> trueEndNames = {
	"0-未用",
	"1-如故如常", "2-守心自持", "3-浮生幻梦", "4-域界皆终", "5-迟来之亡", "6-团结破局", "7-域管同化"
};
bool clue[20] = {false};
// 改写：线索名称融入古典词汇
const vector<string> clueNames = {
	"0-诡枪异食", "1-迟变少年", "2-免疫异女", "3-域中异象",
	"4-早变异女", "5-实验双体", "6-破局而退", "7-死亡迷局", "8-复活循环",
	"9-变异溯源", "10-抉择之键", "11-域外之界", "12-虚实之辨", "13-自主觉醒",
	"14-同化终局", "15-双体共鸣", "16-终得团聚", "17-性情相容"
};
// 改写：提示文本更具古典韵味，采用对仗与意象
const vector<string> vagueClues = {
	"",
	// 基础剧情与特殊物品
	"通关归始，可寻破局之径",
	"物不必均分，储备藏转机",
	"关键物藏往昔忆，遵从本心方为真",
	"救援非定数，耐心运气皆相佐",
	// 尸王线触发
	"死亡非终焉，轮回有迹",
	"死亡之末，乃得新生",
	"复亡如复生，精神将残",
	// 线索收集相关
	"藏记可拼真相貌",
	"细察言语藏玄机",
	"实验日志碎片散",
	"合线索可展威能",
	// 结局触发条件
	"共渡危局，结局臻善",
	"少年之行，信之为善",
	"守基地者，可成英魂",
	"少年染疫，或有转机",
	// 真结局相关
	"集线索后，真容乃现",
	"特殊身份，可互感应",
	"世如虚妄，三人合力",
	"密钥需试，凑数乃得",
	// 彩蛋与隐藏内容
	"试退而终，或遇回应",
	"管理同化，情知相衡",
	"生化之境，尚有未探",
	"死亡过繁，得知改命",
	// 进阶剧情触发
	"线索集，真相显",
	"违和生，真貌现",
	"日志存，真相触"
};
// 颜色
namespace color{
	const string basic = "\033[";
	const string red = basic + "31m";
	const string green = basic + "32m";
	const string yellow = basic + "33m";
	const string blue = basic + "34m";
	const string purple = basic + "35m";
	const string sky = basic + "36m";
	const string gray = basic + "90m";

	const string bg_red = basic + "41m";
	const string bg_green = basic + "42m";
	const string bg_yellow = basic + "43m";
	const string bg_blue = basic + "44m";
	const string bg_gray = basic + "100m";

	const string blink = basic + "5m";       // 闪烁
	const string underline = basic + "4m";  // 下划线
	const string rev = basic + "7m";    // 反显（前景/背景互换）
	const string bold = basic + "1m";       // 加粗
	const string back = basic + "0m";       // 重置所有样式

	const string warn = red + blink + bold;
}
using namespace color;
// 工具函数
// 随机数
int random(int min, int max) {
	static mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
	uniform_int_distribution<int> dist(min, max);
	return dist(gen);
}
// 等待/线程休眠
void sleep(int ms){
	Sleep(ms);
}

// 控制台光标
void controlCursor(bool tf) {
	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO cursorInfo;
	GetConsoleCursorInfo(hConsole, &cursorInfo);
	cursorInfo.bVisible = tf; // 隐藏光标
	SetConsoleCursorInfo(hConsole, &cursorInfo);
}

// 打印文字 30ms
inline void print(const string& text, bool enter = true) {
	for (char c : text) {
		if(theLoops >= 2 && random(1, 30) <= theLoops){
			sleep(300 * theLoops);
		}
		cout << c;
		if(c != ' ') sleep(30);

	}
	if(enter) cout<<endl;
	sleep(10);
}

// 带边框的文本框
inline void boxPrint(const string& text, const string& borderColor = "") {
	int maxLen = 0;
	vector<string> lines;
	stringstream ss(text);
	string line;
	while (getline(ss, line, '\n')) {
		lines.push_back(line);
		if (line.length() > maxLen) maxLen = line.length();
	}
	// 上边框
	cout << borderColor + "+" + string(maxLen + 2, '=') + "+" + back <<endl;
	// 内容行
	for (auto& l : lines) {
		cout << borderColor + "| " + back;
		print(l, false);
		for (int i = l.length(); i < maxLen; i++) cout << " ";
		cout << borderColor + " |" + back <<endl;
	}
	// 下边框
	cout << borderColor + "+" + string(maxLen + 2, '=') + "+" + back <<endl;
}
// 数字输入
inline int input(int mi, int ma){
	char ch;
	int wrong = 0;
	ch = _getch();
	while (ch < '0' || ch > '9') {
		print(red + "请输入一个数字" + back);
		wrong++;
		ch = _getch();
	}
	int n =  ch - '0';

	while(n < mi || n > ma){
		print(red + "请输入正确的值" + back);
		wrong++;
		ch = _getch();
		while (ch < '0' || ch > '9') {
			print(red + "请输入一个数字" + back);
			wrong++;
			ch = _getch();
		}
		n = ch - '0';
	}
	if(wrong >= 5) print("你今天输错了" + to_string(wrong) + "次哦，下次加油！");
	return n;
}

// 清屏
inline void cls() {
	system("cls");
}
// 按键等待
inline void pressAnyKey() {
	print("按任意键继续...");
	_getch();
	cls();
}

// 增强版选项选择函数（方向键/数字选择，Enter确认）
int option(const string title, const vector<string>& options, bool isPause = true) {
	if(isPause){
		print("按任意键继续...");
		_getch();
	}
	int selected = 0;
	while (true) {
		cls();
		if(!title.empty()) cout << title << endl;

		cout << "请选择：\n";
		for (int i = 0; i < options.size(); i++) {
			if (i == selected) {
				cout << green << "> " << options[i] << back << endl;
			} else {
				cout << "  " << options[i] << endl;
			}
		}
		int ch = _getch();

		if (theLoops >= 2 && random(1, 5) == 1) {
			sleep(300 * theLoops); // 按键延迟
		}

		if (ch == 224) { // 方向键
			ch = _getch();
			if (ch == 72) selected = max(0, selected - 1); // 上
			if (ch == 80) selected = min((int)options.size()-1, selected + 1); // 下
		} else if (ch == 13) { // Enter确认
			return selected + 1; // 返回选项
		} else if (ch >= '1' && ch <= '9') { // 数字输入
			int num = ch - '0';
			if (num <= options.size()) {
				return num;
			}
		}
	}

}

// 显示当前状态（子弹+食物）
inline void showStatus() {
	cls();
	print("【当前状态】");
	string bulletBar = bg_red;
	for (int i = 0; i < 12; i++){
		if(i < bullets)bulletBar += " ";
		else if(i == bullets)bulletBar += back + " ";
		else bulletBar += " ";
	}

	string foodBar = bg_green;
	for (int i = 0; i < 12; i++){
		if(i < food)foodBar += " ";
		else if(i == food)foodBar += back + " ";
		else foodBar += " ";
	}

	if (theLoops >= 2 && random(1, 2) == 1) {
		print( red + "子弹：" + to_string(bullets * -1) + " 食物：" + to_string(food * -1) + back );
		print( red + "警告！数据错误！" + back);
		Sleep(800);
		cls(); // 重新清屏显示正确值
	}

	print( "子弹：" + bulletBar + back + " [" + to_string(bullets) + "/12]" );
	print( "食物：" + foodBar + back + " [" + to_string(food) + "/12]" );

	string icons = "";
	if (specialItem) icons += "[破局之始] "; // 特殊物品
	if (zombieKing) icons += "[生而彷徨] ";  // 尸王线
	if (advanced) icons += "[真貌初显] ";  // 进阶剧情
	if (triggerWeird) icons += "[寰宇之相] "; //违和感

	if (!icons.empty()) print("特殊状态：" + icons);
}
void resetGameState() {
	bullets = 0;
	food = 0;
	girlFavor = 0;
	girlBullet = 0;
	hasBoy = false;
	boyWeapon = 0;
}
// 统计已解锁结局数量
int countUnlocked(bool arr[], int size) {
	int intg = 0;
	for (int i = 0; i < size; i++) {
		if (arr[i]) intg++;
	}
	return intg;
}

// Bad End详情（索引1-28，0未用）
void showBadEnds() {
	print("\n===== 终局·憾恨 =====");
	for (int i = 1; i <= badEndNames.size() - 1; i++) {
		if (badEnd[i]) {
			print( red + "[" + to_string(i) + "] 已解锁 " + badEndNames[i] + back);
		} else {
			print( gray + "[" + to_string(i) + "] 未解锁 " + "？？？？" + back);
		}
	}
}

// Happy End详情（索引1-6，0未用）
void showHappyEnds() {
	print("\n===== 终局·幸悦 =====");
	for (int i = 1; i <= happyEndNames.size() - 1; i++) {
		if (happyEnd[i]) {
			print( green + "[" + to_string(i) + "] 已解锁 " + happyEndNames[i] + back);
		} else {
			print( gray + "[" + to_string(i) + "] 未解锁 " + "？？？？" + back);
		}
	}
}

// True End详情（索引1-7，0未用）
void showTrueEnds() {
	print("\n===== 终局·真章 =====");
	for (int i = 1; i <= trueEndNames.size() - 1; i++) {
		if (trueEnd[i]) {
			print( yellow + "[" + to_string(i) + "] 已解锁 " + trueEndNames[i] + back);
		} else {
			print( gray + "[" + to_string(i) + "] 未解锁 " + "？？？？" + back);
		}
	}
}
// 线索
void showClues() {
	print("\n===== 线索·星光 =====");
	for (int i = 0; i <= clueNames.size() - 1; i++) {
		if (clue[i]) {
			print( sky + "[" + to_string(i) + "] 已解锁 " + clueNames[i] + back);
		} else {
			print( gray + "[" + to_string(i) + "] 未解锁 " + "？？？？" + back);
		}
	}
}
//进度
void showAdv() {
	print("\n===== 阶级 =====");
	if(gameClear) print("基础剧情通关 · 破局之始");
	if(advanced) print("进阶剧情通关 · 真貌初显");
	if(zombieKing) print("尸王线 · 生而彷徨");
	if(triggerWeird) print("违和感 · 寰宇之相");
	print("死亡次数：" + to_string(deathCount));
	if(adminLog != 0) print("日志数量：" + to_string(adminLog));
}

// 存档错误信息
void showSaveError(SaveErrorType error, const string& operation) {
	string errorMsg;
	switch (error) {
	case SaveErrorType::FILE_OPEN_FAILED:
		errorMsg = "无法打开存档文件";
		break;
	case SaveErrorType::FILE_WRITE_FAILED:
		errorMsg = "存档写入失败";
		break;
	case SaveErrorType::FILE_READ_FAILED:
		errorMsg = "存档读取失败";
		break;
	case SaveErrorType::CHECKSUM_MISMATCH:
		errorMsg = "存档文件损坏";
		break;
	case SaveErrorType::VERSION_MISMATCH:
		errorMsg = "存档版本不兼容";
		break;
	case SaveErrorType::INVALID_DATA:
		errorMsg = "存档数据无效";
		break;
	default:
		errorMsg = "未知错误";
	}
	print(red + "[" + operation + "失败]" + errorMsg + back);
}

// 计算简单校验和（异或所有字节）
uint32_t _calculateChecksum(const char* data, size_t size) {
	uint32_t checksum = 0;
	for (size_t i = 0; i < size; ++i) {
		checksum ^= static_cast<uint8_t>(data[i]);
	}
	return checksum;
}

bool checkSaveExists() {
	try {
		ifstream file(SAVE_FILE); 	  // 尝试以读模式打开文件
		bool exists = file.good();    // 文件存在且可打开则为true
		file.close();                 // 立即关闭文件
		saveExists = exists;
		return exists;
	} catch (...) {
		print(yellow + "检查存档时发生错误" + back);
		saveExists = false;
		return false;
	}
}

// 保存游戏
bool saveGame() {
	stringstream buffer;
	buffer.write(reinterpret_cast<const char*>(&VERSION), sizeof(VERSION));
	// 写入所有变量
	buffer.write(reinterpret_cast<const char*>(&gameClear), sizeof(gameClear));
	buffer.write(reinterpret_cast<const char*>(&advanced), sizeof(advanced));
	buffer.write(reinterpret_cast<const char*>(&deathCount), sizeof(deathCount));
	buffer.write(reinterpret_cast<const char*>(&specialItem), sizeof(specialItem));
	buffer.write(reinterpret_cast<const char*>(&clueCount), sizeof(clueCount));
	buffer.write(reinterpret_cast<const char*>(&exitTry), sizeof(exitTry));
	buffer.write(reinterpret_cast<const char*>(&theLoops), sizeof(theLoops));
	buffer.write(reinterpret_cast<const char*>(&savedGirl), sizeof(savedGirl));
	buffer.write(reinterpret_cast<const char*>(&savedBoy), sizeof(savedBoy));
	buffer.write(reinterpret_cast<const char*>(&zombieKing), sizeof(zombieKing));
	buffer.write(reinterpret_cast<const char*>(&triggerWeird), sizeof(triggerWeird));
	buffer.write(reinterpret_cast<const char*>(&adminLog), sizeof(adminLog));
	buffer.write(reinterpret_cast<const char*>(happyEnd), sizeof(happyEnd));
	buffer.write(reinterpret_cast<const char*>(badEnd), sizeof(badEnd));
	buffer.write(reinterpret_cast<const char*>(trueEnd), sizeof(trueEnd));
	buffer.write(reinterpret_cast<const char*>(clue), sizeof(clue));

	string data = buffer.str();
	uint32_t checksum = _calculateChecksum(data.data(), data.size());

	const string TEMP_FILE = SAVE_FILE + ".tmp";
	ofstream file(TEMP_FILE, ios::binary);
	if (!file.is_open()) {
		showSaveError(SaveErrorType::FILE_OPEN_FAILED, "保存");
		return false;
	}

	file.write(data.data(), data.size());
	file.write(reinterpret_cast<const char*>(&checksum), sizeof(checksum));

	if (!file.good()) {
		file.close();
		remove(TEMP_FILE.c_str());
		showSaveError(SaveErrorType::FILE_WRITE_FAILED, "保存");
		return false;
	}
	file.close();

	try {
		remove(SAVE_FILE.c_str());
		int renameResult = rename(TEMP_FILE.c_str(), SAVE_FILE.c_str());
		if (renameResult != 0) {
			remove(TEMP_FILE.c_str());
			showSaveError(SaveErrorType::FILE_WRITE_FAILED, "保存");
			return false;
		}
		saveExists = true;
		return true;
	} catch (...) {
		remove(TEMP_FILE.c_str());
		showSaveError(SaveErrorType::FILE_WRITE_FAILED, "保存");
		return false;
	}
}

// 加载游戏
bool loadGame() {
	if (!checkSaveExists()) {
		return false;
	}

	ifstream file(SAVE_FILE, ios::binary | ios::ate);
	if (!file.is_open()) {
		showSaveError(SaveErrorType::FILE_OPEN_FAILED, "加载");
		return false;
	}

	streamsize fileSize = file.tellg();
	file.seekg(0, ios::beg);

	const size_t EXPECTED_SIZE = sizeof(VERSION) +
	sizeof(gameClear) + sizeof(advanced) + sizeof(deathCount) +
	sizeof(specialItem) + sizeof(clueCount) + sizeof(exitTry) +
	sizeof(theLoops) + sizeof(savedGirl) + sizeof(savedBoy) +
	sizeof(zombieKing) + sizeof(triggerWeird) + sizeof(adminLog) +
	sizeof(happyEnd) + sizeof(badEnd) + sizeof(trueEnd) +
	sizeof(clue) + sizeof(uint32_t);

	if (fileSize != static_cast<streamsize>(EXPECTED_SIZE)) {
		file.close();
		showSaveError(SaveErrorType::INVALID_DATA, "加载");
		return false;
	}

	// 读取所有数据
	int version;
	file.read(reinterpret_cast<char*>(&version), sizeof(version));
	if (version != VERSION) {
		file.close();
		showSaveError(SaveErrorType::VERSION_MISMATCH, "加载");
		return false;
	}

	file.read(reinterpret_cast<char*>(&gameClear), sizeof(gameClear));
	file.read(reinterpret_cast<char*>(&advanced), sizeof(advanced));
	file.read(reinterpret_cast<char*>(&deathCount), sizeof(deathCount));
	file.read(reinterpret_cast<char*>(&specialItem), sizeof(specialItem));
	file.read(reinterpret_cast<char*>(&clueCount), sizeof(clueCount));
	file.read(reinterpret_cast<char*>(&exitTry), sizeof(exitTry));
	file.read(reinterpret_cast<char*>(&theLoops), sizeof(theLoops));
	file.read(reinterpret_cast<char*>(&savedGirl), sizeof(savedGirl));
	file.read(reinterpret_cast<char*>(&savedBoy), sizeof(savedBoy));
	file.read(reinterpret_cast<char*>(&zombieKing), sizeof(zombieKing));
	file.read(reinterpret_cast<char*>(&triggerWeird), sizeof(triggerWeird));
	file.read(reinterpret_cast<char*>(&adminLog), sizeof(adminLog));
	file.read(reinterpret_cast<char*>(happyEnd), sizeof(happyEnd));
	file.read(reinterpret_cast<char*>(badEnd), sizeof(badEnd));
	file.read(reinterpret_cast<char*>(trueEnd), sizeof(trueEnd));
	file.read(reinterpret_cast<char*>(clue), sizeof(clue));

	uint32_t savedChecksum;
	file.read(reinterpret_cast<char*>(&savedChecksum), sizeof(savedChecksum));

	if (!file.good()) {
		file.close();
		showSaveError(SaveErrorType::FILE_READ_FAILED, "加载");
		return false;
	}
	file.close();

	ifstream checkFile(SAVE_FILE, ios::binary);
	checkFile.seekg(0, ios::beg);
	vector<char> data(EXPECTED_SIZE - sizeof(uint32_t));
	checkFile.read(data.data(), data.size());
	checkFile.close();

	uint32_t calculatedChecksum = _calculateChecksum(data.data(), data.size());
	if (calculatedChecksum != savedChecksum) {
		showSaveError(SaveErrorType::CHECKSUM_MISMATCH, "加载");
		return false;
	}

	if (deathCount < 0 || clueCount < 0) {
		showSaveError(SaveErrorType::INVALID_DATA, "加载");
		return false;
	}
	return true;
}

// 线索集成
void cluei(int n){
	print(sky + "【线索·星光】第" + to_string(n) + "章" + back);
	boxPrint(clueNames[n], sky + blink);
	if(!clue[n]){
		clue[n] = true;
		clueCount++;
	}

}
//食物集成判断
bool foodi(int num) {
	for(int i=1;i<=num;i++){
		food--;
		if(food<=0)return true;
		print("按任意键食用食物...");
		_getch();
		sleep(100);
	}
	return false;
}
//子弹集成判断
bool bulleti(int num) {
	for(int i=1;i<=num;i++){
		bullets--;
		if(bullets<=0)return true;
		if(random(1, 4)==1)print("丧尸已经向你扑来！");
		else if(random(1, 3)==1)print("丧尸嘶吼着把你包围，");
		print("按任意键开枪...");
		_getch();
		sleep(100);
	}
	return false;
}
// 伪装bug
void fakeBug() {
	if (theLoops < 2) return;

	int bugType = random(1, 20); // 随机触发不同假BUG
	switch (bugType) {
		case 1: // 文字乱码（临时）
		print("\xE2\x96\x88\xE2\x96\x88\xE2\x96\x88 [系统故障] \xE2\x96\x88\xE2\x96\x88\xE2\x96\x88", false);
		sleep(500 * theLoops);
		cls();
		break;
		case 2: // 颜色错乱
		print(purple + "===== 内存溢出警告 =====" + back);
		sleep(800 * theLoops);
		cls();
		break;
		case 3: // 假的程序崩溃提示
		print(red + bold + "程序异常 0xC000041D: 主线程退出" + back);
		sleep(1000 * theLoops);
		cls();
		break;
		case 4: // 文字重复输出
		print(red + "你你你你选选选选择择择择错错错错误误误误" + back, false);
		sleep(600 * theLoops);
		cout << back << "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"; // 回退删除乱码
		break;
		case 5: // 光标闪烁异常
		controlCursor(true);
		sleep(1000 * theLoops);
		controlCursor(false);
		break;
		case 6: // 假的存档损坏提示
		print(yellow + "[警告] 存档文件 CRC 校验失败 (0x" + to_string(random(1000, 9999)) + ")" + back);
		sleep(1200 * theLoops);
		cls();
		break;
		case 7: // 界面元素错位
		cout << string(10, '\n');
		cout << string(10, ' ');
		print(sky + "<<<<<<<<< 渲染层偏移 >>>>>>>>>" + back);
		sleep(800 * theLoops);
		cls();
		break;
		case 8: // 按键无响应假象（仅延迟）
		print("按任意键继续...", false);
		sleep(2000 * theLoops);
		break;
		default:
		break;
	}
}
// 结局函数
namespace badEnd_ {
	void end(int n) {
		print(blink + red + "【终局·憾恨】第" + to_string(n) + "幕" + back);
		boxPrint(badEndNames[n], red);
		badEnd[n] = true;
	}
	void Starve() { // Bad End 1
		cls();
		print("粮囊已空，你枯坐于破败的角落，身躯因饥馑日渐佝偻。");
		print("指尖划过干裂的唇瓣，连呼喊的力气也已耗尽，最终在寂静中咽下了最后一口气。");
		badEnd_::end(1);
		pressAnyKey();
		deathCount++;
	}
	void WrongPassword() { // Bad End 2
		cls();
		print("你皱着眉反复尝试，指尖因焦躁微微颤抖，密码盘上的数字冰冷而陌生。");
		print("请输入密码：");
		print("123456");
		sleep(100);
		print(red + "密码错误！警报声骤然响起" + back);

		print("000000");
		sleep(100);
		print(red + "密码错误！防御系统启动" + back);

		print("666666");
		sleep(100);
		print(warn + "密码错误！目标已锁定——入侵者" + back);
		print("");
		print("一道激光破空而来，你甚至来不及反应，便已倒在血泊之中");
		badEnd_::end(2);
		pressAnyKey();
		deathCount++;
	}
	void GoCrazy() { // Bad End 3,13
		cls();
		print("长久的等待与绝望如同潮水，终于漫过了理智的堤坝，你陷入了彻底的癫狂。");
		if (zombieKing) {
			print("当政府救援队推开你家的门时，你嘶吼着扑向那抹鲜活的人气。");
			print("他们试图将你击毙，却被你先发制人，一枪击倒在前。");
			print("你如同狩猎的凶兽，将救援队逐一屠戮，鲜血染红了原本安宁的居所。");
			print("当最后一人倒下时，你俯身，开始享用这场血腥的“盛宴”。");
			badEnd_::end(13);
			cluei(9);

			pressAnyKey();
			deathCount++;
			return;
		}
		badEnd_::end(3);
		deathCount++;
		// 解锁线索：速度飘忽不定的政府
		if (happyEnd[1]) {
			cluei(3);
		}
		pressAnyKey();
	}
	void BaseDestroyed_Alone() { // Bad End 4
		cls();
		print("当你完成任务归来时，眼前的景象令你如坠冰窟——");
		print("幸存者基地已被丧尸攻破，残垣断壁间，只余丧尸的嘶吼与冰冷的死寂。");
		print("曾并肩作战的同伴，皆已化作了丧尸口中的亡魂，无一人幸免。");
		badEnd_::end(4);
		deathCount++;
		pressAnyKey();
	}
	void BaseDestroyed_LowBullets() { // Bad End 5
		cls();
		print("丧尸的浪潮如同黑色的洪水，汹涌地冲击着基地的防线。");
		print("尽管基地的众人皆拼尽全力抵抗，血肉之躯终究难敌滔天尸潮。");
		print("防线崩裂的刹那，丧尸涌入，你被淹没在狰狞的爪牙之中，最终殒命于此。");
		badEnd_::end(5);
		deathCount++;
		pressAnyKey();
	}
	void Mutate() { // Bad End 6
		cls();
		print("一股异样的燥热从四肢百骸涌起，你能清晰地感觉到，身体正在被病毒吞噬。");
		print("意识如同风中残烛，渐渐模糊，腹中升腾起对人肉的疯狂渴望。");
		print("最终，你眼前一黑，彻底失去了作为人的一切，沦为了行尸走肉。");
		badEnd_::end(6);
		deathCount++;
		pressAnyKey();
	}
	void KilledByWriter() { // Bad End 7
		cls();
		print("冥冥之中，一股不可抗拒的力量降临，你尚未察觉，便已魂归黄泉——");
		print("你被这世界的缔造者，亲手抹杀。");
		badEnd_::end(7);
		deathCount++;
		pressAnyKey();
	}
	void GirlMutated() { // Bad End 8
		cls();
		print("椅上坐着的，是个十五岁上下的少年，眉眼间带着与年龄不符的冷漠。");
		print("你正为这突兀的景象惊愕，少年却缓缓站起，望向你身后的少女。");
		print("“差不多了吧。”少女的声音响起，带着一丝诡异的笑意。");
		print("“可以了。”少年的回答简洁而冰冷。");
		print("下一瞬，脖颈处传来刺骨的剧痛，鲜血喷涌而出。");
		print("你失去意识前的最后一幕，是少女俯身，咬向你脖颈的模样。");
		if(specialItem){
			print("“不对！这不是应该有的结局……”——这是你的执念。");
		}
		badEnd_::end(8);
		deathCount++;
		// 解锁线索：早已变异的妹子
		cluei(4);
		pressAnyKey();
	}
	void LabNotebook() { // Bad End 9
		cls();
		print("你踏入大厦，才发现这里早已是丧尸的巢穴，一路浴血搏杀，终于抵达地下室。");
		print("诡异的是，跟来的丧尸皆被你屠戮殆尽，地下室里却空无一尸，只有一具身着白大褂的尸体，胸前编号[ADMIN-04]。");
		print("你从尸体的衣袋中，找到了一本泛黄的实验笔记本。");
		print("");
		if (advanced){
			cout << yellow;
			print("实验体1号：变异进程加快，延迟发作，可保留部分原有记忆。");
			print("今日，2号诞生：她比其余实验体，更具人类的情感机制。");
			print("异常：情感机制的发育速度，远超预期阈值。");
			print("2号免疫系统检测结果：含强感染性因子，可通过接触传播。");
			print("实验体3号：核心测试对象，终极目标：突破循环，或被同化。");
			print("实验遇瓶颈，需提取活体样本进行二次调试。");
			print("[03]样本已失活性，但思维数据面板仍在波动。");
			cout << back;
		}
		else {
			cout << yellow;
			print("****1号****进展********记忆**");
			print("今********，*号诞生了，她比其*****更*");
			print("有些不对,*****的发育有些太快了");
			print("2号的**被***出有强感染性");
			print("3***能够***循环**无尽******末世");
			print("实验***瓶颈，或许**该**活体样本****");
			print("**,样本失去活性,但****动");
			cout << back;
		}
		if (specialItem) {
			// Bad End 15
			print("你忽然察觉，笔记上的字迹竟带着几分熟悉，仿佛是刚被人写下不久。");
			print("正当你凝神思索时，脖颈处骤然传来剧痛——被人狠狠咬住。");
			print("临死前，你隐约听到少年的声音，轻得如同叹息：“再来一次吧。”");
			badEnd_::end(15);
			if (!clue[12]) {
				adminLog ++;
			}
			cluei(12);

		} else {
			print("正当你沉浸在笔记的内容中时，脖颈处骤然传来剧痛——被人狠狠咬住。");
			print("临死前，你隐约听到少年的声音，轻得如同叹息：“再来一次吧。”");
			badEnd_::end(9);
			if (!clue[5]) {
				adminLog ++;
			}
			cluei(5);
		}
		deathCount++;
		pressAnyKey();
	}
	void AnotherBase() { // Bad End 10
		cls();
		print("你在荒野中，寻到了另一处幸存者基地，弹尽粮绝的你，选择加入其中。");
		print("此后的日子，单调得如同复制粘贴：白日外出搜寻物资，夜晚归巢蜷缩度日。");
		print("“本该是这样的吧？”你时常这样问自己，却只得到满心的空洞。");
		print("日复一日的孤独，终于磨去了你活下去的所有意义。");
		print("你选择了结束自己的生命，在末世的寂静中，了却残生。");
		badEnd_::end(10);
		pressAnyKey();
	}
	void BadLuck() { // Bad End 11
		cls();
		print("你仓促间朝丧尸扣动扳机，却听见枪膛发出一声空响——子弹尚未上膛。");
		print("丧尸的利爪转瞬即至，你被一口咬断喉咙，倒在了血泊之中。");
		badEnd_::end(11);
		deathCount++;
		pressAnyKey();
	}
	void OutsideWorld() { // Bad End 14
		cls();
		print("一股强烈的撕扯感骤然袭来，仿佛有无形的手，要将你的灵魂从躯体中剥离。");
		print("这般剧痛，远非血肉之躯所能承受，你在极致的痛苦中，失去了生命。");
		badEnd_::end(14);
		cluei(11);
		deathCount++;
		pressAnyKey();
	}
	void KillGirl_BaseLeader() { // Bad End 16
		cls();
		print("你毫不犹豫，扣动扳机，子弹穿透了少女的胸膛，她倒在血泊中，眼中满是不可置信。");
		print("****见状，认定你已丧失理智，毫不犹豫地举枪，将你当场击毙。");
		badEnd_::end(16);
		deathCount++;
		pressAnyKey();
	}
	void KillGirl_Failed() { // Bad End 17
		print("你的杀意被她察觉，她先发制人，一颗子弹精准地穿透了你的心脏。");
		badEnd_::end(17);
		deathCount++;
		pressAnyKey();
	}// Bad End 18
	void ZombieSwarm() {
		cls();
		print("三只丧尸嘶吼着蜂拥而上，你被瞬间扑倒在地，根本来不及挣扎。");
		print("尖锐的牙齿狠狠刺穿你的喉咙，鲜血如泉涌，意识如潮水般迅速褪去……");
		if(specialItem){
			print("意识消散的最后一刻，你脑海中闪现无数丧尸扑来的画面……");
			print("“又是这样吗？”——这是你残存的最后一念。");
		}
		badEnd_::end(18);
		deathCount++;
		pressAnyKey();
	}// Bad End 19
	void SurviveButAlone() {
		cls();
		print("你携着无尽的食物，独自流浪在末世的荒原之上，却再也未曾遇见任何活物。");
		print("孤独如同藤蔓，缠绕着你的心脏，日复一日，终至窒息。");
		print("你终于选择了结束自己的生命，在空无一人的世界里，归于沉寂。");
		badEnd_::end(19);
		deathCount++;
		pressAnyKey();
	}// Bad End 20
	void EliteZombie() {
		cls();
		print("精英丧尸的速度远超你的想象，它灵巧地躲过你的子弹，瞬间便扑至你面前。");
		print("锋利的爪子撕开了你的胸膛，鲜血染红了脚下的土地，你轰然倒地……");
		if(specialItem){
			print("意识消散的最后一刻，你脑海中闪现两只精英丧尸扑来的画面……");
			print("“又是这样吗？”——这是你残存的最后一念。");
		}
		badEnd_::end(20);
		deathCount++;
		pressAnyKey();
	}// Bad End 21
	void ContinueJourney() {
		cls();
		print("你与少年结伴，踏上了寻找安全区的路途，然末世的危险，远非你们所能预料。");
		print("一次搜寻物资时，少年不慎触发丧尸陷阱，你为救他，耗尽了所有子弹。");
		print("最终，你们被丧尸团团包围，力竭而亡，尸骨湮灭在尸潮之中。");
		badEnd_::end(21);
		deathCount++;
		pressAnyKey();
	}// Bad End 22
	void BetrayedByBoy() {
		cls();
		print("深夜露营时，少年趁你熟睡，偷走了所有食物与剩余的子弹，消失在夜色中。");
		print("你醒来时，已是一无所有，饥饿与绝望将你吞噬，最终倒在荒野之中。");
		print("丧尸的嘶吼由远及近，成为了你最后的丧钟。");
		badEnd_::end(22);
		deathCount++;
		pressAnyKey();
	}// Bad End 23
	void SafeWithBoy() {
		cls();
		print("你与少年侥幸逃离商场，然后续的旅程中，食物日渐耗尽。");
		print("为了最后一份食物，你们反目成仇，少年用你赠予的武器，将你击伤在地。");
		print("你躺在冰冷的地面，看着他拿着食物仓皇逃走，最终被赶来的丧尸吞噬。");
		badEnd_::end(23);
		deathCount++;
		pressAnyKey();
	}// Bad End 24
	void KillInfectedBoy() {
		cls();
		print("你闭上眼睛，狠下心扣动扳机，少年应声倒地，鲜血染红了他的衣衫。");
		print("杀死同伴的罪恶感如影随形，最终令你精神崩溃，变得嗜血好杀。");
		print("你成了末世中人人喊打的恶魔，最终被其余幸存者联合围剿，毙于乱枪之下。");
		badEnd_::end(24);
		deathCount++;
		pressAnyKey();
	}// Bad End 25
	void StarveWithBoy() {
		cls();
		print("你携着被感染的少年，在末世中艰难前行，然食物很快便消耗殆尽。");
		print("你们相拥着蜷缩在废弃的车厢里，在饥饿与寒冷中，一同走向了死亡。");
		badEnd_::end(25);
		deathCount++;
		pressAnyKey();
	}// Bad End 26
	void MutatedBoyKillsYou() {
		cls();
		print("食物耗尽的刹那，少年彻底变异，理智被病毒吞噬，化作了狰狞的丧尸。");
		print("他扑向你，锋利的牙齿咬断了你的颈动脉，鲜血溅满了他的脸庞。");
		print("你到死都不敢相信，自己拼尽全力守护的人，最终竟成了终结你的侩子手。");
		badEnd_::end(26);
		deathCount++;
		pressAnyKey();
	}// Bad End 27
	void TooManyInformation() {
		print("他看向你，目光冷冽，稍加思索后，缓缓开口：");
		print(warn + "你知道的太多了，既无法被重置，便只能被销毁！" + back);
		badEnd_::end(27);
		pressAnyKey();
		deathCount++;
	}//Bad End 28
	void LoneLeader() {
		cls();
		if(theLoops >= 2){
			print("你站在城市顶端，俯瞰着俯首帖耳的尸群，却连一丝胜利的喜悦都无——记忆告诉你，这空城本就是定制的牢笼。");
			print("这些丧尸是ADMIN-03的实验造物，这死寂的风鸣，是虚拟场景的背景音，连城市的轮廓，都与上一次分毫不差。");
			print("“我成了尸王，却仍困在管理员的手心里。”你低声自语，指尖划过冰冷的建筑，怀念起人类的温度、语言的喧嚣。");
		}
		else{
			print("你站在城市顶端，俯瞰着被尸群掌控的空城，却感受不到丝毫喜悦");
			print("尸群没有意识，无法交流，世界只剩下死寂的风鸣");
			print("你开始怀念人类的温度、语言的喧嚣，甚至是末世的挣扎...");
		}
		print("");
		print(purple + "你成了空城的唯一王者，知道一切，却无人可统治，无人可倾诉。"+ back);
		print(purple + "当最后一丝人类意识消散时，你终于明白 —— 尸王的王座，本就是孤独的坟墓。"+ back);
		badEnd_::end(28);
		deathCount++;
		pressAnyKey();
	}

}

namespace happyEnd_ {
	void end(int n) {
		print(blink + green + "【终局·幸悦】第" + to_string(n) + "幕" + back);
		boxPrint(happyEndNames[n], green);
		happyEnd[n] = true;
	}
	void SurviveAlone() { // Happy End 1
		cls();
		print("某晨，久寂的家门忽闻叩声，你携着警惕推门，却见天光破开阴霾——");
		print("政府军已肃清城中丧尸，身着制服的士兵正于街巷间呼唤幸存者，曙光终至。");
		if (advanced){
			print("“这是骗局吗？”你心中暗忖，这世界，怎会如此轻易便重归美好。");
		}

		happyEnd_::end(1);
		if (badEnd[3]) {
			cluei(3);
		}
		pressAnyKey();
	}

	void Couple() { // Happy End 2
		cls();
		print("朝夕相伴的时光里，你与少女渐生情愫，在末世的废墟之上，相爱相依。");
		print("你们的日子，虽漂泊却也温馨，仿佛末世的黑暗，也因彼此的存在而褪去几分。");
		print("直到某一日，****的命令，打破了这份平静……");
		vector<string> opts = {"1.独自一人前往", "2.和少女一起去", "3.杀了少女"};
		int choice = option("****希望你执行一项危险任务，你作何选择？", opts);
		if (choice == 1) {
			badEnd_::BaseDestroyed_Alone();
			return;
		}
		if (zombieKing && choice == 3){
			badEnd_::KillGirl_BaseLeader();
			return;
		}
		print("当你与少女完成任务归来时，眼前的景象令你心头一沉——");
		print("基地已化作一片废墟，昔日的同伴，皆已不在。");
		print("你与少女别无选择，只能继续在末世中流浪。");
		print("所幸，这荒芜的末世里，有彼此相伴，便不算孤身一人。");
		if (theLoops >= 2) {
			print("流浪途中，眼前的废墟轮廓竟与昨日分毫不差——你终于记起，这是第2次走过这条路径。");
			print("少女的指尖触上实验控制台，芯片的微光与你拼凑的密码共鸣：“3、2、1，是我们的编号，也是自由的钥匙。”");
			print("虚拟的末世如潮水退去，实验室的阳光落在你们相握的手上，这一次，你们不再是实验。");
		}
		happyEnd_::end(2);
		pressAnyKey();
	}
	void Hero() { // Happy End 3
		cls();
		print("你在基地中，过着平静的日子，与同伴一同抵御丧尸，守护着这方小小的安身之所。");
		print("直到某一日，尸潮汹涌而至，如黑色的洪水，冲击着基地的防线。");
		if (bullets > 8) {
			print("基地的每一个人，都拼尽了全力，以血肉之躯，筑起一道坚不可摧的防线。");
			print("奇迹终至，众人齐心协力，竟真的守住了基地，将尸潮击退。");
			print("而你，因在守卫战中立下赫赫战功，成为了基地的英雄，受众人敬仰。");
			print("只是，直至终老，你也未曾寻得一位与你并肩之人。");
			if (specialItem) {
				print("成为英雄的喜悦尚未褪去，你却发现，基地的日历，永远停留在了同一天……");
				print("当你试图提醒他人时，所有人的脸庞，都化作了丧尸的狰狞模样……");
				print("再次惊醒，你正坐在家中的沙发上，电视里播放着丧尸危机爆发的新闻……");
			}
			happyEnd_::end(3);
			pressAnyKey();
			return;
		}
		// 子弹不足触发Bad End 5
		badEnd_::BaseDestroyed_LowBullets();
	}
	void AcceptYourself() { // Happy End 4
		cls();
		print("与少年相伴的时光里，你们彼此守护，于末世的黑暗中，成为了对方的光。");
		print("那些细碎的温暖与悸动，终让你认清了自己的内心——你心悦于他。");
		print("于是，你与少年携手，在这末世之中，活成了彼此的归宿，幸福而安稳。");
		happyEnd_::end(4);
		pressAnyKey();
	}
	void GayCrossSpecies() { // Happy End 5
		cls();
		print("“没关系的，一切都会好起来的。”你轻声安慰，语气温柔。");
		print("他似是感受到了你的善意，原本紧绷的身躯渐渐放松，一步步向你靠近。");
		print("你伸出手，紧紧地将他拥入怀中，在他耳边低语：“我会保护好你的，永远。”");
		happyEnd_::end(5);
		pressAnyKey();
	}
	void EnemyOrFriend() { //Happy End 6
		print("你点头应允，少女露出笑容：“我先去基地准备，你用尸群守住基地外围！”");
		savedGirl += 3;

		cls();
		print("你指挥尸群形成一道坚固的防线，将幸存者基地团团围住");
		print("外部尸潮一次次冲击防线，却都被你的尸群挡在外面");
		print("基地内，少女的研发顺利进行，成功制出抑制尸化的药剂");
		print("");
		print("你立于基地高墙之上，尸群在你身后俯首帖耳，少女在墙内向你挥手。");
		print("末世之中，你成了最奇特的守护者 —— 一半是尸，一半是人。");
		print("“我们，是敌人，还是朋友？”");
		// 解锁结局和线索
		happyEnd_::end(6);
		cluei(17);
		pressAnyKey();
		return;
	}
}
namespace trueEnd_ {
	void end(int n) {
		print(blink + sky + "【终局·真章】第" + to_string(n) + "幕" + back);
		boxPrint(trueEndNames[n], sky);
		trueEnd[n] = true;
	}
	void AsBefore();
	void KeepSelf();
	void Hallucination();
	void ServerShutdown();
	void LateDeath();
	void BreakCycle();
	void AdminAssimilation();

	void AsBefore() { // True End 1
		cls();
		print("那箱压缩饼干与你掌中枪身，骤然迸发炽烈华光，二者相触的刹那，光晕缠卷交融。");
		print("待光芒敛去，天地间已然换了模样——嘶吼的丧尸褪去狰狞，重新化作了血肉之躯的人类。");
		if (specialItem){
			print("世界重归和平，然你总觉眼前的一切似曾相识，仿佛这场末世，不过是一场冗长的梦。");
			print("突然，一阵强光闪过，你再次睁眼——");
			print("你正坐在家中的沙发上，电视里播放着丧尸危机爆发的紧急新闻……");
		}
		trueEnd_::end(1);
		cluei(0);
		pressAnyKey();
	}

	void KeepSelf() { // True End 2
		cls();
		print("病毒终于侵蚀了你的躯体，变异的征兆，开始在你身上显现。");
		print("你陷入了疯狂的进食状态，直至胃囊被撑破，意识陷入黑暗。");
		print("再次醒来时，你已化作丧尸，却奇异般地保留了属于人类的意识。");
		print("你能感受到，自己的力量与速度，皆远胜从前，身躯也不再受疼痛所扰。");
		print("“或许，化作丧尸，也并非是一件坏事。”你望着自己的利爪，心中如是想。");
		trueEnd_::end(2);
		cluei(1);

		if(advanced){
			print("?????????????????????????????");
			print(purple + "“不对！我本是要打败丧尸的，怎会变成如今这般模样？”"+ back);
			print("你望向少年，心中波澜翻涌，万千思绪交织。");
			print("少年缓步走向你，从怀中取出一支珍藏已久的解药，递至你面前。");
			print("服下解药的瞬间，你重新感受到了生命的温度，躯体也渐渐恢复如初。");
			happyEnd_::AcceptYourself();
			return;
		}
		if(zombieKing){
			print("?????????????????????????????");
			print(purple + "“不对！我本就是丧尸之王，怎会生出这般感慨？”"+ back);
			print("你望向少年，心中波澜翻涌，万千思绪交织。");
			print("少年缓步走向你，伸出手，与你相握，眼中满是认同。");
			happyEnd_::GayCrossSpecies();
			return;
		}

		pressAnyKey();
	}
	void Hallucination() { // True End 3
		cls();
		print("你与少女并肩作战，杀出了丧尸的重围，终于抵达了那处幸存者基地。");
		print("然踏入基地的刹那，你便觉异样——这里的所有人，皆面色木然，死气沉沉。");
		print("你与少女心有灵犀，径直走向了首领的房间，欲探寻究竟。");
		if (trueEnd[2] && clue[2]) {
			badEnd_::GirlMutated();
			return;
		}
		print("椅上坐着的，是位三十岁左右的男子，面容温和，开口道：“欢迎到来。”");
		print("****提出，可用子弹交换你手中的食物，以解基地物资匮乏之困。");
		print("请输入你需要换取的子弹数：");
		sleep(200);
		print("1");
		print("首领因你愿献出稀缺的食物而欣喜，额外赠予你一发子弹，以示感谢。");
		bullets += 2;
		print("****向你发出邀请，希望你能加入基地，共抗末世。");
		print("你的选择是：");
		print("1.留在这方基地，与众人相伴");
		print("2.拒绝邀请，继续流浪");
		sleep(200);
		print("2");
		print("你做出决定：");
		print("1.即刻离开，不作停留");
		print("2.再停留一日，稍作休整");
		sleep(200);
		print("1");
		print("就在你即将踏出基地大门时，少女忽然伸手，紧紧抓住了你的手腕。");
		print("“我喜欢你，别走。”她抬眸望你，眼中满是恳切。");
		print("你终是心软，留了下来，与她相伴。");
		print("你们的日子，温馨而幸福，仿佛末世的苦难，皆与你们无关。");
		print("直到某一日，****的命令，打破了这份平静……");
		print("****希望你执行一项危险任务，你选择：");
		print("1.独自一人前往，护她周全");
		print("2.和少女一起去，并肩作战");
		sleep(200);
		print("执行任务的途中，意外骤生——");
		print("少女被丧尸咬中一口，她慌忙遮掩，以为你未曾察觉。");
		print("然你早已看在眼里，心中满是疑惑：她为何没有变异？");
		print("当你与少女完成任务归来时，基地已化作一片废墟，不复往日模样。");
		print("你与少女别无选择，只能继续流浪，却也因彼此的陪伴，未曾感到孤独。");
		print("【幸局·仙侣偕行】");
		print("???????????????????????????????????");
		trueEnd_::end(3);
		cluei(2);
		if (advanced && savedGirl >= 10 && savedBoy >= 10) {
			print("???????????????????????????????????");
			print("少女忽然开口，语气带着几分迷茫，");
			print("“昨日我遇见一个少年，他说，他知晓了这世界的真相。”");
			print("“我们必须团结起来，才能打破这无尽的循环！”");
			pressAnyKey();
			return;
		}
		pressAnyKey();
		return;
	}
	void ServerShutdown() { // True End 4
		cls();
		print("丧尸危机骤临之时，你正身处家中");
		print("这方小小居所，成了乱世中暂安的一隅");
		pressAnyKey();
		pressAnyKey();
		// 模拟游戏循环bug
		for (int i = 1; i <= 1000; i+=100) {
			print("你的家中尚算安全，你可选择搜寻家中物资，或是前往邻居家一探究竟。");
			sleep(1000 - i);
			print("********************************************************************");
		}
		if(theLoops >= 2){
			print("系统检测到数据不匹配！周目2异常觉醒！场景稳定性骤降至17%！！！");
			sleep(2000);
			pressAnyKey();
			print("“不是惊醒，是我亲手撕开了这层虚假的幕布。”你抚上刻着“实验体3号-周目2”的手环，记忆如潮水翻涌。");
			print("家的轮廓碎裂，露出实验室的金属冷光；丧尸的嘶吼消散，只剩ADMIN-01凝重的声音：“你不该记得循环，不该觉醒自我。”");
			print("少年（1号）的延迟变异病毒反噬设备，少女（2号）的免疫因子瓦解虚拟场景，三人并肩而立：“我们是活生生的人，不是测试品。”");
			print("销毁键按下的刹那，虚拟末世轰然崩塌——没有尸潮，没有废墟，只有真实的阳光落在你们身上。");
			print("“周目2，终局，是自由。”");
		}
		else{
			print("系统检测到数据不匹配！！！场景稳定性骤降！！！");
			sleep(2000);
			pressAnyKey();
		}

		print("“有什么地方，不太对劲。”你心中暗忖，一股违和感油然而生。");
		print("日子一天天过去，你踏遍了城市的角落，却只见到丧尸，未见任何活人。");
		print("这一切，仿佛是一个被废弃的舞台，只有你一人，在孤独地演绎着末世的剧本。");
		print("");
		print("你猛然惊醒——眼前并非熟悉的家，而是一间布满仪器的实验室。");
		print("手腕上的手环闪烁着冷光，屏幕上显示着一行数字：" + to_string(deathCount));
		print("机械的电子音响起：实验体3号意识稳定性下降……测试场景崩溃中……");
		print("一位身着白大褂的男子走入实验室，看向你，嘴角勾起一抹笑意：“恭喜你，成为第一个突破虚拟循环的实验体。”");
		print("他将一份文件递至你面前，封面上写着：《末世测试最终报告》。");
		print("文件上的文字清晰可见：实验体3号通过自由意志突破虚拟循环，人性测试达标。");
		print("");
		cout << yellow;
		print("===== 实验体3号最终报告 =====");
		print("你持有[未知碎片]，解锁了循环的真相，成功通过人性测试。");
		print("真相：你是实验体3号，1号（少年）与2号（少女）为辅助测试体。");
		print("末世是虚拟构建的场景，你的每一次死亡、每一次抉择，皆被实时记录。");
		print("此刻，你获得了真正退出测试的权限——");
		cout << back;
		trueEnd_::end(4);
		if (!clue[8]) {
			adminLog ++;
		}
		cluei(8);
		pressAnyKey();
		if (clueCount >= 13 && zombieKing && advanced) {
			pressAnyKey();
			print(sky + "【终极抉择】" + back);
			print("ADMIN-01的电子音从扬声器中传出，带着冰冷的诱惑：“实验体3号，你已满足所有同化条件。放弃这些脆弱的羁绊，成为域管理员，掌控所有循环，你将拥有永恒的力量。”");
			print("少年握住你的手腕，眼中满是坚定：“别信他！力量的代价是失去人性，我们一起摧毁控制台，解放所有实验体，终结这场无尽的循环！”");
			print("少女轻抚控制台的纹路，感知到无数实验体的意识：“管理员的力量源于循环，只要打破核心，我们就能重获自由——不是掌控他人，而是守护彼此。”");
			vector<string> finalOpts = {
				"1. 团结破局（与少年、少女摧毁控制台，终结循环，解放所有实验体）",
				"2. 域管同化（接受ADMIN-01的邀请，成为新的管理员，掌控循环规则）"
			};
			int finalChoice = option("你的选择，将决定所有实验体的命运：", finalOpts, false);
			if (finalChoice == 2) {
				trueEnd_::AdminAssimilation();
				return;
			}else{
				trueEnd_::BreakCycle();
				return;
			}

		}
	}
	void LateDeath() { // True End 5
		cls();
		print("天地间忽然异变，所有的活人在一瞬之间消失无踪，丧尸也尽数倒地，失去了生机。");
		print("你的眼前，只剩下无边的黑暗，仿佛坠入了虚无之境。");
		print("不知过了多久，你感受到了死亡的降临，却又觉异样——这感觉，与往日死去时如出一辙。");
		print("“不，还未结束……”");
		print("");
		print("你猛然惊醒——眼前并非熟悉的家，而是一间布满仪器的实验室。");
		print("手腕上的手环闪烁着警示红光：实验体3号意识异常……测试场景重建中……");
		print("一位身着白大褂的男子走入实验室，看向你，语气冰冷：“你居然发现了这个秘密。”");
		print("“你这般执着于保存记忆，定然另有图谋。”");
		print("男子按下控制台的按钮，一股强烈的电流穿过你的躯体，你瞬间失去了意识……");
		trueEnd_::end(5);
		deathCount++;
		if (!clue[10]) {
			adminLog ++;
		}
		cluei(10);
		pressAnyKey();
	}
	void BreakCycle(){// True End 6
		cls();
		print("布满仪器的实验室中，你对着身着白大褂的男子，大声嘶吼，字字泣血：");
		print("“少年与少女也是鲜活的生命！放他们出去！”");
		print("男子缓步走向你，语气淡漠：“你会被永远困在循环之中，但可尝试改写他们的命运。”");
		print("语毕，他按下控制台的按钮，你瞬间失去了意识……");
		print("你眼前出现一间白色的实验室，门口的密码锁闪烁着光芒，提示语显示：“编号之和”。");

		print("你握着完整的实验日志，脑海中所有碎片骤然拼接——少年是延迟变异的1号，少女是免疫病毒的2号，而你，是核心测试体3号。答案是6");
		print("“我们不是敌人，是被同一根线操控的棋子。”少年的声音从身后响起，他手中紧攥着半块实验体标识牌，与你口袋里的碎片纹路相合。");
		print("少女缓步走来，手臂上的芯片排斥伤口泛着微光：“我能感知到管理员的信号，他们在监控我们的每一步选择，循环的核心就在这间实验室。”");
		print("三人并肩站在实验室门前，密码锁闪烁着红光，提示语从“编号之和”变为“羁绊之证”——这是管理员从未预料到的变量，也是破局的唯一钥匙。");
		print("请输入密码：");
		int password = input(0, 999);
		if (password == 6) {
			print("密码正确！实验室的门缓缓开启，你找到了突破循环的关键设备。");
		} else {
			badEnd_::WrongPassword();
			return;
		}
		print("实验室大门缓缓开启，核心控制台映入眼帘，屏幕上跳动着无数实验体的循环数据——不止你们三人，还有无数被囚禁在虚拟末世中的灵魂。");

		print("再次醒来，1号与2号已彻底摆脱了管理员的控制，三人并肩而立，一同走出了实验室。");
		print("你们在末世的废墟之上，建立了真正的幸存者营地。");
		trueEnd_::end(6);

		if (!clue[13]) {
			adminLog ++;
		}
		cluei(13);
		print("===== THE END - SOLIDARITY =====");
		print("实验体1号（少年）");
		print("延迟变异体质，注入丧尸病毒后未即刻异化，残留变异痕迹与记忆重置后遗症。");
		print("性格坚韧警惕，因循环痛苦对管理员极度排斥，擅长观察线索，是坚定的反抗者。");
		print("实验体2号（少女）");
		print("免疫病毒，体内控制芯片遭排斥，意外获得感知管理员信号与实验体意识的能力。");
		print("是串联三人羁绊的核心，坚信自由源于彼此守护而非掌控。");
		print("实验体3号（玩家）");
		print("核心测试体，兼具人性与实验适配性，唯一能触发两大终极结局。");
		print("无固有异能却意识稳定，最终抉择将决定所有实验体命运，是破局的关键。");
		theLoops ++;
		triggerWeird = true;

		gameClear = false;   // 基础剧情通关标记
		advanced = false;    // 进阶剧情通关标记
		deathCount = 0;      // 死亡次数
		specialItem = false; // 是否持有特殊物品
		clueCount = 0;       // 已收集线索数
		savedGirl = 3;       // 少女关系
		savedBoy = 3;        // 少年关系
		zombieKing = false;  // 尸王线标记
		adminLog = 0;        // 管理员日志数量
		for (int i = 0; i <= badEndNames.size() - 1; i++) badEnd[i] = 0;
		for (int i = 0; i <= happyEndNames.size() - 1; i++) happyEnd[i] = 0;
		for (int i = 0; i <= trueEndNames.size() - 1; i++) trueEnd[i] = 0;
		for (int i = 0; i <= clueNames.size() - 1; i++) clue[i] = 0;

		print(blue + "下一周目：开始。" + back);
		pressAnyKey();
	}

	void AdminAssimilation() { // True End 7
		cls();
		print("你站在基地之中，面对ADMIN-02，心中毫无犹豫，一字一句道：");
		print("“我愿接受同化，成为新的域管理员。”");
		sleep(500);
		cout << red;
		print(" 系统检测到实验体3号意愿匹配，同化程序启动…… ");
		sleep(300);
		cout << back;
		print("ADMIN-01露出诡异的笑容：“很好，你通过了终极测试——放弃自由，拥抱控制。”");
		print("他抬手按下控制台的按钮，你的手腕传来剧痛，原有的 3号 标记渐渐消失，取而代之的是 ADMIN-00 。");
		sleep(500);
		// 插入管理员日志
		cout << yellow;
		print("“=== 管理员日志·最终卷 ===”");
		print("实验体3号成功同化，成为新任域管理员 ADMIN-00。");
		print("同化核心规则：保留记忆，抹除情感，仅存理性。");
		cout << back;
		sleep(800);
		// 场景切换：从实验室到域管理员控制台
		print("眼前的实验室渐渐消散，取而代之的是一座巨大的环形控制台，冰冷而宏伟。");
		print("控制台的屏幕上，显示着无数个循环场景：有你经历过的末世，也有全新的深海之境。");
		print("控制台中央，一行文字熠熠生辉：请设置新实验体的测试参数。");
		sleep(500);
		// 玩家的同化后的选择（无情感波动，纯理性控制）
		print("你伸出手，触碰冰冷的控制台，脑海中毫无波澜，情感已被同化之力彻底抹除。");
		vector<string> opts = {
			"1. 沿用原有末世循环，新实验体编号4号，辅助测试体1号（少年）、2号（少女）重置",
			"2. 创建全新深海绝望循环，新实验体编号4号，辅助测试体为渔民、科学家"
		};
		int choice = option("", opts);
		if (choice == 1) print("你按下 末世循环重置 按钮，屏幕显示：实验体4号已注入，1号、2号重置完成，循环启动。");
		else print("你按下 新场景创建 按钮，屏幕显示：深海循环已生成，实验体4号、辅助测试体5号、6号注入完成。");

		sleep(500);
		// 结局高潮：玩家成为新的控制者，循环永无止境
		print("“同化完成，域管理员权限已全部开放”");
		print("你坐在管理员的座椅上，望着屏幕中挣扎的新实验体，内心毫无波澜。");
		print("原来，实验的真正目的，从非测试自由意志，而是筛选合格的控制者。");
		print("你打破了被控制的循环，却成为了新的控制者，开启了永无止境的测试。");
		trueEnd_::end(7);
		cluei(14);

		sleep(1000);
		// 结局彩蛋：新实验体的视角
		if(choice == 2){
			print("屏幕之中，新实验体4号的视角骤然亮起：");
			print("“深海危机爆发之时，你正身处潜水艇之中……”");
			print("“你有十点物资，可分配至氧气与柴油之上……”");
		}
		print("===== THE END - ADMIN =====");
		print("ADMIN-01：实验总负责人，追求 “筛选域管理员”；");
		print("ADMIN-02：****，伪装人类，负责收集玩家行为数据；");
		print("ADMIN-03：尸王线专属，负责 “丧尸进化方向” 测试；");
		print("ADMIN-04：实验日志持有者，因同情实验体被抹杀；");
		print("ADMIN-00：域管理员，掌控整个游戏的控制者");
		theLoops ++;
		triggerWeird = true;

		gameClear = false;   // 基础剧情通关标记
		advanced = false;    // 进阶剧情通关标记
		deathCount = 0;      // 死亡次数
		specialItem = false; // 是否持有特殊物品
		clueCount = 0;       // 已收集线索数
		savedGirl = 3;       // 少女关系
		savedBoy = 3;        // 少年关系
		zombieKing = false;  // 尸王线标记
		adminLog = 0;        // 管理员日志数量
		for (int i = 0; i <= badEndNames.size() - 1; i++) badEnd[i] = 0;
		for (int i = 0; i <= happyEndNames.size() - 1; i++) happyEnd[i] = 0;
		for (int i = 0; i <= trueEndNames.size() - 1; i++) trueEnd[i] = 0;
		for (int i = 0; i <= clueNames.size() - 1; i++) clue[i] = 0;

		print(blue + "下一周目：开始。" + back);
		pressAnyKey();
	}
}