internal static bool Prefix(GameServer __instance, IncomingMessage message)
{
if (gsskip)
{
return(true);
}
try
{
if (message.MessageType == 99)
{
PyNet.receiveMessage(message);
}
else
{
gsskip = true;
__instance.processIncomingMessage(message);
gsskip = false;
}
}
catch (Exception e)
{
PyTKMod._monitor.Log("Errot processing Message: Type:" + message.MessageType + " Data:" + message.Data, StardewModdingAPI.LogLevel.Error);
PyTKMod._monitor.Log(e.Message + ":" + e.StackTrace, StardewModdingAPI.LogLevel.Error);
}
return(false);
}
private void respondToFarmer(long farmer, int id, params TOut[] dataSet)
{
foreach (TOut data in dataSet)
{
object objectData = data;
if (serializationType == SerializationType.XML)
{
if (xmlSerializer == null)
{
xmlSerializer = new XmlSerializer(typeof(TOut));
}
StringWriter writer = new StringWriter();
xmlSerializer.Serialize(writer, data);
objectData = writer.ToString();
}
else if (serializationType == SerializationType.JSON)
{
objectData = JsonConvert.SerializeObject(data);
}
PyNet.sendMessage(new MPMessage(address + "." + id, Game1.player, objectData, (int)serializationType, farmer));
}
}
public IEnumerable <T> receive(long fromFarmer = -1)
{
foreach (MPMessage msg in PyNet.getNewMessages(address, -1, fromFarmer))
{
yield return(deserialize((SerializationType)msg.type, msg.message));
}
}
private IEnumerable <MPMessage> receive()
{
foreach (MPMessage msg in PyNet.getNewMessages(address, -1, -1))
{
yield return(msg);
}
}
public static string serialize(object contents, ContentType type)
{
if (type == ContentType.DictInt)
{
StringWriter writer = new StringWriter();
(contents as SerializableDictionary <int, string>).WriteXml(XmlWriter.Create(writer));
return(PyNet.CompressString(writer.ToString()));
}
if (type == ContentType.DictString)
{
StringWriter writer = new StringWriter();
(contents as SerializableDictionary <string, string>).WriteXml(XmlWriter.Create(writer));
return(PyNet.CompressString(writer.ToString()));
}
if (type == ContentType.Texture)
{
return(PyNet.CompressString(JsonConvert.SerializeObject(new SerializationTexture2D((contents as Texture2D)))));
}
if (type == ContentType.Map)
{
NewTiledTmxFormat format = new NewTiledTmxFormat();
return(PyNet.CompressString(format.AsString((contents as Map))));
}
return("na");
}
private static void sendInstruction <T>(string assetName, T asset, ContentType type, bool toGameContent, Farmer farmer, Action <bool> callback, int timeout)
{
if (contentPipe.ContainsKey(farmer) && contentPipe[farmer].Contains(assetName))
{
return;
}
if (contentPipe.ContainsKey(farmer))
{
contentPipe[farmer].AddOrReplace(assetName);
}
else
{
contentPipe.Add(farmer, new List <string>()
{
assetName
});
}
Task.Run(async() =>
{
await PyNet.sendRequestToFarmer <bool>(receiverName, new ContentResponse(assetName, (int)type, serialize(asset, type), toGameContent), farmer, (r) =>
{
if (!r)
{
callback(false);
}
else
{
callback(r);
}
}, SerializationType.JSON, timeout);
});
}
public void sendToFarmer(long farmer, SerializationType serializationType = SerializationType.PLAIN, params T[] dataSet)
{
foreach (T data in dataSet)
{
PyNet.sendMessage(new MPMessage(address, Game1.player, serialize(serializationType, data), (int)serializationType, farmer));
}
}
public static T deserialize <T>(ContentResponse response)
{
if (response.type == (int)ContentType.DictInt)
{
SerializableDictionary <int, string> newAsset = new SerializableDictionary <int, string>();
StringReader reader = new StringReader(PyNet.DecompressString(response.content));
newAsset.ReadXml(XmlReader.Create(reader));
return((T)(object)newAsset);
}
if (response.type == (int)ContentType.DictString)
{
SerializableDictionary <string, string> newAsset = new SerializableDictionary <string, string>();
StringReader reader = new StringReader(PyNet.DecompressString(response.content));
newAsset.ReadXml(XmlReader.Create(reader));
return((T)(object)newAsset);
}
if (response.type == (int)ContentType.Texture)
{
SerializationTexture2D sTexture = JsonConvert.DeserializeObject <SerializationTexture2D>(PyNet.DecompressString(response.content));
return((T)(object)sTexture.getTexture());
}
if (response.type == (int)ContentType.Map)
{
NewTiledTmxFormat format = new NewTiledTmxFormat();
StringReader reader = new StringReader(PyNet.DecompressString(response.content));
Map map = format.Load(XmlReader.Create(reader));
return((T)(object)map);
}
return((T)(object)null);
}
internal static bool canBeRebuildInMultiplayer(object obj)
{
if (!(getDataString(obj).StartsWith(newPrefix) || getDataString(obj).StartsWith(oldPrefix)))
{
return(false);
}
string dataString = getDataString(obj);
preProcessors.useAll(p => dataString = p.Invoke(dataString));
dataString = dataString.Replace(" " + valueSeperator.ToString() + " ", valueSeperator.ToString());
string[] data = splitElemets(dataString);
bool result = true;
if (typeCheckCache.Contains(data[2]))
{
return(true);
}
foreach (Farmer farmer in Game1.otherFarmers.Values.Where(f => f.isActive() && f != Game1.player))
{
Task <bool> fResult = PyNet.sendRequestToFarmer <bool>(typeCheckerName, data[2], farmer);
fResult.Wait();
result = result && fResult.Result;
}
if (result)
{
typeCheckCache.Add(data[2]);
}
return(result);
}
public virtual void ReadFull(BinaryReader reader, NetVersion version)
{
string dataString = PyNet.DecompressString(reader.ReadString());
reader.ReadBoolean();
string replacementString = PyNet.DecompressString(reader.ReadString());
Dictionary <string, string> data = new Dictionary <string, string>();
foreach (string s in dataString.Split(SaveHandler.seperator))
{
string[] d = s.Split(SaveHandler.valueSeperator);
data.Add(d[0], d[1]);
}
object elementReplacement = Element.getReplacement();
SaveHandler.ReplaceAll(elementReplacement, elementReplacement);
if (ReplacementSerializer == null)
{
ReplacementSerializer = new XmlSerializer(elementReplacement.GetType());
}
StringReader replacementStringReader = new StringReader(replacementString);
object replacement = ReplacementSerializer.Deserialize(replacementStringReader);
SaveHandler.RebuildAll(replacement, replacement);
Element.rebuild(data, replacement);
}
public static Map Load(string path, IModHelper helper, bool syncTexturesToClients, IContentPack contentPack)
{
Dictionary <TileSheet, Texture2D> tilesheets = Helper.Reflection.GetField <Dictionary <TileSheet, Texture2D> >(Game1.mapDisplayDevice, "m_tileSheetTextures").GetValue();
Map map = tmx2map(Path.Combine(contentPack != null ? contentPack.DirectoryPath : helper.DirectoryPath, path));
string fileName = new FileInfo(path).Name;
Monitor.Log(path);
foreach (TileSheet t in map.TileSheets)
{
t.ImageSource = t.ImageSource.Replace(".png", "");
string[] seasons = new string[] { "summer_", "fall_", "winter_" };
string tileSheetPath = path.Replace(fileName, t.ImageSource + ".png");
FileInfo tileSheetFile = new FileInfo(Path.Combine(contentPack != null ? contentPack.DirectoryPath : helper.DirectoryPath, tileSheetPath));
FileInfo tileSheetFileVanilla = new FileInfo(Path.Combine(PyUtils.getContentFolder(), "Content", t.ImageSource + ".xnb"));
if (tileSheetFile.Exists && !tileSheetFileVanilla.Exists && tilesheets.Find(k => k.Key.ImageSource == t.ImageSource).Key == null)
{
Texture2D tilesheet = contentPack != null?contentPack.LoadAsset <Texture2D>(tileSheetPath) : helper.Content.Load <Texture2D>(tileSheetPath);
tilesheet.inject(t.ImageSource);
tilesheet.inject("Maps/" + t.ImageSource);
if (syncTexturesToClients && Game1.IsMultiplayer && Game1.IsServer)
{
foreach (Farmer farmhand in Game1.otherFarmers.Values)
{
PyNet.sendGameContent(t.ImageSource, tilesheet, farmhand, (b) => Monitor.Log("Syncing " + t.ImageSource + " to " + farmhand.Name + ": " + (b ? "successful" : "failed"), b ? LogLevel.Info : LogLevel.Warn));
}
}
if (t.ImageSource.Contains("spring_"))
{
foreach (string season in seasons)
{
string seasonPath = path.Replace(fileName, t.ImageSource.Replace("spring_", season));
FileInfo seasonFile = new FileInfo(Path.Combine(contentPack != null ? contentPack.DirectoryPath : helper.DirectoryPath, seasonPath + ".png"));
if (seasonFile.Exists && tilesheets.Find(k => k.Key.ImageSource == t.ImageSource.Replace("spring_", season)).Key == null)
{
Texture2D seasonTilesheet = contentPack != null?contentPack.LoadAsset <Texture2D>(seasonPath + ".png") : helper.Content.Load <Texture2D>(seasonPath + ".png");
string seasonTextureName = t.ImageSource.Replace("spring_", season);
seasonTilesheet.inject(seasonTextureName);
seasonTilesheet.inject("Maps/" + seasonTextureName);
if (syncTexturesToClients && Game1.IsMultiplayer && Game1.IsServer)
{
foreach (Farmer farmhand in Game1.otherFarmers.Values)
{
PyNet.sendGameContent(new string[] { seasonTextureName, "Maps/" + seasonTextureName }, seasonTilesheet, farmhand, (b) => Monitor.Log("Syncing " + seasonTextureName + " to " + farmhand.Name + ": " + (b ? "successful" : "failed"), b ? LogLevel.Info : LogLevel.Warn));
}
}
}
}
}
}
}
map.LoadTileSheets(Game1.mapDisplayDevice);
return(map);
}
internal static void sendMoney(Farmer receiver, int money)
{
Task.Run(async() =>
{
await PyNet.sendRequestToFarmer <bool>(moneyReceiverName, money, receiver, (b) => { if (!b)
{
Game1.player.Money += money;
}
}, SerializationType.PLAIN, 3000);
});
}
private void syncMaps(IEnumerable <SFarmer> farmers)
{
foreach (SFarmer farmer in farmers)
{
foreach (KeyValuePair <string, Map> map in mapsToSync)
{
PyNet.syncMap(map.Value, map.Key, Game1.player);
}
syncedFarmers.AddOrReplace(farmer);
}
}
public virtual void Read(BinaryReader reader, NetVersion version)
{
string dataString = PyNet.DecompressString(reader.ReadString());
Dictionary <string, string> data = new Dictionary <string, string>();
foreach (string s in dataString.Split(SaveHandler.seperator))
{
string[] d = s.Split(SaveHandler.valueSeperator);
data.Add(d[0], d[1]);
}
Element.sync(data);
}
internal static bool Prefix(IncomingMessage message)
{
if (message.MessageType == 99)
{
PyNet.receiveMessage(message);
}
else
{
return(true);
}
return(false);
}
public Texture2D getTexture()
{
byte[] buffer = PyNet.DecompressBytes(Data);
MemoryStream stream = new MemoryStream(buffer);
BinaryReader reader = new BinaryReader(stream);
Color[] colors = new Color[Width * Height];
for (int i = 0; i < colors.Length; i++)
{
var r = reader.ReadByte();
var g = reader.ReadByte();
var b = reader.ReadByte();
var a = reader.ReadByte();
colors[i] = new Color(r, g, b, a);
}
Texture2D texture = null;
if (IsScaled)
{
byte[] sbuffer = PyNet.DecompressBytes(ScaledData);
MemoryStream sstream = new MemoryStream(sbuffer);
BinaryReader sreader = new BinaryReader(sstream);
Color[] scolors = new Color[ScaledWidth * ScaledHeight];
for (int i = 0; i < scolors.Length; i++)
{
var sr = sreader.ReadByte();
var sg = sreader.ReadByte();
var sb = sreader.ReadByte();
var sa = sreader.ReadByte();
scolors[i] = new Color(sr, sg, sb, sa);
}
Texture2D stexture = new Texture2D(Game1.graphics.GraphicsDevice, ScaledWidth, ScaledHeight);
stexture.SetData(scolors);
texture = new ScaledTexture2D(Game1.graphics.GraphicsDevice, Width, Height, stexture, Scale, (ForcedSourceRectangle.Length > 0 && ForcedSourceRectangle[0] != -1) ? new Rectangle?(new Rectangle(ForcedSourceRectangle[0], ForcedSourceRectangle[1], ForcedSourceRectangle[2], ForcedSourceRectangle[3])) : null);
}
else
{
texture = new Texture2D(Game1.graphics.GraphicsDevice, Width, Height);
}
texture.SetData(colors);
return(texture);
}
public static Map LoadAndSyncToClients(string path, IModHelper helper, IContentPack contentPack = null, string assetNameMap = null)
{
Map map = Load(path, helper, true, contentPack);
if (assetNameMap != null)
{
if (Game1.IsMultiplayer && Game1.IsServer)
{
foreach (Farmer farmhand in Game1.otherFarmers.Values)
{
PyNet.sendGameContent(assetNameMap, map, farmhand, (b) => Monitor.Log("Syncing " + assetNameMap + " to " + farmhand.Name + ": " + (b ? "successful" : "failed"), b ? LogLevel.Info : LogLevel.Warn));
}
}
}
return(map);
}
public virtual void Write(BinaryWriter writer)
{
Dictionary <string, string> data = Element.getSyncData();
if (data == null)
{
data = new Dictionary <string, string>()
{
{ "na", "na" }
}
}
;
string dataString = string.Join(SaveHandler.seperator.ToString(), data.Select(x => x.Key + SaveHandler.valueSeperator + x.Value));
writer.Write(PyNet.CompressString(dataString));
}
private static void sendInstruction <T>(string[] assetName, T asset, ContentType type, bool toGameContent, Farmer farmer, Action <bool> callback, int timeout)
{
Task.Run(async() =>
{
await PyNet.sendRequestToFarmer <bool>(receiverName, new ContentResponse(String.Join("|", assetName), (int)type, serialize(asset, type), toGameContent), farmer, (r) =>
{
if (!r)
{
PyTKMod._monitor.Log("ContentRequest Failed: Could not send asset: " + String.Join("|", assetName) + " to " + farmer.Name);
callback(false);
}
else
{
callback(r);
}
}, SerializationType.JSON, timeout);
});
}
private static void getResponse <T>(string assetName, ContentType type, bool fromGameContent, Farmer farmer, Action <T> callback, Func <ContentResponse, T> deserializer, int timeout)
{
Task.Run(async() =>
{
await PyNet.sendRequestToFarmer <ContentResponse>(responderName, new ContentRequest(type, assetName, fromGameContent), farmer, (r) =>
{
if (r.content == "na")
{
PyTKMod._monitor.Log("ContentRequest Failed: Could not obtain asset: " + r.assetName);
callback((T)(object)null);
}
else
{
callback(deserializer(r));
}
}, SerializationType.JSON, timeout);
});
}
public void serialize(Texture2D texture)
{
Color[] data = new Color[Width * Height];
byte[] buffer = new byte[data.Length * 4];
texture.GetData(data);
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
for (int i = 0; i < data.Length; i++)
{
writer.Write(data[i].R);
writer.Write(data[i].G);
writer.Write(data[i].B);
writer.Write(data[i].A);
}
Data = PyNet.CompressBytes(stream.ToArray());
}
private void runSync(object sender, UpdateTickedEventArgs e)
{
if (!Game1.IsMultiplayer)
{
return;
}
if (!e.IsMultipleOf((uint)interval))
{
return;
}
T data = syncSender();
if (data != null)
{
PyNet.sendDataToFarmer(receiverName, data, -1, SerializationType.JSON);
}
}
public static void setScore(string name, int score)
{
Highscore highscore = new Highscore(name, score);
var oldEntry = HighscoreTable.Entries.Find(entry => entry.Name == name && entry.Value >= score);
if (!(oldEntry is Highscore))
{
HighscoreTable.Entries.Add(highscore);
SnakeMod.monitor.Log("New Highscore!");
SnakeMod.monitor.Log(highscore.Name + ": " + highscore.Value);
if (Game1.IsMasterGame)
{
PyNet.sendRequestToAllFarmers <bool>(SnakeMod.highscoreListReceiverName, HighscoreTable, null, serializationType: PyTK.Types.SerializationType.JSON);
}
else
{
Task.Run(async() => await PyNet.sendRequestToFarmer <bool>(SnakeMod.highscoreReceiverName, highscore, Game1.MasterPlayer, serializationType: PyTK.Types.SerializationType.JSON));
}
}
}
internal static bool Prefix(Farmer receiver, ProposalType proposalType, Item gift)
{
if (proposalType == ProposalType.Gift && gift is GoldItem)
{
int money = Game1.player.ActiveObject.Stack;
Task.Run(async() =>
{
await PyNet.sendRequestToFarmer <bool>(moneyReceiverName, money, receiver, (b) => { if (!b)
{
Game1.player.Money += money;
}
}, SerializationType.PLAIN, 3000);
});
Game1.player.removeItemFromInventory(Game1.player.ActiveObject);
return(false);
}
else
{
return(true);
}
}
public Texture2D getTexture()
{
byte[] buffer = PyNet.DecompressBytes(Data);
MemoryStream stream = new MemoryStream(buffer);
BinaryReader reader = new BinaryReader(stream);
Color[] colors = new Color[Width * Height];
for (int i = 0; i < colors.Length; i++)
{
var r = reader.ReadByte();
var g = reader.ReadByte();
var b = reader.ReadByte();
var a = reader.ReadByte();
colors[i] = new Color(r, g, b, a);
}
Texture2D texture = new Texture2D(Game1.graphics.GraphicsDevice, Width, Height);
texture.SetData(colors);
return(texture);
}
public void serialize(Texture2D texture)
{
Color[] data = new Color[Width * Height];
byte[] buffer = new byte[data.Length * 4];
texture.GetData(data);
MemoryStream stream = new MemoryStream();
BinaryWriter writer = new BinaryWriter(stream);
for (int i = 0; i < data.Length; i++)
{
writer.Write(data[i].R);
writer.Write(data[i].G);
writer.Write(data[i].B);
writer.Write(data[i].A);
}
Data = PyNet.CompressBytes(stream.ToArray());
if (texture is ScaledTexture2D stexture)
{
Color[] sdata = new Color[ScaledWidth * ScaledHeight];
byte[] sbuffer = new byte[sdata.Length * 4];
stexture.STexture.GetData(sdata);
MemoryStream sstream = new MemoryStream();
BinaryWriter swriter = new BinaryWriter(sstream);
for (int i = 0; i < sdata.Length; i++)
{
swriter.Write(sdata[i].R);
swriter.Write(sdata[i].G);
swriter.Write(sdata[i].B);
swriter.Write(sdata[i].A);
}
ScaledData = PyNet.CompressBytes(sstream.ToArray());
}
}
public virtual void WriteFull(BinaryWriter writer)
{
Dictionary <string, string> data = Element.getAdditionalSaveData();
string dataString = string.Join(SaveHandler.seperator.ToString(), data.Select(x => x.Key + SaveHandler.valueSeperator + x.Value));;
object elementReplacement = Element.getReplacement();
SaveHandler.ReplaceAll(elementReplacement, elementReplacement);
if (ReplacementSerializer == null)
{
ReplacementSerializer = new XmlSerializer(elementReplacement.GetType());
}
StringWriter replacementStringWriter = new StringWriter();
ReplacementSerializer.Serialize(replacementStringWriter, elementReplacement);
string replacementString = replacementStringWriter.ToString();
writer.Write(PyNet.CompressString(dataString));
writer.Write(true);
writer.Write(PyNet.CompressString(replacementString));
}
public static void Prefix_drawHairAndAccesories(FarmerRenderer __instance, Farmer who, int facingDirection, Vector2 position, Vector2 origin, float scale, int currentFrame, float rotation, Color overrideColor)
{
if (Game1.activeClickableMenu is TitleMenu && who.hat.Value is Hat h && !(h is CustomHat) && SaveHandler.getAdditionalSaveData(h) is Dictionary <string, string> savdata)
{
if (savdata.ContainsKey("blueprint") && savdata["blueprint"] is string bid && CustomShirtsMod.hats.Find(bp => bp.fullid == bid) is HatBlueprint hbp)
{
who.hat.Value = new CustomHat(hbp);
}
}
if (who.hat.Value is CustomHat c)
{
if (c.texture == null && CustomShirtsMod.syncedHats.ContainsKey(c.hatId + "." + who.UniqueMultiplayerID))
{
c.texture = CustomShirtsMod.syncedHats[c.hatId + "." + who.UniqueMultiplayerID];
}
if (c.texture == null && !requestedHatSyncs.Contains(c.hatId + "." + who.UniqueMultiplayerID))
{
requestedHatSyncs.Add(c.hatId + "." + who.UniqueMultiplayerID);
try
{
Task.Run(async() =>
{
await PyNet.sendRequestToFarmer <HatSync>(CustomShirtsMod.HatSyncerRequestName, c.hatId, who, (hs) =>
{
requestedHatSyncs.Remove(c.hatId + "." + who.UniqueMultiplayerID);
if (hs == null || hs.Texture == null)
{
return;
}
if (CustomShirtsMod.syncedHats.ContainsKey(hs.SyncId))
{
CustomShirtsMod.syncedHats.Remove(hs.SyncId);
}
CustomShirtsMod.syncedHats.Add(hs.SyncId, hs.Texture.getTexture());
}, SerializationType.PLAIN, 1000);
});
}
catch (Exception e)
{
CustomShirtsMod._monitor.Log(e.Message + ":" + e.StackTrace);
}
}
if (c.texture != null)
{
int direction = who.FacingDirection;
FarmerRenderer.hatsTexture = c.texture;
if (direction == 0)
{
direction = 3;
}
else if (direction == 2)
{
direction = 0;
}
else if (direction == 3)
{
direction = 2;
}
if (Game1.activeClickableMenu is TitleMenu || Game1.activeClickableMenu is GameMenu)
{
direction = 0;
}
if (c.texture is ScaledTexture2D sct)
{
sct.ForcedSourceRectangle = new Rectangle(0, (int)(direction * 20 * sct.Scale), (int)(20 * sct.Scale), (int)(20 * sct.Scale));
}
}
}
else
{
FarmerRenderer.hatsTexture = CustomShirtsMod.vanillaHats;
}
bool savedShirt = CustomShirtsMod.playerShirts.ContainsKey(who.UniqueMultiplayerID) && CustomShirtsMod.playerBaseShirts.ContainsKey(who.UniqueMultiplayerID) && CustomShirtsMod.playerBaseShirts[who.UniqueMultiplayerID] != -9999;
if (savedShirt && (Game1.activeClickableMenu is CharacterCustomization || menuIsCC()))
{
savedShirt = false;
CustomShirtsMod.playerShirts.Remove(who.UniqueMultiplayerID);
CustomShirtsMod.playerBaseShirts.Remove(who.UniqueMultiplayerID);
who.shirt.Value = ((CustomShirtsMod.shirts.FindIndex(fj => fj.fullid == CustomShirtsMod.config.ShirtId) + 1) * -1);
}
if (who.shirt.Value >= 0 && !savedShirt)
{
FarmerRenderer.shirtsTexture = CustomShirtsMod.vanillaShirts;
return;
}
else
{
try
{
if (!savedShirt && who == Game1.player)
{
FarmerRenderer.shirtsTexture = CustomShirtsMod.shirts[(who.shirt.Value * -1) - 1].texture2d;
}
else
{
if (CustomShirtsMod.playerShirts[who.UniqueMultiplayerID] == null)
{
return;
}
FarmerRenderer.shirtsTexture = CustomShirtsMod.playerShirts[who.UniqueMultiplayerID];
}
}
catch { }
}
if (FarmerRenderer.shirtsTexture is ScaledTexture2D st)
{
st.ForcedSourceRectangle = new Rectangle?(new Rectangle(0, (int)((facingDirection == 0 ? 24 : facingDirection == 1 ? 8 : facingDirection == 3 ? 16 : 0) * st.Scale), (int)(8 * st.Scale), (int)(8 * st.Scale)));
}
}
public override void Entry(IModHelper helper)
{
monitor = Monitor;
SnakeMod.helper = helper;
helper.Events.GameLoop.GameLaunched += (o, e) =>
{
sdata = new CustomObjectData("Snake", "Snake/0/-300/Crafting -9/Play 'Snake by Platonymous' at home!/true/true/0/Snake", helper.Content.Load <Texture2D>(@"Assets/arcade.png"), Color.White, bigCraftable: true, type: typeof(SnakeMachine));
if (Helper.ModRegistry.GetApi <IMobilePhoneApi>("aedenthorn.MobilePhone") is IMobilePhoneApi api)
{
Texture2D appIcon = Helper.Content.Load <Texture2D>(Path.Combine("assets", "mobile_app_icon.png"));
bool success = api.AddApp(Helper.ModRegistry.ModID + "MobileSnake", "Snake", () =>
{
Game1.currentMinigame = new SnakeMinigame(helper);
}, appIcon);
}
};
helper.Events.GameLoop.SaveLoaded += (o, e) =>
{
if (Game1.IsMasterGame)
{
SnakeMinigame.HighscoreTable = helper.Data.ReadSaveData <HighscoreList>("Platonymous.SnakeAcrcade.Highscore");
if (SnakeMinigame.HighscoreTable == null)
{
SnakeMinigame.HighscoreTable = new HighscoreList();
}
Monitor.Log("Loading Highscores");
foreach (Highscore h in SnakeMinigame.HighscoreTable.Entries)
{
Monitor.Log(h.Name + ": " + h.Value);
}
}
addToCatalogue();
};
helper.Events.GameLoop.Saving += (o, e) =>
{
if (Game1.IsMasterGame)
{
helper.Data.WriteSaveData <HighscoreList>("Platonymous.SnakeAcrcade.Highscore", SnakeMinigame.HighscoreTable);
}
};
highscoreReceiver = new PyResponder <bool, Highscore>(highscoreReceiverName, (score) =>
{
if (Game1.IsMasterGame)
{
Monitor.Log("Received Highscore from " + score.Name + "(" + score.Value + ")");
SnakeMinigame.setScore(score.Name, score.Value);
PyNet.sendRequestToAllFarmers <bool>(highscoreListReceiverName, SnakeMinigame.HighscoreTable, null, serializationType: PyTK.Types.SerializationType.JSON);
}
return(true);
}, 60, requestSerialization: SerializationType.JSON);
highscoreReceiver.start();
highscoreListReceiver = new PyResponder <bool, HighscoreList>(highscoreListReceiverName, (score) =>
{
if (!Game1.IsMasterGame)
{
Monitor.Log("Received Highscore Update");
foreach (Highscore h in score.Entries)
{
Monitor.Log(h.Name + ": " + h.Value);
}
SnakeMinigame.HighscoreTable = score;
}
return(true);
}, 40, requestSerialization: SerializationType.JSON);
highscoreListReceiver.start();
helper.Events.Multiplayer.PeerContextReceived += (s, e) =>
{
if (Game1.IsMasterGame)
{
PyUtils.setDelayedAction(5000, () => PyNet.sendRequestToAllFarmers <bool>(highscoreListReceiverName, SnakeMinigame.HighscoreTable, null, serializationType: PyTK.Types.SerializationType.JSON));
}
};
}