private void ControlEvents_KeyPressed(object sender, StardewModdingAPI.Events.EventArgsKeyPressed e)
{
//J key for shop
#region
if (e.KeyPressed == Microsoft.Xna.Framework.Input.Keys.J)
{
CoreMonitor.Log("OK THE J KEY WAS PRESSED!");
List <Item> shoppingList = new List <Item>();
StarAI.PathFindingCore.TileNode t = new StarAI.PathFindingCore.TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Aqua));
if (t == null)
{
CoreMonitor.Log("WTF?????");
}
try
{
if (t == null)
{
return;
}
shoppingList.Add((Item)t);
Game1.activeClickableMenu = new StardewValley.Menus.ShopMenu(shoppingList);
}
catch (Exception err)
{
CoreMonitor.Log(Convert.ToString(err));
}
}
#endregion
//K key for placing a tile.
#region
if (e.KeyPressed == Microsoft.Xna.Framework.Input.Keys.K)
{
CoreMonitor.Log("OK THE K KEY WAS PRESSED!");
StarAI.PathFindingCore.TileNode t = new StarAI.PathFindingCore.TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.randomColor());
if (t == null)
{
CoreMonitor.Log("WTF?????");
}
try
{
if (t == null)
{
return;
}
CoreMonitor.Log(new Vector2(Game1.player.getTileX() * Game1.tileSize, Game1.player.getTileY() * Game1.tileSize).ToString());
int xPos = (int)(Game1.player.getTileX()) * Game1.tileSize;
int yPos = (int)(Game1.player.getTileY()) * Game1.tileSize;
Rectangle r = new Rectangle(xPos, yPos, Game1.tileSize, Game1.tileSize);
Vector2 pos = new Vector2(r.X, r.Y);
bool ok = StarAI.PathFindingCore.TileNode.checkIfICanPlaceHere(t, pos, Game1.player.currentLocation);
if (ok == false)
{
return;
}
t.placementAction(Game1.currentLocation, Game1.player.getTileX() * Game1.tileSize, Game1.player.getTileY() * Game1.tileSize);
//t.setAdjacentTiles(true);
}
catch (Exception err)
{
CoreMonitor.Log(Convert.ToString(err));
}
}
#endregion
if (e.KeyPressed == Microsoft.Xna.Framework.Input.Keys.U)
{
ExecutionCore.TaskList.printAllTaskMetaData();
}
if (e.KeyPressed == Microsoft.Xna.Framework.Input.Keys.O)
{
foreach (var v in Game1.player.currentLocation.map.TileSheets)
{
foreach (var q in Game1.player.currentLocation.map.Layers)
{
string[] s = q.ToString().Split(':');
string layer = s[1].Trim();
if (Game1.player.currentLocation.map.GetLayer(layer) == null)
{
ModCore.CoreMonitor.Log("SHITTTTTT: " + layer, LogLevel.Error);
}
int tileIndex = Game1.player.currentLocation.getTileIndexAt((int)Game1.player.getTileX() / Game1.tileSize, (int)Game1.player.getTileY() / Game1.tileSize, layer);
if (tileIndex == -1)
{
continue;
}
//ModCore.CoreMonitor.Log("Position: " + (Game1.player.getTileLocation() / Game1.tileSize).ToString(), LogLevel.Warn);
//ModCore.CoreMonitor.Log("Layer: " + layer, LogLevel.Warn);
//ModCore.CoreMonitor.Log("Index: " + tileIndex.ToString(), LogLevel.Warn);
//ModCore.CoreMonitor.Log("Image Source: " + v.ImageSource, LogLevel.Warn);
if (layer == "Buildings")
{
TileExceptionNode tileException = new TileExceptionNode(v.ImageSource, tileIndex);
foreach (var tile in PathFindingCore.Utilities.ignoreCheckTiles)
{
if (tile.imageSource == tileException.imageSource && tile.index == tileException.index)
{
ModCore.CoreMonitor.Log("Tile exception already initialized!");
return; //tile is already initialized.
}
}
PathFindingCore.Utilities.ignoreCheckTiles.Add(tileException);
tileException.serializeJson(Path.Combine(ModCore.CoreHelper.DirectoryPath, PathFindingCore.Utilities.folderForExceptionTiles));
//StardustCore.ModCore.SerializationManager.
}
}
}
}
}
public static void pathFindToSingleGoal(object data)
{
int index = 0;
List <TileNode> path = new List <TileNode>();
//path.Clear();
//ModCore.CoreMonitor.Log("LET'S GO!!!!", LogLevel.Error);
object[] obj = (object[])data;
TileNode Source = (TileNode)obj[0];
if (Source.parent != null)
{
Source.parent = null;
}
// ModCore.CoreMonitor.Log("PATH FROM SOURCE: "+Source.tileLocation, LogLevel.Error);
TileNode Goal = (TileNode)obj[1];
// ModCore.CoreMonitor.Log("PATH To GOAL: " + Goal.tileLocation, LogLevel.Error);
List <TileNode> Queue = (List <TileNode>)obj[2];
totalPathCost = 0;
TileNode currentNode = Source;
queue.Add(currentNode);
index++;
bool goalFound = false;
while (currentNode.tileLocation != Goal.tileLocation && queue.Count != 0)
{
// ModCore.CoreMonitor.Log("LET'S GO SINGLE GOAL!!!!", LogLevel.Error);
//Add children to current node
int xMin = -1;
int yMin = -1;
int xMax = 1;
int yMax = 1;
//try to set children to tiles where children haven't been before
for (int x = xMin; x <= xMax; x++)
{
for (int y = yMin; y <= yMax; y++)
{
if (x == 0 && y == 0)
{
continue;
}
//Include these 4 checks for just left right up down movement. Remove them to enable 8 direction path finding
if (x == -1 && y == -1)
{
continue; //upper left
}
if (x == -1 && y == 1)
{
continue; //bottom left
}
if (x == 1 && y == -1)
{
continue; //upper right
}
if (x == 1 && y == 1)
{
continue; //bottom right
}
//TileNode t = new TileNode(1, Vector2.Zero, Souce.texturePath,source.dataPath, source.drawColor);
TileNode.setSingleTileAsChild(currentNode, (int)currentNode.tileLocation.X + x, (int)currentNode.tileLocation.Y + y, false);
Vector2 check = new Vector2((int)currentNode.tileLocation.X + x, (int)currentNode.tileLocation.Y + y);
if (check.X == Goal.tileLocation.X && check.Y == Goal.tileLocation.Y)
{
Goal.parent = currentNode;
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.LightGreen);
currentNode = Goal;
// ModCore.CoreMonitor.Log("SNAGED THE GOAL!!!!!!");
//System.Threading.Thread.Sleep(2000);
goalFound = true;
}
}
}
if (goalFound == true)
{
currentNode = Goal;
//ModCore.CoreMonitor.Log("FOUND YOU!!!");
//System.Threading.Thread.Sleep(2000);
break;
}
List <TileNode> adjList = new List <TileNode>();
foreach (var node in currentNode.children)
{
//TileNode t = new TileNode(1, Vector2.Zero, Souce.texturePath,source.dataPath, source.drawColor);
//TileNode.setSingleTileAsChild(source, (int)source.tileLocation.X + x, (int)source.tileLocation.Y + y);
if (node.parent == null)
{
ModCore.CoreMonitor.Log("I DONT UNDERSTAND!");
System.Threading.Thread.Sleep(delay);
}
//ModCore.CoreMonitor.Log("ok checking adj:" + node.tileLocation.ToString());
if (node.seenState == 0)
{
node.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.LightPink); //Seen
adjList.Add(node);
}
if (node.seenState == 1)
{
node.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Blue);
}
if (node.seenState == 2)
{
node.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.DarkOrange);
}
}
foreach (var v in adjList)
{
if (queue.Contains(v))
{
continue;
}
else
{
queue.Add(v);
}
}
currentNode.seenState = 2;
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.DarkOrange); //Finished
try
{
currentNode = queue.ElementAt(index);
}
catch (Exception err)
{
break;
}
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Blue); //Working
index++;
}
if (currentNode.tileLocation != Goal.tileLocation)
{
// ModCore.CoreMonitor.Log("NO PATH FOUND", LogLevel.Error);
return;
}
if (currentNode.tileLocation == Goal.tileLocation)
{
// ModCore.CoreMonitor.Log("SWEET BEANS!!!!!!", LogLevel.Error);
queue.Clear();
index = 0;
//ModCore.CoreMonitor.Log(currentNode.parent.ToString(), LogLevel.Error);
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.LightGreen);
//currentGoal.drawColor=
}
while (currentNode.parent != null)
{
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Red); //Working
path.Add(currentNode);
if (currentNode.parent.tileLocation.X < currentNode.tileLocation.X)
{
currentNode.parent.animationManager.setAnimation("Right", 0);
}
if (currentNode.parent.tileLocation.X > currentNode.tileLocation.X)
{
currentNode.parent.animationManager.setAnimation("Left", 0);
}
if (currentNode.parent.tileLocation.Y < currentNode.tileLocation.Y)
{
currentNode.parent.animationManager.setAnimation("Down", 0);
}
if (currentNode.parent.tileLocation.Y > currentNode.tileLocation.Y)
{
currentNode.parent.animationManager.setAnimation("Up", 0);
}
currentNode.parent.animationManager.enableAnimation();
currentNode = currentNode.parent;
System.Threading.Thread.Sleep(delay);
if (currentNode.parent == null)
{
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Red); //Working
path.Add(currentNode);
}
}
List <TileNode> removalList = new List <TileNode>();
foreach (var v in StardustCore.ModCore.SerializationManager.trackedObjectList)
{
if (v is TileNode)
{
foreach (var exc in Utilities.tileExceptionList)
{
if (exc.tile == (v as TileNode))
{
continue;
}
}
if (path.Contains(v) || goals.Contains(v) || v.drawColor == StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Red))
{
continue;
}
else
{
removalList.Add((TileNode)v);
}
}
}
foreach (var v in removalList)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(v);
v.thisLocation.removeObject(v.tileLocation, false);
//v.performRemoveAction(v.tileLocation, v.thisLocation);
//StardustCore.Utilities.masterRemovalList.Add(v);
}
calculateMovement(path);
// goals.Remove(Goal);
//goals.Remove(Goal);
}
public static void calculateMovement(List <TileNode> path)
{
path.Reverse();
// ModCore.CoreMonitor.Log("PATH COUNT TIME!!!!: " + path.Count);
bool xTargetReached = false;
bool yTargetReached = false;
List <TileNode> removalList = new List <TileNode>();
if (path.Count == 0)
{
return;
}
while (path.Count > 0)
{
TileNode w = path[0];
// ModCore.CoreMonitor.Log("Here: " +Game1.player.position.ToString());
// ModCore.CoreMonitor.Log("LOC: " + Game1.player.currentLocation);
Vector2 center2 = Utilities.parseCenterFromTile((int)w.tileLocation.X, (int)w.tileLocation.Y);
// ModCore.CoreMonitor.Log("Goto: " + center2);
//ModCore.CoreMonitor.Log("My position now: " + Game1.player.getTileLocation());
//ModCore.CoreMonitor.Log("My Point position now: " + Game1.player.getTileLocationPoint());
if (Game1.player.getTileX() == w.tileLocation.X && Game1.player.getTileY() == w.tileLocation.Y)
{
removalList.Add(w);
path.Remove(w);
xTargetReached = false;
yTargetReached = false;
//ModCore.CoreMonitor.Log("LOOOP", LogLevel.Debug);
// return;
continue;
}
else
{
Vector2 center = Utilities.parseCenterFromTile((int)w.tileLocation.X, (int)w.tileLocation.Y);
while (Game1.player.position.X > center.X && xTargetReached == false)
{
if (Utilities.isWithinRange(Game1.player.position.X, center.X, 6) == true)
{
//ModCore.CoreMonitor.Log("XXXXXXXtargetReached");
xTargetReached = true;
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_A);
//break;
continue;
}
if (InputSimulator.IsKeyDown(VirtualKeyCode.VK_A) == false)
{
InputSimulator.SimulateKeyDown(VirtualKeyCode.VK_A);
}
}
while (Game1.player.position.X < center.X && xTargetReached == false)
{
//ModCore.CoreMonitor.Log("Player x: " + Game1.player.position.X);
//ModCore.CoreMonitor.Log("center x: " + center.X);
if (Utilities.isWithinRange(Game1.player.position.X, center.X, 6) == true)
{
xTargetReached = true;
//ModCore.CoreMonitor.Log("XXXXXXXtargetReached");
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_D);
continue;
}
if (InputSimulator.IsKeyDown(VirtualKeyCode.VK_D) == false)
{
InputSimulator.SimulateKeyDown(VirtualKeyCode.VK_D);
}
}
while (Game1.player.position.Y < center.Y && yTargetReached == false)
{
//ModCore.CoreMonitor.Log("banana");
if (Utilities.isWithinRange(Game1.player.position.Y, center.Y, 6) == true)
{
yTargetReached = true;
//ModCore.CoreMonitor.Log("YYYYYYYYYtargetReached");
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_S);
continue;
}
if (InputSimulator.IsKeyDown(VirtualKeyCode.VK_S) == false)
{
InputSimulator.SimulateKeyDown(VirtualKeyCode.VK_S);
}
}
while (Game1.player.position.Y > center.Y && yTargetReached == false)
{
//ModCore.CoreMonitor.Log("potato");
if (Utilities.isWithinRange(Game1.player.position.Y, center.Y, 6) == true)
{
yTargetReached = true;
// ModCore.CoreMonitor.Log("YYYYYYYYYtargetReached");
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_W);
continue;
}
if (InputSimulator.IsKeyDown(VirtualKeyCode.VK_W) == false)
{
InputSimulator.SimulateKeyDown(VirtualKeyCode.VK_W);
}
}
if (xTargetReached == true && yTargetReached == true)
{
removalList.Add(w);
path.Remove(w);
xTargetReached = false;
yTargetReached = false;
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_A);
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_D);
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_W);
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_S);
//return;
//ModCore.CoreMonitor.Log("Reached goal!", LogLevel.Error);
//Game1.player.position = new Vector2(center.X, center.Y);
continue;
}
ModCore.CoreMonitor.Log("UNCAUGHT EXCEPTION", LogLevel.Error);
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_A);
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_D);
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_W);
InputSimulator.SimulateKeyUp(VirtualKeyCode.VK_S);
}
}
foreach (var v in removalList)
{
//v.thisLocation.objects.Remove(v.tileLocation);
//v.thisLocation.removeObject(v.tileLocation, false);
//v.performRemoveAction(v.tileLocation, v.thisLocation);
//StardustCore.Utilities.masterRemovalList.Add(v);
v.thisLocation.objects.Remove(v.tileLocation);
//ModCore.CoreMonitor.Log("WHUT???"+v.tileLocation);
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(v);
//var ok = v;
//ok = null;
}
//goals.Clear();
}
public static List <TileNode> pathFindToSingleGoalReturnPathList(object data)
{
int index = 0;
List <TileNode> path = new List <TileNode>();
//path.Clear();
//ModCore.CoreMonitor.Log("LET'S GO 2222!!!!", LogLevel.Error);
object[] obj = (object[])data;
TileNode Source = (TileNode)obj[0];
if (Source.parent != null)
{
Source.parent = null;
}
//
List <TileNode> Goals = (List <TileNode>)obj[1];
List <TileNode> Queue = (List <TileNode>)obj[2];
totalPathCost = 0;
TileNode currentNode = Source;
bool placement = (bool)obj[3];
bool checkForUtility = (bool)obj[4];
queue.Add(currentNode);
// index++;
bool goalFound = false;
while (doesNodeEqualGoal(currentNode, Goals).Key == false && queue.Count != 0)
{
// ModCore.CoreMonitor.Log("LET'S GO PATH!!!!", LogLevel.Error);
// ModCore.CoreMonitor.Log("PATH FROM Node: " + currentNode.tileLocation, LogLevel.Error);
// ModCore.CoreMonitor.Log("PATH FROM Source: " + Source.tileLocation, LogLevel.Error);
// ModCore.CoreMonitor.Log("GOALS COUNT " + Goals.Count, LogLevel.Error);
// ModCore.CoreMonitor.Log("THIS IS MY MISTAKE!!!!!!! " + Goals.Count, LogLevel.Error);
//Console.WriteLine("OK WTF IS GOING ON????");
//Add children to current node
int xMin = -1;
int yMin = -1;
int xMax = 1;
int yMax = 1;
//try to set children to tiles where children haven't been before
for (int x = xMin; x <= xMax; x++)
{
for (int y = yMin; y <= yMax; y++)
{
if (x == 0 && y == 0)
{
continue;
}
//Include these 4 checks for just left right up down movement. Remove them to enable 8 direction path finding
if (x == -1 && y == -1)
{
continue; //upper left
}
if (x == -1 && y == 1)
{
continue; //bottom left
}
if (x == 1 && y == -1)
{
continue; //upper right
}
if (x == 1 && y == 1)
{
continue; //bottom right
}
//TileNode t = new TileNode(1, Vector2.Zero, Souce.texturePath,source.dataPath, source.drawColor);
//ModCore.CoreMonitor.Log("HERE1", LogLevel.Error);
TileNode.setSingleTileAsChild(currentNode, (int)currentNode.tileLocation.X + x, (int)currentNode.tileLocation.Y + y, checkForUtility, placement);
// ModCore.CoreMonitor.Log("OR NO?", LogLevel.Error);
Vector2 check = new Vector2((int)currentNode.tileLocation.X + x, (int)currentNode.tileLocation.Y + y);
if (doesNodeEqualGoal(check, Goals).Key == true)
{
doesNodeEqualGoal(check, Goals).Value.parent = currentNode;
// Goal = doesNodeEqualGoal(check, Goals).Value;
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.LightGreen);
currentNode = doesNodeEqualGoal(check, Goals).Value;
// ModCore.CoreMonitor.Log("SNAGED THE GOAL!!!!!!");
//System.Threading.Thread.Sleep(2000);
goalFound = true;
}
}
}
if (goalFound == true)
{
currentNode = doesNodeEqualGoal(currentNode, Goals).Value;
// ModCore.CoreMonitor.Log("FOUND YOU!!!");
// path.Add(currentNode);
//System.Threading.Thread.Sleep(2000);
break;
}
List <TileNode> adjList = new List <TileNode>();
foreach (var node in currentNode.children)
{
// ModCore.CoreMonitor.Log("MAYBE HERE",LogLevel.Warn);
//TileNode t = new TileNode(1, Vector2.Zero, Souce.texturePath,source.dataPath, source.drawColor);
//TileNode.setSingleTileAsChild(source, (int)source.tileLocation.X + x, (int)source.tileLocation.Y + y);
if (node.parent == null)
{
//ModCore.CoreMonitor.Log("I DONT UNDERSTAND!");
System.Threading.Thread.Sleep(delay);
}
//ModCore.CoreMonitor.Log("ok checking adj:" + node.tileLocation.ToString());
if (node.seenState == 0)
{
node.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.LightPink); //Seen
}
if (node.seenState == 1)
{
node.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Blue);
}
if (node.seenState == 2)
{
node.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.DarkOrange);
}
adjList.Add(node);
}
foreach (var v in adjList)
{
if (queue.Contains(v))
{
continue;
}
else
{
queue.Add(v);
}
}
currentNode.seenState = 2;
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.DarkOrange); //Finished
try
{
currentNode = queue.ElementAt(index);
}
catch (Exception err)
{
//ModCore.CoreMonitor.Log("INDEX ERROR:"+index, LogLevel.Error);
break;
}
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Blue); //Working
index++;
}
if (doesNodeEqualGoal(currentNode, Goals).Key == false)
{
// ModCore.CoreMonitor.Log("NO PATH FOUND", LogLevel.Error);
return(new List <TileNode>());
}
if (doesNodeEqualGoal(currentNode, Goals).Key == true)
{
// ModCore.CoreMonitor.Log("SWEET BEANS!!!!!!", LogLevel.Error);
queue.Clear();
index = 0;
//ModCore.CoreMonitor.Log(currentNode.parent.ToString(), LogLevel.Error);
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.LightGreen);
//currentGoal.drawColor=
}
while (currentNode.parent != null)
{
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Red); //Working
path.Add(currentNode);
if (currentNode.parent.tileLocation.X < currentNode.tileLocation.X)
{
currentNode.parent.animationManager.setAnimation("Right", 0);
}
if (currentNode.parent.tileLocation.X > currentNode.tileLocation.X)
{
currentNode.parent.animationManager.setAnimation("Left", 0);
}
if (currentNode.parent.tileLocation.Y < currentNode.tileLocation.Y)
{
currentNode.parent.animationManager.setAnimation("Down", 0);
}
if (currentNode.parent.tileLocation.Y > currentNode.tileLocation.Y)
{
currentNode.parent.animationManager.setAnimation("Up", 0);
}
if (currentNode.parent.tileLocation == currentNode.tileLocation)
{
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Black); //Working
}
currentNode.parent.animationManager.enableAnimation();
currentNode = currentNode.parent;
System.Threading.Thread.Sleep(delay);
if (currentNode.parent == null)
{
currentNode.drawColor = StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.Red); //Working
path.Add(currentNode);
}
// ModCore.CoreMonitor.Log("??????");
}
List <TileNode> removalList = new List <TileNode>();
List <TileNode> ignoreList = new List <TileNode>();
foreach (var v in StardustCore.ModCore.SerializationManager.trackedObjectList)
{
if (v is TileNode)
{
// ModCore.CoreMonitor.Log("Removing item: " + why + " / " + StardustCore.ModCore.SerializationManager.trackedObjectList.Count);
removalList.Add((TileNode)v);
}
}
foreach (var v in removalList)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(v);
//v.performRemoveAction(v.tileLocation, v.thisLocation);
try
{
StardewValley.Object ob = v.thisLocation.objects[v.tileLocation];
//ModCore.CoreMonitor.Log(ob.name);
if (v.name != "Generic Colored Tile")
{
continue; // ModCore.CoreMonitor.Log("Culperate 3");
}
if (placement)
{
v.thisLocation.removeObject(v.tileLocation, false);
}
}
catch (Exception err)
{
}
//StardustCore.Utilities.masterRemovalList.Add(v);
}
if (path.Count == 0 && goalFound == true)
{
path.Add(Source);
}
return(path);
//calculateMovement(path);
// goals.Remove(Goal);
}
/// <summary>
/// Used to return the path to the destination without moving towards the goal.
/// </summary>
/// <param name="Source">The starting point to path from.</param>
/// <param name="Goal">The goal to path to.</param>
/// <param name="Queue">Depreciated for further builds.</param>
/// <param name="Placement">Whether or not tiles are actually going to be placed</param>
/// <returns></returns>
public static List <TileNode> pathFindToSingleGoalReturnPath(TileNode Source, TileNode Goal, List <TileNode> Queue, bool Placement, bool CheckForUtility)
{
object[] obj = new object[5];
obj[0] = Source;
obj[1] = Goal;
obj[2] = Queue;
obj[3] = Placement;
obj[4] = CheckForUtility;
return(pathFindToSingleGoalReturnPath(obj));
}
/// <summary>
/// This is used to pathfind to any target that statisfies conditions. The first one hit becomes the new goal.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static List <TileNode> getAnyIdealPath(object obj)
{
object[] objArr = (object[])obj;
List <TileNode> vList = (List <TileNode>)objArr[0];
bool utility = true;
int xMin = -1;
int yMin = -1;
int xMax = 1;
int yMax = 1;
List <TileNode> miniGoals = new List <TileNode>();
List <List <TileNode> > paths = new List <List <TileNode> >();
//try to set children to tiles where children haven't been before
foreach (var v in vList)
{
for (int x = xMin; x <= xMax; x++)
{
for (int y = yMin; y <= yMax; y++)
{
if (x == 0 && y == 0)
{
continue;
}
//Include these 4 checks for just left right up down movement. Remove them to enable 8 direction path finding
if (x == -1 && y == -1)
{
continue; //upper left
}
if (x == -1 && y == 1)
{
continue; //bottom left
}
if (x == 1 && y == -1)
{
continue; //upper right
}
if (x == 1 && y == 1)
{
continue; //bottom right
}
Vector2 pos = new Vector2(v.tileLocation.X + x, v.tileLocation.Y + y);
//ModCore.CoreMonitor.Log("AHHHHHHH POSITION: " + pos.ToString(), LogLevel.Alert);
bool f = PathFindingCore.TileNode.checkIfICanPlaceHere(v, pos * Game1.tileSize, v.thisLocation, true, utility);
// ModCore.CoreMonitor.Log("OK THIS IS THE RESULT F: " + f, LogLevel.Alert);
if (f == true)
{
TileNode t = new TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.RosyBrown));
if (placement)
{
t.placementAction(v.thisLocation, (int)pos.X * Game1.tileSize, (int)pos.Y * Game1.tileSize);
}
else
{
t.fakePlacementAction(v.thisLocation, (int)pos.X, (int)pos.Y);
}
//StardustCore.Utilities.masterAdditionList.Add(new StardustCore.DataNodes.PlacementNode( t, Game1.currentLocation, (int)pos.X * Game1.tileSize, (int)pos.Y * Game1.tileSize));
miniGoals.Add(t);
Utilities.tileExceptionList.Add(new TileExceptionMetaData(t, "Navigation"));
}
}
}
}
List <TileNode> removalList = new List <TileNode>();
Utilities.clearExceptionListWithName("Child");
Utilities.clearExceptionListWithName("Navigation");
TileNode tempSource = new TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.RosyBrown));
if (placement)
{
tempSource.placementAction(Game1.player.currentLocation, Game1.player.getTileX() * Game1.tileSize, Game1.player.getTileY() * Game1.tileSize);
}
else
{
tempSource.fakePlacementAction(Game1.player.currentLocation, Game1.player.getTileX(), Game1.player.getTileY());
}
Utilities.tileExceptionList.Add(new TileExceptionMetaData(tempSource, "Navigation"));
//StaardustCore.Utilities.masterAdditionList.Add(new StardustCore.DataNodes.PlacementNode(tempSource, Game1.currentLocation, Game1.player.getTileX() * Game1.tileSize, Game1.player.getTileY() * Game1.tileSize));
//have this take in a list of goals and see which goal it reaches first
List <TileNode> path = PathFindingCore.PathFindingLogic.pathFindToSingleGoalReturnPath(tempSource, miniGoals, new List <TileNode>(), placement, utility);
ModCore.CoreMonitor.Log("OK MY PATH IS:" + path.Count);
Utilities.clearExceptionListWithName("Child");
Utilities.clearExceptionListWithName("Navigation");
if (path.Count == 0)
{
ModCore.CoreMonitor.Log("NOPE, no path I guess.", LogLevel.Warn);
}
else
{
ModCore.CoreMonitor.Log("There is a path", LogLevel.Alert);
ModCore.CoreMonitor.Log("COST OF THE PATH IS: " + path.Count.ToString(), LogLevel.Alert);
}
if (path.Count != 0)
{
//ModCore.CoreMonitor.Log("PATH WAS NOT NULL", LogLevel.Warn);
paths.Add(path);
foreach (var someTile in path)
{
removalList.Add(someTile);
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(someTile);
if (placement)
{
someTile.thisLocation.objects.Remove(someTile.tileLocation);
}
//someTile.performRemoveAction(someTile.tileLocation, someTile.thisLocation);
//StardustCore.Utilities.masterRemovalList.Add(someTile);
//ModCore.CoreMonitor.Log("CAUGHT MY CULPERATE", LogLevel.Warn);
}
}
Console.WriteLine("GOALS COUNT:" + miniGoals.Count);
foreach (var q in removalList)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(q);
if (placement)
{
q.thisLocation.objects.Remove(q.tileLocation);
}
}
removalList.Clear();
int pathCost = 999999999;
List <TileNode> correctPath = new List <TileNode>();
foreach (var potentialPath in paths)
{
if (potentialPath.Count == 0)
{
continue;
}
if (potentialPath.Count < pathCost)
{
pathCost = potentialPath.Count;
correctPath = potentialPath;
}
}
return(correctPath);
}
public static int calculatePathCost(object obj)
{
object[] objArr = (object[])obj;
TileNode v = (TileNode)objArr[0];
bool placement;
try
{
placement = (bool)objArr[1];
}
catch (Exception err)
{
placement = true;
}
foreach (var q in objArr)
{
ModCore.CoreMonitor.Log("OK THIS IS THE RESULT !: " + q, LogLevel.Alert);
}
if (v == null)
{
ModCore.CoreMonitor.Log("WTF MARK!!!!!!: ", LogLevel.Alert);
}
bool moveOn = false;
WindowsInput.InputSimulator.SimulateKeyUp(WindowsInput.VirtualKeyCode.VK_X);
int xMin = -1;
int yMin = -1;
int xMax = 1;
int yMax = 1;
List <TileNode> miniGoals = new List <TileNode>();
List <List <TileNode> > paths = new List <List <TileNode> >();
//try to set children to tiles where children haven't been before
for (int x = xMin; x <= xMax; x++)
{
for (int y = yMin; y <= yMax; y++)
{
if (x == 0 && y == 0)
{
continue;
}
//Include these 4 checks for just left right up down movement. Remove them to enable 8 direction path finding
if (x == -1 && y == -1)
{
continue; //upper left
}
if (x == -1 && y == 1)
{
continue; //bottom left
}
if (x == 1 && y == -1)
{
continue; //upper right
}
if (x == 1 && y == 1)
{
continue; //bottom right
}
Vector2 pos = new Vector2(v.tileLocation.X + x, v.tileLocation.Y + y);
//ModCore.CoreMonitor.Log("AHHHHHHH POSITION: " + pos.ToString(), LogLevel.Alert);
bool f = PathFindingCore.TileNode.checkIfICanPlaceHere(v, pos * Game1.tileSize, v.thisLocation, true, true);
ModCore.CoreMonitor.Log("OK THIS IS THE RESULT F: " + f, LogLevel.Alert);
if (f == true)
{
TileNode t = new TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.RosyBrown));
if (placement)
{
t.placementAction(v.thisLocation, (int)pos.X * Game1.tileSize, (int)pos.Y * Game1.tileSize);
}
else
{
t.fakePlacementAction(v.thisLocation, (int)pos.X, (int)pos.Y);
}
//StardustCore.Utilities.masterAdditionList.Add(new StardustCore.DataNodes.PlacementNode(t, Game1.currentLocation, (int)pos.X * Game1.tileSize, (int)pos.Y * Game1.tileSize));
miniGoals.Add(t);
//Utilities.tileExceptionList.Add(new TileExceptionMetaData(t, "CostCalculation"));
}
}
}
List <TileNode> removalList = new List <TileNode>();
foreach (var nav in miniGoals)
{
TileNode tempSource = new TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.RosyBrown));
if (placement)
{
tempSource.placementAction(Game1.player.currentLocation, Game1.player.getTileX() * Game1.tileSize, Game1.player.getTileY() * Game1.tileSize);
}
else
{
tempSource.fakePlacementAction(v.thisLocation, (int)v.tileLocation.X, (int)v.tileLocation.Y);
}
List <TileNode> path = PathFindingCore.PathFindingLogic.pathFindToSingleGoalReturnPath(tempSource, nav, new List <TileNode>(), true, true);
Utilities.clearExceptionListWithName(placement, "Child");
ModCore.CoreMonitor.Log(tempSource.tileLocation.ToString() + tempSource.tileLocation.ToString());
ModCore.CoreMonitor.Log(nav.tileLocation.ToString() + nav.tileLocation.ToString());
if (path.Count != 0)
{
ModCore.CoreMonitor.Log("PATH WAS NOT NULL", LogLevel.Warn);
paths.Add(path);
foreach (var someTile in path)
{
if (someTile == nav)
{
removalList.Add(someTile);
}
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(someTile);
if (placement)
{
try
{
StardewValley.Object ob = someTile.thisLocation.objects[someTile.tileLocation];
ModCore.CoreMonitor.Log(ob.name);
if (ob.name == "Twig")
{
ModCore.CoreMonitor.Log("Culperate 2");
}
someTile.thisLocation.objects.Remove(someTile.tileLocation);
}
catch (Exception err)
{
}
}
//someTile.performRemoveAction(someTile.tileLocation, someTile.thisLocation);
//StardustCore.Utilities.masterRemovalList.Add(v);
}
}
}
foreach (var q in removalList)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(q);
if (placement)
{
try
{
StardewValley.Object ob = q.thisLocation.objects[q.tileLocation];
ModCore.CoreMonitor.Log(ob.name);
if (ob.name == "Twig")
{
ModCore.CoreMonitor.Log("Culperate 1");
}
q.thisLocation.objects.Remove(q.tileLocation);
}
catch (Exception err)
{
}
}
}
removalList.Clear();
int pathCost = 999999999;
List <TileNode> correctPath = new List <TileNode>();
foreach (var potentialPath in paths)
{
if (potentialPath.Count == 0)
{
continue;
}
if (potentialPath.Count < pathCost)
{
pathCost = potentialPath.Count;
correctPath = potentialPath;
}
}
foreach (var goodTile in correctPath)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Add(goodTile);
//goodTile.placementAction(goodTile.thisLocation, (int)goodTile.tileLocation.X * Game1.tileSize, (int)goodTile.tileLocation.Y * Game1.tileSize);
//StardustCore.Utilities.masterAdditionList.Add(new StardustCore.DataNodes.PlacementNode(goodTile, Game1.currentLocation, (int)goodTile.tileLocation.X * Game1.tileSize, (int)goodTile.tileLocation.Y * Game1.tileSize));
}
//END HERE FOR JUST CALCULATING PATH COST
if (paths.Count == 0)
{
return(Int32.MaxValue);
}
return(correctPath.Count);
}
public static void pathToSingleChest(object obj)
{
object[] objArr = (object[])obj;
TileNode v = (TileNode)objArr[0];
bool moveOn = false;
foreach (var q in Utilities.tileExceptionList)
{
if (q.tile == v && q.actionType == "Chest")
{
moveOn = true;
}
}
if (moveOn == false)
{
return;
}
WindowsInput.InputSimulator.SimulateKeyUp(WindowsInput.VirtualKeyCode.VK_C);
int xMin = -1;
int yMin = -1;
int xMax = 1;
int yMax = 1;
List <TileNode> miniGoals = new List <TileNode>();
List <List <TileNode> > paths = new List <List <TileNode> >();
//try to set children to tiles where children haven't been before
for (int x = xMin; x <= xMax; x++)
{
for (int y = yMin; y <= yMax; y++)
{
if (x == 0 && y == 0)
{
continue;
}
//Include these 4 checks for just left right up down movement. Remove them to enable 8 direction path finding
if (x == -1 && y == -1)
{
continue; //upper left
}
if (x == -1 && y == 1)
{
continue; //bottom left
}
if (x == 1 && y == -1)
{
continue; //upper right
}
if (x == 1 && y == 1)
{
continue; //bottom right
}
Vector2 pos = new Vector2(v.tileLocation.X + x, v.tileLocation.Y + y);
//ModCore.CoreMonitor.Log("AHHHHHHH POSITION: " + pos.ToString(), LogLevel.Alert);
bool f = PathFindingCore.TileNode.checkIfICanPlaceHere(v, pos * Game1.tileSize, v.thisLocation, true);
// ModCore.CoreMonitor.Log("OK THIS IS THE RESULT F: " + f, LogLevel.Alert);
if (f == true)
{
TileNode t = new TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.RosyBrown));
t.placementAction(Game1.currentLocation, (int)pos.X * Game1.tileSize, (int)pos.Y * Game1.tileSize);
//StardustCore.Utilities.masterAdditionList.Add(new StardustCore.DataNodes.PlacementNode( t, Game1.currentLocation, (int)pos.X * Game1.tileSize, (int)pos.Y * Game1.tileSize));
miniGoals.Add(t);
Utilities.tileExceptionList.Add(new TileExceptionMetaData(t, "CropNavigation"));
}
}
}
List <TileNode> removalList = new List <TileNode>();
foreach (var nav in miniGoals)
{
TileNode tempSource = new TileNode(1, Vector2.Zero, Path.Combine("Tiles", "GenericUncoloredTile.xnb"), Path.Combine("Tiles", "TileData.xnb"), StardustCore.IlluminateFramework.Colors.invertColor(StardustCore.IlluminateFramework.ColorsList.RosyBrown));
tempSource.placementAction(Game1.player.currentLocation, Game1.player.getTileX() * Game1.tileSize, Game1.player.getTileY() * Game1.tileSize);
//StaardustCore.Utilities.masterAdditionList.Add(new StardustCore.DataNodes.PlacementNode(tempSource, Game1.currentLocation, Game1.player.getTileX() * Game1.tileSize, Game1.player.getTileY() * Game1.tileSize));
List <TileNode> path = PathFindingCore.PathFindingLogic.pathFindToSingleGoalReturnPath(tempSource, nav, new List <TileNode>(), true);
if (path.Count != 0)
{
//ModCore.CoreMonitor.Log("PATH WAS NOT NULL", LogLevel.Warn);
paths.Add(path);
foreach (var someTile in path)
{
if (someTile == nav)
{
removalList.Add(someTile);
}
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(someTile);
someTile.thisLocation.objects.Remove(someTile.tileLocation);
//someTile.performRemoveAction(someTile.tileLocation, someTile.thisLocation);
//StardustCore.Utilities.masterRemovalList.Add(someTile);
//ModCore.CoreMonitor.Log("CAUGHT MY CULPERATE", LogLevel.Warn);
}
}
}
Console.WriteLine("GOALS COUNT:" + miniGoals.Count);
foreach (var q in removalList)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(q);
q.thisLocation.objects.Remove(q.tileLocation);
}
removalList.Clear();
int pathCost = 999999999;
List <TileNode> correctPath = new List <TileNode>();
foreach (var potentialPath in paths)
{
if (potentialPath.Count == 0)
{
continue;
}
if (potentialPath.Count < pathCost)
{
pathCost = potentialPath.Count;
correctPath = potentialPath;
}
}
foreach (var goodTile in correctPath)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Add(goodTile);
//StardustCore.Utilities.masterAdditionList.Add(new StardustCore.DataNodes.PlacementNode(goodTile, Game1.currentLocation, (int)goodTile.tileLocation.X * Game1.tileSize, (int)goodTile.tileLocation.Y * Game1.tileSize));
goodTile.placementAction(goodTile.thisLocation, (int)goodTile.tileLocation.X * Game1.tileSize, (int)goodTile.tileLocation.Y * Game1.tileSize);
}
PathFindingLogic.calculateMovement(correctPath);
if (v.tileLocation.X < Game1.player.getTileX())
{
Game1.player.faceDirection(3);
}
else if (v.tileLocation.X > Game1.player.getTileX())
{
Game1.player.faceDirection(1);
}
else if (v.tileLocation.Y < Game1.player.getTileY())
{
Game1.player.faceDirection(0);
}
else if (v.tileLocation.Y > Game1.player.getTileY())
{
Game1.player.faceDirection(2);
}
bool move = false;
Chest chest = (Chest)v.thisLocation.objects[v.tileLocation];
List <Item> removalListSeeds = new List <Item>();
//Try to grab all the seeds I can from the chest.
while (Game1.player.isInventoryFull() == false && chest.items.Count > 0)
{
if (chest.giftbox)
{
ModCore.CoreMonitor.Log("GIFT BOX", LogLevel.Warn);
v.thisLocation.objects.Remove(v.tileLocation);
}
foreach (var item in chest.items)
{
if (item.getCategoryName() == "Seed")
{
int seedIndex = item.parentSheetIndex;
if (seedIndex == 770)
{
seedIndex = Crop.getRandomLowGradeCropForThisSeason(Game1.currentSeason);
if (seedIndex == 473)
{
--seedIndex;
}
}
StardewValley.Crop c = new Crop(seedIndex, 0, 0);
if (c.seasonsToGrowIn.Contains(Game1.currentSeason))
{
Game1.player.addItemByMenuIfNecessary(item);
removalListSeeds.Add(item);
break;
}
}
}
foreach (var remove in removalListSeeds)
{
chest.items.Remove(remove);
}
// if (WindowsInput.InputSimulator.IsKeyDown(WindowsInput.VirtualKeyCode.VK_C) == false) WindowsInput.InputSimulator.SimulateKeyDown(WindowsInput.VirtualKeyCode.VK_C);
Vector2 center = new Vector2();
if (Game1.player.facingDirection == 2)
{
center = Utilities.parseCenterFromTile((int)v.tileLocation.X + 1, (int)v.tileLocation.Y);
continue;
}
if (Game1.player.facingDirection == 1)
{
center = Utilities.parseCenterFromTile((int)v.tileLocation.X - 1, (int)v.tileLocation.Y);
continue;
}
if (Game1.player.facingDirection == 0)
{
center = Utilities.parseCenterFromTile((int)v.tileLocation.X, (int)v.tileLocation.Y + 1);
continue;
}
if (Game1.player.facingDirection == 3)
{
center = Utilities.parseCenterFromTile((int)v.tileLocation.X, (int)v.tileLocation.Y - 1);
continue;
}
Game1.player.position = center;
}
Utilities.cleanExceptionList(v);
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(v);
// StardustCore.Utilities.masterRemovalList.Add(v);
//v.performRemoveAction(v.tileLocation, v.thisLocation);
// v.thisLocation.objects.Remove(v.tileLocation);
foreach (var goodTile in correctPath)
{
StardustCore.ModCore.SerializationManager.trackedObjectList.Remove(goodTile);
//StardustCore.Utilities.masterRemovalList.Add(v);
goodTile.performRemoveAction(goodTile.tileLocation, goodTile.thisLocation);
//goodTile.placementAction(goodTile.thisLocation, (int)goodTile.tileLocation.X * Game1.tileSize, (int)goodTile.tileLocation.Y * Game1.tileSize);
}
//WindowsInput.InputSimulator.SimulateKeyUp(WindowsInput.VirtualKeyCode.VK_C);
}