void ResetBuilding()
    {
        // Reset the selector parent.
        this.ReleaseSelector();

        // Set state to selecting.
        this.state = ConstructionState.SELECTING;

        // Hide all used tiles.
        this.HideAllUsedTiles();

        // Reset object.
        this.selectedBuilding.Reset();

        // Turn off building menu. Close menu if object has been deleted.
        if (this.selectedBuilding != null)
        {
            this.buildingMenu.Show(this.selectedBuilding, this.state);
            this.BindSelector(this.selectedBuilding);
        }
        else
        {
            this.buildingMenu.Close();
        }
    }
    void LiftBuilding(Building b)
    {
        this.state = ConstructionState.PLACING;

        // Disable all further construction.
        foreach (A_TouchDrag button in this.constructionButtons)
        {
            button.eventTrigger.enabled = false;
        }

        // Set the given building's used tiles as not used.
        foreach (IntVector2 v in b.UsedTileLocations)
        {
            this.tc.SetTileInUse(v, false);
        }

        // Show used tiles.
        this.ShowAllUsedTiles();

        // Lift the building.
        b.LiftUp();

        // Show the placing building menu.
        this.buildingMenu.Show(b, this.state);
    }
예제 #3
0
        public void SpawnBuilding(int index)
        {
            if (gameRules.waveStatus ||
                !CheckBuildingValidity(index) ||
                !CheckRessourcesAvailability(index))
            {
                return;
            }

            if (constructionState == ConstructionState.Positioning)
            {
                Destroy(selectedBuilding.gameObject);
            }
            else
            {
                constructionState = ConstructionState.Positioning;
            }

            Tile tile = rayCast.GetNearestTileFromCursor();

            if (tile != null)
            {
                defaultSpawnPosition = tile.tileCenter.position;
            }

            selectedBuilding = Instantiate(playerData.availableBuildings[index]);
            selectedBuilding.Move(defaultSpawnPosition);
            return;
        }
예제 #4
0
        private bool TryCreateSetup(TKey key, out ConstructionState state)
        {
            if (Storage.ContainsKey(key))
            {
                state = null;
                return(false);
            }

            state = new ConstructionState();
            if (States.TryAdd(key, state))
            {
                if (Storage.ContainsKey(key))
                {
                    TryCreateTeardown(key, state);
                    return(false);
                }

                return(true);
            }
            else
            {
                state.Dispose();
                return(false);
            }
        }
예제 #5
0
    public override void OnBehaviourEnter()
    {
        switch (state)
        {
        case WorkerState.Construction:

            constructionState = ConstructionState.Idle;

            break;

        case WorkerState.Harvesting:

            if (ressourceInventory.currentRessourceTransportLoad < ressourceInventory.ressourceTransportLoad)
            {
                harvestingState = HarvestingState.Idle;
            }
            else
            {
                harvestingState = HarvestingState.TransportingRessourceToHarvester;
                Vector3 targetPosition = assignedHarvester.transform.position + (entity.transform.position - assignedHarvester.transform.position).normalized * assignedHarvester.width / 2;
                movement.MoveTo(targetPosition);
            }

            break;

        case WorkerState.Depositing:

            state = WorkerState.Idle;

            break;
        }
    }
예제 #6
0
    public void Show(Building b, ConstructionState state)
    {
        this.target            = b;
        this.buildingName.text = b.buildingName;

        switch (state)
        {
        case ConstructionState.NO_SELECTION:
            this.selectingPanel.SetActive(false);
            this.placingPanel.SetActive(false);
            this.editingPanel.SetActive(true);
            break;

        case ConstructionState.PLACING:
            this.selectingPanel.SetActive(false);
            this.placingPanel.SetActive(true);
            this.editingPanel.SetActive(false);
            break;

        case ConstructionState.SELECTING:
            this.selectingPanel.SetActive(true);
            this.placingPanel.SetActive(false);
            this.editingPanel.SetActive(false);
            break;

        default:
            break;
        }

        this.parentMenu.gameObject.SetActive(true);
    }
