/// <summary>
/// Serialises HexMapGraph edges collection
/// </summary>
/// <returns>Serialised edges collection</returns>
/// <param name="edgesIn">Edges collection to be converted</param>
public static List <TaggedEdge <string, string> > EdgeCollection_serialise(List <TaggedEdge <Fief, string> > edgesIn)
{
List <TaggedEdge <string, string> > edgesOut = new List <TaggedEdge <string, string> >();
foreach (TaggedEdge <Fief, string> element in edgesIn)
{
// convert each Fief object to string ID
edgesOut.Add(DatabaseWrite.EdgeFief_serialise(element));
}
return(edgesOut);
}
/// <summary>
/// Writes a Province or Province_Serialised object to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="p">Province to write</param>
/// <param name="ps">Province_Serialised to write</param>
public static bool DatabaseWrite_Province(string gameID, Province p = null, Province_Serialised ps = null)
{
if (p != null)
{
// convert Province into Province_Serialised
ps = DatabaseWrite.Province_serialise(p);
}
var rProv = new RiakObject(gameID, ps.id, ps);
var putProvResult = Globals_Server.rClient.Put(rProv);
if (!putProvResult.IsSuccess)
{
Globals_Server.logError("Write failed: Province " + rProv.Key + " to bucket " + rProv.Bucket);
}
return(putProvResult.IsSuccess);
}
/// <summary>
/// Writes a Kingdom or Kingdom_Serialised object to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="k">Kingdom to write</param>
/// <param name="ks">Kingdom_Serialised to write</param>
public static bool DatabaseWrite_Kingdom(string gameID, Kingdom k = null, Kingdom_Serialised ks = null)
{
if (k != null)
{
// convert Kingdom into Kingdom_Serialised
ks = DatabaseWrite.Kingdom_serialise(k);
}
var rKing = new RiakObject(gameID, ks.id, ks);
var putKingResult = Globals_Server.rClient.Put(rKing);
if (!putKingResult.IsSuccess)
{
Globals_Server.logError("Write failed: Kingdom " + rKing.Key + " to bucket " + rKing.Bucket);
}
return(putKingResult.IsSuccess);
}
/// <summary>
/// Writes a Position or Position_Serialised object to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="p">Position to write</param>
/// <param name="ps">Position_Serialised to write</param>
public static bool DatabaseWrite_Position(string gameID, Position p = null, Position_Serialised ps = null)
{
if (p != null)
{
// convert Position into Position_Serialised
ps = DatabaseWrite.Position_serialise(p);
}
var rPos = new RiakObject(gameID, ps.id.ToString(), ps);
var putPosResult = Globals_Server.rClient.Put(rPos);
if (!putPosResult.IsSuccess)
{
Globals_Server.logError("Write failed: Position " + rPos.Key + " to bucket " + rPos.Bucket);
}
return(putPosResult.IsSuccess);
}
/// <summary>
/// Writes a HexMapGraph edges collection to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="map">HexMapGraph containing edges collection to write</param>
/// <param name="edges">Edges collection to write</param>
public static bool DatabaseWrite_MapEdges(string gameID, HexMapGraph map = null, List <TaggedEdge <string, string> > edges = null)
{
if (map != null)
{
// convert Language into Language_Serialised
edges = DatabaseWrite.EdgeCollection_serialise(map.myMap.Edges.ToList());
}
var rMapE = new RiakObject(gameID, "mapEdges", edges);
var putMapResultE = Globals_Server.rClient.Put(rMapE);
if (!putMapResultE.IsSuccess)
{
Globals_Server.logError("Write failed: Map edges collection " + rMapE.Key + " to bucket " + rMapE.Bucket);
}
return(putMapResultE.IsSuccess);
}
/// <summary>
/// Writes a Fief or Fief_Serialised object to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="f">Fief to write</param>
/// <param name="fs">Fief_Serialised to write</param>
public static bool DatabaseWrite_Fief(string gameID, Fief f = null, Fief_Serialised fs = null)
{
if (f != null)
{
// convert Fief to Fief_Serialised
fs = DatabaseWrite.Fief_serialise(f);
}
var rFief = new RiakObject(gameID, fs.id, fs);
var putFiefResult = Globals_Server.rClient.Put(rFief);
if (!putFiefResult.IsSuccess)
{
Globals_Server.logError("Write failed: Fief " + rFief.Key + " to bucket " + rFief.Bucket);
}
return(putFiefResult.IsSuccess);
}
/// <summary>
/// Writes a PlayerCharacter or PlayerCharacter_Serialised object to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="pc">PlayerCharacter to write</param>
/// <param name="pcs">PlayerCharacter_Serialised to write</param>
public static bool DatabaseWrite_PC(string gameID, PlayerCharacter pc = null, PlayerCharacter_Serialised pcs = null)
{
if (pc != null)
{
// convert PlayerCharacter into PlayerCharacter_Serialised
pcs = DatabaseWrite.PC_serialise(pc);
}
// write PlayerCharacter_Serialised to database
var rPC = new RiakObject(gameID, pcs.charID, pcs);
var putPCresult = Globals_Server.rClient.Put(rPC);
if (!putPCresult.IsSuccess)
{
Globals_Server.logError("Write failed: PC " + rPC.Key + " to bucket " + rPC.Bucket);
}
return(putPCresult.IsSuccess);
}
/// <summary>
/// Writes a NonPlayerCharacter or NonPlayerCharacter_Serialised object to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="npc">NonPlayerCharacter to write</param>
/// <param name="npcs">NonPlayerCharacter_Serialised to write</param>
public static bool DatabaseWrite_NPC(string gameID, NonPlayerCharacter npc = null, NonPlayerCharacter_Serialised npcs = null)
{
if (npc != null)
{
// convert NonPlayerCharacter into NonPlayerCharacter_Serialised
npcs = DatabaseWrite.NPC_serialise(npc);
}
// write NonPlayerCharacter_Serialised to database
var rNPC = new RiakObject(gameID, npcs.charID, npcs);
var putNPCresult = Globals_Server.rClient.Put(rNPC);
if (!putNPCresult.IsSuccess)
{
Globals_Server.logError("Write failed: NPC " + rNPC.Key + " to bucket " + rNPC.Bucket);
}
return(putNPCresult.IsSuccess);
}
/// <summary>
/// Writes a Language or Language_Serialised object to the database
/// </summary>
/// <returns>bool indicating success</returns>
/// <param name="gameID">Game (bucket) to write to</param>
/// <param name="l">Language to write</param>
/// <param name="ls">Language_Serialised to write</param>
public static bool DatabaseWrite_Language(string gameID, Language l = null, Language_Serialised ls = null)
{
if (l != null)
{
// convert Language into Language_Serialised
ls = DatabaseWrite.Language_serialise(l);
}
// write Language_Serialised to database
var rLanguage = new RiakObject(gameID, ls.id, ls);
var putLanguageResult = Globals_Server.rClient.Put(rLanguage);
if (!putLanguageResult.IsSuccess)
{
Globals_Server.logError("Write failed: Language " + rLanguage.Key + " to bucket " + rLanguage.Bucket);
}
return(putLanguageResult.IsSuccess);
}
//TODO implement server error log
//TODO add loop to write all client things
/// <summary>
/// Writes all game objects to the database
/// </summary>
/// <param name="gameID">ID of game (used for database bucket)</param>
public static void DatabaseWriteAll(string gameID)
{
// ========= test
DatabaseWrite.DatabaseWrite_Test(gameID);
// ========= write CLOCK
DatabaseWrite.DatabaseWrite_Clock(gameID, Globals_Game.clock);
// ========= write GLOBALS_SERVER/GAME DICTIONARIES
DatabaseWrite.DatabaseWrite_Dictionary(gameID, "combatValues", Globals_Server.combatValues);
DatabaseWrite.DatabaseWrite_Dictionary(gameID, "recruitRatios", Globals_Server.recruitRatios);
DatabaseWrite.DatabaseWrite_Dictionary(gameID, "battleProbabilities", Globals_Server.battleProbabilities);
DatabaseWrite.DatabaseWrite_Dictionary(gameID, "gameTypes", Globals_Server.gameTypes);
DatabaseWrite.DatabaseWrite_Dictionary(gameID, "ownershipChallenges", Globals_Game.ownershipChallenges);
Console.WriteLine("Finished writing dictionaries");
// convert jEntryPriorities prior to writing
Dictionary <string, byte> jEntryPriorities_serialised = DatabaseWrite.JentryPriorities_serialise(Globals_Game.jEntryPriorities);
DatabaseWrite.DatabaseWrite_Dictionary(gameID, "jEntryPriorities", jEntryPriorities_serialised);
// ========= write JOURNALS
DatabaseWrite.DatabaseWrite_Journal(gameID, "serverScheduledEvents", Globals_Game.scheduledEvents);
DatabaseWrite.DatabaseWrite_Journal(gameID, "serverPastEvents", Globals_Game.pastEvents);
Console.WriteLine("Finished writing journals");
// ========= write GLOBALS_GAME/CLIENT/SERVER CHARACTER VARIABLES
// Globals_Game.sysAdmin
if (Globals_Game.sysAdmin != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, "sysAdmin", Globals_Game.sysAdmin.charID);
}
// Globals_Game.kingOne
if (Globals_Game.kingOne != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, "kingOne", Globals_Game.kingOne.charID);
}
// Globals_Game.kingTwo
if (Globals_Game.kingTwo != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, "kingTwo", Globals_Game.kingTwo.charID);
}
// Globals_Game.princeOne
if (Globals_Game.princeOne != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, "princeOne", Globals_Game.princeOne.charID);
}
// Globals_Game.princeTwo
if (Globals_Game.princeTwo != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, "princeTwo", Globals_Game.princeTwo.charID);
}
// Globals_Game.heraldOne
if (Globals_Game.heraldOne != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, "heraldOne", Globals_Game.heraldOne.charID);
}
// Globals_Game.heraldTwo
if (Globals_Game.heraldTwo != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, "heraldTwo", Globals_Game.heraldTwo.charID);
}
Console.WriteLine("Finished writing important people");
// ========= write GLOBALS_GAME/CLIENT/SERVER newID VARIABLES
// newCharID
DatabaseWrite.DatabaseWrite_newID(gameID, "newCharID", Globals_Game.newCharID);
// newArmyID
DatabaseWrite.DatabaseWrite_newID(gameID, "newArmyID", Globals_Game.newArmyID);
// newDetachmentID
DatabaseWrite.DatabaseWrite_newID(gameID, "newDetachmentID", Globals_Game.newDetachmentID);
// newAilmentID
DatabaseWrite.DatabaseWrite_newID(gameID, "newAilmentID", Globals_Game.newAilmentID);
// newSiegeID
DatabaseWrite.DatabaseWrite_newID(gameID, "newSiegeID", Globals_Game.newSiegeID);
// newJournalEntryID
DatabaseWrite.DatabaseWrite_newID(gameID, "newJournalEntryID", Globals_Game.newJournalEntryID);
// gameType
DatabaseWrite.DatabaseWrite_newID(gameID, "gameType", Globals_Game.gameType);
// duration
DatabaseWrite.DatabaseWrite_newID(gameID, "duration", Globals_Game.duration);
// startYear
DatabaseWrite.DatabaseWrite_newID(gameID, "startYear", Globals_Game.startYear);
// newGameID
DatabaseWrite.DatabaseWrite_newID(gameID, "newGameID", Globals_Server.newGameID);
// newOwnChallengeID
DatabaseWrite.DatabaseWrite_newID(gameID, "newOwnChallengeID", Globals_Game.newOwnChallengeID);
Console.WriteLine("Finished writing new IDs");
// ========= write GLOBALS_GAME/CLIENT/SERVER BOOL VARIABLES
// Globals_Game.loadFromDatabase
DatabaseWrite.DatabaseWrite_Bool(gameID, "loadFromDatabase", Globals_Game.loadFromDatabase);
// Globals_Game.loadFromCSV
DatabaseWrite.DatabaseWrite_Bool(gameID, "loadFromCSV", Globals_Game.loadFromCSV);
// Globals_Game.writeToDatabase
DatabaseWrite.DatabaseWrite_Bool(gameID, "writeToDatabase", Globals_Game.writeToDatabase);
// Globals_Game.statureCapInForce
DatabaseWrite.DatabaseWrite_Bool(gameID, "statureCapInForce", Globals_Game.statureCapInForce);
Console.WriteLine("Finished writing bools");
// ========= write TRAITS
// clear existing key list
if (Globals_Game.traitKeys.Count > 0)
{
Globals_Game.traitKeys.Clear();
}
// write each object in traitMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Trait> pair in Globals_Game.traitMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Trait(gameID, pair.Value);
if (success)
{
Globals_Game.traitKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "traitKeys", Globals_Game.traitKeys);
// ========= write BASELANGUAGES
// clear existing key list
if (Globals_Game.baseLangKeys.Count > 0)
{
Globals_Game.baseLangKeys.Clear();
}
Console.WriteLine("Finished writing traits");
// write each object in baseLanguageMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, BaseLanguage> pair in Globals_Game.baseLanguageMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_BaseLanguage(gameID, pair.Value);
if (success)
{
Globals_Game.baseLangKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "baseLangKeys", Globals_Game.baseLangKeys);
// ========= write LANGUAGES
// clear existing key list
if (Globals_Game.langKeys.Count > 0)
{
Globals_Game.langKeys.Clear();
}
// write each object in languageMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Language> pair in Globals_Game.languageMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Language(gameID, l: pair.Value);
if (success)
{
Globals_Game.langKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "langKeys", Globals_Game.langKeys);
// ========= write NATIONALITY OBJECTS
// clear existing key list
if (Globals_Game.nationalityKeys.Count > 0)
{
Globals_Game.nationalityKeys.Clear();
}
Console.WriteLine("Finished writing languages");
// write each object in nationalityMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Nationality> pair in Globals_Game.nationalityMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Nationality(gameID, pair.Value);
if (success)
{
Globals_Game.nationalityKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "nationalityKeys", Globals_Game.nationalityKeys);
Console.WriteLine("Finished writing nationalities");
// ========= write RANKS
// clear existing key list
if (Globals_Game.rankKeys.Count > 0)
{
Globals_Game.rankKeys.Clear();
}
// write each object in rankMasterList, whilst also repopulating key list
foreach (KeyValuePair <byte, Rank> pair in Globals_Game.rankMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Rank(gameID, pair.Value);
if (success)
{
Globals_Game.rankKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "rankKeys", Globals_Game.rankKeys);
Console.WriteLine("Finished writing ranks");
// ========= write POSITIONS
// clear existing key list
if (Globals_Game.positionKeys.Count > 0)
{
Globals_Game.positionKeys.Clear();
}
// write each object in positionMasterList, whilst also repopulating key list
foreach (KeyValuePair <byte, Position> pair in Globals_Game.positionMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Position(gameID, p: pair.Value);
if (success)
{
Globals_Game.positionKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "positionKeys", Globals_Game.positionKeys);
Console.WriteLine("Finished writing positions");
// ========= write NPCs
// clear existing key list
if (Globals_Game.npcKeys.Count > 0)
{
Globals_Game.npcKeys.Clear();
}
// write each object in npcMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, NonPlayerCharacter> pair in Globals_Game.npcMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_NPC(gameID, npc: pair.Value);
if (success)
{
Globals_Game.npcKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "npcKeys", Globals_Game.npcKeys);
Console.WriteLine("Finished writing npcs");
// ========= write PCs
// clear existing key list
if (Globals_Game.pcKeys.Count > 0)
{
Globals_Game.pcKeys.Clear();
}
// write each object in pcMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, PlayerCharacter> pair in Globals_Game.pcMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_PC(gameID, pc: pair.Value);
if (success)
{
Globals_Game.pcKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "pcKeys", Globals_Game.pcKeys);
Console.WriteLine("Finished writing PCs");
// ========= write KINGDOMS
// clear existing key list
if (Globals_Game.kingKeys.Count > 0)
{
Globals_Game.kingKeys.Clear();
}
// write each object in kingdomMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Kingdom> pair in Globals_Game.kingdomMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Kingdom(gameID, k: pair.Value);
if (success)
{
Globals_Game.kingKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "kingKeys", Globals_Game.kingKeys);
Console.WriteLine("Finished writing kingdoms");
// ========= write PROVINCES
// clear existing key list
if (Globals_Game.provKeys.Count > 0)
{
Globals_Game.provKeys.Clear();
}
// write each object in provinceMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Province> pair in Globals_Game.provinceMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Province(gameID, p: pair.Value);
if (success)
{
Globals_Game.provKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "provKeys", Globals_Game.provKeys);
Console.WriteLine("Finished writing provinces");
// ========= write TERRAINS
// clear existing key list
if (Globals_Game.terrKeys.Count > 0)
{
Globals_Game.terrKeys.Clear();
}
// write each object in terrainMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Terrain> pair in Globals_Game.terrainMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Terrain(gameID, pair.Value);
if (success)
{
Globals_Game.terrKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "terrKeys", Globals_Game.terrKeys);
Console.WriteLine("Finished writing terrains");
// ========= write VICTORYDATA OBJECTS
// clear existing key list
if (Globals_Game.victoryDataKeys.Count > 0)
{
Globals_Game.victoryDataKeys.Clear();
}
// write each object in victoryData, whilst also repopulating key list
foreach (KeyValuePair <string, VictoryData> pair in Globals_Game.victoryData)
{
bool success = DatabaseWrite.DatabaseWrite_VictoryData(gameID, pair.Value);
if (success)
{
Globals_Game.victoryDataKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "victoryDataKeys", Globals_Game.victoryDataKeys);
Console.WriteLine("Finished writing victory data");
// ========= write FIEFS
// clear existing key list
if (Globals_Game.fiefKeys.Count > 0)
{
Globals_Game.fiefKeys.Clear();
}
// write each object in fiefMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Fief> pair in Globals_Game.fiefMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Fief(gameID, f: pair.Value);
if (success)
{
Globals_Game.fiefKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "fiefKeys", Globals_Game.fiefKeys);
Console.WriteLine("Finished writing fiefs");
// ========= write ARMIES
// clear existing key list
if (Globals_Game.armyKeys.Count > 0)
{
Globals_Game.armyKeys.Clear();
}
// write each object in armyMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Army> pair in Globals_Game.armyMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Army(gameID, pair.Value);
if (success)
{
Globals_Game.armyKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "armyKeys", Globals_Game.armyKeys);
Console.WriteLine("Finished writing armies");
// ========= write SIEGES
// clear existing key list
if (Globals_Game.siegeKeys.Count > 0)
{
Globals_Game.siegeKeys.Clear();
}
// write each object in siegeMasterList, whilst also repopulating key list
foreach (KeyValuePair <string, Siege> pair in Globals_Game.siegeMasterList)
{
bool success = DatabaseWrite.DatabaseWrite_Siege(gameID, pair.Value);
if (success)
{
Globals_Game.siegeKeys.Add(pair.Key);
}
}
// write key list to database
DatabaseWrite.DatabaseWrite_KeyList(gameID, "siegeKeys", Globals_Game.siegeKeys);
Console.WriteLine("Finished writing sieges");
// write clients
foreach (KeyValuePair <string, Client> pair in Globals_Server.Clients)
{
bool success = DatabaseWrite_Client(gameID, pair.Value);
if (success)
{
Globals_Server.client_keys.Add(pair.Key);
}
}
DatabaseWrite_KeyList(gameID, "clientKeys", Globals_Server.client_keys);
Console.WriteLine("Finished writing clients");
// ========= write MAP (edges collection)
DatabaseWrite.DatabaseWrite_MapEdges(gameID, map: Globals_Game.gameMap);
foreach (KeyValuePair <string, Client> pair in Globals_Server.Clients)
{
DatabaseWrite.DatabaseWrite_Journal(gameID, pair.Value.username + "_journal", pair.Value.myPastEvents);
// Globals_Client.myPlayerCharacter
if (pair.Value.myPlayerCharacter != null)
{
DatabaseWrite.DatabaseWrite_String(gameID, pair.Value.username + "_playerChar", pair.Value.myPlayerCharacter.charID);
}
// Globals_Client.showMessages
DatabaseWrite.DatabaseWrite_Bool(gameID, pair.Value.username + "_showMessages", pair.Value.showMessages);
// Globals_Client.showDebugMessages
DatabaseWrite.DatabaseWrite_Bool(gameID, pair.Value.username + "_showDebugMessages", pair.Value.showDebugMessages);
}
Console.WriteLine("Finished writing map");
}
