bind_menu.cpp
No OneTemporary
Actions

Authored By

Unknown

Size

8 KB

Referenced Files

None

Subscribers

None

bind_menu.cpp
View Options

	#include "binds.h"
	#include "main/references.h"
	#include "main/initialization.h"
	#include "main/tick.h"
	#include "network/network_manager.h"
	#include "processing.h"
	#include "main/save_load.h"
	#include "main/logging.h"
	#include "util/save_file.h"
	#include "files.h"
	#include "../../as_addons/include/scriptarray.h"

	extern bool watch_resources;
	bool queuedModSwitch = false;
	std::vector<std::string> modSetup;

	void startNewGame(net::Message& msg) {
	if(game_running)
	destroyGame();
	setGameSettings(msg);
	game_state = GS_Game;
	}

	void startNewGame() {
	if(game_running)
	destroyGame();
	clearGameSettings();
	game_state = GS_Game;
	}

	void stopGame() {
	if(!game_running)
	return;
	destroyGame();
	clearGameSettings();
	game_state = GS_Menu;
	}

	namespace scripts {

	static void switchToMods(CScriptArray* arr) {
	if(!arr)
	return;
	if(game_running)
	stopGame();
	modSetup.clear();
	for(unsigned i = 0, cnt = arr->GetSize(); i < cnt; ++i)
	modSetup.push_back((std::string)arr->At(i));
	queuedModSwitch = true;
	devices.network->disconnect();
	}

	static void quickstartGame() {
	if(game_running)
	destroyGame();
	clearGameSettings();
	game_state = GS_Game;
	}

	static void toMenu() {
	game_state = GS_Menu;
	}

	static void toGame() {
	game_state = GS_Game;
	}

	static void quitGame() {
	game_state = GS_Quit;
	}

	static void preRenderClient() {
	if(devices.scripts.client && game_running)
	devices.scripts.client->preRender(realFrameLen);
	}

	static void renderClient() {
	if(devices.scripts.client && game_running)
	devices.scripts.client->render(realFrameLen);
	}

	bool scr_saveGame(const std::string& fname) {
	if(!game_running) {
	scripts::throwException("No game to save.");
	return false;
	}
	if(devices.network->isClient) {
	scripts::throwException("Cannot save game from multiplayer clients.");
	return false;
	}
	if(!isAccessible(fname)) {
	scripts::throwException("Cannot access file outside game or profile directories.");
	return false;
	}

	processing::pause();
	bool success = saveGame(fname);
	processing::resume();
	return success;
	}

	void scr_loadGame(const std::string& fname) {
	loadSaveName = fname;
	game_state = GS_Load_Prep;
	}

	struct ThreadedImageData {
	Image img;
	std::string filename;

	ThreadedImageData(const std::string& fname) : filename(fname) {}
	};

	static threads::threadreturn threadcall SaveImage(void* arg) {
	ThreadedImageData& data = (ThreadedImageData)arg;

	try {
	if(!saveImage(&data.img, data.filename.c_str(), true))
	throw 0;
	}
	catch(...) {
	error("Could not write image");
	}

	delete &data;
	return 0;
	}

	static void saveWorldScreen(const std::string& fname) {
	auto* data = new ThreadedImageData(fname);
	getFrameRender(data->img);
	threads::createThread(SaveImage, data);
	}

	static unsigned saveVersion(const std::string& fname) {
	if(!isAccessible(fname)) {
	scripts::throwException("Cannot access file outside game or profile directories.");
	return (unsigned)-1;
	}
	SaveFileInfo info;
	getSaveFileInfo(fname, info);
	return info.version;
	}

	static bool saveInfo(const std::string& fname, SaveFileInfo& info) {
	if(!isAccessible(fname)) {
	scripts::throwException("Cannot access file outside game or profile directories.");
	return (unsigned)-1;
	}
	return getSaveFileInfo(fname, info);
	}

	static void makeSaveFileInfo(SaveFileInfo* dat) {
	new(dat) SaveFileInfo();
	}

	static void dtorSaveFileInfo(SaveFileInfo* dat) {
	dat->~SaveFileInfo();
	}

	static void copySaveFileInfo(SaveFileInfo* into, SaveFileInfo* from) {
	new(into) SaveFileInfo();
	into = from;
	}

	static mods::Mod* getTopMod() {
	if(devices.mods.activeMods.empty())
	return nullptr;
	return devices.mods.activeMods[devices.mods.activeMods.size()-1];
	}

	static const mods::Mod* getMod(unsigned index) {
	if(index < devices.mods.mods.size())
	return devices.mods.mods[index];
	else
	return nullptr;
	}

	static const mods::Mod* getMod_id(const std::string& name) {
	return devices.mods.getMod(name);
	}

	static unsigned getModCount() {
	return devices.mods.mods.size();
	}

	static void saveModState() {
	devices.mods.saveState();
	}

	static bool createNewMod(const std::string& ident) {
	if(!isIdentifier(ident, " ") \|\| ident.empty())
	return false;
	std::string dirname = path_join("mods", ident);
	std::string infoPath = path_join(dirname, "modinfo.txt");

	makeDirectory(dirname);
	std::ofstream file(infoPath);
	file << "Name: " << ident << "\n";
	file << "Compatibility: 200\n";
	file.close();

	devices.mods.registerMod(dirname, ident); //Nothing could possibly go wrong here
	return true;
	}

	void modConflicts(mods::Mod* mine, mods::Mod* other, CScriptArray* arr) {
	std::vector<std::string> conflicts;
	mine->getConflicts(other, conflicts);

	unsigned index = arr->GetSize();
	arr->Resize(index + conflicts.size());
	foreach(it, conflicts)
	(std::string)arr->At(index++) = *it;
	}

	static bool saveFileHasMods(SaveFileInfo* info) {
	for(size_t i = 0, cnt = info->mods.size(); i < cnt; ++i) {
	auto* mod = devices.mods.getMod(info->mods[i].id);
	if(mod)
	mod = mod->getFallback(info->mods[i].version);
	if(mod == nullptr)
	return false;
	}
	return true;
	}

	void RegisterMenuBinds(bool ingame) {
	//Start a game
	bind("void startNewGame(Message&)", asFUNCTIONPR(startNewGame, (net::Message&), void));
	bind("void startNewGame()", asFUNCTION(quickstartGame));
	bind("void stopGame()", asFUNCTION(stopGame));
	bind("void loadGame(const string& fname)", asFUNCTION(scr_loadGame));
	bind("bool saveGame(const string& fname)", asFUNCTION(scr_saveGame));
	bind("void saveWorldScreen(const string& fname)", asFUNCTION(saveWorldScreen));
	bind("void switchToMenu()", asFUNCTION(toMenu));
	bind("void switchToGame()", asFUNCTION(toGame));
	bind("void quitGame()", asFUNCTION(quitGame));

	ClassBind saveData("SaveFileInfo", asOBJ_VALUE \| asOBJ_APP_CLASS_CDK, sizeof(SaveFileInfo));
	saveData.addConstructor("void f()", asFUNCTION(makeSaveFileInfo));
	saveData.addDestructor("void f()", asFUNCTION(dtorSaveFileInfo));
	saveData.addConstructor("void f(const SaveFileInfo& other)", asFUNCTION(copySaveFileInfo));
	saveData.addExternMethod("bool hasMods()", asFUNCTION(saveFileHasMods));
	saveData.addMember("uint version", offsetof(SaveFileInfo, version));
	saveData.addMember("uint startVersion", offsetof(SaveFileInfo, startVersion));
	bind("void getSaveFileInfo(const string& fname, SaveFileInfo& dat)", asFUNCTION(saveInfo));
	bind("uint getSaveVersion(const string& fname)", asFUNCTION(saveVersion));

	EnumBind gs("GameState");
	gs["GS_Game"] = GS_Game;
	gs["GS_Menu"] = GS_Menu;
	gs["GS_Quit"] = GS_Quit;

	bindGlobal("GameState game_state", &game_state);

	//Menu rendering
	bind("void preRenderClient()", asFUNCTION(preRenderClient));
	bind("void renderClient()", asFUNCTION(renderClient));

	//Mod listing
	ClassBind mod("Mod", asOBJ_REF \| asOBJ_NOCOUNT, 0);
	mod.addMember("string ident", offsetof(mods::Mod, ident));
	mod.addMember("string name", offsetof(mods::Mod, name));
	mod.addMember("string dirname", offsetof(mods::Mod, dirname));
	mod.addMember("string abspath", offsetof(mods::Mod, abspath));
	mod.addMember("string parentname", offsetof(mods::Mod, parentname));
	mod.addMember("string description", offsetof(mods::Mod, description));
	mod.addMember("bool listed", offsetof(mods::Mod, listed));
	mod.addMember("bool enabled", offsetof(mods::Mod, enabled));
	mod.addMember("bool isNew", offsetof(mods::Mod, isNew));
	mod.addMember("bool forced", offsetof(mods::Mod, forced));
	mod.addMember("bool isBase", offsetof(mods::Mod, isBase));
	mod.addMember("uint compatibility", offsetof(mods::Mod, compatibility));
	mod.addMember("bool forCurrentVersion", offsetof(mods::Mod, forCurrentVersion));
	mod.addMember("Mod@ parent", offsetof(mods::Mod, parent));
	mod.addMethod("bool isCompatible(Mod& other)", asMETHOD(mods::Mod, isCompatible));
	mod.addExternMethod("void getConflicts(Mod& other, array<string>& files)", asFUNCTION(modConflicts));

	bindGlobal("bool watchResources", &watch_resources);

	bindGlobal("Mod@ currentMod", &devices.mods.currentMod);
	bindGlobal("Mod@ baseMod", &devices.mods.currentMod);
	bind("Mod& get_topMod()", asFUNCTION(getTopMod));
	bind("Mod@ getMod(uint index)", asFUNCTION(getMod));
	bind("Mod@ getMod(const string& id)", asFUNCTION(getMod_id));
	bind("uint get_modCount()", asFUNCTION(getModCount));
	bind("void saveModState()", asFUNCTION(saveModState));

	bind("bool createNewMod(const string& ident)", asFUNCTION(createNewMod));
	bind("void switchToMods(const array<string>& mods)", asFUNCTION(switchToMods));
	}

	};

File Metadata

Mime Type: text/x-c++
Expires: Sat, Nov 14, 4:17 PM (9 h, 6 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 131061
Default Alt Text: bind_menu.cpp (8 KB)

bind_menu.cppNo OneTemporaryActions

bind_menu.cppView Options

File Metadata

Event Timeline

bind_menu.cpp
No OneTemporary
Actions

bind_menu.cpp
View Options