예제 #7
0
        public BuildingItem(BuildingItemType itemtype)
        {
            _itemType = itemtype;

            _constructionState = ConstructionState.InProgress;

            //TODO: set initial values - is there anything else that needs to be set?
        }
예제 #8
0
 public void SetConstructionMode(ConstructionState state)
 {
     if (mode != state)
     {
         previousMode = mode;
         mode         = state;
     }
 }
예제 #9
0
 private void TryCreateTeardown(TKey key, ConstructionState state)
 {
     if (States.TryRemove(key, out state))
     {
         state.Set();
         state.Dispose();
     }
 }
예제 #10
0
 public FacilityConstructionEventDto(FacilityConstructionEvent fce)
 {
     date     = CareerLog.UTToDate(fce.UT).ToString("o");
     facility = fce.Facility;
     newLevel = fce.NewLevel;
     cost     = fce.Cost;
     state    = fce.State;
 }
예제 #11
0
 private void Start()
 {
     worldData     = FindObjectOfType <TileMapGenerator>().worldData;
     city          = FindObjectOfType <CityController>();
     buildingsData = new BuildingsData <Building>(worldData, () => GenerateTerrainPlaceability(worldData));
     state         = ConstructionState.None;
     cam           = Camera.main;
 }
예제 #12
0
 public FacilityConstructionEvent(FacilityConstructionEventDto f)
 {
     Date     = f.Date;
     Facility = f.Facility;
     NewLevel = f.NewLevel;
     Cost     = f.Cost;
     State    = f.State;
 }
예제 #13
0
 /// <summary>
 /// Resets the current state and deletes all instances of old state.
 /// </summary>
 private void CleanUp()
 {
     if (instance != null)
     {
         Destroy(instance);
     }
     state     = ConstructionState.None;
     placeable = null;
 }
예제 #14
0
 public void AssignToConstruction(EC_Base assignedBase)
 {
     if (state == WorkerState.Idle)
     {
         PlayerManager.Instance.RemoveIdleWorker(this);
     }
     this.assignedBase = assignedBase;
     state             = WorkerState.Construction;
     constructionState = ConstructionState.Idle;
     nextScanTime      = Time.time;
     ChangeAcessories();
 }
예제 #15
0
    public Round(RoundParameters parameters, WasabiRandom random)
    {
        Parameters = parameters;

        CoinjoinState = new ConstructionState(Parameters);

        AmountCredentialIssuer           = new(new(random), random, Parameters.MaxAmountCredentialValue);
        VsizeCredentialIssuer            = new(new(random), random, Parameters.MaxVsizeCredentialValue);
        AmountCredentialIssuerParameters = AmountCredentialIssuer.CredentialIssuerSecretKey.ComputeCredentialIssuerParameters();
        VsizeCredentialIssuerParameters  = VsizeCredentialIssuer.CredentialIssuerSecretKey.ComputeCredentialIssuerParameters();

        InputRegistrationTimeFrame      = TimeFrame.Create(Parameters.StandardInputRegistrationTimeout).StartNow();
        ConnectionConfirmationTimeFrame = TimeFrame.Create(Parameters.ConnectionConfirmationTimeout);
        OutputRegistrationTimeFrame     = TimeFrame.Create(Parameters.OutputRegistrationTimeout);
        TransactionSigningTimeFrame     = TimeFrame.Create(Parameters.TransactionSigningTimeout);

        Id = CalculateHash();
    }
예제 #16
0
        public IEnumerator PlaceBuilding()
        {
            selectedBuilding.GetComponent <NavMeshObstacle>().enabled = true;
            yield return(null);

            if (gameRules.RefreshWavePath())
            {
                playerData.ressources -= selectedBuilding.ressourceCost;
                onPlayerRessourceChange.Raise();
                selectedBuilding.Initialize();
                selectedBuilding  = null;
                constructionState = ConstructionState.Off;
            }
            else
            {
                selectedBuilding.GetComponent <NavMeshObstacle>().enabled = false;
                messageLog.AddMessage("Do not block the path", true);
            }
        }
