void ServerConfig::saveSettings()
{
settings().beginGroup("internalConfig");
settings().remove("");
settings().setValue("numColumns", numColumns());
settings().setValue("numRows", numRows());
settings().setValue("hasHeartbeat", hasHeartbeat());
settings().setValue("heartbeat", heartbeat());
settings().setValue("relativeMouseMoves", relativeMouseMoves());
settings().setValue("screenSaverSync", screenSaverSync());
settings().setValue("win32KeepForeground", win32KeepForeground());
settings().setValue("hasSwitchDelay", hasSwitchDelay());
settings().setValue("switchDelay", switchDelay());
settings().setValue("hasSwitchDoubleTap", hasSwitchDoubleTap());
settings().setValue("switchDoubleTap", switchDoubleTap());
settings().setValue("switchCornerSize", switchCornerSize());
settings().setValue("ignoreAutoConnectClient", ignoreAutoConnectClient());
writeSettings(settings(), switchCorners(), "switchCorner");
settings().beginWriteArray("screens");
for (int i = 0; i < screens().size(); i++)
{
settings().setArrayIndex(i);
screens()[i].saveSettings(settings());
}
settings().endArray();
settings().beginWriteArray("hotkeys");
for (int i = 0; i < hotkeys().size(); i++)
{
settings().setArrayIndex(i);
hotkeys()[i].saveSettings(settings());
}
settings().endArray();
settings().endGroup();
}
void ServerConfig::loadSettings()
{
settings().beginGroup("internalConfig");
setNumColumns(settings().value("numColumns", 5).toInt());
setNumRows(settings().value("numRows", 3).toInt());
// we need to know the number of columns and rows before we can set up ourselves
init();
haveHeartbeat(settings().value("hasHeartbeat", false).toBool());
setHeartbeat(settings().value("heartbeat", 5000).toInt());
setRelativeMouseMoves(settings().value("relativeMouseMoves", false).toBool());
setScreenSaverSync(settings().value("screenSaverSync", true).toBool());
setWin32KeepForeground(settings().value("win32KeepForeground", false).toBool());
haveSwitchDelay(settings().value("hasSwitchDelay", false).toBool());
setSwitchDelay(settings().value("switchDelay", 250).toInt());
haveSwitchDoubleTap(settings().value("hasSwitchDoubleTap", false).toBool());
setSwitchDoubleTap(settings().value("switchDoubleTap", 250).toInt());
setSwitchCornerSize(settings().value("switchCornerSize").toInt());
setIgnoreAutoConnectClient(settings().value("ignoreAutoConnectClient").toBool());
readSettings(settings(), switchCorners(), "switchCorner", false, NumSwitchCorners);
int numScreens = settings().beginReadArray("screens");
Q_ASSERT(numScreens <= screens().size());
for (int i = 0; i < numScreens; i++)
{
settings().setArrayIndex(i);
screens()[i].loadSettings(settings());
}
settings().endArray();
int numHotkeys = settings().beginReadArray("hotkeys");
for (int i = 0; i < numHotkeys; i++)
{
settings().setArrayIndex(i);
Hotkey h;
h.loadSettings(settings());
hotkeys().append(h);
}
settings().endArray();
settings().endGroup();
}
/**
* When loading the game, load from file if possible
*/
void GameStatePlay::loadGame() {
int saved_hp = 0;
int saved_mp = 0;
int currency = 0;
// game slots are currently 1-4
if (game_slot == 0) return;
FileParser infile;
std::vector<int> hotkeys(ACTIONBAR_MAX, -1);
std::stringstream ss;
ss << PATH_USER << "saves/" << SAVE_PREFIX << "/" << game_slot << "/avatar.txt";
if (infile.open(path(&ss), false)) {
while (infile.next()) {
if (infile.key == "name") pc->stats.name = infile.val;
else if (infile.key == "permadeath") {
pc->stats.permadeath = toBool(infile.val);
}
else if (infile.key == "option") {
pc->stats.gfx_base = infile.nextValue();
pc->stats.gfx_head = infile.nextValue();
pc->stats.gfx_portrait = infile.nextValue();
}
else if (infile.key == "class") {
pc->stats.character_class = infile.nextValue();
pc->stats.character_subclass = infile.nextValue();
}
else if (infile.key == "xp") {
pc->stats.xp = toUnsignedLong(infile.val);
}
else if (infile.key == "hpmp") {
saved_hp = toInt(infile.nextValue());
saved_mp = toInt(infile.nextValue());
}
else if (infile.key == "build") {
pc->stats.physical_character = toInt(infile.nextValue());
pc->stats.mental_character = toInt(infile.nextValue());
pc->stats.offense_character = toInt(infile.nextValue());
pc->stats.defense_character = toInt(infile.nextValue());
if (pc->stats.physical_character < 0 || pc->stats.physical_character > pc->stats.max_points_per_stat ||
pc->stats.mental_character < 0 || pc->stats.mental_character > pc->stats.max_points_per_stat ||
pc->stats.offense_character < 0 || pc->stats.offense_character > pc->stats.max_points_per_stat ||
pc->stats.defense_character < 0 || pc->stats.defense_character > pc->stats.max_points_per_stat) {
logError("SaveLoad: Some basic stats are out of bounds, setting to zero");
pc->stats.physical_character = 0;
pc->stats.mental_character = 0;
pc->stats.offense_character = 0;
pc->stats.defense_character = 0;
}
}
else if (infile.key == "currency") {
currency = toInt(infile.val);
}
else if (infile.key == "equipped") {
menu->inv->inventory[EQUIPMENT].setItems(infile.val);
}
else if (infile.key == "equipped_quantity") {
menu->inv->inventory[EQUIPMENT].setQuantities(infile.val);
}
else if (infile.key == "carried") {
menu->inv->inventory[CARRIED].setItems(infile.val);
}
else if (infile.key == "carried_quantity") {
menu->inv->inventory[CARRIED].setQuantities(infile.val);
}
else if (infile.key == "spawn") {
mapr->teleport_mapname = infile.nextValue();
if (mapr->teleport_mapname != "" && fileExists(mods->locate(mapr->teleport_mapname))) {
mapr->teleport_destination.x = static_cast<float>(toInt(infile.nextValue())) + 0.5f;
mapr->teleport_destination.y = static_cast<float>(toInt(infile.nextValue())) + 0.5f;
mapr->teleportation = true;
// prevent spawn.txt from putting us on the starting map
mapr->clearEvents();
}
else {
logError("SaveLoad: Unable to find %s, loading maps/spawn.txt", mapr->teleport_mapname.c_str());
mapr->teleport_mapname = "maps/spawn.txt";
mapr->teleport_destination.x = 0.5f;
mapr->teleport_destination.y = 0.5f;
mapr->teleportation = true;
}
}
else if (infile.key == "actionbar") {
for (int i = 0; i < ACTIONBAR_MAX; i++) {
hotkeys[i] = toInt(infile.nextValue());
if (hotkeys[i] < 0) {
logError("SaveLoad: Hotkey power on position %d has negative id, skipping", i);
hotkeys[i] = 0;
}
else if (static_cast<unsigned>(hotkeys[i]) > powers->powers.size()-1) {
logError("SaveLoad: Hotkey power id (%d) out of bounds 1-%d, skipping", hotkeys[i], static_cast<int>(powers->powers.size()));
hotkeys[i] = 0;
}
else if (hotkeys[i] != 0 && static_cast<unsigned>(hotkeys[i]) < powers->powers.size() && powers->powers[hotkeys[i]].name == "") {
logError("SaveLoad: Hotkey power with id=%d, found on position %d does not exist, skipping", hotkeys[i], i);
hotkeys[i] = 0;
}
}
menu->act->set(hotkeys);
}
else if (infile.key == "transformed") {
pc->stats.transform_type = infile.nextValue();
if (pc->stats.transform_type != "") {
pc->stats.transform_duration = -1;
pc->stats.manual_untransform = toBool(infile.nextValue());
}
}
else if (infile.key == "powers") {
std::string power;
while ( (power = infile.nextValue()) != "") {
if (toInt(power) > 0)
pc->stats.powers_list.push_back(toInt(power));
}
}
else if (infile.key == "campaign") camp->setAll(infile.val);
}
infile.close();
}
else logError("SaveLoad: Unable to open %s!", ss.str().c_str());
// add legacy currency to inventory
menu->inv->addCurrency(currency);
// apply stats, inventory, and powers
applyPlayerData();
// trigger passive effects here? Saved HP/MP values might depend on passively boosted HP/MP
// powers->activatePassives(pc->stats);
if (SAVE_HPMP && saved_hp != 0) {
if (saved_hp < 0 || saved_hp > pc->stats.get(STAT_HP_MAX)) {
logError("SaveLoad: HP value is out of bounds, setting to maximum");
pc->stats.hp = pc->stats.get(STAT_HP_MAX);
}
else pc->stats.hp = saved_hp;
if (saved_mp < 0 || saved_mp > pc->stats.get(STAT_MP_MAX)) {
logError("SaveLoad: MP value is out of bounds, setting to maximum");
pc->stats.mp = pc->stats.get(STAT_MP_MAX);
}
else pc->stats.mp = saved_mp;
}
else {
pc->stats.hp = pc->stats.get(STAT_HP_MAX);
pc->stats.mp = pc->stats.get(STAT_MP_MAX);
}
// reset character menu
menu->chr->refreshStats();
loadPowerTree();
}
// Write out the config file for the whole application
int configAppSaveXml()
{
if (bCmdOptUsed) {
return 1;
}
char configName[MAX_PATH];
createConfigName(configName);
try {
char tempStr[64] = "";
// root
ticpp::Document doc;
ticpp::Declaration decl("1.0", "UTF-8", "");
doc.LinkEndChild(&decl);
ticpp::Element root("configuration");
setAttr(root, "version", configVersion);
ticpp::Comment comment("Don't edit this file manually unless you know what you're doing\n" \
APP_TITLE " will restore default settings when this file is deleted");
doc.LinkEndChild(&comment);
doc.LinkEndChild(&root);
// title
sprintf(tempStr, "0x%06X", nBurnVer);
addTextNode(root, "version", tempStr);
// emulation
ticpp::Element emulation("emulation");
root.LinkEndChild(&emulation);
setAttr(emulation, "asm-68k", bBurnUseASM68K);
setAttr(emulation, "all-ram", bDrvSaveAll);
// video
ticpp::Element video("video");
root.LinkEndChild(&video);
ticpp::Element fullscreen("fullscreen");
video.LinkEndChild(&fullscreen);
setAttr(fullscreen, "width", nVidWidth);
setAttr(fullscreen, "height", nVidHeight);
setAttr(fullscreen, "depth", nVidDepth);
setAttr(fullscreen, "refresh", nVidRefresh);
ticpp::Element adjust("adjust");
video.LinkEndChild(&adjust);
setAttr(adjust, "rotate-vertical", nVidRotationAdjust);
ticpp::Element screen_size("screen-size");
video.LinkEndChild(&screen_size);
setAttr(screen_size, "window", nWindowSize);
ticpp::Element window_position("window-position");
video.LinkEndChild(&window_position);
setAttr(window_position, "x", nWindowPosX);
setAttr(window_position, "y", nWindowPosY);
ticpp::Element stretch("stretch");
video.LinkEndChild(&stretch);
setAttr(stretch, "full-stretch", bVidFullStretch);
setAttr(stretch, "correct-aspect", bVidCorrectAspect);
ticpp::Element color("color");
video.LinkEndChild(&color);
setAttr(color, "enable", bcolorAdjust);
setAttr(color, "contrast", color_contrast);
setAttr(color, "brightness", color_brightness);
setAttr(color, "gamma", color_gamma);
setAttr(color, "grayscale", color_grayscale);
setAttr(color, "invert", color_invert);
ticpp::Element vsync("vsync");
video.LinkEndChild(&vsync);
setAttr(vsync, "enable", bVidVSync);
ticpp::Element triple_buffer("triple-buffer");
video.LinkEndChild(&triple_buffer);
setAttr(triple_buffer, "enable", bVidTripleBuffer);
// video render
ticpp::Element render("render");
video.LinkEndChild(&render);
ticpp::Element render_driver("render-driver");
render.LinkEndChild(&render_driver);
setAttr(render_driver, "driver", nVidSelect);
setAttr(render_driver, "adapter", nVidAdapter);
ticpp::Element filter("filter");
render.LinkEndChild(&filter);
setAttr(filter, "linear", vidFilterLinear);
setAttr(filter, "use-pixelfilter", vidUseFilter);
setAttr(filter, "pixel-filter", nVidFilter);
ticpp::Element option("option");
render.LinkEndChild(&option);
setAttr(option, "force-16bit", bVidForce16bit);
setAttr(option, "hardware-vertex", vidHardwareVertex);
setAttr(option, "motion-blur", vidMotionBlur);
setAttr(option, "projection", nVid3DProjection);
setAttr(option, "angel", fVidScreenAngle);
setAttr(option, "curvature", fVidScreenCurvature);
setAttr(option, "dxmanager", nVidDXTextureManager);
setAttr(option, "x-offset", nXOffset);
setAttr(option, "y-offset", nYOffset);
setAttr(option, "x-scale", nXScale);
setAttr(option, "y-scale", nYScale);
// video others
ticpp::Element monitor("monitor");
video.LinkEndChild(&monitor);
setAttr(monitor, "auto-aspect", autoVidScrnAspect);
setAttr(monitor, "aspect-x", nVidScrnAspectX);
setAttr(monitor, "aspect-y", nVidScrnAspectY);
ticpp::Element frame("frame");
video.LinkEndChild(&frame);
setAttr(frame, "auto-frameskip", autoFrameSkip);
setAttr(frame, "force-60hz", bForce60Hz);
// audio
ticpp::Element audio("audio");
root.LinkEndChild(&audio);
addTextNode(audio, "sound", audSelect);
ticpp::Element device("device");
audio.LinkEndChild(&device);
setAttr(device, "ds", dsDevice);
setAttr(device, "xa2", xa2Device);
setAttr(device, "oal", oalDevice);
ticpp::Element audio_set("setting");
audio.LinkEndChild(&audio_set);
setAttr(audio_set, "rate", nAudSampleRate);
setAttr(audio_set, "frame", nAudSegCount);
setAttr(audio_set, "dsp", nAudDSPModule);
setAttr(audio_set, "pcm-interp", nInterpolation);
setAttr(audio_set, "fm-interp", nFMInterpolation);
setAttr(audio_set, "stereo-upmix", audStereoUpmixing);
// gui
ticpp::Element gui("gui");
root.LinkEndChild(&gui);
addTextNode(gui, "language", szLanguage);
//addTextNode(gui, "gamelist", szTransGamelistFile);
ticpp::Element chat("chat-font");
gui.LinkEndChild(&chat);
setAttr(chat, "min-size", nMinChatFontSize);
setAttr(chat, "max-size", nMaxChatFontSize);
ticpp::Element menu("menu");
gui.LinkEndChild(&menu);
setAttr(menu, "modeless", bModelessMenu);
setAttr(menu, "style", menuNewStyle);
ticpp::Element gui_misc("gui-misc");
gui.LinkEndChild(&gui_misc);
setAttr(gui_misc, "on-top", bShowOnTop);
setAttr(gui_misc, "auto-fullscreen", bFullscreenOnStart);
setAttr(gui_misc, "lastRom", nLastRom);
setAttr(gui_misc, "lastFilter", nLastFilter);
setAttr(gui_misc, "hideChildren", HideChildren);
setAttr(gui_misc, "showThreeFourPlayerOnly", ThreeOrFourPlayerOnly);
setAttr(gui_misc, "arcadeJoyStickSettings", ArcadeJoystick);
// gui load game dialog
ticpp::Element gamelist("gamelist-dlg");
gui.LinkEndChild(&gamelist);
setAttr(gamelist, "options", nLoadMenuShowX);
//setAttr(gamelist, "drivers", nLoadDriverShowX);
//setAttr(gamelist, "sys-sel", nSystemSel);
//setAttr(gamelist, "tab-sel", nTabSel);
//addTextNode(gamelist, "user-filter", szUserFilterStr);
// gui ips
ticpp::Element ips("ips");
gui.LinkEndChild(&ips);
setAttr(ips, "language", nPatchLang);
setAttr(ips, "dependancy", bEnforceDep);
//ticpp::Element skin("skin");
//gui.LinkEndChild(&skin);
//setAttr(skin, "use-placeholder", bVidUsePlaceholder);
//setAttr(skin, "random", nRandomSkin);
//addTextNode(skin, NULL, szPlaceHolder);
// preferences
ticpp::Element preference("preferences");
root.LinkEndChild(&preference);
ticpp::Element settings("settings");
preference.LinkEndChild(&settings);
setAttr(settings, "always-processkey", bAlwaysProcessKey);
setAttr(settings, "auto-pause", bAutoPause);
//setAttr(settings, "avi-audio", nAviIntAudio);
//setAttr(settings, "use-gdip", bUseGdip);
ticpp::Element fastforward("fastforward");
preference.LinkEndChild(&fastforward);
setAttr(fastforward, "speed", nFastSpeed);
ticpp::Element thread("thread");
preference.LinkEndChild(&thread);
setAttr(thread, "priority", nAppThreadPriority);
ticpp::Element autofire("autofire");
preference.LinkEndChild(&autofire);
setAttr(autofire, "enable", nAutofireEnabled);
setAttr(autofire, "default-delay", autofireDefaultDelay);
ticpp::Element macro("macro");
preference.LinkEndChild(¯o);
setAttr(macro, "enable", nInputMacroEnabled);
// pref misc
ticpp::Element pref_misc("misc");
preference.LinkEndChild(&pref_misc);
setAttr(pref_misc, "effect", nShowEffect);
ticpp::Element controls("controls");
preference.LinkEndChild(&controls);
for (int i = 0; i < 4; i++) {
sprintf(tempStr, "default%d", i);
addTextNode(controls, tempStr, szPlayerDefaultIni[i]);
}
// paths
ticpp::Element paths("paths");
root.LinkEndChild(&paths);
ticpp::Element rom_path("rom");
paths.LinkEndChild(&rom_path);
for (int i = 0; i < DIRS_MAX; i++) {
addTextNode(rom_path, "path", szAppRomPaths[i]);
}
ticpp::Element misc_path("misc");
paths.LinkEndChild(&misc_path);
for (int i = PATH_PREVIEW; i < PATH_SUM; i++) {
sprintf(tempStr, "path%d", i);
addTextNode(misc_path, tempStr, szMiscPaths[i]);
}
// hotkeys
ticpp::Element hotkeys("hotkeys");
root.LinkEndChild(&hotkeys);
/*for (int i = 0; !lastCustomKey(customKeys[i]); i++) {
CustomKey& customkey = customKeys[i];
ticpp::Element key(customkey.config_code);
hotkeys.LinkEndChild(&key);
setAttr(key, "key", customkey.key);
setAttr(key, "mod", customkey.keymod);
}*/
// save file
doc.SaveFile(configName, TIXML_ENCODING_UTF8);
}
catch (ticpp::Exception& ex) {
return 1;
}
return 0;
}
void tinyConsole::run ()
{
//show prompt
std::cout << _prompt;
// grab input
for (;;)
{
c = getch();
if(!hotkeys(c))
switch (c)
{
case ESC:
// TODO escape is only detected if double-pressed. this should be fixed
std::cout << "(Esc)";
break;
case KEY_CTRL1: // look for arrow keys
switch (c = getch())
{
case UP_ARROW:
if (!history.size()) break;
if (pos == -1)
{
// store current command
unused = "";
unused.assign(buffer.begin(), buffer.end());
}
// clear line
for (int i = 0; i < line_pos; i++)
{
std::cout << "\b \b";
}
// clean buffer
buffer.erase(buffer.begin(), buffer.end());
pos++;
if (pos > (history.size() - 1)) pos = history.size() - 1;
// store in buffer
for (int i = 0; i < history[pos].size(); i++)
{
buffer.push_back(history[pos][i]);
}
line_pos = buffer.size();
// output to screen
std::cout << history[pos];
break;
case DOWN_ARROW:
if (!history.size()) break;
// clear line
for (int i = 0; i < line_pos; i++)
{
std::cout << "\b \b";
}
// clean buffer
buffer.erase(buffer.begin(), buffer.end());
pos--;
if (pos<-1) pos = -1;
if (pos >= 0) {
std::cout << history[pos];
// store in buffer
for (int i = 0; i < history[pos].size(); i++)
{
buffer.push_back(history[pos][i]);
}
} else {
if (buffer.size())
{
std::cout << unused;
// store in buffer
for (int i = 0; i < unused.size(); i++)
{
buffer.push_back(unused[i]);
}
}
}
line_pos = buffer.size();
break;
case LEFT_ARROW:
// if there are characters to move left over, do so
if (line_pos)
{
std::cout << "\b";
line_pos--;
}
break;
case RIGHT_ARROW:
// if there are characters to move right over, do so
if (line_pos < buffer.size())
{
std::cout << buffer[line_pos];
line_pos++;
}
break;
case DEL:
if (line_pos < buffer.size())
{
skip_out = 1;
buffer.erase(buffer.begin()+line_pos);
// update screen after current position
for (int i = line_pos; i < buffer.size(); i++ )
{
std::cout << buffer[i];
}
// erase last char
std::cout << " ";
for (int i = line_pos; i < buffer.size(); i++ )
{
std::cout << "\b";
}
// make-up for erase position
std::cout << "\b";
//std::cout << "(DEL)";
}
break;
default:
skip_out = 1;
//std::cout << "(" << (int) c << ")" << std::endl;
}
break;
case BACKSPACE:
if (line_pos == 0) break;
// move cursor back, blank char, and move cursor back again
std::cout << "\b \b";
// don't forget to clean the buffer and update line position
if (line_pos == buffer.size()) {
buffer.pop_back();
line_pos--;
} else {
line_pos--;
buffer.erase(buffer.begin()+line_pos);
// update screen after current position
for (int i = line_pos; i < buffer.size(); i++ ) {
std::cout << buffer[i];
}
// erase last char
std::cout << " ";
for (int i = line_pos+1; i < buffer.size(); i++ ) {
std::cout << "\b";
}
// make-up for erase position and go to new position
std::cout << "\b\b";
}
break;
case TAB:
break;
// print history
for (int i = 0; i < history.size(); i++) {
std::cout << history[i] << std::endl;
}
break;
case NEWLINE:
// store in string
s.assign(buffer.begin(), buffer.end());
// save command to history
// trimming of command should be done in callback function
if(s.length())
history.push_front(s);
// run command
//(*callbackFunc)(s.c_str());
std::cout << std::endl;
trigger(s);
// check for exit command
if(_quit == true) {
return;
}
if (history.size() > _max_history) history.pop_back();
// clean buffer
buffer.erase(buffer.begin(), buffer.end());
// print prompt. new line should be added from callback function
std::cout << _prompt;
// reset position
pos = -1;
line_pos = 0;
break;
default:
if (skip_out) {
skip_out = 0;
break;
}
std::cout << c;
if(line_pos == buffer.size()) {
// line position is at the end of the buffer, just append
buffer.push_back(c);
} else {
// line position is not at end. Insert new char
buffer.insert(buffer.begin()+line_pos, c);
// update screen after current position
for (int i = line_pos+1; i < buffer.size(); i++ ) {
std::cout << buffer[i];
}
for (int i = line_pos+1; i < buffer.size(); i++ ) {
std::cout << "\b";
}
}
line_pos++;
break;
} // end switch
}
}
