565 lines
22 KiB
C#
565 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using Newtonsoft.Json;
|
|
using PyTK.CustomElementHandler;
|
|
using Revitalize.Framework.Utilities;
|
|
using StardewValley;
|
|
using StardewValley.Objects;
|
|
|
|
namespace Revitalize.Framework.Objects
|
|
{
|
|
public class MultiTiledObject : CustomObject
|
|
{
|
|
[JsonIgnore]
|
|
public override string ItemInfo
|
|
{
|
|
get
|
|
{
|
|
string infoStr = Revitalize.ModCore.Serializer.ToJSONString(this.info);
|
|
string guidStr = this.guid.ToString();
|
|
string pytkData = ModCore.Serializer.ToJSONString(this.data);
|
|
string dictStr = ModCore.Serializer.ToJSONString(this.childrenGuids);
|
|
if (this.objects != null)
|
|
{
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
if (pair.Value == null) continue;
|
|
if ((pair.Value as CustomObject) == null) continue;
|
|
if((pair.Value as CustomObject).guid==null) continue;
|
|
if(ModCore.CustomObjects.ContainsKey( (pair.Value as CustomObject).guid))
|
|
{
|
|
ModCore.CustomObjects[(pair.Value as CustomObject).guid] = (CustomObject)pair.Value;
|
|
}
|
|
else
|
|
{
|
|
ModCore.CustomObjects.Add((pair.Value as CustomObject).guid, (pair.Value as CustomObject));
|
|
}
|
|
}
|
|
}
|
|
|
|
//ModCore.log("Serializing dict:" + dictStr);
|
|
return infoStr + "<" + guidStr + "<" + pytkData+"<"+dictStr;
|
|
}
|
|
set
|
|
{
|
|
if (string.IsNullOrEmpty(value)) return;
|
|
string[] data = value.Split('<');
|
|
string infoString = data[0];
|
|
string guidString = data[1];
|
|
string pytkData = data[2];
|
|
string dictStr = data[3];
|
|
//ModCore.log("Getting dictStr:" + dictStr);
|
|
|
|
this.info = (BasicItemInformation)Revitalize.ModCore.Serializer.DeserializeFromJSONString(infoString, typeof(BasicItemInformation));
|
|
this.data = Revitalize.ModCore.Serializer.DeserializeFromJSONString<CustomObjectData>(pytkData);
|
|
Guid oldGuid = this.guid;
|
|
this.guid = Guid.Parse(guidString);
|
|
|
|
//this.childrenGuids = ModCore.Serializer.DeserializeFromJSONString<Dictionary<Vector2, Guid>>(dictStr);
|
|
if (ModCore.CustomObjects.ContainsKey(this.guid))
|
|
{
|
|
ModCore.CustomObjects[this.guid] = this;
|
|
}
|
|
else
|
|
{
|
|
ModCore.CustomObjects.Add(this.guid, this);
|
|
}
|
|
|
|
if (ModCore.CustomObjects.ContainsKey(oldGuid) && ModCore.CustomObjects.ContainsKey(this.guid))
|
|
{
|
|
if (ModCore.CustomObjects[oldGuid] == ModCore.CustomObjects[this.guid] && oldGuid != this.guid)
|
|
{
|
|
//ModCore.CustomObjects.Remove(oldGuid);
|
|
}
|
|
}
|
|
|
|
Dictionary<Vector2, Guid> dict = ModCore.Serializer.DeserializeFromJSONString<Dictionary<Vector2, Guid>>(dictStr);
|
|
if (dict == null) return;
|
|
if (dict.Count == 0) return;
|
|
else
|
|
{
|
|
//ModCore.log("Children dicts are updated!");
|
|
this.childrenGuids = dict;
|
|
foreach(KeyValuePair<Vector2,Guid> pair in dict)
|
|
{
|
|
if (ModCore.CustomObjects.ContainsKey(pair.Value))
|
|
{
|
|
this.removeComponent(pair.Key);
|
|
this.addComponent(pair.Key, (MultiTiledComponent)ModCore.CustomObjects[pair.Value]);
|
|
}
|
|
else
|
|
{
|
|
MultiplayerUtilities.RequestGuidObject(pair.Value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[JsonIgnore]
|
|
public Dictionary<Vector2, StardewValley.Object> objects;
|
|
|
|
public Dictionary<Vector2, Guid> childrenGuids;
|
|
|
|
private int width;
|
|
private int height;
|
|
public int Width
|
|
{
|
|
get
|
|
{
|
|
return this.width + 1;
|
|
}
|
|
}
|
|
public int Height
|
|
{
|
|
get
|
|
{
|
|
return this.height + 1;
|
|
}
|
|
}
|
|
|
|
public MultiTiledObject()
|
|
{
|
|
this.objects = new Dictionary<Vector2, StardewValley.Object>();
|
|
this.childrenGuids = new Dictionary<Vector2, Guid>();
|
|
|
|
}
|
|
|
|
public MultiTiledObject(CustomObjectData PyTKData, BasicItemInformation info)
|
|
: base(PyTKData, info)
|
|
{
|
|
this.objects = new Dictionary<Vector2, StardewValley.Object>();
|
|
this.childrenGuids = new Dictionary<Vector2, Guid>();
|
|
|
|
}
|
|
|
|
public MultiTiledObject(CustomObjectData PyTKData, BasicItemInformation info, Vector2 TileLocation)
|
|
: base(PyTKData, info, TileLocation)
|
|
{
|
|
this.objects = new Dictionary<Vector2, StardewValley.Object>();
|
|
this.childrenGuids = new Dictionary<Vector2, Guid>();
|
|
|
|
}
|
|
|
|
public MultiTiledObject(CustomObjectData PyTKData, BasicItemInformation info, Vector2 TileLocation, Dictionary<Vector2, MultiTiledComponent> ObjectsList)
|
|
: base(PyTKData, info, TileLocation)
|
|
{
|
|
this.objects = new Dictionary<Vector2, StardewValley.Object>();
|
|
this.childrenGuids = new Dictionary<Vector2, Guid>();
|
|
foreach (var v in ObjectsList)
|
|
{
|
|
MultiTiledComponent component = (MultiTiledComponent)v.Value.getOne();
|
|
this.addComponent(v.Key, component);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public bool addComponent(Vector2 key, MultiTiledComponent obj)
|
|
{
|
|
if (this.objects.ContainsKey(key))
|
|
{
|
|
ModCore.log("Bad DATA");
|
|
return false;
|
|
}
|
|
|
|
this.objects.Add(key, obj);
|
|
if (this.childrenGuids.ContainsKey(key) == false)
|
|
{
|
|
this.childrenGuids.Add(key, obj.guid);
|
|
}
|
|
|
|
|
|
if (key.X > this.width) this.width = (int)key.X;
|
|
if (key.Y > this.height) this.height = (int)key.Y;
|
|
(obj as MultiTiledComponent).containerObject = this;
|
|
(obj as MultiTiledComponent).offsetKey = key;
|
|
this.info.forceUpdate();
|
|
return true;
|
|
}
|
|
public bool removeComponent(Vector2 key)
|
|
{
|
|
if (!this.objects.ContainsKey(key))
|
|
return false;
|
|
this.objects.Remove(key);
|
|
return true;
|
|
}
|
|
|
|
public override void draw(SpriteBatch spriteBatch, int x, int y, float alpha = 1)
|
|
{
|
|
this.updateInfo();
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
(pair.Value as MultiTiledComponent).draw(spriteBatch, x + ((int)pair.Key.X), y + ((int)pair.Key.Y), alpha);
|
|
}
|
|
}
|
|
|
|
public override void draw(SpriteBatch spriteBatch, int xNonTile, int yNonTile, float layerDepth, float alpha = 1)
|
|
{
|
|
this.updateInfo();
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
pair.Value.draw(spriteBatch, xNonTile + (int)pair.Key.X * Game1.tileSize, yNonTile + (int)pair.Key.Y * Game1.tileSize, layerDepth, alpha);
|
|
}
|
|
|
|
//base.draw(spriteBatch, xNonTile, yNonTile, layerDepth, alpha);
|
|
}
|
|
|
|
public override void drawInMenu(SpriteBatch spriteBatch, Vector2 location, float scaleSize, float transparency, float layerDepth, bool drawStackNumber, Color c, bool drawShadow)
|
|
{
|
|
this.updateInfo();
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
pair.Value.drawInMenu(spriteBatch, location + (pair.Key * 16), 1.0f, transparency, layerDepth, drawStackNumber, c, drawShadow);
|
|
//base.drawInMenu(spriteBatch, location, scaleSize, transparency, layerDepth, drawStackNumber, c, drawShadow);
|
|
}
|
|
|
|
public override void drawWhenHeld(SpriteBatch spriteBatch, Vector2 objectPosition, Farmer f)
|
|
{
|
|
this.updateInfo();
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
pair.Value.drawWhenHeld(spriteBatch, objectPosition + (pair.Key * Game1.tileSize), f);
|
|
//base.drawWhenHeld(spriteBatch, objectPosition, f);
|
|
}
|
|
|
|
|
|
public override void drawPlacementBounds(SpriteBatch spriteBatch, GameLocation location)
|
|
{
|
|
this.updateInfo();
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
if (!this.isPlaceable())
|
|
return;
|
|
int x = Game1.getOldMouseX() + Game1.viewport.X + (int)((pair.Value as MultiTiledComponent).offsetKey.X * Game1.tileSize);
|
|
int y = Game1.getOldMouseY() + Game1.viewport.Y + (int)((pair.Value as MultiTiledComponent).offsetKey.Y * Game1.tileSize);
|
|
if ((double)Game1.mouseCursorTransparency == 0.0)
|
|
{
|
|
x = ((int)Game1.player.GetGrabTile().X + (int)((pair.Value as MultiTiledComponent).offsetKey.X)) * 64;
|
|
y = ((int)Game1.player.GetGrabTile().Y + (int)((pair.Value as MultiTiledComponent).offsetKey.Y)) * 64;
|
|
}
|
|
if (Game1.player.GetGrabTile().Equals(Game1.player.getTileLocation()) && (double)Game1.mouseCursorTransparency == 0.0)
|
|
{
|
|
Vector2 translatedVector2 = Utility.getTranslatedVector2(Game1.player.GetGrabTile(), Game1.player.FacingDirection, 1f);
|
|
translatedVector2 += (pair.Value as MultiTiledComponent).offsetKey;
|
|
x = (int)translatedVector2.X * 64;
|
|
y = (int)translatedVector2.Y * 64;
|
|
}
|
|
bool flag = (pair.Value as MultiTiledComponent).canBePlacedHere(location, new Vector2(x / Game1.tileSize, y / Game1.tileSize));
|
|
spriteBatch.Draw(Game1.mouseCursors, new Vector2((float)(x / 64 * 64 - Game1.viewport.X), (float)(y / 64 * 64 - Game1.viewport.Y)), new Microsoft.Xna.Framework.Rectangle?(new Microsoft.Xna.Framework.Rectangle(flag ? 194 : 210, 388, 16, 16)), Color.White, 0.0f, Vector2.Zero, 4f, SpriteEffects.None, 0.01f);
|
|
|
|
//Revitalize.ModCore.log(new Vector2(x + ((int)pair.Key.X), y + ((int)pair.Key.Y)));
|
|
if ((pair.Value as MultiTiledComponent).info.ignoreBoundingBox)
|
|
{
|
|
x *= -1;
|
|
y *= -1;
|
|
}
|
|
(pair.Value as MultiTiledComponent).draw(spriteBatch, x / Game1.tileSize, y / Game1.tileSize, 0.5f);
|
|
//break;
|
|
//this.draw(spriteBatch, x / 64, y / 64, 0.5f);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public virtual void pickUp(Farmer who)
|
|
{
|
|
bool canPickUp = this.removeAndAddToPlayersInventory();
|
|
if (canPickUp)
|
|
{
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
if ((pair.Value as MultiTiledComponent).info.lightManager != null)
|
|
{
|
|
ModCore.log("Let there be light.");
|
|
if ((pair.Value as MultiTiledComponent).info.lightManager.lightsOn == true)
|
|
{
|
|
ModCore.log("Got a light???");
|
|
}
|
|
}
|
|
(pair.Value as MultiTiledComponent).removeFromLocation(who.currentLocation, pair.Key);
|
|
|
|
}
|
|
this.location = null;
|
|
}
|
|
else
|
|
Game1.showRedMessage("NOOOOOOOO");
|
|
}
|
|
|
|
public override bool removeAndAddToPlayersInventory()
|
|
{
|
|
if (Game1.player.isInventoryFull())
|
|
{
|
|
Game1.showRedMessage("Inventory full.");
|
|
return false;
|
|
}
|
|
Game1.player.addItemToInventory(this);
|
|
return true;
|
|
}
|
|
|
|
public override bool placementAction(GameLocation location, int x, int y, Farmer who = null)
|
|
{
|
|
this.updateInfo();
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
/*
|
|
if ((pair.Value as CustomObject).info.ignoreBoundingBox)
|
|
{
|
|
pair.Value.placementAction(location, -1 * (x + (int)pair.Key.X * Game1.tileSize), -1 * (y + (int)pair.Key.Y * Game1.tileSize), who);
|
|
}
|
|
else
|
|
{
|
|
pair.Value.placementAction(location, x + (int)pair.Key.X * Game1.tileSize, y + (int)pair.Key.Y * Game1.tileSize, who);
|
|
}*/
|
|
(pair.Value as MultiTiledComponent).placementAction(location, x + (int)pair.Key.X * Game1.tileSize, y + (int)pair.Key.Y * Game1.tileSize, who);
|
|
//ModCore.log(pair.Value.TileLocation);
|
|
}
|
|
this.location = location;
|
|
return true;
|
|
//return base.placementAction(location, x, y, who);
|
|
}
|
|
|
|
public override bool canBePlacedHere(GameLocation l, Vector2 tile)
|
|
{
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
if (!pair.Value.canBePlacedHere(l, tile + pair.Key))
|
|
return false;
|
|
}
|
|
return true;
|
|
|
|
}
|
|
public override bool clicked(Farmer who)
|
|
{
|
|
bool cleanUp = this.clicked(who);
|
|
if (cleanUp)
|
|
this.pickUp(who);
|
|
return cleanUp;
|
|
}
|
|
|
|
public override bool rightClicked(Farmer who)
|
|
{
|
|
return base.rightClicked(who);
|
|
}
|
|
|
|
public override bool shiftRightClicked(Farmer who)
|
|
{
|
|
return base.shiftRightClicked(who);
|
|
}
|
|
|
|
public override bool checkForAction(Farmer who, bool justCheckingForActivity = false)
|
|
{
|
|
|
|
return base.checkForAction(who, justCheckingForActivity);
|
|
}
|
|
|
|
public override Item getOne()
|
|
{
|
|
Dictionary<Vector2, MultiTiledComponent> objs = new Dictionary<Vector2, MultiTiledComponent>();
|
|
foreach (var pair in this.objects)
|
|
{
|
|
objs.Add(pair.Key, (MultiTiledComponent)pair.Value);
|
|
}
|
|
return new MultiTiledObject(this.data, this.info.Copy(), this.TileLocation, objs);
|
|
}
|
|
|
|
public override ICustomObject recreate(Dictionary<string, string> additionalSaveData, object replacement)
|
|
{
|
|
MultiTiledObject obj = (MultiTiledObject)Revitalize.ModCore.Serializer.DeserializeGUID<MultiTiledObject>(additionalSaveData["GUID"]);
|
|
if (obj == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
Dictionary<Vector2, Guid> guids = new Dictionary<Vector2, Guid>();
|
|
|
|
foreach (KeyValuePair<Vector2, Guid> pair in obj.childrenGuids)
|
|
{
|
|
guids.Add(pair.Key, pair.Value);
|
|
}
|
|
|
|
foreach (KeyValuePair<Vector2, Guid> pair in guids)
|
|
{
|
|
obj.childrenGuids.Remove(pair.Key);
|
|
MultiTiledComponent component = Revitalize.ModCore.Serializer.DeserializeGUID<MultiTiledComponent>(pair.Value.ToString());
|
|
component.InitNetFields();
|
|
obj.removeComponent(pair.Key);
|
|
obj.addComponent(pair.Key, component);
|
|
|
|
|
|
}
|
|
obj.InitNetFields();
|
|
|
|
if (!Revitalize.ModCore.ObjectGroups.ContainsKey(additionalSaveData["GUID"]))
|
|
{
|
|
Revitalize.ModCore.ObjectGroups.Add(additionalSaveData["GUID"], obj);
|
|
return obj;
|
|
}
|
|
else
|
|
{
|
|
return Revitalize.ModCore.ObjectGroups[additionalSaveData["GUID"]];
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recreate the data from data already stored on the object.
|
|
/// </summary>
|
|
public virtual void recreate()
|
|
{
|
|
Dictionary<Vector2, Guid> guids = new Dictionary<Vector2, Guid>();
|
|
|
|
foreach (KeyValuePair<Vector2, Guid> pair in this.childrenGuids)
|
|
{
|
|
guids.Add(pair.Key, pair.Value);
|
|
}
|
|
|
|
foreach (KeyValuePair<Vector2, Guid> pair in guids)
|
|
{
|
|
this.childrenGuids.Remove(pair.Key);
|
|
MultiTiledComponent component = Revitalize.ModCore.Serializer.DeserializeGUID<MultiTiledComponent>(pair.Value.ToString());
|
|
component.InitNetFields();
|
|
this.removeComponent(pair.Key);
|
|
this.addComponent(pair.Key, component);
|
|
|
|
|
|
}
|
|
this.InitNetFields();
|
|
|
|
if (!Revitalize.ModCore.ObjectGroups.ContainsKey(this.guid.ToString()))
|
|
{
|
|
Revitalize.ModCore.ObjectGroups.Add(this.guid.ToString(), this);
|
|
}
|
|
}
|
|
|
|
public override Dictionary<string, string> getAdditionalSaveData()
|
|
{
|
|
Dictionary<string, string> saveData = base.getAdditionalSaveData();
|
|
saveData.Add("GUID", this.guid.ToString());
|
|
Revitalize.ModCore.Serializer.SerializeGUID(this.guid.ToString(), this);
|
|
return saveData;
|
|
}
|
|
|
|
public void setAllAnimationsToDefault()
|
|
{
|
|
foreach (KeyValuePair<Vector2, StardewValley.Object> pair in this.objects)
|
|
{
|
|
string animationKey = (pair.Value as MultiTiledComponent).generateDefaultRotationalAnimationKey();
|
|
if ((pair.Value as MultiTiledComponent).animationManager.animations.ContainsKey(animationKey))
|
|
{
|
|
(pair.Value as MultiTiledComponent).animationManager.setAnimation(animationKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool canStackWith(Item other)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override int maximumStackSize()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
public override void updateInfo()
|
|
{
|
|
//this.recreateComponents();
|
|
if (this.info == null)
|
|
{
|
|
this.ItemInfo = this.text;
|
|
ModCore.log("Updated item info for container!");
|
|
return;
|
|
}
|
|
if (this.objects != null)
|
|
{
|
|
if (this.childrenGuids != null)
|
|
{
|
|
if (this.objects.Count == 0 || this.objects.Count != this.childrenGuids.Count)
|
|
{
|
|
this.ItemInfo = this.text;
|
|
//ModCore.log("Updated item info for container!");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.objects.Count == 0)
|
|
{
|
|
this.ItemInfo = this.text;
|
|
//ModCore.log("Updated item info for container!");
|
|
return;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (this.requiresUpdate())
|
|
{
|
|
//this.ItemInfo = this.text;
|
|
this.text = this.ItemInfo;
|
|
this.info.cleanAfterUpdate();
|
|
MultiplayerUtilities.RequestUpdateSync(this.guid);
|
|
}
|
|
}
|
|
|
|
public virtual void recreateComponents()
|
|
{
|
|
|
|
if (ModCore.CustomObjects.ContainsKey(this.guid))
|
|
{
|
|
if ((ModCore.CustomObjects[this.guid] as MultiTiledObject).objects.Count > 0)
|
|
{
|
|
this.objects = (ModCore.CustomObjects[this.guid] as MultiTiledObject).objects;
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
if((ModCore.CustomObjects[this.guid] as MultiTiledObject).childrenGuids.Count > 0)
|
|
{
|
|
this.childrenGuids = (ModCore.CustomObjects[this.guid] as MultiTiledObject).childrenGuids;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MultiplayerUtilities.RequestGuidObject(this.guid);
|
|
MultiplayerUtilities.RequestGuidObject_Tile(this.guid);
|
|
}
|
|
if (this.objects == null || this.childrenGuids == null)
|
|
{
|
|
ModCore.log("Either objects or children guids are null");
|
|
return;
|
|
}
|
|
|
|
|
|
ModCore.log("Recreate children components");
|
|
if (this.objects.Count < this.childrenGuids.Count)
|
|
{
|
|
foreach (KeyValuePair<Vector2, Guid> pair in this.childrenGuids)
|
|
{
|
|
if (ModCore.CustomObjects.ContainsKey(pair.Value))
|
|
{
|
|
this.removeComponent(pair.Key);
|
|
this.addComponent(pair.Key,(MultiTiledComponent)ModCore.CustomObjects[pair.Value]);
|
|
}
|
|
else
|
|
{
|
|
MultiplayerUtilities.RequestGuidObject(pair.Value);
|
|
MultiplayerUtilities.RequestGuidObject_Tile(pair.Value);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ModCore.log("Count is exactly the same!");
|
|
ModCore.log("Count is: " + this.objects.Count+" : and " + this.childrenGuids.Count);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|