예제 #17
0
        /// <summary>
        /// Initiates the placement of placeables.
        /// </summary>
        /// <param name="placeable"> Placeable to use for placement </param>
        public void StartPlacement(IPlaceable <Building> placeable)
        {
            CleanUp();
            this.placeable = placeable;
            state          = ConstructionState.Placing;

            var pos = CoordinateConverter.ToVector3Int(CoordinateConverter.GetCurrentMouseTilePosition(cam));

            instance = Instantiate(placeable.GetObject(), pos, Quaternion.identity, transform);
            instance.GetComponent <Building>().enabled = false;

            spriteRenderers = instance.GetComponentsInChildren <SpriteRenderer>();
            // Make instance be in the foreground.
            for (int i = 0; i < spriteRenderers.Length; i++)
            {
                spriteRenderers[i].sortingOrder += 20;
            }
            onStateChanged?.Invoke();
        }
예제 #18
0
        public Round(RoundParameters roundParameters)
        {
            RoundParameters = roundParameters;

            var allowedAmounts = new MoneyRange(roundParameters.MinRegistrableAmount, RoundParameters.MaxRegistrableAmount);
            var txParams       = new MultipartyTransactionParameters(roundParameters.FeeRate, allowedAmounts, allowedAmounts, roundParameters.Network);

            CoinjoinState = new ConstructionState(txParams);

            InitialInputVsizeAllocation = CoinjoinState.Parameters.MaxTransactionSize - MultipartyTransactionParameters.SharedOverhead;
            MaxRegistrableVsize         = Math.Min(InitialInputVsizeAllocation / RoundParameters.MaxInputCountByRound, (int)ProtocolConstants.MaxVsizeCredentialValue);
            MaxVsizeAllocationPerAlice  = MaxRegistrableVsize;

            AmountCredentialIssuer           = new(new(RoundParameters.Random), RoundParameters.Random, MaxRegistrableAmount);
            VsizeCredentialIssuer            = new(new(RoundParameters.Random), RoundParameters.Random, MaxRegistrableVsize);
            AmountCredentialIssuerParameters = AmountCredentialIssuer.CredentialIssuerSecretKey.ComputeCredentialIssuerParameters();
            VsizeCredentialIssuerParameters  = VsizeCredentialIssuer.CredentialIssuerSecretKey.ComputeCredentialIssuerParameters();

            Id = CalculateHash();
        }
    void PlaceBuilding(Building b)
    {
        if (this.CanBuildingBePlaced(b))
        {
            // Hide all used tiles.
            this.HideAllUsedTiles();

            // Re-enable touchdrag buttons.
            foreach (TouchDrag_Button tdb in this.constructionButtons)
            {
                tdb.eventTrigger.enabled = true;
            }

            // Add the placed building to the list if necessary.
            if (!this.placedBuildings.Contains(b))
            {
                this.placedBuildings.Add(b);
                Debug.Log("created new building");
            }

            // Set tiles as in-use.
            foreach (IntVector2 v in b.UsedTileLocations)
            {
                this.tc.SetTileInUse(v, true);
            }

            // Set state to selecting.
            this.state = ConstructionState.SELECTING;

            // Reset object.
            //temp.PlaceDown ();
            this.selectedBuilding.PlaceDown();

            // Turn off building menu.
            this.buildingMenu.Show(b, this.state);
        }
        else
        {
            Debug.Log("cannot place building in location");
        }
    }
예제 #20
0
파일: Util.cs 프로젝트: shreedharcva/JSIL
        public bool TryCreate(TKey key, Func <TValue> creator)
        {
            ConstructionState state;

            if (Storage.ContainsKey(key))
            {
                return(false);
            }

            state = new ConstructionState();
            if (States.TryAdd(key, state))
            {
                try {
                    if (Storage.ContainsKey(key))
                    {
                        return(false);
                    }

                    var result = creator();

                    if (!Storage.TryAdd(key, result))
                    {
                        throw new InvalidOperationException("Cache entry was created by someone else while construction lock was held");
                    }

                    return(true);
                } finally {
                    States.TryRemove(key, out state);
                    state.Set();
                    state.Dispose();
                }
            }
            else
            {
                state.Dispose();
            }

            return(false);
        }
