private void SpawnTree(Farm farm, Vector2 point)
{
StardewValley.TerrainFeatures.Tree t = new Tree(1, 5);
t.seasonUpdate(true);
ClearResourceClump(ref farm.resourceClumps, point);
TerrainFeature feature = null;
if (farm.terrainFeatures.TryGetValue(point, out feature))
{
if (feature.GetType() != t.GetType())
{
farm.terrainFeatures.Clear();
farm.terrainFeatures.Add(point, t);
}
}
else
{
farm.terrainFeatures.Add(point, t);
}
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, SFarmer player, Tool tool, Item item, GameLocation location)
{
// apply tool
if (tool != null && this.CustomNames.Contains(tool.Name))
{
return(this.UseToolOnTile(tool, tile));
}
// apply item
if (item != null && item.Stack > 0 && this.CustomNames.Contains(item.Name))
{
if (item is SObject obj && obj.canBePlacedHere(location, tile) && obj.placementAction(location, (int)(tile.X * Game1.tileSize), (int)(tile.Y * Game1.tileSize), player))
{
this.ConsumeItem(player, item);
return(true);
}
}
return(false);
}
/****
** Methods
****/
/// <summary>Grow all trees eligible for growth.</summary>
private void GrowTrees()
{
foreach (GameLocation location in Game1.locations)
{
foreach (var entry in location.terrainFeatures)
{
Vector2 tile = entry.Key;
TerrainFeature feature = entry.Value;
if (this.Config.RegularTreesInstantGrow && feature is Tree)
{
this.GrowTree((Tree)feature, location, tile);
}
if (this.Config.FruitTreesInstantGrow && feature is FruitTree)
{
GrowFruitTree((FruitTree)feature, location, tile);
}
}
}
}
private void Joystick_EndOfRouteReached(object sender, NpcMovementController.EndOfRouteReachedEventArgs e)
{
if (this.ai.CurrentController != this)
{
return;
}
if (this.targetObject != null)
{
this.targetObject.performUseAction(this.Forager.getTileLocation(), this.Forager.currentLocation);
this.ignoreList.Add(this.targetObject);
}
else
{
this.Forager.currentLocation.localSound("leafrustle");
this.Forager.currentLocation.temporarySprites.Add(new TemporaryAnimatedSprite("TileSheets\\animations", new Rectangle(0, 1085, 58, 58), 60f, 8, 0, this.Forager.GetGrabTile() * 64, false, this.Forager.FacingDirection == 3, 1f, 0.0f, Color.White, 1f, 0.0f, 0.0f, 0.0f, false));
}
double potentialChance = 0.02 + 1.0 / (this.foragedObjects.Count + 1) + this.Leader.LuckLevel / 100.0 + this.Leader.DailyLuck;
double boost = this.Leader.professions.Contains(Farmer.gatherer) ? 2.0 : 1.0;
double realChance = potentialChance * 0.33 + (this.ForagingLevel + 1) * 0.005 * boost;
double current = this.r.NextDouble();
if (this.ai.Monitor.IsVerbose)
{
this.ai.Monitor.VerboseLog($"(Pick forage) Companion foraging level: {this.ForagingLevel} " +
$"| potential chance: {potentialChance} " +
$"| boost: {boost} " +
$"| real chance: {realChance} " +
$"| current: {current} " +
$"| passed: {(current < realChance ? "Yes" : "No")}");
}
if (current < realChance || NpcAdventureMod.DebugFlags.Contains("forager.pickAlways"))
{
this.PickForageObject(this.targetObject);
}
this.targetObject = null;
this.IsIdle = true;
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, Farmer player, Tool tool, Item item, GameLocation location)
{
if (item == null || item.Stack <= 0)
{
return(false);
}
switch (item.ParentSheetIndex)
{
// tree fertilizer
case 805:
if (tileFeature is Tree tree && !tree.fertilized.Value && tree.growthStage.Value < Tree.treeStage && tree.fertilize(location))
{
this.ConsumeItem(player, item);
return(true);
}
return(false);
// crop fertilizer
default:
// get unfertilised dirt
if (!this.TryGetHoeDirt(tileFeature, tileObj, out HoeDirt dirt, out bool dirtCoveredByObj, out _) || dirt.fertilizer.Value != HoeDirt.noFertilizer)
{
return(false);
}
// ignore if there's a giant crop, meteorite, etc covering the tile
if (dirtCoveredByObj || this.GetResourceClumpCoveringTile(location, tile) != null)
{
return(false);
}
// apply fertilizer
bool fertilized = dirt.plant(item.ParentSheetIndex, (int)tile.X, (int)tile.Y, player, isFertilizer: true, location);
if (fertilized)
{
this.ConsumeItem(player, item);
}
return(fertilized);
}
}
public static KeyValuePair <Vector2, TerrainFeature> checkCardinalForTerrainFeature(Type terrainType)
{
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
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((Game1.player.getTileX() + x), (Game1.player.getTileY() + y));
bool f = Game1.player.currentLocation.isTerrainFeatureAt((int)pos.X, (int)pos.Y);
if (f == false)
{
continue;
}
TerrainFeature t = Game1.player.currentLocation.terrainFeatures[pos]; //((Game1.player.getTileX() + x) * Game1.tileSize, (Game1.player.getTileY() + y) * Game1.tileSize);
if (t == null)
{
continue;
}
if (t.GetType() == terrainType)
{
return(new KeyValuePair <Vector2, TerrainFeature>(pos, t));
}
}
}
return(new KeyValuePair <Vector2, TerrainFeature>(new Vector2(), null));
}
protected bool TryGetHoeDirt(TerrainFeature terrain, SObject obj, out HoeDirt dirt, out bool isCoveredByObj)
{
//Check to see if it's a garden pot
if (obj is IndoorPot pot)
{
dirt = pot.hoeDirt.Value;
isCoveredByObj = false;
return(true);
}
//Check to see if it's normal dirt
if ((dirt = terrain as HoeDirt) != null)
{
isCoveredByObj = obj != null;
return(true);
}
//Found nothing
dirt = null;
isCoveredByObj = false;
return(false);
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, SFarmer player, Tool tool, Item item, GameLocation location)
{
if (!this.Enable)
{
return(false);
}
if (!(tileFeature is HoeDirt dirt) || dirt.state == HoeDirt.watered)
{
return(false);
}
WateringCan can = (WateringCan)tool;
int prevWater = can.WaterLeft;
can.WaterLeft = 100;
this.UseToolOnTile(tool, tile);
can.WaterLeft = prevWater;
return(true);
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, Farmer player, Tool tool, Item item, GameLocation location)
{
// clear weeds
if (this.Config.ClearWeeds && this.IsWeed(tileObj))
{
return(this.UseToolOnTile(tool, tile));
}
// till plain dirt
if (this.Config.TillDirt && tileFeature == null && tileObj == null)
{
return(this.UseToolOnTile(tool, tile));
}
// collect artifact spots
if (this.Config.DigArtifactSpots && tileObj?.ParentSheetIndex == HoeAttachment.ArtifactSpotItemID)
{
return(this.UseToolOnTile(tool, tile));
}
return(false);
}
/// <summary>Get the tilled dirt for a tile, if any.</summary>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="dirt">The tilled dirt found, if any.</param>
/// <param name="isCoveredByObj">Whether there's an object placed over the tilled dirt.</param>
/// <returns>Returns whether tilled dirt was found.</returns>
protected bool TryGetHoeDirt(TerrainFeature tileFeature, SObject tileObj, out HoeDirt dirt, out bool isCoveredByObj)
{
// garden pot
if (tileObj is IndoorPot pot)
{
dirt = pot.hoeDirt.Value;
isCoveredByObj = false;
return(true);
}
// regular dirt
if ((dirt = tileFeature as HoeDirt) != null)
{
isCoveredByObj = tileObj != null;
return(true);
}
// none found
dirt = null;
isCoveredByObj = false;
return(false);
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, SFarmer player, Tool tool, Item item, GameLocation location)
{
// clear twigs & weeds
if (tileObj?.Name == "Twig" || tileObj?.Name.ToLower().Contains("weed") == true)
{
return(this.UseToolOnTile(tool, tile));
}
// cut non-fruit tree
if (tileFeature is Tree)
{
return(this.CutTrees && this.UseToolOnTile(tool, tile));
}
// cut fruit tree
if (tileFeature is FruitTree)
{
return(this.CutFruitTrees && this.UseToolOnTile(tool, tile));
}
// clear crops
if (tileFeature is HoeDirt dirt && dirt.crop != null && (dirt.crop.dead || this.ClearCrops))
{
return(this.UseToolOnTile(tool, tile));
}
// clear stumps
// This needs to check if the axe upgrade level is high enough first, to avoid spamming
// 'need to upgrade your tool' messages. Based on ResourceClump.performToolAction.
{
ResourceClump clump = this.GetResourceClumpCoveringTile(location, tile);
if (clump != null && this.ResourceUpgradeLevelsNeeded.ContainsKey(clump.parentSheetIndex) && tool.upgradeLevel >= this.ResourceUpgradeLevelsNeeded[clump.parentSheetIndex])
{
this.UseToolOnTile(tool, tile);
}
}
return(false);
}
public Tile(string terrain, string feature, int base_buildingCapacity, int base_popCapacity)
{
if (TerrainType.instances.Exists(t => t.name == terrain))
{
this.terrain = TerrainType.instances.Find(t => t.name == terrain);
}
else
{
Debug.Log("ERROR: No terrain named " + terrain + " exists.");
}
if (TerrainFeature.instances.Exists(t => t.name == feature))
{
this.feature = TerrainFeature.instances.Find(t => t.name == feature);
}
else
{
Debug.Log("ERROR: No feature named " + terrain + " exists.");
}
this.base_buildingCapacity = base_buildingCapacity;
this.base_popCapacity = base_popCapacity;
instances.Add(this);
}
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, SFarmer who, Tool tool, Item item, GameLocation location)
{
if (_config.CutDebris && (tileObj?.Name == "Twig" || tileObj?.Name.ToLower().Contains("weed") == true))
{
return(UseToolOnTile(tool, tile));
}
switch (tileFeature)
{
case Tree tree:
if (_config.CutTrees)
{
return(UseToolOnTile(tool, tile));
}
break;
case HoeDirt dirt when dirt.crop != null:
if (_config.CutDeadCrops && dirt.crop.dead.Value)
{
return(UseToolOnTile(tool, tile));
}
if (_config.CutLiveCrops && !dirt.crop.dead.Value)
{
return(UseToolOnTile(tool, tile));
}
break;
}
if (_config.CutDebris)
{
ResourceClump rc = ResourceClumpCoveringTile(location, tile);
if (rc != null && _resourceUpgradeNeeded.ContainsKey(rc.parentSheetIndex.Value) && tool.UpgradeLevel >= _resourceUpgradeNeeded[rc.parentSheetIndex.Value])
{
UseToolOnTile(tool, tile);
}
}
return(false);
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, Farmer player, Tool tool, Item item, GameLocation location)
{
// clear dead crops
if (this.Config.ClearDeadCrops && tileFeature is HoeDirt dirt && dirt.crop != null && dirt.crop.dead.Value)
{
return(this.UseToolOnTile(this.FakePickaxe, tile, player, location));
}
// break mine containers
if (this.Config.BreakMineContainers && tileObj is BreakableContainer container)
{
return(container.performToolAction(tool, location));
}
// attack monsters
if (this.Config.AttackMonsters)
{
return(this.UseWeaponOnTile((MeleeWeapon)tool, tile, player, location));
}
return(false);
}
public virtual void OnRequestGourmandCheck()
{
if (!Game1.IsMasterGame)
{
return;
}
string gourmand_response = "";
IslandWest island_farm = Game1.getLocationFromName("IslandWest") as IslandWest;
foreach (Vector2 key in island_farm.terrainFeatures.Keys)
{
TerrainFeature feature = island_farm.terrainFeatures[key];
if (!(feature is HoeDirt))
{
continue;
}
HoeDirt dirt = feature as HoeDirt;
if (dirt.crop == null)
{
continue;
}
bool harvestable = (int)dirt.crop.currentPhase >= dirt.crop.phaseDays.Count - 1 && (!dirt.crop.fullyGrown || (int)dirt.crop.dayOfCurrentPhase <= 0);
if (dirt.crop.indexOfHarvest.Value == IndexForRequest(gourmandRequestsFulfilled.Value))
{
if (harvestable)
{
Point target_tile = new Point((int)key.X, (int)key.Y);
Point player_tile = FindNearbyUnoccupiedTileThatFitsCharacter(island_farm, target_tile.X, target_tile.Y);
Point gourmand_tile = FindNearbyUnoccupiedTileThatFitsCharacter(island_farm, target_tile.X, target_tile.Y, 2, player_tile);
int farmer_direction = GetRelativeDirection(player_tile, target_tile);
gourmandResponseEvent.Fire(key.X + " " + key.Y + " " + player_tile.X + " " + player_tile.Y + " " + farmer_direction + " " + gourmand_tile.X + " " + gourmand_tile.Y + " 2");
return;
}
gourmand_response = "inProgress";
}
}
gourmandResponseEvent.Fire(gourmand_response);
}
internal static BaseFeatureSaveData CreateFeatureSaveData(Vector2 position, TerrainFeature feature,
IReflectionHelper helper)
{
switch (feature)
{
case Tree tree:
return(new TreeSaveData(position, tree));
case FruitTree fruitTree:
return(new FruitTreeSaveData(position, fruitTree));
case CosmeticPlant cosmeticPlant:
return(new CosmeticPlantSaveData(position, cosmeticPlant));
case Grass grass:
return(new GrassSaveData(position, grass));
case DiggableWall wall:
return(new DiggableWallSaveData(position, wall, helper));
}
return(new BaseFeatureSaveData(position, feature));
}
/// <summary>Handle a game update if <see cref="ICheat.OnSaveLoaded"/> indicated updates were needed.</summary>
/// <param name="context">The cheat context.</param>
/// <param name="e">The update event arguments.</param>
public override void OnUpdated(CheatContext context, UpdateTickedEventArgs e)
{
// skip if not using a tool
if (!Context.IsPlayerFree || !Game1.player.UsingTool || !(Game1.player.CurrentTool is Axe || Game1.player.CurrentTool is Pickaxe))
{
return;
}
Farmer player = Game1.player;
var tool = player.CurrentTool;
// get affected tile
Vector2 tile = new Vector2((int)player.GetToolLocation().X / Game1.tileSize, (int)player.GetToolLocation().Y / Game1.tileSize);
// break stones
if (tool is Pickaxe && player.currentLocation.objects.ContainsKey(tile))
{
Object obj = player.currentLocation.Objects[tile];
if (obj != null && obj.name == "Stone")
{
obj.MinutesUntilReady = 0;
}
}
// break trees
if (tool is Axe && player.currentLocation.terrainFeatures.ContainsKey(tile))
{
TerrainFeature obj = player.currentLocation.terrainFeatures[tile];
if (obj is Tree tree && tree.health.Value > 1)
{
tree.health.Value = 1;
}
else if (obj is FruitTree fruitTree && fruitTree.health.Value > 1)
{
fruitTree.health.Value = 1;
}
}
public override bool GrabFeature(Vector2 tile, TerrainFeature feature)
{
if (Config.fruitTrees && feature is FruitTree tree && IsHarvestableFruitTree(tree))
{
// impl @ StardewValley::FruitTree::shake
var daysUntilMature = tree.daysUntilMature.Value;
var isStruckByLightning = tree.struckByLightningCountdown.Value > 0;
var fruitQuality = SObject.lowQuality;
if (isStruckByLightning)
{
fruitQuality = SObject.lowQuality;
}
else if (daysUntilMature <= -336)
{
fruitQuality = SObject.bestQuality;
}
else if (daysUntilMature <= -224)
{
fruitQuality = SObject.highQuality;
}
else if (daysUntilMature <= -112)
{
fruitQuality = SObject.medQuality;
}
var crop = new SObject(isStruckByLightning ? ItemIds.Coal : tree.indexOfFruit.Value, tree.fruitsOnTree.Value, false, -1, fruitQuality);
if (TryAddItem(crop))
{
tree.fruitsOnTree.Value = 0;
return(true);
}
else
{
return(false);
}
}
public override IEnumerable <ITarget> GetTargets(GameLocation location, Vector2 lookupTile)
{
// map objects
foreach (KeyValuePair <Vector2, SObject> pair in location.objects.Pairs)
{
if (location is IslandShrine && pair.Value is ItemPedestal)
{
continue; // part of the Fern Islands shrine puzzle, which is handled by the tile lookup provider
}
if (this.GameHelper.CouldSpriteOccludeTile(pair.Key, lookupTile))
{
yield return(new ObjectTarget(this.GameHelper, pair.Value, pair.Key, this.Reflection, () => this.BuildSubject(pair.Value, ObjectContext.World, knownQuality: false)));
}
}
// furniture
foreach (var furniture in location.furniture)
{
Vector2 entityTile = furniture.TileLocation;
if (this.GameHelper.CouldSpriteOccludeTile(entityTile, lookupTile))
{
yield return(new ObjectTarget(this.GameHelper, furniture, entityTile, this.Reflection, () => this.BuildSubject(furniture, ObjectContext.Inventory)));
}
}
// crops
foreach (KeyValuePair <Vector2, TerrainFeature> pair in location.terrainFeatures.Pairs)
{
Vector2 entityTile = pair.Key;
TerrainFeature feature = pair.Value;
if (feature is HoeDirt dirt && dirt.crop != null && this.GameHelper.CouldSpriteOccludeTile(entityTile, lookupTile))
{
yield return(new CropTarget(this.GameHelper, dirt, entityTile, this.Reflection, this.JsonAssets, () => this.BuildSubject(dirt.crop, ObjectContext.World)));
}
}
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, SFarmer player, Tool tool, Item item, GameLocation location)
{
if (item == null || item.Stack <= 0)
{
return(false);
}
// get dirt
if (!(tileFeature is HoeDirt dirt) || dirt.fertilizer != HoeDirt.noFertilizer)
{
return(false);
}
// ignore if there's a giant crop, meteorite, etc covering the tile
if (this.GetResourceClumpCoveringTile(location, tile) != null)
{
return(false);
}
// apply fertiliser
dirt.fertilizer = item.parentSheetIndex;
this.ConsumeItem(player, item);
return(true);
}
//Update tick - check for removed grass and spawn hay if appropriate
private void EighthUpdateTick(object sender, EventArgs e)
{
if (Game1.currentLocation?.terrainFeatures == null || lastTerrainFeatures == null || Game1.currentLocation != currentLocation)
{
return;
}
foreach (var item in this.lastTerrainFeatures.Where(x => x.Value is Grass && IsWithinRange(Game1.player.getTileLocation(), x.Key, 4)))
{
TerrainFeature x = null;
if (!this.currentLocation.terrainFeatures.TryGetValue(item.Key, out x) || !(x is Grass))
{
if (((Game1.IsMultiplayer ? Game1.recentMultiplayerRandom : new Random((int)((double)Game1.uniqueIDForThisGame + (double)item.Key.X * 1000.0 + (double)item.Key.Y * 11.0))).NextDouble() < 0.5))
{
if (Game1.player.CurrentTool is MeleeWeapon && (Game1.player.CurrentTool.Name.Contains("Scythe") || Game1.player.CurrentTool.parentSheetIndex == 47))
{
if (dropGrassStarterRandom.NextDouble() < config.ChanceToDropGrassStarterInsteadOfHay)
{
AttemptToGiveGrassStarter(item.Key, Game1.getFarm().piecesOfHay == Utility.numSilos() * 240);
}
else if (Game1.getFarm().tryToAddHay(1) != 0)
{
if (!BetterHayGrass.TryAddItemToInventory(178) && config.DropHayOnGroundIfNoRoomInInventory)
{
BetterHayGrass.DropOnGround(item.Key, 178);
}
}
}
}
}
}
lastTerrainFeatures = Game1.currentLocation?.terrainFeatures?.Pairs.ToDictionary(entry => entry.Key,
entry => entry.Value);
}
public override IEnumerable <ITarget> GetTargets(GameLocation location, Vector2 lookupTile)
{
// map objects
foreach (KeyValuePair <Vector2, SObject> pair in location.objects.Pairs)
{
if (this.GameHelper.CouldSpriteOccludeTile(pair.Key, lookupTile))
{
yield return(new ObjectTarget(this.GameHelper, pair.Value, pair.Key, this.Reflection, () => this.BuildSubject(pair.Value, ObjectContext.World, knownQuality: false)));
}
}
// furniture
if (location is DecoratableLocation decoratableLocation)
{
foreach (var furniture in decoratableLocation.furniture)
{
Vector2 entityTile = furniture.TileLocation;
if (this.GameHelper.CouldSpriteOccludeTile(entityTile, lookupTile))
{
yield return(new ObjectTarget(this.GameHelper, furniture, entityTile, this.Reflection, () => this.BuildSubject(furniture, ObjectContext.Inventory)));
}
}
}
// crops
foreach (KeyValuePair <Vector2, TerrainFeature> pair in location.terrainFeatures.Pairs)
{
Vector2 entityTile = pair.Key;
TerrainFeature feature = pair.Value;
if (feature is HoeDirt dirt && dirt.crop != null && this.GameHelper.CouldSpriteOccludeTile(entityTile, lookupTile))
{
yield return(new CropTarget(this.GameHelper, dirt, entityTile, this.Reflection, this.JsonAssets, () => this.BuildSubject(dirt.crop, ObjectContext.World)));
}
}
}
private void OnUpdateTicked(object sender, UpdateTickedEventArgs e)
{
if (!e.IsMultipleOf(4))
{
return;
}
#region GetTileUnderCursor
// get tile under cursor
_currentTileBuilding = Game1.currentLocation is BuildableGameLocation buildableLocation
? buildableLocation.getBuildingAt(Game1.currentCursorTile)
: null;
if (Game1.currentLocation != null)
{
if (Game1.currentLocation.Objects == null ||
!Game1.currentLocation.Objects.TryGetValue(Game1.currentCursorTile, out _currentTile))
{
_currentTile = null;
}
if (Game1.currentLocation.terrainFeatures == null ||
!Game1.currentLocation.terrainFeatures.TryGetValue(Game1.currentCursorTile, out _terrain))
{
if (_currentTile is IndoorPot pot &&
pot.hoeDirt.Value != null)
{
_terrain = pot.hoeDirt.Value;
}
else
{
_terrain = null;
}
}
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, Farmer player, Tool tool, Item item, GameLocation location)
{
if (item == null || item.Stack <= 0)
{
return(false);
}
// get empty dirt
if (!this.TryGetHoeDirt(tileFeature, tileObj, out HoeDirt dirt, out bool dirtCoveredByObj) || dirt.crop != null || dirt.fertilizer.Value != HoeDirt.noFertilizer)
{
return(false);
}
// ignore if there's a giant crop, meteorite, etc covering the tile
if (dirtCoveredByObj || this.GetResourceClumpCoveringTile(location, tile) != null)
{
return(false);
}
// apply fertiliser
dirt.fertilizer.Value = item.ParentSheetIndex;
this.ConsumeItem(player, item);
return(true);
}
/// <summary>Apply the tool to the given tile.</summary>
/// <param name="tile">The tile to modify.</param>
/// <param name="tileObj">The object on the tile.</param>
/// <param name="tileFeature">The feature on the tile.</param>
/// <param name="player">The current player.</param>
/// <param name="tool">The tool selected by the player (if any).</param>
/// <param name="item">The item selected by the player (if any).</param>
/// <param name="location">The current location.</param>
public override bool Apply(Vector2 tile, SObject tileObj, TerrainFeature tileFeature, SFarmer player, Tool tool, Item item, GameLocation location)
{
if (item == null || item.Stack <= 0)
{
return(false);
}
// get dirt
HoeDirt dirt = tileFeature as HoeDirt;
if (dirt == null || dirt.crop != null)
{
return(false);
}
// sow seeds
bool sowed = dirt.plant(item.parentSheetIndex, (int)tile.X, (int)tile.Y, player);
if (sowed)
{
this.ConsumeItem(player, item);
}
return(sowed);
}
private string GetTerrainName(TerrainFeature t)
{
string outter = "";
switch (t)
{
case Tree tree:
Monitor.Log(tree.treeType.Value.ToString());
break;
default:
outter = "Nothing Dork.";
break;
}
/*
* if (t is Tree tree)
* outter = Game1.objectInformation[tree.];
* else
* outter = "Nothing Dork.";*/
return(outter);
}
/// <summary>Get whether a map terrain feature is a crop.</summary>
/// <param name="terrain">The map terrain feature.</param>
private bool IsCrop(TerrainFeature terrain)
{
return(terrain is HoeDirt dirt && dirt.crop != null);
}
/// <summary>Get whether a terrain feature is automatable.</summary>
/// <param name="location">The location to check.</param>
/// <param name="tile">The tile to check.</param>
/// <param name="terrainFeature">The terrain feature to check.</param>
public bool IsAutomatable(GameLocation location, Vector2 tile, TerrainFeature terrainFeature)
{
return(this.GetEntityFor(location, tile, terrainFeature) != null);
}
/****
** Targets
****/
/// <summary>Get all potential lookup targets in the current location.</summary>
/// <param name="location">The current location.</param>
/// <param name="originTile">The tile from which to search for targets.</param>
/// <param name="includeMapTile">Whether to allow matching the map tile itself.</param>
public IEnumerable <ITarget> GetNearbyTargets(GameLocation location, Vector2 originTile, bool includeMapTile)
{
// NPCs
foreach (NPC npc in location.characters)
{
if (!this.GameHelper.CouldSpriteOccludeTile(npc.getTileLocation(), originTile))
{
continue;
}
TargetType type = TargetType.Unknown;
if (npc is Child || npc.isVillager())
{
type = TargetType.Villager;
}
else if (npc is Horse)
{
type = TargetType.Horse;
}
else if (npc is Junimo)
{
type = TargetType.Junimo;
}
else if (npc is Pet)
{
type = TargetType.Pet;
}
else if (npc is Monster)
{
type = TargetType.Monster;
}
yield return(new CharacterTarget(this.GameHelper, type, npc, npc.getTileLocation(), this.Reflection));
}
// animals
foreach (FarmAnimal animal in (location as Farm)?.animals.Values ?? (location as AnimalHouse)?.animals.Values ?? Enumerable.Empty <FarmAnimal>())
{
if (!this.GameHelper.CouldSpriteOccludeTile(animal.getTileLocation(), originTile))
{
continue;
}
yield return(new FarmAnimalTarget(this.GameHelper, animal, animal.getTileLocation()));
}
// map objects
foreach (KeyValuePair <Vector2, SObject> pair in location.objects.Pairs)
{
Vector2 spriteTile = pair.Key;
SObject obj = pair.Value;
if (!this.GameHelper.CouldSpriteOccludeTile(spriteTile, originTile))
{
continue;
}
yield return(new ObjectTarget(this.GameHelper, obj, spriteTile, this.Reflection));
}
// furniture
if (location is DecoratableLocation decoratableLocation)
{
foreach (var furniture in decoratableLocation.furniture)
{
yield return(new ObjectTarget(this.GameHelper, furniture, furniture.TileLocation, this.Reflection));
}
}
// terrain features
foreach (KeyValuePair <Vector2, TerrainFeature> pair in location.terrainFeatures.Pairs)
{
Vector2 spriteTile = pair.Key;
TerrainFeature feature = pair.Value;
if (!this.GameHelper.CouldSpriteOccludeTile(spriteTile, originTile))
{
continue;
}
switch (feature)
{
case Bush bush: // planted bush
yield return(new BushTarget(this.GameHelper, bush, this.Reflection));
break;
case HoeDirt dirt when dirt.crop != null:
yield return(new CropTarget(this.GameHelper, dirt, spriteTile, this.Reflection, this.JsonAssets));
break;
case FruitTree fruitTree:
if (this.Reflection.GetField <float>(fruitTree, "alpha").GetValue() < 0.8f)
{
continue; // ignore when tree is faded out (so player can lookup things behind it)
}
yield return(new FruitTreeTarget(this.GameHelper, fruitTree, this.JsonAssets, spriteTile));
break;
case Tree wildTree:
if (this.Reflection.GetField <float>(feature, "alpha").GetValue() < 0.8f)
{
continue; // ignore when tree is faded out (so player can lookup things behind it)
}
yield return(new TreeTarget(this.GameHelper, wildTree, spriteTile, this.Reflection));
break;
default:
yield return(new UnknownTarget(this.GameHelper, feature, spriteTile));
break;
}
}
// large terrain features
foreach (LargeTerrainFeature feature in location.largeTerrainFeatures)
{
Vector2 spriteTile = feature.tilePosition.Value;
if (!this.GameHelper.CouldSpriteOccludeTile(spriteTile, originTile))
{
continue;
}
switch (feature)
{
case Bush bush: // wild bush
yield return(new BushTarget(this.GameHelper, bush, this.Reflection));
break;
}
}
// players
foreach (Farmer farmer in location.farmers)
{
if (!this.GameHelper.CouldSpriteOccludeTile(farmer.getTileLocation(), originTile))
{
continue;
}
yield return(new FarmerTarget(this.GameHelper, farmer));
}
// buildings
if (location is BuildableGameLocation buildableLocation)
{
foreach (Building building in buildableLocation.buildings)
{
if (!this.GameHelper.CouldSpriteOccludeTile(new Vector2(building.tileX.Value, building.tileY.Value + building.tilesHigh.Value), originTile, Constant.MaxBuildingTargetSpriteSize))
{
continue;
}
yield return(new BuildingTarget(this.GameHelper, building));
}
}
// tiles
if (includeMapTile)
{
yield return(new TileTarget(this.GameHelper, originTile));
}
}
public void ServerStartGame()
{
if (IsGameInProgress)
{
Console.WriteLine("A game is already in progress!");
return;
}
IsGameInProgress = true;
Console.WriteLine("Server start game");
NetworkUtility.SendChatMessageToAllPlayers("Game starting!");
//Wipe objects
foreach (GameLocation location in Game1.locations)
{
location.Objects.Clear();
location.debris.Clear();
}
Game1.MasterPlayer.Money = 0;
//Spawn chests
new Chests().SpawnAndFillChests();
#region Store tree locations or replant
Random random = new Random();
if (trees.Count == 0) //Store info
{
foreach (GameLocation gameLocation in Game1.locations)
{
foreach (var pair in gameLocation.terrainFeatures.Pairs)
{
TerrainFeature feature = pair.Value;
if (feature is Tree tree && tree.growthStage.Value >= 5)
{
Vector2 vector = pair.Key;
trees.Add(new TileLocation(gameLocation.Name, (int)vector.X, (int)vector.Y));
}
}
}
}
else //Replant
{
//Delete all trees
foreach (GameLocation gameLocation in Game1.locations)
{
List <Vector2> toRemove = new List <Vector2>();
foreach (Vector2 vector in gameLocation.terrainFeatures.Keys)
{
TerrainFeature feature = gameLocation.terrainFeatures[vector];
if (feature is Tree tree && tree.growthStage.Value >= 5)
{
toRemove.Add(vector);
}
}
foreach (Vector2 vector in toRemove)
{
gameLocation.terrainFeatures.Remove(vector);
}
}
//Replant
foreach (TileLocation treeLocation in trees)
{
treeLocation.GetGameLocation().terrainFeatures.Remove(treeLocation.CreateVector2());
treeLocation.GetGameLocation().terrainFeatures.Add(treeLocation.CreateVector2(), new Tree(random.Next(1, 4), 100));
}
}
#endregion
//Remove resource clumps (e.g. boulders) other than stumps and hollow logs
var rc = Game1.getFarm().resourceClumps;
foreach (var a in rc.Where(a => a.parentSheetIndex.Value != 600 || a.parentSheetIndex.Value != 602).ToList())
{
rc.Remove(a);
}
//Remove small stones and weeds
var farmObjects = Game1.getFarm().objects;
var keys = farmObjects.Keys.ToList();
for (int i = 0; i < keys.Count(); i++)
{
var key0 = keys[i];
if (farmObjects[key0].name == "Stone" || farmObjects[key0].name == "Weeds")
{
farmObjects.Remove(key0);
}
}
//Setup alive players
alivePlayers.Clear();
foreach (Farmer player in Game1.getOnlineFarmers())
{
if (player != null && !(player == Game1.player && !modConfig.ShouldHostParticipate))
{
Console.WriteLine($"Adding {player.Name} to the game");
alivePlayers.Add(player.UniqueMultiplayerID);
}
}
//Storm index
int stormIndex = Storm.GetRandomStormIndex();
//Spawn players in & Tell the clients to start game
var chosenSpawns = new Spawns().ScatterPlayers(Game1.getOnlineFarmers());
foreach (Farmer player in chosenSpawns.Keys)
{
if (player == Game1.player)
{
ClientStartGame(alivePlayers.Count, modConfig.ShouldHostParticipate, stormIndex);
if (modConfig.ShouldHostParticipate)
{
NetworkUtility.WarpFarmer(player, chosenSpawns[player]);
}
else
{
player.warpFarmer(new TileLocation("Forest", 100, 20).CreateWarp());
}
}
else
{
NetworkUtility.BroadcastGameStartToClient(player, alivePlayers.Count, modConfig.ShouldHostParticipate, stormIndex);
NetworkUtility.WarpFarmer(player, chosenSpawns[player]);
}
}
//Remove horses/NPCs
foreach (GameLocation loc in Game1.locations)
{
foreach (NPC horse in loc.characters.Where(x => ModEntry.Config.KillAllNPCs || x is StardewValley.Characters.Horse).ToList())
{
loc.characters.Remove(horse);
}
}
//Freeze time
Game1.timeOfDay = 1400;
FreezeTime.TimeFrozen = true;
}
