/// <summary>
/// Internal constructor used by the code that fires the ActionTriggered event
/// </summary>
/// <param name="who">The player that triggered the action</param>
/// <param name="action">The action they triggered</param>
/// <param name="arguments">Any arguments that are attached to the action</param>
/// <param name="position">The tile position of the action triggered</param>
internal EventArgsActionTriggered(StardewValley.Farmer who, string action, string[] arguments, Microsoft.Xna.Framework.Vector2 position)
{
this.Action = action;
this.Arguments = arguments;
this.Who = who;
this.Position = position;
}
public object[] getAdjustedArgs(NPCPart part, Vector2 pos, StardewValley.Farmer farmer)
{
object[] toReturn = new object[args.Length];
for (int i = 0; i < args.Length; i++)
{
if (args[i] is string)
{
switch ((string)args[i])
{
case "%farmer%":
toReturn[i] = farmer;
break;
default:
toReturn[i] = args[i];
break;
}
}
else
{
toReturn[i] = args[i];
}
}
return(toReturn);
}
public void Trigger(Vector2 pos, StardewValley.Farmer farmer)
{
foreach (T t in rewards)
{
Trigger(t, pos, farmer);
}
}
//Check for pets
private void CheckPets()
{
Farm pFarm = Game1.getFarm();
SFarmer Player = Game1.player;
GameLocation location = Game1.currentLocation;
if (Player.hasPet())
{
foreach (NPC character in Game1.getFarm().characters)
{
if (character is Pet)
{
this.Helper.Reflection.GetField <bool>(character, "wasPetToday").SetValue(true);
}
}
foreach (NPC character in Utility.getHomeOfFarmer(Player).characters)
{
if (character is Pet)
{
this.Helper.Reflection.GetField <bool>(character, "wasPetToday").SetValue(true);
}
}
pFarm.setMapTileIndex(54, 7, 1939, "Buildings", 0);
}
}
public bool HasProfession(SFarmer player, string skillName, string professionName)
{
this._ValidateFarmer(player);
this._ValidateSkill(skillName);
this._ValidateProfession(skillName, professionName);
return(this.SkillData[player.UniqueMultiplayerID].Skills[skillName].Professions.Contains(professionName));
}
//Harvest Coops
private void HarvestProducts()
{
Farm pFarm = Game1.getFarm();
SFarmer Player = Game1.player;
foreach (Building building in pFarm.buildings)
{
if (building is Coop)
{
List <Vector2> coops = new List <Vector2>();
foreach (KeyValuePair <Vector2, SObject> pair in building.indoors.Objects)
{
SObject @object = pair.Value;
if (@object.isAnimalProduct() || @object.parentSheetIndex == 107)
{
if (this.AddToPlayer(@object, Player))
{
coops.Add(pair.Key);
Player.gainExperience(0, 5);
}
}
}
foreach (Vector2 iLocation in coops)
{
building.indoors.removeObject(iLocation, false);
}
}
}
}
public static bool onGainExperience(StardewValley.Farmer __instance, int which, ref int howMuch)
{
howMuch *= Config.GeneralMultiplier;
switch (which)
{
case 0:
howMuch *= Config.FarmingMultiplier;
break;
case 1:
howMuch *= Config.FishingMultiplier;
break;
case 2:
howMuch *= Config.ForagingMultiplier;
break;
case 3:
howMuch *= Config.MiningMultiplier;
break;
case 4:
howMuch *= Config.CombatMultiplier;
break;
case 5:
howMuch *= Config.LuckMultiplier;
break;
}
return(true);
}
public int LoadContents(StardewValley.Farmer player)
{
int numItemsLoaded = 0;
if (player.ActiveObject != null)
{
foreach (var container in _buildingInfo.ReadyToLoadContainers)
{
if (player.ActiveObject != null)
{
//this.Monitor.Log($" {player.Name} is holding {player.ActiveObject.Name} so placing it in container {container.Name}.");
if (container.performObjectDropInAction(player.ActiveObject, false, player))
{
player.reduceActiveItemByOne();
numItemsLoaded++;
}
else
{
Utility.Log($" Unable to load item. Container {container.Name} does not accept items of type {player.ActiveObject.Name}.");
}
}
else
{
Utility.Log($" {player.Name} has run out of items to load. Stopping load.");
break;
}
}
}
else
{
Utility.Log($" {player.Name} is not holding an item, so not loading containers.");
}
return(numItemsLoaded);
}
/*********
** Protected methods
*********/
private void _ValidateFarmer(SFarmer player)
{
if (!this.SkillData.ContainsKey(player.UniqueMultiplayerID))
{
throw new KeyNotFoundException("There is no farmer by this name registered:" + player.Name);
}
}
private void doAction()
{
SFarmer Player = Game1.player;
GameLocation location = Game1.currentLocation;
Tool tool = Player.CurrentTool;
Item item = Player.CurrentItem;
ITool[] tools = this.Tools
.Where(tools1 => tools1.IsEnabled(Player, tool, item, location))
.ToArray();
if (!tools.Any())
{
return;
}
Vector2[] grid = this.GetGrid(Player.getTileLocation(), this.Config.ToolRadius).ToArray();
foreach (Vector2 tile in grid)
{
location.objects.TryGetValue(tile, out SObject tileObj);
location.terrainFeatures.TryGetValue(tile, out TerrainFeature tileFeature);
foreach (ITool tool1 in tools)
{
if (tool1.Apply(tile, tileObj, tileFeature, Player, tool, item, location))
{
break;
}
}
}
}
public MovingStatePacket(byte theId, SFarmer player) : this()
{
clientId = theId;
flags = 0;
if (player.movementDirections.Contains(3))
{
flags |= ( byte )MovementFlags.Left;
}
if (player.movementDirections.Contains(1))
{
flags |= (byte)MovementFlags.Right;
}
if (player.movementDirections.Contains(0))
{
flags |= (byte)MovementFlags.Up;
}
if (player.movementDirections.Contains(2))
{
flags |= (byte)MovementFlags.Down;
}
if (player.running)
{
flags |= (byte)MovementFlags.Running;
}
x = player.position.X;
y = player.position.Y;
}
protected void RemoveItem(SFarmer who, Item item, int number = 1)
{
item.Stack -= 1;
if (item.Stack <= 0)
{
who.removeItemFromInventory(item);
}
}
public int GetSkillLevel(SFarmer player, string skillName)
{
this._ValidateFarmer(player);
this._ValidateSkill(skillName);
ISkill skill = this.GetSkillInfo(skillName);
return(Math.Min(skill.MaxSkillLevel, this.SkillData[player.UniqueMultiplayerID].Skills[skillName].Level));
}
public bool IsActivePrestigeSkill(SFarmer player, string skillName)
{
this._ValidateFarmer(player);
this._ValidateSkill(skillName);
ISkill skill = this.GetSkillInfo(skillName);
return(this.SkillData[player.UniqueMultiplayerID].Skills[skillName].Level <= skill.MaxSkillLevel);
}
public void ResetLoadButtons()
{
LoadGameMenu menu = stardewMenu as LoadGameMenu;
int currentItemIndex = ModEntry.GetHelper().Reflection.GetField <int>(menu, "currentItemIndex").GetValue();
ClearItems();
string ShortDescr(int idx)
{
StardewValley.Farmer farmer = (menuSlots[idx] as LoadGameMenu.SaveFileSlot).Farmer;
return($"slot {idx + 1}: {farmer.Name} on {farmer.farmName} farm");
}
string LongDescr(int idx)
{
StardewValley.Farmer farmer = (menuSlots[idx] as LoadGameMenu.SaveFileSlot).Farmer;
string season = "";
switch (farmer.seasonForSaveGame)
{
case 0: season = "spring"; break;
case 1: season = "summer"; break;
case 2: season = "fall"; break;
case 3: season = "winter"; break;
default: season = ""; break;
}
string timePlayed = StardewValley.Utility.getHoursMinutesStringFromMilliseconds(farmer.millisecondsPlayed);
return($"Day {farmer.dayOfMonthForSaveGame} of {season} in year {farmer.yearForSaveGame}. Playtime {timePlayed}. Press delete button to delete.");
}
for (int j = 0; j < System.Math.Min(itemCount, LoadGameMenu.itemsPerPage); j++)
{
MenuItem menuItem = MenuItem.MenuItemFromComponent(menu.slotButtons[j], menu, ShortDescr(j));
menuItem.Description = LongDescr(j);
menuItem.TextOnAction = "Loading " + ShortDescr(j);
AddItem(menuItem);
}
for (int j = LoadGameMenu.itemsPerPage; j < itemCount; j++)
{
MenuItem menuItem = MenuItem.MenuItemFromComponent(menu.slotButtons[LoadGameMenu.itemsPerPage - 1], menu, ShortDescr(j));
menuItem.Description = LongDescr(j);
menuItem.TextOnAction = "Loading " + ShortDescr(j);
AddItem(menuItem);
}
backButton = MenuItem.MenuItemFromComponent(menu.backButton, StardewValley.Game1.activeClickableMenu);
backButton.Label = "back to title";
backButton.TextOnAction = AccessTitleMenu.Title();
AddItem(backButton);
}
private void doFarmer(SFarmer farmer)
{
farmer.SetMovingLeft((flags & (byte)MovementFlags.Left) != 0);
farmer.SetMovingRight((flags & (byte)MovementFlags.Right) != 0);
farmer.SetMovingUp((flags & (byte)MovementFlags.Up) != 0);
farmer.SetMovingDown((flags & (byte)MovementFlags.Down) != 0);
farmer.setRunning((flags & (byte)MovementFlags.Running) != 0, true);
farmer.position.X = x;
farmer.position.Y = y;
}
public override void process(Client client)
{
SFarmer farmer = client.others[clientId];
if (farmer == null)
{
return;
}
doFarmer(farmer);
}
public ChestState(Chest chest)
{
SFarmer farmer = ( SFarmer )Util.GetInstanceField(typeof(Chest), chest, "opener");
opener = farmer != null?Multiplayer.getFarmerId(farmer) : -1;
// TODO: Move this to a proper place
if (Util.GetInstanceField(typeof(Chest), chest, "opener") == null && chest.frameCounter == -2) // It's stuck open
{
chest.frameCounter = 2;
}
}
public int HarvestContents(StardewValley.Farmer player)
{
int numItemsHarvested = 0;
//Harvest items into inventory
foreach (var container in _buildingInfo.ReadyToHarvestContainers)
{
//Get the item stored in the container
StardewValley.Item item = null;
if (container.name.Equals("Crystalarium"))
{
item = (StardewValley.Item)container.heldObject.Value.getOne();
}
else
{
item = (StardewValley.Item)container.heldObject.Value;
}
//Make sure player can collect item and inventory is not already full
if (player.couldInventoryAcceptThisItem(item))
{
//this.Monitor.Log($" Harvesting item {item.Name} from container {container.Name} and placing in {player.Name}'s inventory.");
if (!player.addItemToInventoryBool(item, false))
{
//Inventory was full - throw exception so we can show a message
Utility.Log($" {player.Name} has run out of inventory space. Stopping harvest.");
throw new InventoryFullException();
}
numItemsHarvested++;
//Remove this item permanently from the container (except Crystalarium).
if (container.name.Equals("Crystalarium"))
{
container.MinutesUntilReady = this.getMinutesForCrystalarium(item.ParentSheetIndex);
}
else
{
container.heldObject.Value = (StardewValley.Object)null;
}
container.readyForHarvest.Value = false;
container.showNextIndex.Value = false;
}
else
{
//Inventory was full - throw exception so we can show a message
Utility.Log($" {player.Name} has run out of inventory space. Stopping harvest.");
throw new InventoryFullException();
}
}
return(numItemsHarvested);
}
public override void process(Client client)
{
SFarmer farmer = client.others[clientId];
if (farmer == null)
{
return;
}
//Log.Async("Movement " + flags + " " + x + " " + y);
doFarmer(farmer);
}
private void doFarmer(SFarmer farmer)
{
if (index == -1)
{
farmer.ActiveObject = null;
}
else
{
farmer.ActiveObject = (big ? new StardewValley.Object(Vector2.Zero, index, false) : new StardewValley.Object(Vector2.Zero, index, 1));
}
//farmer.CurrentToolIndex = tool;
}
private void QuarterSecond(object sender, EventArgs e)
{
SFarmer Player = Game1.player;
// || Player.ActiveObject.Category == -74 || Player.ActiveObject.Category == -19
if (Context.IsWorldReady)
{
if (Game1.activeClickableMenu == null && this.Config.ModEnabled == true && (Player.CurrentTool is Hoe || Player.CurrentTool is WateringCan || Player.CurrentTool is Axe || Player.CurrentTool is Pickaxe || (Player.CurrentTool is MeleeWeapon && Player.CurrentTool.name.ToLower().Contains("scythe"))))
{
doAction();
}
}
}
//Add Item to Player
private bool AddToPlayer(SObject @object, SFarmer Player)
{
if (this.AddItemsToInventory)
{
if (Player.couldInventoryAcceptThisItem(@object))
{
Player.addItemToInventory(@object);
return(true);
}
}
//Need to add for chest.
return(false);
}
//HarvestedCrops
private SObject HarvestedCrop(HoeDirt dirt, Crop crop, int x, int y)
{
SFarmer Player = Game1.player;
int stack = 1;
int iQuality = 0;
int fBuff = 0;
Random rnd = new Random(x * 7 + y + 11 + (int)Game1.stats.DaysPlayed + (int)Game1.uniqueIDForThisGame);
switch (dirt.fertilizer)
{
case 368:
fBuff = 1;
break;
case 369:
fBuff = 2;
break;
}
double qMod = 0.2 * (Player.FarmingLevel / 10) + 0.2 * fBuff * ((Player.FarmingLevel + 2) / 12) + 0.01;
double qModifier = Math.Min(0.75, qMod * 2.0);
if (rnd.NextDouble() < qMod)
{
iQuality = 1;
}
if (crop.minHarvest > 1 || crop.maxHarvest > 1)
{
stack = rnd.Next(crop.minHarvest, Math.Min(crop.minHarvest + 1, crop.maxHarvest + 1 + Player.FarmingLevel / crop.maxHarvestIncreasePerFarmingLevel));
}
if (crop.chanceForExtraCrops > 0.0)
{
while (rnd.NextDouble() < Math.Min(0.9, crop.chanceForExtraCrops))
{
stack++;
}
}
if (rnd.NextDouble() < Player.luckLevel / 1500.0 + Game1.dailyLuck / 1200.0 + 9.99999974737875E-05)
{
stack *= 2;
}
if (crop.indexOfHarvest == 421)
{
crop.indexOfHarvest = 431;
stack = rnd.Next(1, 4);
}
SObject @item = new SObject(crop.indexOfHarvest, stack, false, -1, iQuality);
return(item);
}
public void GiveProfession(SFarmer player, string skillName, string professionName)
{
this._ValidateFarmer(player);
this._ValidateSkill(skillName);
this._ValidateProfession(skillName, professionName);
ISkill skill = this.GetSkillInfo(skillName);
if (skill is VanillaSkill && !player.professions.Contains(SkillHelper.VanillaProfessions[professionName]))
{
player.professions.Add(SkillHelper.VanillaProfessions[professionName]);
}
if (!this.SkillData[player.UniqueMultiplayerID].Skills[skillName].Professions.Contains(professionName))
{
this.SkillData[player.UniqueMultiplayerID].Skills[skillName].Professions.Add(professionName);
}
}
//Harvest Truffles
private void HarvestTruffles()
{
Farm pFarm = Game1.getFarm();
SFarmer Player = Game1.player;
List <Vector2> truffles = new List <Vector2>();
//Go through each truffle that needs to be removed.
foreach (KeyValuePair <Vector2, SObject> pair in pFarm.Objects)
{
SObject @object = pair.Value;
if (@object.name == "Truffle")
{
bool doubleHarvest = false;
if (Player.professions.Contains(16))
{
@object.quality = 4;
}
double randomNum = Game1.random.NextDouble();
bool doubleChance = randomNum < 0.2 ? true : false;
if (Player.professions.Contains(13) && doubleChance)
{
@object.Stack = 2;
doubleHarvest = true;
}
if (this.AddToPlayer(@object, Player))
{
truffles.Add(pair.Key);
Player.gainExperience(2, 7);
if (doubleHarvest)
{
Player.gainExperience(2, 7);
}
}
}
}
//Now we remove them
foreach (Vector2 iLocation in truffles)
{
pFarm.removeObject(iLocation, false);
}
}
public HeldItemPacket(byte theId, SFarmer farmer)
: this()
{
clientId = theId;
if (farmer.ActiveObject == null)
{
index = -1;
big = false;
}
else
{
index = farmer.ActiveObject.ParentSheetIndex;
big = farmer.ActiveObject.bigCraftable;
}
tool = farmer.CurrentToolIndex;
//Log.Async(farmer.Name + " holding " + tool);
}
public void AddSkillExperience(SFarmer player, string skillName, int experience)
{
if (experience < 1)
{
return;
}
this._ValidateFarmer(player);
this._ValidateSkill(skillName);
PlayerSkillInfo info = this.SkillData[player.UniqueMultiplayerID].Skills[skillName];
info.Experience += experience;
if (info.Experience >= this.TotalExperienceRequiredForLevel(skillName, info.Level + 1))
{
// TODO: Setup the levelup menu here
if (this.IsActivePrestigeSkill(player, skillName) && (info.Level + 1) % 10 == 0 || !this.IsActivePrestigeSkill(player, skillName) && this.GetSkillInfo(skillName).Professions.Any(a => a.SkillLevel == info.Level + 1))
{
this.GiveProfessionPoint(player, skillName);
}
}
}
public static bool HasAllProfessionsForSkill(StardewValley.Farmer farmer, int skill)
{
List <int> list;
switch (skill)
{
case StardewValley.Farmer.farmingSkill:
list = Farmer;
break;
case StardewValley.Farmer.fishingSkill:
list = Fishing;
break;
case StardewValley.Farmer.foragingSkill:
list = Foraging;
break;
case StardewValley.Farmer.miningSkill:
list = Mining;
break;
case StardewValley.Farmer.combatSkill:
list = Combat;
break;
default:
return(false);
}
foreach (int profession in list)
{
if (!farmer.professions.Contains(profession))
{
return(false);
}
}
return(true);
}
private void doMine()
{
SFarmer Player = Game1.player;
GameLocation location = Game1.currentLocation;
Tool tool = Player.CurrentTool;
Item item = Player.CurrentItem;
Dictionary <Vector2, SObject> curObj = new Dictionary <Vector2, SObject>();
Dictionary <Vector2, TerrainFeature> curTerrain = new Dictionary <Vector2, TerrainFeature>();
ITool[] tools = this.Tools
.Where(tools1 => tools1.IsEnabled(Player, tool, item, location))
.ToArray();
if (!tools.Any())
{
return;
}
if (location.isFarm || location.name.Contains("Greenhouse") || location.name.Contains("FarmExpan"))
{
return;
}
Vector2[] grid = this.GetGrid(Player.getTileLocation(), 50).ToArray();
foreach (Vector2 tile in grid)
{
location.objects.TryGetValue(tile, out SObject tileObj);
location.terrainFeatures.TryGetValue(tile, out TerrainFeature tileFeature);
foreach (ITool tool1 in tools)
{
if (tool1.Apply(tile, tileObj, tileFeature, Player, tool, item, location))
{
break;
}
}
}
}