예제 #21
0
    public Round(RoundParameters roundParameters)
    {
        RoundParameters = roundParameters;

        var allowedAmounts = new MoneyRange(roundParameters.MinRegistrableAmount, RoundParameters.MaxRegistrableAmount);
        var txParams       = new MultipartyTransactionParameters(roundParameters.FeeRate, roundParameters.CoordinationFeeRate, allowedAmounts, allowedAmounts, roundParameters.Network);

        CoinjoinState = new ConstructionState(txParams);

        InitialInputVsizeAllocation = CoinjoinState.Parameters.MaxTransactionSize - MultipartyTransactionParameters.SharedOverhead;
        MaxVsizeCredentialValue     = Math.Min(InitialInputVsizeAllocation / RoundParameters.MaxInputCountByRound, (int)ProtocolConstants.MaxVsizeCredentialValue);
        MaxVsizeAllocationPerAlice  = MaxVsizeCredentialValue;

        AmountCredentialIssuer           = new(new(RoundParameters.Random), RoundParameters.Random, MaxAmountCredentialValue);
        VsizeCredentialIssuer            = new(new(RoundParameters.Random), RoundParameters.Random, MaxVsizeCredentialValue);
        AmountCredentialIssuerParameters = AmountCredentialIssuer.CredentialIssuerSecretKey.ComputeCredentialIssuerParameters();
        VsizeCredentialIssuerParameters  = VsizeCredentialIssuer.CredentialIssuerSecretKey.ComputeCredentialIssuerParameters();

        InputRegistrationTimeFrame      = TimeFrame.Create(RoundParameters.StandardInputRegistrationTimeout).StartNow();
        ConnectionConfirmationTimeFrame = TimeFrame.Create(RoundParameters.ConnectionConfirmationTimeout);
        OutputRegistrationTimeFrame     = TimeFrame.Create(RoundParameters.OutputRegistrationTimeout);
        TransactionSigningTimeFrame     = TimeFrame.Create(RoundParameters.TransactionSigningTimeout);
    }
    void CreateBuilding(GameObject prefab)
    {
        if (prefab.GetComponent <Building>() != null)
        {
            // Set state to placing.
            this.state = ConstructionState.PLACING;

            // Instantiate object.
            GameObject objectToCreate = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;

            // Create a new building from touchdrag data.
            Building b = objectToCreate.GetComponent <Building> ();

            // Select new building and set base tile to (0, 0).
            this.SelectBuilding(b);
            b.SetBaseTile(this.tc.GetTile(new IntVector2(0, 0)));

            // Show which tiles are being used.
            this.ShowAllUsedTiles();

            // Open menu for the building.
            this.buildingMenu.Show(b, this.state);
        }
    }
