public override void SetProgress(float f)
{
if (!m_TaskProcessing || m_AssignedEquipment == null)
{
m_TimeSinceLastTrigger = 0;
return;
}
base.SetProgress(f);
Vector3 fishingPosition = FMBoardReferences.GetOrCreateInstance().m_ResourceBoatDestinations[m_AssignedEquipment.m_ResourceIndex].position;
// use the position to the fishing hole as 40%, stay still for the middle 20%
// otherwise come back for the last 40%
bool gotFish = progress > 0.6f;
Vector3 destination = gotFish ? m_DockPosition : fishingPosition;
// on the way there
// lerp position will b < 0.5 but we want out of 0.5
float lerpPosition = progress > 0.6f ? (progress - 0.6f) / 0.4f : progress / 0.4f;
Vector3 startPosition = gotFish ? fishingPosition : m_DockPosition;
transform.position = Vector3.Lerp(startPosition, destination, lerpPosition);
if (gotFish && m_Resources.Count > 0)
{
m_Resources.Peek().SetResourceVisible(true);
}
}
private void FinishHarvest()
{
if (!Tutorial.GetOrCreateInstance().HasProcessedFish&& m_AssignedWorkers.Count > 0)
{
Tutorial.GetOrCreateInstance().ShowProcessFishTutorial(m_AssignedWorkers[0]);
}
for (int i = 0; i < m_AssignedWorkers.Count; ++i)
{
m_BoatSlots.UnassignWorker(m_AssignedWorkers[i]);
}
m_AssignedWorkers.Clear();
m_TaskProcessing = false;
m_TimeSinceLastTrigger = 0f;
// Move back to start position.
transform.position = m_DockPosition;
SetProgress(0f);
var processor = FMBoardReferences.GetOrCreateInstance().m_Processor;
if (processor && m_Resources.Count > 0)
{
var generatedResource = m_Resources.Dequeue();
m_BoatSlots.UnassignResource(generatedResource);
processor.ProcessNewResource(generatedResource);
}
}
public void UnassignEquipment(FMEquipment equipment)
{
if (equipment != null)
{
var stagingArea = FMBoardReferences.GetOrCreateInstance().m_EquipmentStagingArea;
stagingArea.AddToStaging(equipment.transform);
}
m_EquipmentSlot.m_AssignedObject = null;
}
protected override void TriggerTask()
{
base.TriggerTask();
if (m_Resources.Count > 0)
{
// done processing
FMResource processedResource = m_Resources.Dequeue();
processedResource.SetResourceVisible(false);
FMBoardReferences.GetOrCreateInstance().m_ResourceSinks[processedResource.m_ResourceIndex].AddResourceToSink(processedResource);
SetProgress(0f);
Tutorial.GetOrCreateInstance().HasProcessedFish = true;
}
}
public void GoToWorkerPool()
{
var drag_handler = gameObject.GetComponent <FMDraggable>();
if (drag_handler)
{
drag_handler.enabled = true;
}
currentTask = null;
m_IsSleepingIn = false;
// move the sprite to pool for selection...
FMBoardReferences.GetOrCreateInstance().m_WorkerPoolStagingArea.AddToStaging(this.transform);
}
public void SpawnCrowd()
{
var sinks = FMBoardReferences.GetOrCreateInstance().m_ResourceSinks;
var canvas = GetComponentInParent <Canvas>();
// spawn equally between the three sinks...
for (int i = 0; i < m_CrowdSize; ++i)
{
// assign evenly between three pools to start
var newCitizen = Instantiate(m_CitizenFishPrefab, canvas.transform);
var sinkIndexToUse = i < 10 ? 0 : i < 20 ? 1 : 2;
var stagingArea = sinks[sinkIndexToUse].m_WorkerStagingArea;
stagingArea.AddToStaging(newCitizen.transform);
m_Citizens.Add(newCitizen);
}
}
public void GoHome()
{
// animate go home
m_TimeSleptIn = 0f;
m_IsSleepingIn = true;
var drag_handler = gameObject.GetComponent <FMDraggable>();
if (drag_handler)
{
drag_handler.enabled = false;
}
currentTask = null;
FMBoardReferences.GetOrCreateInstance().m_WorkerHomeStagingArea.AddToStaging(this.transform);
}
private IEnumerator SpawnMafia()
{
m_ShowingMafia = true;
var mafiaInstance = Instantiate(m_MafiaPrefab, m_SpawnCanvas.transform);
// get a random sink and put mafia there...
//var potentialSinks = FMBoardReferences.GetOrCreateInstance().m_ResourceSinks;
//int randomSink = Random.Range(0, potentialSinks.Length);
//var sink = potentialSinks[randomSink];
var staging = FMBoardReferences.GetOrCreateInstance().m_WorkerPoolStagingArea;
staging.AddToStaging(mafiaInstance.transform);
FMPlayer.GetOrCreateInstance().IncrementCapital(-25f);
//TODO: have the mafia say something
yield return(new WaitForSeconds(5f));
m_LastMafiaSpawnTime = Time.time;
Destroy(mafiaInstance);
m_ShowingMafia = false;
}
public bool CheckProcessing()
{
bool nowProcessing = m_AssignedWorkers.Count >= m_NumberOfWorkersRequired;
nowProcessing &= m_AssignedEquipment != null && m_AssignedEquipment.m_AssignmentCompleted;
if (!m_TaskProcessing && nowProcessing)
{
// todo: send to a specific resource type depending on where boat is directed
var resourcePrefab = FMBoardReferences.GetOrCreateInstance().m_ResourcePrefabs[m_AssignedEquipment.m_ResourceIndex];
var canvas = GetComponentInParent <Canvas>();
var resourceInstance = Instantiate(resourcePrefab, canvas.transform);
resourceInstance.transform.localScale = Vector3.one;
resourceInstance.transform.position = transform.position;
var resourceComponent = resourceInstance.GetComponent <FMResource>();
// size is an index
resourceComponent.m_Size = m_NumberOfWorkersRequired - 1;
resourceComponent.SetRepresentation();
m_BoatSlots.AssignResource(resourceComponent);
resourceComponent.SetResourceVisible(false);
m_Resources.Enqueue(resourceComponent);
for (int i = 0; i < m_AssignedWorkers.Count; ++i)
{
var drag_handler = m_AssignedWorkers[i].gameObject.GetComponent <FMDraggable>();
if (drag_handler)
{
drag_handler.enabled = false;
}
}
{
var drag_handler = m_AssignedEquipment.gameObject.GetComponent <FMDraggable>();
if (drag_handler)
{
drag_handler.enabled = false;
}
}
}
m_TaskProcessing = nowProcessing;
return(m_TaskProcessing);
}
public void GetSomeGrub()
{
// animate get food
int randomSink = Random.Range(0, 3);
var sink = FMBoardReferences.GetOrCreateInstance().m_ResourceSinks[randomSink];
m_SicknessLevel = sink.m_CurrentSicknessLevel;
m_TimeToReturnToWork = m_SicknessSleepInScalar * m_SicknessLevel;
var drag_handler = gameObject.GetComponent <FMDraggable>();
if (drag_handler)
{
drag_handler.enabled = false;
}
currentTask = null;
sink.m_WorkerStagingArea.AddToStaging(this.transform);
//GoHome();
}
protected override void OnStart()
{
base.OnStart();
var startingResource = FMBoardReferences.GetOrCreateInstance().m_ResourcePrefabs[m_ResourceIndex];
var canvas = GetComponentInParent <Canvas>();
var initialResource = Instantiate(startingResource, canvas.transform);
initialResource.transform.localScale = Vector3.one;
initialResource.transform.position = transform.position;
var resourceComponent = initialResource.GetComponent <FMResource>();
resourceComponent.SetResourceVisible(false);
resourceComponent.m_ProcessedAmount = FMResource.m_StartingResourceAmount;
m_Resources.Enqueue(resourceComponent);
m_SinkLevelDisplay.UpdateLevelDisplay(FMResource.m_StartingResourceAmount);
FMGameLoopManager.GetOrCreateInstance().m_CurrentDay.m_OnDayStartEvent += OnDayStart;
//TODO: Add a decent level of starting resources for the player to make money off
}
protected override void OnStart()
{
base.OnStart();
m_WorkerStagingArea = FMBoardReferences.GetOrCreateInstance().m_WorkerPoolStagingArea;
m_DockPosition = transform.position;
}
private Color GetColor()
{
return(FMBoardReferences.GetOrCreateInstance().m_ColorsForResource[m_ResourceIndex]);
}
private IEnumerator UpdateCrowd()
{
var potentialSinks = FMBoardReferences.GetOrCreateInstance().m_ResourceSinks;
var sinks = new List <FMResourceSink>();
while (true)
{
yield return(new WaitForSeconds(1f));
// if there is at least 1 amount there then it is valid...
sinks.Clear();
for (int i = 0; i < potentialSinks.Length; ++i)
{
if (potentialSinks[i].GetCurrentResourceSum() > 0)
{
sinks.Add(potentialSinks[i]);
}
}
// want the ratio of supply between sinks
var totalAmounts = 0f;
float[] sinkAmounts = new float[sinks.Count];
for (int i = 0; i < sinks.Count; ++i)
{
float sum = sinks[i].GetCurrentResourceSum();
sinkAmounts[i] = sum;
totalAmounts += sum;
}
float[] inverseSinkPercentages = new float[sinks.Count];
float totalInversePercentages = 0f;
for (int i = 0; i < sinks.Count; ++i)
{
var inversePercentage = 1 - (sinkAmounts[i] / totalAmounts);
inverseSinkPercentages[i] = inversePercentage;
totalInversePercentages += inversePercentage;
}
// then if we get the percentages of this we can run through the index cutoffs...
float[] sinkPercentages = new float[sinks.Count];
for (int i = 0; i < sinks.Count; ++i)
{
sinkPercentages[i] = (inverseSinkPercentages[i] / totalInversePercentages);
}
int[] sinkIndexCutoffs = new int[sinks.Count];
for (int i = 0; i < sinks.Count; ++i)
{
int thisSinkIndices = (int)(sinkPercentages[i] * m_CrowdSize);
int previousCutoff = i == 0 ? 0 : sinkIndexCutoffs[i - 1];
sinkIndexCutoffs[i] = previousCutoff + thisSinkIndices;
}
// flock proportionately to the ones with the least %
for (int i = 0; i < m_Citizens.Count; ++i)
{
int sinkIndexToGoTo = 0;
for (int c = 0; c < sinkIndexCutoffs.Length; ++c)
{
if (i < sinkIndexCutoffs[c])
{
sinkIndexToGoTo = c;
break;
}
}
if (sinks.Count > 0)
{
sinks[sinkIndexToGoTo].m_WorkerStagingArea.AddToStaging(m_Citizens[i].transform);
}
}
// TODO: adjust to the popular one slowly, not all at once in a sudden reaction
}
}
