private void PlantSeed(FarmPlot plot, string seedName)
{
int count = 1; //Hard coded for now
if (mFarmingSeeds[seedName].modifyCountCond(-count, count))
{
//Seed planted!
//Planting the appropriate seed on the farmplot
plot.PlantSeedPlot(mFarmingSeeds[seedName]); //This might mess with mseeds count
#region Background Updates
switch (seedName)
{
case "Corn":
farmingDetailScript.SetPlant(plot.ID, 1);
break;
case "Wheat":
farmingDetailScript.SetPlant(plot.ID, 0);
break;
case "Potato":
farmingDetailScript.SetPlant(plot.ID, 2);
break;
case "Hops":
farmingDetailScript.SetPlant(plot.ID, 3);
break;
}
#endregion
}
EventController.getInstance().FireEvent(fuei);
}
public void OnRecordPersistentData()
{
Target = GetComponent <FarmPlot>();
VariableName = "FarmPlot " + transform.position.x.ToString() + "," + transform.position.y.ToString();
DialogueLua.SetVariable(VariableName + "CurrentlyWatered", Target.CurrentlyWatered);
DialogueLua.SetVariable(VariableName + "TimeSinceWatered", Target.TimeSinceWatered);
}
public void UnitReachedPlot(SwarmUnit unit, FarmPlot plot)
{
if (plot == _farmPlot)
{
_farmPlot.Decay();
RemoveUnit(unit);
}
}
private void DestroyAnimatedTool(FarmPlot plot)
{
if (_farmPlotAnimatedTools.ContainsKey(plot))
{
var tool = _farmPlotAnimatedTools[plot];
_farmPlotAnimatedTools.Remove(plot);
Destroy(tool);
}
}
public void OnApplyPersistentData()
{
Target = GetComponent <FarmPlot>();
VariableName = "FarmPlot " + transform.position.x.ToString() + "," + transform.position.y.ToString();
Target.CurrentlyWatered = DialogueLua.GetVariable(VariableName + "CurrentlyWatered").asBool;
Target.TimeSinceWatered = DialogueLua.GetVariable(VariableName + "TimeSinceWatered").asInt;
Target.Load();
}
public void Plant(bool pPlotWatered, FarmPlot pPlot)
{
PixelCrushers.MessageSystem.SendMessage(gameObject, "Plant", Template.name);
if (pPlotWatered)
{
Water();
}
Plot = pPlot;
CheckForSun();
}
//Cant use constructor to instantiate objects. Using awake() instead
public void Awake()
{
#region Event setup
fuei.eventGO = gameObject;
ruei.eventGO = gameObject;
//Listening for events
EventController.getInstance().RegisterListener <FarmingWorkerEventInfo>(FarmingWorkerUpdate);
EventController.getInstance().RegisterListener <CookingWorkerEventInfo>(CookWorkerUpdate);
EventController.getInstance().RegisterListener <FarmPurchaseEventInfo>(FarmPurchaseUpdate);
#endregion
mInstance = this;
mFarmPlots = new List <FarmPlot>();
mFarmingSeeds = new Dictionary <string, Seeds>();
#region Init farm plots
for (int i = 0; i < 10; i++)
{
FarmPlot tmp = Instantiate(farmPlotPrefab, FarmingBackgroundPanel, true);
//tmp.transform.SetParent(FarmPlotParent, true); //gets rescaled when we set the parent?
tmp.transform.localScale = new Vector3(1, 1, 1); //resetting scale
float width = tmp.GetComponent <RectTransform>().sizeDelta.x; //getting our width
float height = tmp.GetComponent <RectTransform>().sizeDelta.y;
tmp.transform.localPosition = new Vector3(plotSpawnX + ((width + 20) * (i % 5)), //20 is our buffer
plotSpawnY + -((height + 80) * (int)(i / 5))); //20 is our buffer
//Setting up button click events
tmp.cornButton.onClick.AddListener(() => PlantSeed(tmp, "Corn"));
tmp.wheatButton.onClick.AddListener(() => PlantSeed(tmp, "Wheat"));
tmp.potatoButton.onClick.AddListener(() => PlantSeed(tmp, "Potato"));
tmp.hopsButton.onClick.AddListener(() => PlantSeed(tmp, "Hops"));
tmp.ID = i;
//Disabling all but the first 2 farm plots. Later ones will be purchased later
if (i > 1)
{
tmp.gameObject.SetActive(false);
}
mFarmPlots.Add(tmp);
}
#endregion
//SEEDS
mFarmingSeeds["Corn"] = new Seeds(5, SEED_TYPE.Corn);
mFarmingSeeds["Potato"] = new Seeds(5, SEED_TYPE.Potato);
mFarmingSeeds["Wheat"] = new Seeds(5, SEED_TYPE.Wheat);
mFarmingSeeds["Hops"] = new Seeds(5, SEED_TYPE.Hops);
}
private void SpawnAnimatedTool(FarmPlot plot, FarmPlot.State state, FarmPlot.State currentState)
{
for (var i = 0; i < _playStates.Count; ++i)
{
if (_playStates[i] == state &&
(_playAfterStates[i] == currentState || _playAfterStates[i] == FarmPlot.State.Undifined))
{
var farmTool = Instantiate(_farmTools[i]);
_farmPlotAnimatedTools.Add(plot, farmTool);
farmTool.GetComponent <Animator>().SetBool("isPlaying", true);
farmTool.transform.position = plot.transform.position + _spawnOffset[i];
break;
}
}
}
public override bool CheckTileValidity(Vector2 pTileWorldPos)
{
FarmPlot plot = GetPlot(pTileWorldPos);
if (CheckTileNotOccupied(pTileWorldPos) == false && plot == null || plot != null && plot.Crop == null)
{
return(false);
}
STETilemap affectedLayer = GetTileAffectedLayer(pTileWorldPos);
if (affectedLayer == null && plot == null)
{
return(false);
}
return(true);
}
FarmPlot GetPlot(Vector2 pTileWorldPos)
{
RaycastHit2D hit = Physics2D.Raycast(pTileWorldPos, Vector2.zero, 0.5f, LayerMask.GetMask("Farm"));
if (hit.collider == null)
{
return(null);
}
if (hit.collider.GetComponent <FarmPlot>() == null)
{
return(null);
}
FarmPlot farmPlot = hit.collider.gameObject.GetComponent <FarmPlot>();
return(farmPlot);
}
public void Init(FarmPlot plot)
{
var gameHandler = GameObject.FindGameObjectWithTag("GameHandler");
ISubject gameHandlerSubject;
if (gameHandler.TryGetComponent <ISubject>(out gameHandlerSubject))
{
Subscribe(gameHandlerSubject);
}
_swarmUnits = new List <GameObject>();
_farmPlot = plot;
Subscribe(_farmPlot);
initAngleList();
_destination = _farmPlot.transform.position + new Vector3(0, 0.5f, 0);
NotifyStaticObservers(new SwarmSpawnEvent(this, this));
}
protected override void ProceedUse(List <Vector2> pTiles)
{
NeedBase energyNeed = PlayerNeedManager.Instance.GetNeed("Energy");
energyNeed.Change(-CurrentTool.EnergyCost * (ToolCursorManager.Instance.CursorIndex + 1));
List <Vector2> tiles = pTiles;
foreach (Vector2 tile in tiles)
{
if (CheckTileValidity(tile))
{
STETilemap affectedLayer = GetTileAffectedLayer(tile);
uint rawData = affectedLayer.GetTileData(tile);
TileData tileData = new TileData(rawData);
foreach (AffectedTerrain terrain in AffectedTerrains)
{
if (affectedLayer.name == terrain.LayerName)
{
tileData.brushId = terrain.BrushId;
}
}
if (affectedLayer.name == "Dirt")
{
FarmPlot plot = GetPlot(tile);
if (plot != null)
{
Destroy(plot.gameObject);
}
}
affectedLayer.SetTileData(tile, tileData.BuildData());
affectedLayer.UpdateMeshImmediate();
FindObjectOfType <PlayerInventory>().RemoveFromStack(Toolbar.Instance.SelectedSlot.ReferencedItemStack, 1);
if (Toolbar.Instance.SelectedSlot.ReferencedItemStack == null)
{
return;
}
}
}
}
protected override void ProceedUse(List <Vector2> pTiles)
{
//Spend player energy
NeedBase energyNeed = PlayerNeedManager.Instance.GetNeed("Energy");
energyNeed.Change(-CurrentTool.EnergyCost * (ToolCursorManager.Instance.CursorIndex + 1));
List <Vector2> tiles = pTiles;
foreach (Vector2 tile in tiles)
{
if (CheckTileValidity(tile))
{
FarmPlot plot = GetPlot(tile);
if (plot != null && plot.Crop != null)
{
plot.Crop.SendMessage("Hit", "Hoe");
return;
}
STETilemap affectedLayer = GetTileAffectedLayer(tile);
affectedLayer.Erase(tile);
affectedLayer.UpdateMeshImmediate();
if (affectedLayer.name == "Dirt")
{
GameObject.Instantiate(PlotPrefab, tile, this.transform.rotation);
}
foreach (AffectedLayer layer in AffectedLayerNames)
{
if (layer.Name == affectedLayer.name)
{
int rand = Random.Range(0, 100);
if (rand <= layer.Output.Chance)
{
ItemSpawner.Instance.SpawnItems(layer.Output.ContainedItem, tile, (uint)layer.Output.Amount);
}
}
}
}
}
}
FarmPlot GetPlot(Vector2 pTileWorldPos)
{
// Vector2 pos = pTileWorldPos;
// pos.x = 0.32f * Mathf.Round(pos.x / 0.32f);
// pos.y = 0.32f * Mathf.Round(pos.y / 0.32f);
RaycastHit2D hit = Physics2D.Raycast(pTileWorldPos, Vector2.zero, 0.5f, LayerMask.GetMask("Farm"));
if (hit.collider == null)
{
return(null);
}
if (hit.collider.GetComponent <FarmPlot>() == null)
{
return(null);
}
FarmPlot farmPlot = hit.collider.gameObject.GetComponent <FarmPlot>();
print("Plot " + farmPlot.name);
return(farmPlot);
}
protected override void ProceedUse(List <Vector2> pTiles)
{
NeedBase energyNeed = PlayerNeedManager.Instance.GetNeed("Energy");
energyNeed.Change(-CurrentTool.EnergyCost * (ToolCursorManager.Instance.CursorIndex + 1));
List <Vector2> tiles = pTiles;
foreach (Vector2 tile in tiles)
{
if (CheckTileValidity(tile))
{
FarmPlot plot = GetPlot(tile);
plot.Water();
CurrentTool.CurrentCharge = Mathf.Clamp(CurrentTool.CurrentCharge - 1, 0, CurrentTool.MaxCharge);
if (plot.Crop != null)
{
plot.Crop.Water();
}
}
}
}
protected override void ProceedUse(List <Vector2> pTiles)
{
NeedBase energyNeed = PlayerNeedManager.Instance.GetNeed("Energy");
energyNeed.Change(-CurrentTool.EnergyCost * (ToolCursorManager.Instance.CursorIndex + 1));
List <Vector2> tiles = pTiles;
foreach (Vector2 tile in tiles)
{
if (CheckTileValidity(tile))
{
FarmPlot plot = GetPlot(tile);
if (plot.PlantCrop(CurrentTool))
{
FindObjectOfType <PlayerInventory>().RemoveFromStack(Toolbar.Instance.SelectedSlot.ReferencedItemStack, 1);
if (Toolbar.Instance.SelectedSlot.ReferencedItemStack == null)
{
return;
}
}
}
}
}
public void OnPlotStartStateSwitch(FarmPlot.State switchState, FarmPlot.State currentState, FarmPlot plot)
{
if (switchState == FarmPlot.State.Dug && !_shovelComplete)
{
_shovelComplete = true;
_shovelQuest.fontStyle = FontStyles.Strikethrough;
_completeShovelQuestEvent.Invoke();
CheckCompletion();
}
else if (switchState == FarmPlot.State.Planted && !_plantComplete)
{
_plantComplete = true;
_plantQuest.fontStyle = FontStyles.Strikethrough;
_completePlantQuestEvent.Invoke();
CheckCompletion();
}
else if (switchState == FarmPlot.State.Growing && !_waterComplete)
{
_waterComplete = true;
_waterQuest.fontStyle = FontStyles.Strikethrough;
_completeWaterQuestEvent.Invoke();
CheckCompletion();
}
if (_shovelComplete && _plantComplete && _waterComplete)
{
Notify(new FarmTutorialPlotCompleteEvent(this));
EnableFarmPlots();
}
}
public PlotOnCooldownWarningEvent(FarmPlot farmPlot, FarmTool farmTool) : base(farmPlot)
{
this.farmPlot = farmPlot;
this.farmTool = farmTool;
}
public WrongToolOnPlotWarningEvent(FarmPlot farmPlot, FarmTool farmTool) : base(farmPlot)
{
this.farmPlot = farmPlot;
this.farmTool = farmTool;
}
public void OnPlotStateSwitch(FarmPlot.State state, FarmPlot.State previousState, FarmPlot plot)
{
if (state != FarmPlot.State.Growing)
{
_continueSpawning = false;
_flee = true;
OnFlee();
}
if (state == FarmPlot.State.Healing)
{
}
}
public void OnPlotHarvest(FarmPlot plot)
{
}
public FarmPlotIsInactiveWarningEvent(FarmPlot farmPlot) : base(farmPlot)
{
this.farmPlot = farmPlot;
}
public void OnPlotStartStateSwitch(FarmPlot.State state, FarmPlot.State previousState, FarmPlot plot)
{
}
public void OnPlotStartStateSwitch(FarmPlot.State switchState, FarmPlot.State currentState, FarmPlot plot)
{
for (var i = 0; i < _farmEvents.onPlotChangeStart.Count; ++i)
{
_farmEvents.onPlotChangeStart[i].TryInvoke(switchState, currentState);
}
}
public void Attack()
{
if (Time.time >= attackCoolDown)
{
//Detect hittables in range
Collider[] gotHit = Physics.OverlapSphere(attackPoint.position, attackRange, hittableLayers);
//Apply damage to each hit object
foreach (Collider hit in gotHit)
{
Resource hitResource = hit.GetComponent <Resource>();
TreeScript hitTree = hit.GetComponent <TreeScript>();
BuildingGhost buildingGhost = hit.GetComponent <BuildingGhost>();
Animal animal = hit.GetComponent <Animal>();
UseableItem item = hit.GetComponent <UseableItem>();
FarmPlot farmPlot = hit.GetComponent <FarmPlot>();
Plant plant = hit.GetComponent <Plant>();
//Getting resources
if (hitResource)
{
hitResource.health -= attackDamage;
audioManager.PlaySound("Hit Marker");
}
//Tree chopping
if (hitTree)
{
hitTree.ChopTree(attackDamage);
audioManager.PlaySound("Hit Marker");
}
//Building ghosts
if (buildingGhost)
{
if (buildingGhost.requiredResource == "Wood")
{
if (GameController.Instance.resourceController.wood >= 1)
{
buildingGhost.AddResources(1);
}
}
if (buildingGhost.requiredResource == "Stone")
{
if (GameController.Instance.resourceController.stone >= 1)
{
buildingGhost.AddResources(1);
}
}
}
//Hit animal
if (animal)
{
animal.TakeDamage(attackDamage, this.transform);
audioManager.PlaySound("Smack");
//Debug.Log("Dealt " + damage + " dmg to " + hit.transform.name);
}
//Pickup item
if (item)
{
if (itemInHand == null)
{
item.pickedUp = true;
itemInHand = hit.transform;
audioManager.PlaySound("Item Pickup");
}
}
//Farming
if (farmPlot)
{
farmPlot.PlantSeed();
}
if (plant)
{
plant.Harvest();
}
}
attackCoolDown = Time.time + (1.0f / attackSpeed);
}
}
public void OnPlotStateSwitch(FarmPlot.State state, FarmPlot.State previousState, FarmPlot plot)
{
DestroyAnimatedTool(plot);
}
public void OnPlotStartStateSwitch(FarmPlot.State switchState, FarmPlot.State currentState, FarmPlot plot)
{
SpawnAnimatedTool(plot, switchState, currentState);
}
public void OnPlotHarvest(FarmPlot plot)
{
_farmEvents.onPlotHarvest.Invoke();
}
public void OnPlotStateSwitch(FarmPlot.State state, FarmPlot.State previousState, FarmPlot plot)
{
if (state == FarmPlot.State.Dug && !_plantQuestStarted)
{
Debug.Log("Start plant quest");
_plantQuestStarted = true;
_startPlantQuestEvent.Invoke();
}
else if (state == FarmPlot.State.Planted && !_waterQuestStarted)
{
_waterQuestStarted = true;
_startWaterQuestEvent.Invoke();
}
else if (state == FarmPlot.State.Growing)
{
}
else if (state == FarmPlot.State.Grown)
{
if (_firstHarvest)
{
_firstHarvest = false;
_harvestHand.SetActive(true);
_harvestTweenStart = Camera.main.WorldToScreenPoint(plot.transform.position);
Vector2 truckPos = Camera.main.WorldToScreenPoint(_truck.transform.position);
_harvestHand.transform.position = _harvestTweenStart;
_harvestHand.transform.DOMove(truckPos, 1.5f);
}
}
else if (state == FarmPlot.State.Harvested)
{
if (!_firstHarvestCompleted)
{
_firstHarvestCompleted = true;
DOTween.Kill(_harvestHand.transform);
_harvestHand.SetActive(false);
}
}
else if (state == FarmPlot.State.Decay)
{
if (_firstSpray)
{
_firstSpray = false;
_sprayHand.SetActive(true);
_sprayTweenEnd = Camera.main.WorldToScreenPoint(plot.transform.position);
_sprayHand.transform.position = _sprayTool.transform.position;
_sprayHand.transform.DOMove(_sprayTweenEnd, 1.5f);
}
}
else if (state == FarmPlot.State.Healing)
{
if (!_firstSprayCompleted)
{
_firstSprayCompleted = true;
DOTween.Kill(_sprayHand.transform);
_sprayHand.SetActive(false);
}
}
else if (state == FarmPlot.State.Withered)
{
if (!_firstSprayCompleted)
{
_firstSprayCompleted = true;
DOTween.Kill(_sprayHand.transform);
_sprayHand.SetActive(false);
_failBugKillEvent.Invoke();
}
}
}
public void OnPlotStateSwitch(FarmPlot.State state, FarmPlot.State previousState, FarmPlot plot)
{
for (var i = 0; i < _farmEvents.onPlotChange.Count; ++i)
{
_farmEvents.onPlotChange[i].TryInvoke(state, previousState);
}
}