예제 #23
0
        public void AddFacilityConstructionEvent(SpaceCenterFacility facility, int newLevel, double cost, ConstructionState state)
        {
            if (!IsEnabled)
            {
                return;
            }

            _facilityConstructions.Add(new FacilityConstructionEvent(Planetarium.GetUniversalTime())
            {
                Facility = facility,
                NewLevel = newLevel,
                Cost     = cost,
                State    = state
            });
        }
        /// <summary>
        /// Called every frame from Robot.update() if it's the current state (top of the stack)
        /// </summary>
        /// <param name="r">The robot to update</param>
        public override void update(Robot r)
        {
            bool finished = false;

            ////////////////////////////////////////////////////////////////////////////////////////
            // Initialize variables if necessary when first enter state
            ////////////////////////////////////////////////////////////////////////////////////////
            if (!initialized)
            {
                initialized = true;
                state       = ConstructionState.WAITING_FOR_INITIALIZATION;

                if (initialCommand.text.StartsWith(MessageConstructionStart.TAG))
                {
                    MessageConstructionStart msgData;
                    if (MessageConstructionStart.TryParse(initialCommand.text, out msgData))
                    {
                        waitQueue = msgData.waitQueue;
                        r.pushState(new RobotStateQueue(new Queue <Vector2>(waitQueue), 1.5f));
                        state = ConstructionState.QUEUING;
                        r.pushState(new RobotStateSleep(2 * r.id));
                    }
                    else
                    {
                        Log.a(LogTag.ROBOT, "Failed to parse " + MessageConstructionStart.TAG + " data.");
                        finished = true;
                    }
                }
                else
                {
                    Log.a(LogTag.ROBOT, "Failed to parse initial MessageConstructionStart");
                    finished = true;
                }
            }

            ////////////////////////////////////////////////////////////////////////////////////////
            // Reset variables if robot is returning from another state
            ////////////////////////////////////////////////////////////////////////////////////////
            if (resume)
            {
                resume = false;
                Log.d(LogTag.ROBOT, "Robot " + r.id + " is returning to construction (satellite)");

                switch (state) // resuming from this state
                {
                case ConstructionState.QUEUING:
                {
                    state = ConstructionState.FRONT_OF_QUEUE;

                    Comm.directMessage(r.id, Comm.SATELLITE, "construction\nrequest_task");
                    break;
                }

                case ConstructionState.FINISHED:
                {
                    finished = true;
                    break;
                }

                default:
                {
                    break;
                }
                }
            }

            ////////////////////////////////////////////////////////////////////////////////////////
            // Update
            ////////////////////////////////////////////////////////////////////////////////////////

            ////////////////////////////////////////////////////////////////////////////////////////
            // Process messages: TODO
            ////////////////////////////////////////////////////////////////////////////////////////
            int count = r.unhandledMessages.Count;

            for (int i = 0; i < count; ++i)
            {
                bool        handledMessage = false;
                CommMessage msg            = r.unhandledMessages.Dequeue();

                // TODO: this if-block is more repugnant than someone kicking a puppy
                if (msg.text.StartsWith("construction"))
                {
                    handledMessage = true;

                    if (msg.text.StartsWith(MessageConstructionStart.TAG))
                    {
                        MessageConstructionStart msgData;
                        if (MessageConstructionStart.TryParse(msg.text, out msgData))
                        {
                            if (state == ConstructionState.WAITING_FOR_INITIALIZATION)
                            {
                                waitQueue = msgData.waitQueue;
                                r.pushState(new RobotStateQueue(new Queue <Vector2>(waitQueue), 2f));
                                state = ConstructionState.QUEUING;
                            }
                            else
                            {
                                Log.e(LogTag.ROBOT, "Received " + MessageConstructionStart.TAG + " message outside of WAITING_FOR_INITIALIZATION state");
                            }
                        }
                        else
                        {
                            Log.a(LogTag.ROBOT, "Failed to parse " + MessageConstructionStart.TAG + " data.");
                        }
                    }
                    else if (msg.text.StartsWith(MessageConstructionTask.TAG))
                    {
                        MessageConstructionTask msgData;
                        if (MessageConstructionTask.TryParse(msg.text, out msgData))
                        {
                            if (state == ConstructionState.FRONT_OF_QUEUE)
                            {
                                Queue <Vector2> startToPlacementPerimeter;
                                Queue <Vector2> placementToEndPerimeter;
                                calculateBreakPosition(msgData.constructionPerimeter,
                                                       msgData.resourcePlacement,
                                                       out startToPlacementPerimeter,
                                                       out placementToEndPerimeter);

                                if (msgData.lastTask)
                                {
                                    r.pushState(new RobotStateMove(new Vector2(r.id * -1.5f, 31)));
                                    state = ConstructionState.FINISHED;
                                }
                                else
                                {
                                    r.pushState(new RobotStateQueue(new Queue <Vector2>(waitQueue), 2f));
                                    state = ConstructionState.QUEUING;
                                }

                                r.pushState(new RobotStateQueue(placementToEndPerimeter, 2f));
                                r.pushState(new RobotStatePlaceResource(msgData.resourcePlacement));
                                r.pushState(new RobotStateQueue(startToPlacementPerimeter, 2f));
                                r.pushState(new RobotStateMove(msgData.resourceOrigin + new Vector2(0, -10)));
                                r.pushState(new RobotStateRetrieveResource(msgData.resourceOrigin));
                            }
                            else
                            {
                                Log.e(LogTag.ROBOT, "Received " + MessageConstructionTask.TAG + " message outside of FRONT_OF_QUEUE state");
                            }
                        }
                        else
                        {
                            Log.a(LogTag.ROBOT, "Failed to parse " + MessageConstructionTask.TAG + " data.");
                        }
                    }
                    else if (msg.text == "construction/finished")
                    {
                        r.pushState(new RobotStateMove(new Vector2(r.id * -1.5f, 31)));
                        state = ConstructionState.FINISHED;
                    }
                    else
                    {
                        Log.a(LogTag.ROBOT, "Unknown construction message:\n" + msg.text);
                    }
                }

                if (!handledMessage) // didn't process message, leave for next state
                {
                    r.unhandledMessages.Enqueue(msg);
                }
            }

            ////////////////////////////////////////////////////////////////////////////////////////
            // "Clean up" robot state
            ////////////////////////////////////////////////////////////////////////////////////////
            if (finished)
            {
                Log.d(LogTag.ROBOT, "Robot " + r.id + " has finished construction (satellite).");

                // Pop state off the stack
                r.popState();
            }
        }
