/// <summary>
/// Unserializes the BigDB database world object.
/// </summary>
/// <param name="worlddata">The world data.</param>
/// <param name="width">The width of the world.</param>
/// <param name="height">The height of the world.</param>
public static void UnserializeFromComplexObject(DatabaseArray worlddata, int width, int height)
{
Minimap minimap = new Minimap();
minimap.width = width;
minimap.height = height;
minimap.initialize();
Console.WriteLine("Unserializing complex object...");
foreach (DatabaseObject ct in worlddata) {
if (ct.Count == 0) continue;
uint blockId = ct.GetUInt("type");
int layer = ct.GetInt("layer");
byte[] xs = ct.GetBytes("x"),
ys = ct.GetBytes("y");
for (var b = 0; b < xs.Length; b += 2) {
int nx = (xs[b] << 8) | xs[b + 1],
ny = (ys[b] << 8) | ys[b + 1];
minimap.drawBlock(layer, nx, ny, blockId);
}
}
// Write them "on top" of backgrounds
minimap.rewriteForegroundBlocks();
minimap.Save(worldID + "_bigdb.png");
generating_minimap = false;
}
public void loadPoints(DatabaseObject roomData, String username)
{
DatabaseObject points = roomData.GetObject("points");
if (!points.Contains(username))
{
return;
}
DatabaseObject user = points.GetObject(username);
if (user.GetDateTime("day") < DateTime.Today)
{
Console.WriteLine("Purged old slime point data in map: " + RoomId);
points.Remove(username);
roomData.Save(true, true);
return;
}
DatabaseArray userpoints = user.GetArray("list");
ArrayList listPoints = new ArrayList();
for (int i = 0; i < userpoints.Count; i++)
{
listPoints.Add(userpoints.GetInt(i));
}
Points.Add((String)username.Clone(), listPoints);
}
public SerializedDBA(DatabaseArray dba)
{
this.Data = new Dictionary <int, object>();
if (dba == null)
{
return;
}
foreach (var j in dba.Indexes)
{
if (dba.TryGetValue(j.ToString(), out var i))
{
if (i == null)
{
Console.WriteLine("null val");
}
if (i is DatabaseObject)
{
this.Data[j] = new SerializedDBO((DatabaseObject)i).Data;
}
else if (i is DatabaseArray)
{
this.Data[j] = new SerializedDBA((DatabaseArray)i).Data;
}
else
{
this.Data[j] = i;
}
}
}
}
public void unserializeFromComplexObject(DatabaseArray worlddata)
{
for (var a = 0; a < worlddata.Count; a++)
{
var ct = worlddata.GetObject(a);
var type = (uint)ct.GetValue("type");
var layerNum = ct.GetInt("layer", 0);
var xs = ct.GetBytes("x", new byte[0]);
var ys = ct.GetBytes("y", new byte[0]);
var b = 0;
while (b < xs.Length)
{
var nx = (uint)(((int)xs[b] << 8) + (int)xs[b + 1]);
var ny = (uint)(((int)ys[b] << 8) + (int)ys[b + 1]);
var num = type;
if (num <= 77U)
{
if (num != 43U)
{
if (num != 77U)
{
goto IL_168;
}
this.setBrickSound(ItemTypes.Piano, nx, ny, ct.GetUInt("id", 0U));
}
else
{
this.setBrickCoindoor(nx, ny, (uint)ct.GetValue("goal"), false);
}
}
else if (num != 83U)
{
if (num != 242U)
{
if (num != 1000U)
{
goto IL_168;
}
this.setBrickLabel(nx, ny, ct.GetString("text", "no text found"));
}
else
{
this.setBrickPortal(nx, ny, ct.GetUInt("rotation", 0U), ct.GetUInt("id", 0U), ct.GetUInt("target", 0U), false);
}
}
else
{
this.setBrickSound(ItemTypes.Drums, nx, ny, ct.GetUInt("id", 0U));
}
IL_179:
b += 2;
continue;
IL_168:
this.setBrick(layerNum, nx, ny, type, true);
goto IL_179;
}
}
}
public static object[] ToArray(this DatabaseArray databaseArray)
{
var array = new object[databaseArray.Count];
for (var i = 0; i < databaseArray.Count; i++)
{
array[i] = Convert(databaseArray.GetValue(i));
}
return(array);
}
public void Clear()
{
if (_entrys.Count == 0)
{
return;
}
_entrys = new DatabaseArray <DatabaseEntry>();
_databaseNames.Clear();
Interlocked.Exchange(ref _isDirty, 1);
}
public void AddElementWithFullArrayThrowsException()
{
// Act
this.db = new DatabaseArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
// Assert
var ex = Assert.Throws <InvalidOperationException>(() => this.db.Add(17));
Assert.AreEqual(
"Database is full!",
ex.Message,
"Database should throw exception when trying to add more than 16 elements!");
}
public string list()
{
String result = "";
if (isGuest)
{
result = "Listing data for " + username + ":\n";
}
else
{
result = "Listing data for " + username + " (key " + PlayerObject.Key + "):\n";
DatabaseArray bans = PlayerObject.GetArray("BanHistory");
if (bans.Count > 0)
{
result += "Bans (" + bans.Count + "):\n";
foreach (DatabaseObject ban in bans)
{
result += String.Format("{0:d.M.yyyy HH:mm:ss}", ban.GetDateTime("D"));
result += " - (" + ban.GetInt("Dur") + "days) " + ban.GetString("R");
result += " (" + ban.GetString("M") + ")\n";
}
}
else
{
result += "No bans found\n";
}
DatabaseArray warns = PlayerObject.GetArray("WarnHistory");
if (warns.Count > 0)
{
result += "Warns (" + warns.Count + "):\n";
foreach (DatabaseObject warn in warns)
{
result += String.Format("{0:d.M.yyyy HH:mm:ss}", warn.GetDateTime("D"));
result += " - " + warn.GetString("R");
result += " (" + warn.GetString("M") + ")\n";
}
}
else
{
result += "No warns found\n";
}
}
result += "current IP: " + IPAddress.ToString() + "\n";
return(result);
}
public static List <World.Block> FromWorldData(this DatabaseArray input)
{
var blocks = new List <World.Block>();
if (input == null || input.Count == 0)
{
return(blocks);
}
for (int i = 0; i < input.Count; i++)
{
if (input.Contains(i) && input.GetObject(i).Count != 0)
{
var obj = input.GetObject(i);
dynamic temp = new World.Block();
foreach (var kvp in obj)
{
temp[kvp.Key] = kvp.Value;
}
byte[] x = obj.TryGetBytes("x", new byte[0]), y = obj.TryGetBytes("y", new byte[0]);
byte[] x1 = obj.TryGetBytes("x1", new byte[0]), y1 = obj.TryGetBytes("y1", new byte[0]);
for (int j = 0; j < x1.Length; j++)
{
temp.Locations.Add(new World.Block.Location()
{
X = x1[j], Y = y1[j]
});
}
for (int k = 0; k < x.Length; k += 2)
{
temp.Locations.Add(new World.Block.Location()
{
X = (x[k] << 8) + x[k + 1], Y = (y[k] << 8) + y[k + 1]
});
}
blocks.Add(temp);
}
}
return(blocks);
}
private void UnserializeFromComplexObject(DatabaseArray worlddata)
{
foreach (DatabaseObject ct in worlddata)
{
if (ct.Count == 0)
{
continue;
}
try
{
var type = Convert.ToUInt32(ct.GetValue("type"));
var layerNum = ct.GetInt("layer", 0);
var xArr = ct.GetBytes("x", new byte[0]);
var yArr = ct.GetBytes("y", new byte[0]);
var x1Arr = ct.GetBytes("x1", new byte[0]);
var y1Arr = ct.GetBytes("y1", new byte[0]);
var points = WorldUtils.GetShortPos(x1Arr, y1Arr)
.Concat(WorldUtils.GetPos(xArr, yArr));
if (layerNum == 0)
{
var foreground = (Foreground.Id)type;
var block = WorldUtils.GetForegroundFromDatabase(ct, foreground);
foreach (var loc in points)
{
this.Foreground[loc.X, loc.Y] = block;
}
}
else
{
var background = (Background.Id)type;
var block = new BackgroundBlock(background);
foreach (var loc in points)
{
this.Background[loc.X, loc.Y] = block;
}
}
}
catch (Exception)
{
}
}
}
private void setRandom(AuthPlayer player)
{
switch (this.rnd.Next(5))
{
default:
{
player.PlayerObject.Set("crap" + this.rnd.Next(5), this.rnd.Next(100000));
return;
}
case 1:
{
player.PlayerObject.Set("crap" + this.rnd.Next(5), "String " + this.rnd.Next(100000));
return;
}
case 2:
{
player.PlayerObject.Set("crap" + this.rnd.Next(5), this.rnd.Next(1) == 0);
return;
}
case 3:
{
player.PlayerObject.Set("crap" + this.rnd.Next(5), this.rnd.NextDouble());
return;
}
case 4:
{
var tst = new DatabaseArray();
for (var i = 0; i < this.rnd.Next(50); i++)
{
tst.Add(this.rnd.Next());
}
player.PlayerObject.Set("crap" + this.rnd.Next(5), tst);
return;
}
}
}
public static List <World.Block> FromJsonArray(this JObject world)
{
var array = world["worlddata"].Values().AsJEnumerable();
var temp = new DatabaseArray();
foreach (var block in array)
{
var dbo = new DatabaseObject();
foreach (var token in block)
{
var property = (JProperty)token;
var value = property.Value;
switch (value.Type)
{
case JTokenType.Integer:
dbo.Set(property.Name, (uint)value);
break;
case JTokenType.Boolean:
dbo.Set(property.Name, (bool)value);
break;
case JTokenType.Float:
dbo.Set(property.Name, (double)value);
break;
default:
dbo.Set(property.Name, (string)value);
break;
}
}
temp.Add(dbo);
}
return(FromWorldData(temp));
}
private void UnserializeFromComplexObject(DatabaseArray worlddata)
{
foreach (DatabaseObject ct in worlddata)
{
if (ct.Count == 0)
{
continue;
}
var type = (uint)ct.GetValue("type");
var layerNum = ct.GetInt("layer", 0);
var xs = ct.GetBytes("x", new byte[0]);
var ys = ct.GetBytes("y", new byte[0]);
if (layerNum == 0)
{
var foreground = (Foreground.Id)type;
var block = WorldUtils.GetDatabaseBlock(ct, foreground);
for (var b = 0; b < xs.Length; b += 2)
{
var nx = (xs[b] << 8) + xs[b + 1];
var ny = (ys[b] << 8) + ys[b + 1];
this.Foreground[nx, ny] = block;
}
}
else
{
var background = (Background.Id)type;
var block = new BackgroundBlock(background);
for (var b = 0; b < xs.Length; b += 2)
{
var nx = (xs[b] << 8) + xs[b + 1];
var ny = (ys[b] << 8) + ys[b + 1];
this.Background[nx, ny] = block;
}
}
}
}
private void createPreviewObjects()
{
Console.WriteLine("Objects of same type were deleted.");
int currentObjectSize = 0;
int currentPartID = 1;
var currentObject = new DatabaseObject();
var currentFramesSet = new DatabaseArray();
foreach (byte[] arr in outGoingSnapshots)
{
Console.WriteLine("Obj size: " + arr.Length);
currentObjectSize += arr.Length;
currentFramesSet.Add(arr);
if (currentObjectSize > 400000)
//start new preview part if currentObject size is > 400kb (Playerio obj limmit size is 500kb)
{
fillObject(currentObject, currentFramesSet);
gamelink.PlayerIO.BigDB.CreateObject("Previews", spellName + "_part_" + currentPartID, currentObject,
onObjCreated);
currentObject = new DatabaseObject();
currentFramesSet = new DatabaseArray();
currentPartID++;
currentObjectSize = 0;
}
}
if (currentFramesSet.Count > 0) //create last object
{
fillObject(currentObject, currentFramesSet);
gamelink.PlayerIO.BigDB.CreateObject("Previews", spellName + "_part_" + currentPartID, currentObject,
onObjCreated);
}
Console.WriteLine("Will write obhects with total size: " + outGoingSnapshots);
}
public void TestInit()
{
// Arrange
this.type = typeof(DatabaseArray);
this.db = new DatabaseArray(1);
}
/// <summary>
/// Deserialize's the world data
/// </summary>
/// <param name="worldObject">The world data as a database array</param>
private void Deserialize(DatabaseObject worldObject)
{
Owner = GetValue <string>(worldObject, "owner");
Width = GetValue <int>(worldObject, "width", 200);
Height = GetValue <int>(worldObject, "height", 200);
Title = GetValue <string>(worldObject, "name");
Plays = GetValue <int>(worldObject, "plays");
WorldType = (WorldType)GetValue <int>(worldObject, "type", 3);
AllowPotions = GetValue <bool>(worldObject, "allowpotions", true);
Woots = GetValue <int>(worldObject, "woots", 0);
TotalWoots = GetValue <int>(worldObject, "totalwoots", 0);
Visible = GetValue <bool>(worldObject, "visible", true);
BackgroundColor = new FluidColor(GetValue <uint>(worldObject, "backgroundColor", 0));
//Check is worlddata is present
if (!worldObject.Contains("worlddata"))
{
return;
}
CreateEmptyWorld();
DatabaseArray databaseArray = (DatabaseArray)worldObject["worlddata"];
IEnumerable <object> databaseEnum = (IEnumerable <object>)databaseArray;
using (IEnumerator <object> enumerator = databaseEnum.GetEnumerator())
{
while (enumerator.MoveNext())
{
DatabaseObject blockData = (DatabaseObject)enumerator.Current;
byte[] xBytes = blockData.GetBytes("x");
byte[] yBytes = blockData.GetBytes("y");
BlockID blockId = (BlockID)blockData.GetUInt("type");
for (int i = 0; i < xBytes.Length; i += 2)
{
int x = xBytes[i] << 8 | xBytes[i + 1];
int y = yBytes[i] << 8 | yBytes[i + 1];
if (blockData.Contains("layer"))
{
Layer layer = (Layer)blockData.GetInt("layer");
switch (blockId)
{
case BlockID.HazardSpike:
case BlockID.DecorSciFi2013BlueSlope:
case BlockID.DecorSciFi2013BlueStraight:
case BlockID.DecorSciFi2013YellowSlope:
case BlockID.DecorSciFi2013YellowStraight:
case BlockID.DecorSciFi2013GreenSlope:
case BlockID.DecorSciFi2013GreenStraight:
case BlockID.OneWayCyan:
case BlockID.OneWayPink:
case BlockID.OneWayRed:
case BlockID.OneWayYellow:
{
Rotation rotation = (Rotation)blockData.GetUInt("rotation");
RotatableBlock rotatableBlock = new RotatableBlock(blockId, x, y, rotation);
SetBlock(rotatableBlock);
}
break;
case BlockID.CoinDoor:
case BlockID.BlueCoinDoor:
case BlockID.CoinGate:
case BlockID.BlueCoinGate:
{
uint goal = blockData.GetUInt("goal");
CoinBlock door = new CoinBlock(blockId, x, y, goal);
SetBlock(door);
}
break;
case BlockID.MusicDrum:
case BlockID.MusicPiano:
{
uint musicId = blockData.GetUInt("id");
MusicBlock musicBlock = new MusicBlock(blockId, x, y, musicId);
SetBlock(musicBlock);
}
break;
case BlockID.Portal:
case BlockID.InvisiblePortal:
{
Rotation rotation = (Rotation)blockData.GetUInt("rotation");
uint portalid = blockData.GetUInt("id");
uint portaltarget = blockData.GetUInt("target");
Portal portal = new Portal(blockId, x, y, rotation, portalid, portaltarget);
SetBlock(portal);
}
break;
case BlockID.SwitchPurple:
case BlockID.PurpleSwitchDoor:
case BlockID.PurpleSwitchGate:
{
uint goal = 0;
if (blockData.Contains("goal"))
{
goal = blockData.GetUInt("goal");
}
PurpleBlock purpleBlock = new PurpleBlock(blockId, x, y, goal);
SetBlock(purpleBlock);
}
break;
case BlockID.DeathDoor:
case BlockID.DeathGate:
{
uint goal = blockData.GetUInt("goal");
DeathBlock deathBlock = new DeathBlock(blockId, x, y, goal);
SetBlock(deathBlock);
}
break;
case BlockID.WorldPortal:
{
string targetId = blockData.GetString("target");
WorldPortal worldPortal = new WorldPortal(blockId, x, y, targetId);
SetBlock(worldPortal);
}
break;
case BlockID.DecorSign:
{
string text = blockData.GetString("text");
TextBlock textBlock = new TextBlock(blockId, x, y, text);
SetBlock(textBlock);
}
break;
case BlockID.DecorLabel:
{
string text = blockData.GetString("text");
if (blockData.Contains("text_color"))
{
string hexColor = blockData.GetString("text_color");
LabelBlock labelBlock = new LabelBlock(blockId, x, y, text, hexColor);
SetBlock(labelBlock);
}
else
{
LabelBlock labelBlock = new LabelBlock(blockId, x, y, text);
SetBlock(labelBlock);
}
}
break;
default:
Block block = new Block(blockId, layer, x, y);
SetBlock(block);
break;
}
}
}
}
}
IsLoaded = true;
}
public override void resolve(Player player, string[] commandInput)
{
var lastreport = player.lastreport;
if (lastreport.AddSeconds(90) > DateTime.Now)
{
Console.WriteLine("Spamming. Not saved. " + lastreport + " vs " + DateTime.Now);
player.Send("info", "Report submitted", "Thank you for your report, we'll look into it shortly.");
return;
}
if (commandInput.Length < 3)
{
player.Send("info", "Report", "Please specify a playername and a reason for this report");
return;
}
var reportedUserName = commandInput[1].Trim().ToLower();
var existingReport = this._game.GetLocalCopyOfReport(reportedUserName);
if (existingReport != null)
{
if (existingReport.GetDateTime("Date").AddSeconds(90) > DateTime.Now)
{
Console.WriteLine("Existing report found. Not saved");
//if (existingReport.GetString("ReportedByUsername", "") == player.name)
//{
player.Send("info", "Report submitted", "Thank you for your report, we'll look into it shortly.");
return;
//}
}
}
this._game.PlayerIO.BigDB.Load("usernames", reportedUserName, delegate(DatabaseObject o)
{
if (o == null || o.GetString("owner", null) == null)
{
player.Send("write", this._game.SystemName, "User " + reportedUserName.ToUpper() + " not found");
return;
}
var reportedUserConnectId = o.GetString("owner");
// if theres a reason
var reason = "";
for (var a = 2; a < commandInput.Length; a++)
{
reason += commandInput[a] + " ";
}
// get current chat texts
var chatMessages = this._game.GetLastChatMessages();
var messages = new StringBuilder();
foreach (var message in chatMessages)
{
if (message != null)
{
messages.Append("name: " + message.name + ": " + message.text + " | ");
}
}
var signsList = this._game.BaseWorld.GetBrickTextSignList();
var signtextArray = new DatabaseArray();
foreach (var sign in signsList)
{
signtextArray.Add(sign.text);
}
var chattextArray = new DatabaseArray();
foreach (var message in chatMessages)
{
chattextArray.Add(message.name + ": " + message.text);
}
var report = new DatabaseObject();
report.Set("ReportedByUsername", player.name);
report.Set("ReportedByConnectId", player.ConnectUserId);
report.Set("State", "Open");
report.Set("Date", DateTime.Now);
report.Set("WorldId", this._game.BaseWorld.key);
report.Set("WorldName", this._game.BaseWorld.name);
report.Set("Reason", reason);
report.Set("Signs", signtextArray);
report.Set("ChatLog", chattextArray);
report.Set("ReportedUsername", reportedUserName);
report.Set("ReportedUserConnectId", reportedUserConnectId);
this._game.SaveLocalCopyOfReport(report);
player.lastreport = DateTime.Now;
this._game.PlayerIO.BigDB.CreateObject("AbuseReports", null, report,
delegate
{
player.Send("info", "Report submitted", "Thank you for your report, we'll look into it shortly.");
}, delegate
{
player.lastreport = DateTime.Now.AddHours(-1);
player.Send("info", "Error occured", "An error occured in while submitting. Please try again.");
});
});
}
public override void GotMessage(FBPlayer player, Message m)
{
switch (m.Type)
{
case MessageID.FB_INVITED_USERS:
player.RefreshPlayerObject(delegate() {
DatabaseArray invited = player.PlayerObject.GetArray("FBInvites");
if (invited == null)
{
player.PlayerObject.Set("FBInvites", new DatabaseArray());
invited = player.PlayerObject.GetArray("FBInvites");
}
int count = m.GetInt(0);
string[] keys = new string[count];
int keyCount = 0;
for (uint i = 0; i < count; i++)
{
string id = m.GetString(i + 1);
bool found = false;
for (int j = 0; j < invited.Count; j++)
{
if (id == invited.GetString(j))
{
found = true;
break;
}
}
if (!found)
{
//invited.Add(id);
keys[keyCount++] = id;
}
}
/*for (int j = 0; j < invited.Count; j++) {
* keys[j] = invited.GetString(j);
* }*/
// remove already playing players
PlayerIO.BigDB.LoadKeys("PlayerObjects", keys, delegate(DatabaseObject[] arr) {
foreach (DatabaseObject dbo in arr)
{
if (dbo != null)
{
for (int j = count - 1; j >= 0; j--)
{
if ("fb" + keys[j] == dbo.Key)
{
//invited.RemoveAt(j);
keys[j] = null;
}
}
}
}
for (int i = 0; i < count; i++)
{
if (keys[i] != null)
{
invited.Add(keys[i]);
}
}
player.PlayerObject.Save();
});
});
break;
}
}
public void addLastPlayedMap(String mapKey)
{
if (isGuest)
{
return;
}
DatabaseArray maps = PlayerObject.GetArray("LastPlayedMaps");
DatabaseObject mapEntry = null;
DatabaseObject oldestEntry = null;
int oldestIndex = 0;
for (int i = 0; i < maps.Count; ++i)
{
DatabaseObject entry = maps.GetObject(i.ToString());
if (entry.Contains("Map"))
{
if (entry.GetString("Map") == mapKey)
{
mapEntry = entry;
}
else
{
if (oldestEntry == null || DateTime.Compare(entry.GetDateTime("Date"), oldestEntry.GetDateTime("Date")) < 0)
{
oldestEntry = entry;
oldestIndex = i;
}
}
}
}
// remove oldest entry if list is full
//if (maps.Count > 8) {
// maps.Remove(oldestIndex.ToString());
//}
// if current map is already in last played list, just update date
if (mapEntry != null)
{
mapEntry.Set("Date", DateTime.Now);
}
else
{
DatabaseObject entry = new DatabaseObject();
entry.Set("Map", mapKey);
entry.Set("Date", DateTime.Now);
maps.Add(entry);
}
PlayerObject.Remove("LastPlayedMaps");
//sort the array from the latest to oldest
DatabaseArray newMaps = new DatabaseArray();
int newestIndex = 0;
bool found = false;
do
{
found = false;
newestIndex = 0;
DatabaseObject newestEntry = null;
//foreach(DatabaseObject entry in maps) {
for (int i = 0; i < maps.Count; ++i)
{
if (!maps.Contains(i.ToString()))
{
continue;
}
DatabaseObject entry = maps.GetObject(i.ToString());
if (!entry.Contains("Date"))
{
continue;
}
if (newestEntry == null || DateTime.Compare(entry.GetDateTime("Date"), newestEntry.GetDateTime("Date")) > 0)
{
newestEntry = entry;
newestIndex = i;
found = true;
}
}
if (found)
{
DatabaseObject tmp = maps.GetObject(newestIndex.ToString());
maps.Remove(newestIndex.ToString());
bool duplicate = false;
foreach (DatabaseObject dbo in newMaps)
{
if (dbo.GetString("Map") == tmp.GetString("Map"))
{
duplicate = true;
break;
}
}
if (duplicate)
{
continue;
}
DatabaseObject tmp2 = new DatabaseObject();
tmp2.Set("Map", tmp.GetString("Map"));
tmp2.Set("Date", tmp.GetDateTime("Date"));
//newMaps.Add(tmp2);
newMaps.Insert(0, tmp2);
}
} while (found && newMaps.Count < 8);
//newMaps = (DatabaseArray)newMaps.Reverse();
PlayerObject.Set("LastPlayedMaps", newMaps);
/*maps = PlayerObject.GetArray("LastPlayedMaps");
* for (int i = 0; i < maps.Count; i++) {
* Console.WriteLine(maps.GetObject(i).GetString("Map"));
* }*/
savePlayerData();
}
private void UnserializeFromComplexObject(DatabaseArray worlddata)
{
foreach (DatabaseObject ct in worlddata)
{
if (ct.Count == 0) continue;
var type = (uint)ct.GetValue("type");
var layerNum = ct.GetInt("layer", 0);
var xs = ct.GetBytes("x", new byte[0]);
var ys = ct.GetBytes("y", new byte[0]);
if (layerNum == 0)
{
var foreground = (Foreground.Id)type;
var block = WorldUtils.GetDatabaseBlock(ct, foreground);
for (var b = 0; b < xs.Length; b += 2)
{
var nx = (xs[b] << 8) + xs[b + 1];
var ny = (ys[b] << 8) + ys[b + 1];
this.Foreground[nx, ny] = block;
}
}
else
{
var background = (Background.Id)type;
var block = new BackgroundBlock(background);
for (var b = 0; b < xs.Length; b += 2)
{
var nx = (xs[b] << 8) + xs[b + 1];
var ny = (ys[b] << 8) + ys[b + 1];
this.Background[nx, ny] = block;
}
}
}
}
// This method is called when a player sends a message into the server code
public override void GotMessage(Player player, Message message)
{
switch (message.Type)
{
// player has moved up, down, left, or right
case "move":
{
//Console.WriteLine("Player position before move: " + player.positionX + ", " + player.positionY); //debug
int messageX = message.GetInt(0);
int messageY = message.GetInt(1);
player.positionX = player.positionX + messageX;
player.positionY = player.positionY + messageY;
//Console.WriteLine("Player " + player.Id + " is moving to (" + player.positionX + ", " + player.positionY + ")"); //debug
Broadcast("PlayerMove", player.Id, messageX, messageY);
break;
}
case "LoadPlayers":
{
// this is how you broadcast a messa"LoadPlayers":
//Update them on who is already in the game
foreach (Player x in players)
{
if (x != null && x != player)
{
//Console.WriteLine("Sending Player " + player.Id + " Player " + x.Id + " Position (" + x.positionX + ", " + x.positionY + ")"); //debug
player.Send("UserJoined", x.Id, x.positionX, x.positionY, x.ConnectUserId);
}
}
break;
}
//Load the coins, randomize them if they dont exist
case "LoadCoins":
{
Random random = new Random();
if (Coins == null)
{
DatabaseArray coins = new DatabaseArray();
for (int i = 0; i < 5; i++)
{
DatabaseObject coin = new DatabaseObject();
int randomX = random.Next(0, 9);
int randomY = random.Next(0, 9);
coin.Set("xTile", randomX);
coin.Set("yTile", randomY);
coin.Set("Uses", 0);
player.Send("coinSetup", randomX, randomY, 0);
coins.Set(i, coin);
}
Coins = coins;
quest.Set("Coins", Coins);
quest.Save();
}
else
{
for (int i = 0; i < 5; i++)
{
DatabaseObject coin = Coins.GetObject(i);
player.Send("coinSetup", coin.GetInt("xTile"), coin.GetInt("yTile"), coin.GetInt("Uses"));
}
}
break;
}
// client is asking for data about player to draw on the screen
case "playerInfo":
{
if (players[player.Id - 1] == null)
{
player.Send("noSuchPlayer");
}
else
{
player.Send("playerInfo", players[player.Id - 1].positionX, players[player.Id - 1].positionY, playerConnectUserId, player.characterClass);
}
break;
}
case "MapTileChanged":
{
int xTile = message.GetInt(0);
int yTile = message.GetInt(1);
int newTileType = message.GetInt(2);
//Console.WriteLine("Map Tile Change From Player " + player.Id + " (" + xTile + "," + yTile + ") to type: " + newTileType);
Broadcast("MapTileChanged", player.Id, xTile, yTile, newTileType);
break;
}
// update server's variables for this player stat
case "updateStat":
{
String statType = message.GetString(0);
switch (statType)
{
case "AP":
player.AP = message.GetInt(1);
//Console.WriteLine("server: player's AP changed! " + player.AP);
break;
case "lumber":
amountLumber = message.GetInt(1);
//Console.WriteLine("server: player's lumber changed! " + amountLumber);
break;
case "cherry":
amountCherry = message.GetInt(1);
//Console.WriteLine("server: player's cherry changed! " + amountCherry);
break;
}
break;
}
case "win":
{
PlayerIO.BigDB.Load(mapType, levelKey,
delegate(DatabaseObject result)
{
// todo: change these based on what you got in the level
int gainedxp = 0; // = result.GetInt("XP");
int gainedcoin = 0; // = result.GetInt("Coin");
if (result != null)
{
gainedxp = result.GetInt("XP", 0); //How much XP the Level was worth
gainedcoin = result.GetInt("Coin", 0); //How mucg coin the level was worth
}
String nextLevel = "";
//Check to see if player completed Tutorial level, in which case update their tutorial value
if (player.PlayerObject.GetInt("tutorial") == 1)
{
DatabaseArray abilities = new DatabaseArray();
abilities.Add("Crafter_Bridge");
player.PlayerObject.Set("abilities", abilities);
player.PlayerObject.Set("tutorial", 2);
nextLevel = "Tutorial_2";
}
else if (player.PlayerObject.GetInt("tutorial") == 2)
{
DatabaseArray abilities = player.PlayerObject.GetArray("abilities");
abilities.Add("Planter_RedFlower");
player.PlayerObject.Set("tutorial", 3);
nextLevel = "Tutorial_3";
}
else if (player.PlayerObject.GetInt("tutorial") == 3)
{
player.PlayerObject.Set("tutorial", 4);
nextLevel = "Tutorial_4";
}
else if (player.PlayerObject.GetInt("tutorial") == 4)
{
DatabaseArray abilities = player.PlayerObject.GetArray("abilities");
abilities.Add("Cook_MonsterBacon");
player.PlayerObject.Set("tutorial", 5);
nextLevel = "Tutorial_5";
}
else if (player.PlayerObject.GetInt("tutorial") == 5)
{
nextLevel = "Class_Choose";
player.PlayerObject.Set("tutorial", 6);
}
int experience = player.PlayerObject.GetInt("xp");
/*int level = player.PlayerObject.GetInt("level");
*
*
* //Check to see if the player has enough XP to level up
* if (experience + gainedxp >= levelXP(level + 1))
* {
* player.PlayerObject.Set("level", level + 1);
* }*/
player.PlayerObject.Set("xp", experience + gainedxp);
player.PlayerObject.Set("coin", player.PlayerObject.GetInt("coin", 0) + gainedcoin);
player.PlayerObject.Save(delegate()
{
// quest is finished; remove this quest from the table
// todo: what happens if another player is playing this quest?
PlayerIO.BigDB.DeleteKeys("NewQuests", questID);
//Console.WriteLine("deleted newquest key");
PlayerIO.BigDB.Load("PlayerObjects", player.ConnectUserId,
delegate(DatabaseObject thisPlayer)
{
thisPlayer.Set("questID", "noQuest");
thisPlayer.Save(delegate() { Broadcast("win", gainedxp, gainedcoin, nextLevel); });
}
);
});
},
delegate(PlayerIOError error)
{
//Console.WriteLine(error.ToString());
});
break;
}
// recieves one string that is the newly updated map; save to associated quest object
case "QuestMapUpdate":
{
questMap = message.GetString(0);
player.GetPlayerObject(
delegate(DatabaseObject updatedPlayerObject){
PlayerIO.BigDB.Load("NewQuests", questID,
delegate(DatabaseObject dbo)
{
dbo.Set("tileValues", message.GetString(0));
dbo.Save();
});
});
break;
}
case "MonsterAPChange":
{
int newAp = message.GetInt(0);
int monsterIndex = message.GetInt(1);
PlayerIO.BigDB.Load("newQuests", questID,
delegate(DatabaseObject dbo)
{
DatabaseArray monsters = dbo.GetArray("Monsters");
monsters.GetObject(monsterIndex).Set("AP", newAp);
dbo.Save();
});
Broadcast("MonsterAPChange", player.Id, newAp, monsterIndex);
break;
}
case "SpriteMove":
{
String type = message.GetString(0);
int newXTile = message.GetInt(1);
int newYTile = message.GetInt(2);
int monsterIndex = message.GetInt(3);
PlayerIO.BigDB.Load("newQuests", questID,
delegate(DatabaseObject dbo)
{
DatabaseArray sprites = dbo.GetArray(type);
DatabaseObject sprite = sprites.GetObject(monsterIndex);
sprite.Set("xTile", newXTile);
sprite.Set("yTile", newYTile);
dbo.Save();
});
break;
}
case "AddSprite":
{
String type = message.GetString(0);
int xTile = message.GetInt(1);
int yTile = message.GetInt(2);
String name = message.GetString(3);
int range = message.GetInt(4);
DatabaseObject newSprite = new DatabaseObject();
newSprite.Set("xTile", xTile);
newSprite.Set("yTile", yTile);
newSprite.Set("Type", name);
newSprite.Set("Uses", 0);
newSprite.Set("Range", range);
Broadcast("AddSprite", xTile, yTile, name, range);
PlayerIO.BigDB.Load("newQuests", questID,
delegate(DatabaseObject dbo)
{
if (dbo.Contains(type))
{
DatabaseArray sprites = dbo.GetArray(type);
sprites.Add(newSprite);
}
else
{
DatabaseArray sprites = new DatabaseArray();
sprites.Add(newSprite);
dbo.Set(type, sprites);
}
dbo.Save();
});
break;
}
case "SpriteUse":
{
int index = message.GetInt(0);
int uses = message.GetInt(1);
//Console.WriteLine("Sprite " + index + " Is being used for the " + uses + " time");
Broadcast("SpriteUse", player.Id, index);
PlayerIO.BigDB.Load("newQuests", questID,
delegate(DatabaseObject dbo)
{
DatabaseArray sprites = dbo.GetArray("Effects");
DatabaseObject sprite = sprites.GetObject(index);
sprite.Set("Uses", uses);
dbo.Save();
});
break;
}
case "CoinUse":
{
int index = message.GetInt(0);
int uses = message.GetInt(1);
Broadcast("CoinUse", player.Id, index);
PlayerIO.BigDB.Load("newQuests", questID,
delegate(DatabaseObject dbo)
{
DatabaseArray sprites = dbo.GetArray("Coins");
DatabaseObject sprite = sprites.GetObject(index);
Coins.GetObject(index).Set("Uses", uses);
sprite.Set("Uses", uses);
dbo.Save();
});
break;
}
}
}
// This method is called whenever a player joins the game
public override void UserJoined(Player player)
{
// this is how you send a player a message
//Send the player their player Number.
playerConnectUserId = player.ConnectUserId;
if (numPlayers < players.Length)
{
players[numPlayers] = player;
//Console.WriteLine("New Player " + player.Id);
numPlayers++;
// if player is not attached to a quest, give them a new quest ID
PlayerIO.BigDB.Load("PlayerObjects", player.ConnectUserId,
delegate(DatabaseObject result)
{
player.characterClass = result.GetString("role", "Novice");
player.costume = result.GetString("costume", "novice");
player.tutorialLevel = result.GetInt("tutorial", 1);
//Console.WriteLine("player class: " + player.characterClass);
if (questID != null && (!result.Contains("questID") || result.GetString("questID") == "noQuest"))
{
result.Set("questID", questID);
result.Save();
PlayerIO.BigDB.Load("NewQuests", questID,
delegate(DatabaseObject quest)
{
this.quest = quest;
DatabaseObject questPlayerData = new DatabaseObject();
player.positionX = startX;
player.positionY = startY;
questPlayerData.Set("positionX", startX);
questPlayerData.Set("positionY", startY);
questPlayerData.Set("AP", 20);
quest.GetObject("players").Set(player.ConnectUserId, questPlayerData);
quest.GetObject("players").Set("numPlayers", quest.GetObject("players").Count - 1);
quest.Save(delegate()
{
player.Send("init", player.Id, player.ConnectUserId, startX, startY, questID, 20, levelKey, "", player.characterClass);
});
Broadcast("UserJoined", player.Id, player.positionX, player.positionY);
});
}
// if player does not have a questID associated with it
// create new object in Quests db
else if (!result.Contains("questID") || result.GetString("questID") == "noQuest")
{
// create new quest object
DatabaseObject newQuest = new DatabaseObject();
// create array for players playing this new quest object
DatabaseObject questPlayers = new DatabaseObject();
// create new object for this player and their quest data
DatabaseObject questPlayerData = new DatabaseObject();
//Console.WriteLine("questPlayers contents: " + questPlayers.ToString());
//Console.WriteLine("Level key: " + levelKey);
//Add Static Map to Quest, to be updated later
PlayerIO.BigDB.Load(mapType, levelKey,
delegate(DatabaseObject staticMap)
{
player.positionX = startX = staticMap.GetInt("startX", 0);
player.positionY = startY = staticMap.GetInt("startY", 0);
questPlayerData.Set("positionX", startX);
questPlayerData.Set("positionY", startY);
questPlayerData.Set("AP", 20);
// add this player to players playing this quest
questPlayers.Set("numPlayers", 1);
questPlayers.Set(player.ConnectUserId, questPlayerData);
newQuest.Set("players", questPlayers);
newQuest.Set("StaticMapKey", staticMap.Key);
newQuest.Set("tileValues", staticMap.GetString("tileValues"));
newQuest.Set("MonsterCount", staticMap.GetInt("MonsterCount"));
if (staticMap.Contains("Monsters"))
{
DatabaseArray monsters = staticMap.GetArray("Monsters");
DatabaseArray newMonsters = new DatabaseArray();
for (int i = 1; i <= monsters.Count; i++)
{
DatabaseObject monster = new DatabaseObject();
monster.Set("Type", monsters.GetObject(i - 1).GetString("Type"));
monster.Set("xTile", monsters.GetObject(i - 1).GetInt("xTile"));
monster.Set("yTile", monsters.GetObject(i - 1).GetInt("yTile"));
monster.Set("AP", monsters.GetObject(i - 1).GetInt("AP"));
newMonsters.Add(monster);
}
newQuest.Set("Monsters", newMonsters);
}
if (staticMap.Contains("Buttons"))
{
DatabaseArray buttons = staticMap.GetArray("Buttons");
DatabaseArray newButtons = new DatabaseArray();
for (int i = 1; i <= buttons.Count; i++)
{
DatabaseObject button = new DatabaseObject();
button.Set("xTile", buttons.GetObject(i - 1).GetInt("xTile"));
button.Set("yTile", buttons.GetObject(i - 1).GetInt("yTile"));
button.Set("xOpen", buttons.GetObject(i - 1).GetInt("xOpen"));
button.Set("yOpen", buttons.GetObject(i - 1).GetInt("yOpen"));
newButtons.Add(button);
}
newQuest.Set("Buttons", newButtons);
}
Console.WriteLine("Setting up new quest " + newQuest.ToString());
// add this quest object to Quests db
PlayerIO.BigDB.CreateObject("NewQuests", null, newQuest,
delegate(DatabaseObject addedQuest)
{
questID = addedQuest.Key;
addedQuest.Set("RoomID", this.RoomId);
Console.WriteLine("made new questID! new questID is: " + questID);
result.Set("questID", addedQuest.Key);
result.Save();
//levelKey = addedQuest.Key;
// tell client to initialize (board, monsters, player object & player sprite) with max AP amount
addedQuest.Save(delegate() { quest = addedQuest; player.Send("init", player.Id, player.ConnectUserId, startX, startY, questID, 20, levelKey, "", player.costume); });
Broadcast("UserJoined", player.Id, player.positionX, player.positionY);
});
});
// save positions in the serverside
player.AP = 20;
}
// else, this player has a questID saved
else
{
questID = result.GetString("questID");
//levelKey = questID;
// obtain player's last position and save to serverside
PlayerIO.BigDB.Load("NewQuests", questID,
delegate(DatabaseObject questObject)
{
quest = questObject;
questObject.Set("RoomID", this.RoomId);
questObject.Save();
Coins = questObject.GetArray("Coins");
String resources = ""; // player's resources, to pass to client
if (questObject != null)
{
levelKey = questObject.GetString("StaticMapKey");
// extract players playing this quest
DatabaseObject playersInQuest = questObject.GetObject("players");
DatabaseObject thisPlayer = playersInQuest.GetObject(player.ConnectUserId);
player.positionX = thisPlayer.GetInt("positionX");
player.positionY = thisPlayer.GetInt("positionY");
int startAP = thisPlayer.GetInt("AP");
if (thisPlayer.Contains("lastSessionEndTime"))
{
// figure out how much AP player should have based on how long they've been away
lastSessionEndTime = thisPlayer.GetDateTime("lastSessionEndTime");
//Console.WriteLine("last session end time : " + lastSessionEndTime.ToString(DateTimeFormat));
int minutesPassedSinceLastPlay = (startSessionTime - lastSessionEndTime).Minutes;
startAP += minutesPassedSinceLastPlay / 3;
//Console.WriteLine("minutes passed: " + minutesPassedSinceLastPlay + ", amount of AP to add: " + (minutesPassedSinceLastPlay / 3) + ", starting AP: " + startAP);
if (startAP > 20)
{
startAP = 20;
}
player.AP = startAP;
}
else
{
player.AP = 20;
}
// get information about player resources from db
if (thisPlayer.Contains("resources"))
{
DatabaseObject resourcesObject = thisPlayer.GetObject("resources");
Console.WriteLine("resources object: " + resourcesObject.ToString());
if (resourcesObject.Contains("lumber"))
{
amountLumber = resourcesObject.GetInt("lumber");
resources += "Lumber:" + amountLumber;
}
if (resourcesObject.Contains("cherry"))
{
amountCherry = resourcesObject.GetInt("cherry");
resources += "/Cherry:" + amountCherry;
}
Console.WriteLine("resources string: " + resources);
}
}
// tell client to initialize (board, monsters, player object & player sprite)
player.Send("init", player.Id, player.ConnectUserId, player.positionX, player.positionY, questID, player.AP, levelKey, resources, player.costume);
Broadcast("UserJoined", player.Id, player.positionX, player.positionY);
}
);
}
}
);
}
else
{
player.Send("full");
}
Console.WriteLine("userJoined is done");
}
private void fillObject(DatabaseObject currentObject, DatabaseArray currentFramesSet)
{
currentObject.Set("spellName", spellName);
currentObject.Set("frames", currentFramesSet);
currentObject.Set("areaWidth", areaWidth);
currentObject.Set("areaHeight", areaHeight);
}
public void Save(string roomId, World world)
{
var dbo = this.campaignPlayer;
var effects = new DatabaseArray();
foreach (var effect in this.player.GetEffects())
{
// If it's timed effect we can assume it expired and simply reset player's position to checkpoint
if (effect.CanExpire)
{
this.player.Checkpoint =
world.GetBrickType(0, this.player.Checkpoint.X, this.player.Checkpoint.Y) ==
(uint)ItemTypes.Checkpoint
? this.player.Checkpoint
: world.GetSpawn();
this.player.X = this.player.Checkpoint.X * 16;
this.player.Y = this.player.Checkpoint.Y * 16;
this.player.SpeedX = 0;
this.player.SpeedY = 0;
this.player.Deaths += 1;
}
else
{
var effectObject = new DatabaseObject().Set("Id", (int)effect.Id);
if (effect.Id == EffectId.Multijump)
{
effectObject.Set("Arg", effect.Duration);
}
else if (effect.Id == EffectId.Gravity)
{
effectObject.Set("Arg", effect.Duration);
}
effects.Add(effectObject);
}
}
var goldCoins = this.GetPositionsArray(this.player.Coinmap.Where(it => it.Block.Type == 100).ToList());
var blueCoins = this.GetPositionsArray(this.player.Coinmap.Where(it => it.Block.Type == 101).ToList());
var coinsObject = new DatabaseObject()
.Set("Gold", new DatabaseObject()
.Set("Count", this.player.Coins)
.Set("PosX", goldCoins.Item1)
.Set("PosY", goldCoins.Item2))
.Set("Blue", new DatabaseObject()
.Set("Count", this.player.BlueCoins)
.Set("PosX", blueCoins.Item1)
.Set("PosY", blueCoins.Item2));
var backupObject = new DatabaseObject()
.Set("RoomId", roomId)
.Set("SaveTime", DateTime.UtcNow)
.Set("PosX", this.player.X)
.Set("PosY", this.player.Y)
.Set("Coins", coinsObject)
.Set("Deaths", this.player.Deaths)
.Set("CheckpointX", this.player.Checkpoint.X)
.Set("CheckpointY", this.player.Checkpoint.Y)
.Set("TotalMovements", this.player.TotalMovements)
.Set("IsCheater", this.player.IsCheater)
.Set("AntiFlightHeat", this.player.AntiFlightHeat)
.Set("AntiJumpHeat", this.player.AntiJumpHeat)
.Set("Switches", VarintConverter.GetVarintBytes(this.player.Switches))
.Set("Team", this.player.Team)
.Set("Effects", effects)
.Set("SpeedX", this.player.SpeedX)
.Set("SpeedY", this.player.SpeedY)
.Set("PlayTime", (DateTime.UtcNow - this.player.CampaignJoinTime).TotalMinutes);
dbo.Set(ObjectName, backupObject);
dbo.Save();
}
public static BigDBObjectValue Create(object value)
{
switch (value)
{
case string temp: return(new BigDBObjectValue(ObjectType.String, value));
case int temp: return(new BigDBObjectValue(ObjectType.Int, value));
case uint temp: return(new BigDBObjectValue(ObjectType.UInt, value));
case long temp: return(new BigDBObjectValue(ObjectType.Long, value));
case float temp: return(new BigDBObjectValue(ObjectType.Float, value));
case double temp: return(new BigDBObjectValue(ObjectType.Double, value));
case bool temp: return(new BigDBObjectValue(ObjectType.Bool, value));
case byte[] temp: return(new BigDBObjectValue(ObjectType.ByteArray, value));
case DateTime DateTime: return(new BigDBObjectValue(ObjectType.DateTime, DateTime.ToUnixTime()));
case DatabaseObject DatabaseObject: return(new BigDBObjectValue(ObjectType.DatabaseObject, DatabaseObject.Properties.ToArray()));
case DatabaseObject[] DatabaseArray: return(new BigDBObjectValue(ObjectType.DatabaseArray, DatabaseArray.SelectMany(p => p.Properties).ToArray()));
default: throw new ArgumentException($"The type { value.GetType().FullName } is not supported.", nameof(value));
}
}
public void save(Callback callback)
{
if (this.dbo != null)
{
var bricks = this.getBrickList(0);
bricks.AddRange(this.getBrickList(1));
var worlddata = new DatabaseArray();
foreach (var b in bricks)
{
var cb = new DatabaseObject();
var i = b.xs.Count;
var xs = new byte[i * 2];
var ys = new byte[i * 2];
for (var a = 0; a < i; a++)
{
xs[a * 2] = (byte)((b.xs[a] & 65280U) >> 8);
xs[a * 2 + 1] = (byte)(b.xs[a] & 255U);
ys[a * 2] = (byte)((b.ys[a] & 65280U) >> 8);
ys[a * 2 + 1] = (byte)(b.ys[a] & 255U);
}
cb.Set("type", b.type);
cb.Set("layer", b.layer);
cb.Set("x", xs);
cb.Set("y", ys);
var type = b.type;
if (type <= 77U)
{
if (type != 43U)
{
if (type == 77U)
{
cb.Set("id", b.id);
}
}
else
{
cb.Set("goal", b.goal);
}
}
else if (type != 83U)
{
if (type != 242U)
{
if (type == 1000U)
{
cb.Set("text", b.text);
}
}
else
{
cb.Set("rotation", b.rotation);
cb.Set("id", b.id);
cb.Set("target", b.target);
}
}
else
{
cb.Set("id", b.id);
}
worlddata.Add(cb);
}
this.dbo.Set("worlddata", worlddata);
if (this.dbo.Contains("world"))
{
this.dbo.Remove("world");
}
this.dbo.Save(callback);
}
}