예제 #25
0
        public void AddFacilityConstructionEvent(SpaceCenterFacility facility, int newLevel, double cost, ConstructionState state)
        {
            if (CareerEventScope.ShouldIgnore || !IsEnabled)
            {
                return;
            }

            _facilityConstructions.Add(new FacilityConstructionEvent(KSPUtils.GetUT())
            {
                Facility = facility,
                NewLevel = newLevel,
                Cost     = cost,
                State    = state
            });
        }
예제 #26
0
 /// <summary>
 /// Start selling mode.
 /// </summary>
 public void StartSelling()
 {
     CleanUp();
     state = ConstructionState.Selling;
     onStateChanged?.Invoke();
 }
예제 #27
0
    protected override void Update()
    {
        switch (state)
        {
        case WorkerState.Idle:

            if (Time.time > nextIdleMovementTime)
            {
                nextIdleMovementTime = Time.time + idleMovementInterval;
                Vector3 wanderPoint = UnityEngine.Random.insideUnitSphere * 4;
                wanderPoint.y = entity.transform.position.y;

                wanderPoint += entity.transform.forward * 4 + entity.transform.position;

                Vector3 basePosition = BuildingSystem.Instance.playersBaseLocation.position;
                //if he would stray off to far, bring him back to base
                if (Vector3.Distance(basePosition, wanderPoint) > maxDistanceToBaseForWander)
                {
                    wanderPoint += (basePosition - wanderPoint) / 4;
                }

                movement.MoveTo(wanderPoint);
            }

            break;

        case WorkerState.Construction:

            switch (constructionState)
            {
            case ConstructionState.Idle:

                //if idle /first get nearest Building  which needs construction, if there is no we just chill beside the base
                if (Time.time > nextScanTime)
                {
                    nextScanTime = Time.time + scanInterval;

                    if (BuildingSystem.Instance.AreThereBuildingsToConstruct())
                    {
                        standingBesideBaseAndWaiting = false;

                        BuildingInConstruction nearestBuildingToConstruct = null;
                        float nearestDistance = Mathf.Infinity;

                        foreach (BuildingInConstruction building in BuildingSystem.Instance.GetBuildingsWaitingForConstruction())
                        {
                            float currentDistance = (building.transform.position - entity.transform.position).sqrMagnitude;

                            if (currentDistance < nearestDistance)
                            {
                                nearestDistance            = currentDistance;
                                nearestBuildingToConstruct = building;
                            }
                        }

                        assignedBuildingToBuild = nearestBuildingToConstruct;
                        //we move to a position from where we can build, not to a position inside the building
                        Vector3 targetPosition = nearestBuildingToConstruct.transform.position + (entity.transform.position - nearestBuildingToConstruct.transform.position).normalized * nearestBuildingToConstruct.width / 2;
                        movement.MoveTo(targetPosition);
                        constructionState = ConstructionState.MovingToBuilding;
                    }
                    else if (!standingBesideBaseAndWaiting)
                    {
                        Vector3 positonToMoveTo = UnityEngine.Random.insideUnitSphere * 8;
                        positonToMoveTo += BuildingSystem.Instance.playersBaseLocation.position;
                        standingBesideBaseAndWaiting = true;
                        movement.MoveTo(positonToMoveTo);
                    }
                }

                break;

            case ConstructionState.MovingToBuilding:

                if (Time.time > nextScanTime)
                {
                    nextScanTime = Time.time + scanInterval;

                    if (assignedBuildingToBuild != null)
                    {
                        if (Vector3.Distance(entity.transform.position, assignedBuildingToBuild.transform.position) < assignedBuildingToBuild.width + constructionRange)
                        {
                            movement.Stop();
                            constructionState = ConstructionState.Constructing;
                            constructionTool.StartAnimation();
                            nextConstructionTime = Time.time + constructionInterval;
                        }
                    }
                    else
                    {
                        constructionState = ConstructionState.Idle;
                    }
                }

                break;

            case ConstructionState.Constructing:

                if (Time.time > nextConstructionTime)
                {
                    //check if it istn completed yet
                    if (assignedBuildingToBuild != null)
                    {
                        nextConstructionTime = Time.time + constructionInterval;
                        assignedBuildingToBuild.Construct(constructionPoints);
                    }
                    else
                    {
                        constructionState = ConstructionState.Idle;
                        constructionTool.StopAnimation();
                    }
                }

                break;
            }



            break;

        case WorkerState.Harvesting:

            switch (harvestingState)
            {
            case HarvestingState.Idle:

                //check if there are some ressources in the area - should it check with physics check or get the nearest from the ressourcesmanager?
                if (Time.time > nextScanTime)
                {
                    nextScanTime = Time.time + scanInterval;

                    HashSet <Ressource> ressources = RessourcesManager.Instance.GetRessources(assignedHarvesterType);

                    if (ressources.Count > 0)
                    {
                        standingBesideHarvesterAndWaiting = false;


                        Ressource nearestRessource = null;
                        float     nearestDistance  = Mathf.Infinity;

                        foreach (Ressource ressource in ressources)
                        {
                            float currentDistance = (ressource.transform.position - assignedHarvester.transform.position).sqrMagnitude;

                            if (currentDistance < nearestDistance)
                            {
                                nearestDistance  = currentDistance;
                                nearestRessource = ressource;
                            }
                        }

                        currentSelectedRessource = nearestRessource;
                        Vector3 targetPosition = currentSelectedRessource.transform.position + (entity.transform.position - currentSelectedRessource.transform.position).normalized * currentSelectedRessource.width / 2;
                        movement.MoveTo(targetPosition);
                        harvestingState = HarvestingState.MovingToRessource;
                    }
                    else if (!standingBesideHarvesterAndWaiting)
                    {
                        Vector3 positonToMoveTo = UnityEngine.Random.insideUnitSphere * 5;
                        positonToMoveTo += assignedHarvester.transform.position;
                        standingBesideHarvesterAndWaiting = true;
                        movement.MoveTo(positonToMoveTo);
                    }
                }

                break;

            case HarvestingState.MovingToRessource:

                if (Time.time > nextScanTime)
                {
                    nextScanTime = Time.time + scanInterval;


                    if (currentSelectedRessource != null)
                    {
                        if (Vector3.Distance(entity.transform.position, currentSelectedRessource.transform.position) < currentSelectedRessource.width)
                        {
                            movement.Stop();
                            harvestingState = HarvestingState.GatheringRessource;

                            //activate the tool
                            if (assignedHarvesterType == RessourceType.fer)
                            {
                                ferHarvestingTool.StartAnimation();
                            }
                            else if (assignedHarvesterType == RessourceType.mer)
                            {
                                merHarvestingTool.StartAnimation();
                            }

                            nextRessourceGatheringTime = Time.time + ressourceGatherInterval;
                        }
                    }
                    else
                    {
                        harvestingState = HarvestingState.Idle;
                        ferHarvestingTool.StopAnimation();
                        merHarvestingTool.StopAnimation();
                    }
                }

                break;

            case HarvestingState.GatheringRessource:

                if (Time.time > nextRessourceGatheringTime)
                {
                    //check if it istn completed yet
                    if (currentSelectedRessource != null)
                    {
                        nextRessourceGatheringTime = Time.time + ressourceGatherInterval;
                        //gather but check how much will fit
                        if (ressourceInventory.currentRessourceTransportLoad + ressourceGatheringPower > ressourceInventory.ressourceTransportLoad)
                        {
                            ressourceInventory.AddRessource(currentSelectedRessource.type, currentSelectedRessource.TakeRessource(ressourceInventory.ressourceTransportLoad - ressourceInventory.currentRessourceTransportLoad));
                        }
                        else
                        {
                            ressourceInventory.AddRessource(currentSelectedRessource.type, currentSelectedRessource.TakeRessource(ressourceGatheringPower));
                        }

                        //if the sack is full, go back
                        if (ressourceInventory.currentRessourceTransportLoad == ressourceInventory.ressourceTransportLoad)
                        {
                            Vector3 targetPosition = assignedHarvester.transform.position + (entity.transform.position - assignedHarvester.transform.position).normalized * assignedHarvester.width / 2;
                            movement.MoveTo(targetPosition);
                            // movement.MoveTo(assignedHarvester.transform.position);
                            harvestingState = HarvestingState.TransportingRessourceToHarvester;
                            ferHarvestingTool.StopAnimation();
                            merHarvestingTool.StopAnimation();
                        }
                    }
                    else
                    {
                        ferHarvestingTool.StopAnimation();
                        merHarvestingTool.StopAnimation();

                        if (ressourceInventory.currentRessourceTransportLoad > 0)
                        {
                            Vector3 targetPosition = assignedHarvester.transform.position + (entity.transform.position - assignedHarvester.transform.position).normalized * assignedHarvester.width / 2;
                            movement.MoveTo(targetPosition);
                            //movement.MoveTo(assignedHarvester.transform.position);
                            harvestingState = HarvestingState.TransportingRessourceToHarvester;
                        }
                        else
                        {
                            harvestingState = HarvestingState.Idle;
                        }
                    }
                }

                break;

            case HarvestingState.TransportingRessourceToHarvester:

                if (Time.time > nextScanTime)
                {
                    nextScanTime = Time.time + scanInterval;

                    if (Vector3.Distance(entity.transform.position, assignedHarvester.transform.position) < assignedHarvester.width)
                    {
                        movement.Stop();
                        assignedHarvester.DepotRessource(ressourceInventory.currentRessourceTransportLoad);
                        ressourceInventory.Clear();

                        if (currentSelectedRessource != null)
                        {
                            harvestingState = HarvestingState.MovingToRessource;
                            movement.MoveTo(currentSelectedRessource.transform.position);
                        }
                        else
                        {
                            harvestingState = HarvestingState.Idle;
                        }
                    }
                }
                break;
            }

            break;

        case WorkerState.Depositing:

            if (Time.time > nextScanTime)
            {
                nextScanTime = Time.time + scanInterval;

                if (despositionBuilding != null)
                {
                    if (Vector3.Distance(entity.transform.position, despositionBuilding.transform.position) < despositionBuilding.width)
                    {
                        despositionBuilding.GetComponent <IDepositioneable <B_Worker> >().DepositionWorker(this);
                    }
                }
                else
                {
                    AssignToIdle();
                }
            }


            break;
        }
    }
예제 #28
0
 public void RevertToPreviousConstructionMode()
 {
     mode = previousMode;
 }