Exemplo n.º 1
0
    private ACTOR_STATE CheckTileState()
    {
        processedState = ACTOR_STATE.NONE;
        switch (currentTile.effectsOnTile)
        {
        case Tile.TILE_EFFECTS.CHILL | Tile.TILE_EFFECTS.HAUNT:
        case Tile.TILE_EFFECTS.HAUNT:
            GameObject player = GameObject.FindGameObjectWithTag("Player");
            if (player)
            {
                Haunt h = player.GetComponent <Haunt>();
                moveDirection  = h.HauntActor(this);
                forceDirection = true;
                PlaySound(3, 0);
                gameObject.GetComponent <Animator>().Play("Run 01");
            }
            else
            {
                Debug.LogError("Found haunted tile but no player for getting the haunt direction");
            }
            processedState = ACTOR_STATE.HAUNTED;
            break;

        case Tile.TILE_EFFECTS.CHILL:
            processedState = ACTOR_STATE.CHILLED;
            break;

        default:
            processedState = ACTOR_STATE.NONE;
            break;
        }

        return(processedState);
    }
Exemplo n.º 2
0
    // place the currently held data in Output
    IEnumerator OUTPUT()
    {
        // detect possible errors first
        if (CurrentValue == null)
        {
            // cannot output null
            error        = true;
            currentState = ACTOR_STATE.REPORTING;
            yield return(StartCoroutine(currentState.ToString()));
        }
        else if (!OutputBox.GetComponent <OutputBox>().Output(CurrentValue.Value))
        {
            // current value is not correct for this solution
            error        = true;
            currentState = ACTOR_STATE.REPORTING;
            yield return(StartCoroutine(currentState.ToString()));
        }

        // current value is correct
        HideDataCube();
        CurrentValue = null;
        yield return(new WaitForSeconds(InstructionDelay));

        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 3
0
    // initial state of Computron
    public void Start()
    {
        // acquire Scene References
        commandStream = FindObjectOfType <Interpreter>();
        cardContainer = GameObject.FindWithTag("RegisterContainer").GetComponent <CardContainer>();
        InputBox      = this.transform.parent.Find("Input").gameObject;
        OutputBox     = this.transform.parent.Find("Output").gameObject;
        StepButton    = GameObject.FindWithTag("Step");

        // initialize starting parameters
        transform.position = RestWaypoint.transform.position;
        current            = null;
        previous           = null;

        // kick off the state machine
        currentState      = ACTOR_STATE.IDLE;
        error             = false;
        conditionalResult = null;
        CurrentValue      = null;
        SecondValue       = null;
        stepping          = false;
        step           = false;
        implicitSubmit = false;
        stepCount      = 0;

        StartCoroutine(ActorStateMachine());
    }
Exemplo n.º 4
0
    // if current value is null, jump; else, continue sequential execution
    IEnumerator JUMP_IF_NULL()
    {
        yield return(new WaitForSeconds(InstructionDelay));

        conditionalResult = (CurrentValue == null);
        currentState      = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 5
0
    // place the currently held value in the specified Card
    IEnumerator MOVE_TO()
    {
        // grab card reference
        CurrentArg = current.Arg;
        CardLogic card = cardContainer.GetCard((int)CurrentArg);

        HideDataCube();

        // trying to store null causes a runtime error
        if (CurrentValue == null)
        {
            error        = true;
            currentState = ACTOR_STATE.REPORTING;
            yield return(StartCoroutine(currentState.ToString()));
        }
        else
        {
            // put down the value held, and hands are now empty
            card.MoveTo((int)CurrentValue);
            CurrentValue = null;
            yield return(new WaitForSeconds(InstructionDelay));
        }

        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 6
0
    // simulates the current command being carried out
    IEnumerator PROCESSING()
    {
        while (currentState == ACTOR_STATE.PROCESSING)
        {
            // grab the next instruction
            FetchCommand();

            // need to ensure current position is accurate
            if (!(current.Instruction == OpCode.JUMP) && !(current.Instruction == OpCode.JUMP_IF_NULL) &&
                !(current.Instruction == OpCode.NO_OP) && !(current.Instruction == OpCode.SUBMIT))
            {
                currentState = ACTOR_STATE.MOVING;
                yield return(StartCoroutine(currentState.ToString()));
            }

            if (current == null)
            {
                Debug.Log("Processing aborted");
                break;
            }

            // execute the instruction
            yield return(StartCoroutine(current.Instruction.ToString()));
        }
    }
Exemplo n.º 7
0
 public override void OnExitState(ACTOR_STATE state)
 {
     if (state == ACTOR_STATE.AS_RUN && curActorState == ACTOR_STATE.AS_RUN)
     {
         RunType = 0;
         if (AudioSource1 != null)
         {
             AudioSource1.loop = false;
             AudioSource1.Stop();
         }
     }
 }
Exemplo n.º 8
0
    // pull a value from Input
    IEnumerator INPUT()
    {
        // insert a pause if grabbing consecutive inputs so the action is visible to the player
        if (previous != null && previous.Instruction == OpCode.INPUT)
        {
            yield return(new WaitForSeconds(InstructionDelay));
        }

        // Computron picks up the top item from Input
        CurrentValue = InputBox.GetComponent <InputBox>().Input();
        ShowDataCube(CurrentValue);

        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 9
0
    // get a copy of the top value from the specified Card
    // the Card still keeps the value
    IEnumerator COPY_FROM()
    {
        // get card reference
        CurrentArg = current.Arg;
        CardLogic card = cardContainer.GetCard((int)CurrentArg);

        // insert a pause if grabbing consecutive inputs so the action is visible to the player
        if (previous != null && previous.Instruction == OpCode.COPY_FROM)
        {
            yield return(new WaitForSeconds(InstructionDelay));
        }

        // Computron gets a copy of the top item from the specified Card
        CurrentValue = (int)card.CopyFrom();
        ShowDataCube(CurrentValue);

        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 10
0
    // if current value is less than value at destination, jump; else, continue sequential execution
    IEnumerator JUMP_IF_LESS()
    {
        // grab card reference
        CurrentArg = current.Arg;
        CardLogic card = cardContainer.GetCard((int)CurrentArg);

        // Computron gets a copy of the top item from the specified Card
        SecondValue = card.CopyFrom();

        // ensure neither value is null
        if (CurrentValue == null || SecondValue == null)
        {
            error        = true;
            currentState = ACTOR_STATE.REPORTING;
            yield return(StartCoroutine(currentState.ToString()));
        }

        yield return(new WaitForSeconds(InstructionDelay));

        conditionalResult = (CurrentValue < SecondValue);

        // show the two values being compared
        DisplayMessage(CurrentValue.ToString());
        yield return(new WaitForSeconds(InstructionDelay));

        DisplayMessage(DisplayText.text + " < ");
        yield return(new WaitForSeconds(InstructionDelay));

        DisplayMessage(DisplayText.text + SecondValue.ToString());
        yield return(new WaitForSeconds(InstructionDelay));

        DisplayMessage(DisplayText.text + " ?");
        yield return(new WaitForSeconds(InstructionDelay));

        DisplayMessage(conditionalResult.ToString());
        yield return(new WaitForSeconds(InstructionDelay));

        ShowDataCube(CurrentValue);
        HideTextBox();

        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 11
0
 public void ScreamedAt(ACTOR_DIRECTION dir)
 {
     moveDirection  = dir;
     forceDirection = true;
     TryForceActorToNextTile();
     if (forceDirection)
     {
         transform.LookAt(movementTarget.characterPosition, Vector3.up);
         gameObject.GetComponent <Animator>().Play("Run 01");
         state = ACTOR_STATE.MOVING;
     }
     else
     {
         Debug.LogError("Screamed Actor in a non valid direction");
         state = ACTOR_STATE.CHOOSING;
     }
     talkRefreshTimer  = talkRefresh;
     talkCooldownTimer = talkCooldown;
     ResetTalkingActor();
 }
Exemplo n.º 12
0
    // final instruction of every solution
    IEnumerator SUBMIT()
    {
        DisplayMessage(".");
        yield return(new WaitForSeconds(0.5f));

        DisplayMessage("..");
        yield return(new WaitForSeconds(0.5f));

        DisplayMessage("...");
        yield return(new WaitForSeconds(InstructionDelay));

        HideTextBox();
        // check the solution
        bool res = OutputBox.GetComponent <OutputBox>().GradeOutput();

        if (!res)
        {
            error = true;
        }
        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 13
0
    // place a copy of the currently held value in the specified Card
    // Computron still keeps the held value
    IEnumerator COPY_TO()
    {
        // get card reference
        CurrentArg = current.Arg;
        CardLogic card = cardContainer.GetCard((int)CurrentArg);

        // trying to store null causes a runtime error
        if (CurrentValue == null)
        {
            error        = true;
            currentState = ACTOR_STATE.REPORTING;
            yield return(StartCoroutine(currentState.ToString()));
        }
        else
        {
            // put down a copy of the value held
            card.CopyTo((int)CurrentValue);
            yield return(new WaitForSeconds(InstructionDelay));
        }

        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 14
0
    // controls movement between waypoints
    IEnumerator MOVING()
    {
        while (currentState == ACTOR_STATE.MOVING)
        {
            // initialize values needed for movement
            var currentPosition   = transform.position;
            var targetPosition    = FindTargetWaypoint();
            var translationVector = targetPosition - currentPosition;

            // stop within a certain distance and move to processing state
            if (translationVector.sqrMagnitude < 0.5)
            {
                currentState = ACTOR_STATE.PROCESSING;
            }
            else
            {
                UpdatePosition(currentPosition, targetPosition);
            }


            yield return(null);
        }
    }
Exemplo n.º 15
0
    // called via Interpreter when the player hits the Halt button
    public void AbortExecution()
    {
        // snap back to idle waypoint and reset all state machine values
        transform.position = RestWaypoint.transform.position;
        current            = null;
        previous           = null;
        stepping           = false;
        CurrentValue       = null;
        SecondValue        = null;
        conditionalResult  = null;
        error          = false;
        implicitSubmit = false;
        stepCount      = 0;

        MoveSpeed        = 0.3f;
        InstructionDelay = 0.3f;

        // halt all processes and start a new instance of the state machine
        StopAllCoroutines();
        currentState = ACTOR_STATE.IDLE;
        HideTextBox();
        HideDataCube();
        StartCoroutine(ActorStateMachine());
    }
Exemplo n.º 16
0
    //*** END OF STATE MACHINE ***//

    //*** INTERPRETER INTERACTIONS ***//

    // signal function for the Interpreter to let the Actor know to begin collecting commands
    public void BeginProcessing()
    {
        currentState = ACTOR_STATE.PROCESSING;
    }
Exemplo n.º 17
0
    // used only as a landing spot for jump instructions
    IEnumerator NO_OP()
    {
        yield return(new WaitForSeconds(InstructionDelay));

        currentState = ACTOR_STATE.REPORTING;
    }
Exemplo n.º 18
0
    // generates a report for the instruction that was executed
    IEnumerator REPORTING()
    {
        if (error)
        {
            // halt the simulation if an error was encountered in processing
            CompleteExecution(new ExecutionReport(error, conditionalResult));
            currentState = ACTOR_STATE.HALTED;
            yield return(StartCoroutine(currentState.ToString()));
        }

        // if the player is stepping through a solution, we need to hold here
        while (stepping)
        {
            stepCount++;

            // if we have a Jump or Conditional Jump command, we need to adjust the stepCount accordingly
            if (current.Instruction == OpCode.JUMP || conditionalResult == true)
            {
                // update stepCount
                stepCount = (int)current.Target;

                // if this puts us on the second to last command, we need to implicitly submit the solution
                if (stepCount + 1 == commandStream.GetInstructionCount())
                {
                    implicitSubmit = true;
                }
                // otherwise, assert false
                else
                {
                    implicitSubmit = false;
                }
            }

            // moves to the SUBMIT command without requiring the player to click step again
            if (implicitSubmit)
            {
                BeginProcessing();
            }

            // wait for the player to click step again
            stepping = false;
            StepButton.GetComponent <UIControl>().Enable();
            while (currentState == ACTOR_STATE.REPORTING)
            {
                yield return(null);
            }
            break;
        }

        // generate a report based on the current values
        CompleteExecution(new ExecutionReport(error, conditionalResult));

        // reset values
        conditionalResult = null;
        error             = false;

        // if the simulation is complete
        while (current.Instruction == OpCode.SUBMIT)
        {
            yield return(null);
        }
        // else, continue processing
        currentState = ACTOR_STATE.PROCESSING;
    }
Exemplo n.º 19
0
    // Update is called once per frame
    void Update()
    {
                #if UNITY_EDITOR
        if (currentTile == null)
        {
            Debug.Log(this.actorName + " no current tile");
        }
                #endif

        //Updating the UI
        if (barScript != null)
        {
            if (fear < fearSpookedAmount)
            {
                fearStatus = "Normal";
            }
            else if (fear >= fearSpookedAmount && fear < fearPanicAmount)
            {
                fearStatus = "Spooked";
            }
            else if (fear >= fearPanicAmount && fear < 100)
            {
                fearStatus = "PANIC!";
            }
            else if (fear >= 100)
            {
                fearStatus = "FAINTED!!!";
            }
            barScript.SetAmount(fear * 0.01f, fearStatus);
        }

        //Updating state for the player
        if (fear > fearPanicAmount)
        {
            isPanicking = true;
        }
        else
        {
            isPanicking = false;
        }

        if (fear >= 100 && state != ACTOR_STATE.FIENTED)
        {
            PlaySound(4, 0.0f);
            string randoFall = "Fall 0" + Random.Range(1, 4);
            gameObject.GetComponent <Animator>().Play(randoFall);
            state = ACTOR_STATE.FIENTED;
        }

        //Always decrease fear
        if (fear > 0)
        {
            fear -= Time.deltaTime * fearReductionPerSecond;
        }
        //Lower limit is zero
        fear = Mathf.Max(fear, 0);

        if (state == ACTOR_STATE.FIENTED)
        {
            if (fear < 80)
            {
                roamingWaitTime = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                roamingT        = 0f;
                state           = ACTOR_STATE.CHOOSING;
            }
        }
        else if (state == ACTOR_STATE.MOVING)
        {
            if (talkRefreshTimer > 0)
            {
                talkRefreshTimer -= Time.deltaTime;
                if (talkRefreshTimer < 0)
                {
                    talkRefreshTimer = 0;
                }
            }

            if (GetActorFearState() == LevelController.ACTOR_STATES.NORMAL && !forceDirection)
            {
                gameObject.GetComponent <Animator>().Play("Walk 01");
            }
            else
            {
                gameObject.GetComponent <Animator>().Play("Run 01");
            }

            movementT += Time.deltaTime * GetSpeed();
            if (movementT < 1.0f)
            {
                if (currentTile != null && movementTarget != null)
                {
                    this.transform.position = Vector3.Lerp(currentTile.characterPosition,
                                                           movementTarget.characterPosition,
                                                           movementT);
                }
                else
                {
                    Debug.LogError("Movement attempt without start or end tile");
                }
            }
            else
            {
                this.transform.position = movementTarget.characterPosition;
                state = ACTOR_STATE.GETNEXTTILE;
            }
        }
        else if (state == ACTOR_STATE.GETNEXTTILE)
        {
            if (talkRefreshTimer > 0)
            {
                talkRefreshTimer -= Time.deltaTime;
                if (talkRefreshTimer < 0)
                {
                    talkRefreshTimer = 0;
                }
            }

            previousTile = currentTile;
            currentTile  = movementTarget;
            movementT    = 0;

            currentTile.occupant = this.gameObject;

            //Checking if the tile is marked with something;
            //This will set Processed state
            //If none then next operation is talking or continue moving if panicked

            CheckTileState();

            switch (processedState)
            {
            case ACTOR_STATE.NONE:
                if (forceDirection)
                {
                    //forcing actor to move in a direction, if failing forcedirection will be setted to false
                    TryForceActorToNextTile();
                    if (forceDirection)
                    {
                        transform.LookAt(movementTarget.characterPosition, Vector3.up);
                        state = ACTOR_STATE.MOVING;
                    }
                    else
                    {
                        this.GetComponent <Animator>().Play("Run 06 Stop");
                        roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                        roamingT                 = 0f;
                        currIdleAnimationPlaying = Random.Range(1, 5);
                        state = ACTOR_STATE.CHOOSING;
                    }
                }
                else
                {
                    //can talk or continue to move
                    if (talkTarget != null && !isPanicking && Mathf.Approximately(talkRefreshTimer, 0f))
                    {
                        this.GetComponent <Animator>().Play(talkAnimation);
                        talkCooldownTimer = talkCooldown;
                        talkRefreshTimer  = talkRefresh;
                        state             = ACTOR_STATE.TALKING;
                    }
                    else
                    {
                        if (isPanicking)
                        {
                            talkRefreshTimer  = talkRefresh;
                            talkCooldownTimer = talkCooldown;
                            ResetTalkingActor();
                        }

                        movementTarget = pathHelper.GetNextMove();
                        if (movementTarget == null)
                        {
                            //string str = "Idle 0"+Random.Range(1,5);
                            //Debug.Log(str);
                            //gameObject.GetComponent<Animator>().Play(str);
                            roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                            roamingT                 = 0f;
                            currIdleAnimationPlaying = Random.Range(1, 5);
                            state = ACTOR_STATE.CHOOSING;
                        }
                        else
                        {
                            transform.LookAt(movementTarget.characterPosition, Vector3.up);
                            state = ACTOR_STATE.MOVING;
                        }
                    }
                }
                break;

            case ACTOR_STATE.HAUNTED:
                if (forceDirection)
                {
                    //forcing actor to move in a direction, if failing forcedirection will be setted to false
                    TryForceActorToNextTile();
                    if (forceDirection)
                    {
                        transform.LookAt(movementTarget.characterPosition, Vector3.up);
                        state = ACTOR_STATE.MOVING;
                    }
                    else
                    {
                        roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                        roamingT                 = 0f;
                        currIdleAnimationPlaying = Random.Range(1, 5);
                        state = ACTOR_STATE.CHOOSING;
                    }
                }
                break;

            case ACTOR_STATE.CHILLED:
                scaredAnimation = "Scared 0" + Random.Range(1, 3);
                GameObject player = GameObject.FindGameObjectWithTag("Player");
                if (player)
                {
                    Chill c = player.GetComponent <Chill>();
                    if (c)
                    {
                        c.AddActorToCurrentChill(this);
                    }
                }
                state = ACTOR_STATE.CHILLED;
                break;

            default:
                break;
            }
        }
        else if (state == ACTOR_STATE.CHOOSING)
        {
            roamingT += Time.deltaTime;

            CheckTileState();

            switch (processedState)
            {
            case ACTOR_STATE.NONE:
                //If someone is asking me to talk do that
                if (talkTarget != null && !isPanicking)
                {
                    this.GetComponent <Animator>().Play(talkAnimation);
                    talkCooldownTimer = talkCooldown;
                    state             = ACTOR_STATE.TALKING;
                }
                //playing idle animation when choosing
                else if (roamingT < roamingWaitTime)
                {
                    LevelController.ACTOR_STATES fearState = GetActorFearState();
                    if (fearState == LevelController.ACTOR_STATES.NORMAL)
                    {
                        string str = "Idle 0" + currIdleAnimationPlaying.ToString();
                        //Debug.Log(str);
                        gameObject.GetComponent <Animator>().Play(str);
                    }
                    if (fearState == LevelController.ACTOR_STATES.SPOOKED)
                    {
                        gameObject.GetComponent <Animator>().Play("Scared 01");
                    }
                    if (fearState == LevelController.ACTOR_STATES.PANICKED)
                    {
                        gameObject.GetComponent <Animator>().Play("Scared 02");
                    }
                }
                else
                {
                    roamingT = 0;

                    pathHelper.RequestNewRandomPath(currentTile);
                    movementTarget = pathHelper.GetNextMove();

                    if (movementTarget == null)
                    {
                        roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                        roamingT                 = 0f;
                        currIdleAnimationPlaying = Random.Range(1, 5);
                        state = ACTOR_STATE.CHOOSING;
                    }
                    else
                    {
                        transform.LookAt(movementTarget.characterPosition, Vector3.up);
                        currentTile.occupant = null;
                        state = ACTOR_STATE.MOVING;
                    }
                }
                break;

            case ACTOR_STATE.HAUNTED:
                if (forceDirection)
                {
                    //forcing actor to move in a direction, if failing forcedirection will be setted to false
                    TryForceActorToNextTile();
                    if (forceDirection)
                    {
                        transform.LookAt(movementTarget.characterPosition, Vector3.up);
                        state = ACTOR_STATE.MOVING;
                    }
                    else
                    {
                        roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                        roamingT                 = 0f;
                        currIdleAnimationPlaying = Random.Range(1, 5);
                        state = ACTOR_STATE.CHOOSING;
                    }
                }
                break;

            case ACTOR_STATE.CHILLED:
                scaredAnimation = "Scared 0" + Random.Range(1, 3);
                GameObject player = GameObject.FindGameObjectWithTag("Player");
                if (player)
                {
                    Chill c = player.GetComponent <Chill>();
                    if (c)
                    {
                        c.AddActorToCurrentChill(this);
                    }
                }
                state = ACTOR_STATE.CHILLED;
                break;

            default:
                break;
            }
        }
        else if (state == ACTOR_STATE.TALKING)
        {
            fear -= Time.deltaTime * fearReductionPerSecond;

            if (talkCooldownTimer > 0)
            {
                talkCooldownTimer -= Time.deltaTime;
                if (talkCooldownTimer < 0)
                {
                    talkCooldownTimer = 0;
                }
            }

            CheckTileState();

            switch (processedState)
            {
            case ACTOR_STATE.NONE:
                //PLAY TALK ANIMATION
                if (talkTarget != null)
                {
                    transform.LookAt(talkTarget.transform.position, Vector3.up);

                    if (Mathf.Approximately(talkCooldownTimer, 0.0f))
                    {
                        talkCooldownTimer = talkCooldown;
                        talkRefreshTimer  = talkRefresh;
                        ResetTalkingActor();
                        roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                        roamingT                 = 0f;
                        currIdleAnimationPlaying = Random.Range(1, 5);

                        if (audioSource.isPlaying)
                        {
                            audioSource.Stop();
                        }

                        state = ACTOR_STATE.CHOOSING;
                    }
                    else if (!audioSource.isPlaying)
                    {
                        PlaySound(Random.Range(0, 3), Random.Range(minDelayTimeTalking, maxDelayTimeTalking));
                    }
                }
                //NICE! This makes them go back to the previous tile for talking:
                //TODO can be dangerous when applying powers
//				if(talkTarget != null && this.currentTile == talkTarget.currentTile)
//				{
//					movementTarget = previousTile;
//					state = ACTOR_STATE.MOVING;
//				}
                //STOP talking go to do something else
                else if (talkTarget == null)
                {
                    roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                    roamingT                 = 0f;
                    currIdleAnimationPlaying = Random.Range(1, 5);
                    talkCooldownTimer        = talkCooldown;
                    state = ACTOR_STATE.CHOOSING;
                }

                break;

            case ACTOR_STATE.HAUNTED:
                talkRefreshTimer  = talkRefresh;
                talkCooldownTimer = talkCooldown;
                ResetTalkingActor();
                if (forceDirection)
                {
                    //forcing actor to move in a direction, if failing forcedirection will be setted to false
                    TryForceActorToNextTile();
                    if (forceDirection)
                    {
                        transform.LookAt(movementTarget.characterPosition, Vector3.up);
                        state = ACTOR_STATE.MOVING;
                    }
                    else
                    {
                        roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                        roamingT                 = 0f;
                        currIdleAnimationPlaying = Random.Range(1, 5);
                        state = ACTOR_STATE.CHOOSING;
                    }
                }
                break;

            case ACTOR_STATE.CHILLED:
                scaredAnimation = "Scared 0" + Random.Range(1, 3);
                GameObject player = GameObject.FindGameObjectWithTag("Player");
                if (player)
                {
                    Chill c = player.GetComponent <Chill>();
                    if (c)
                    {
                        c.AddActorToCurrentChill(this);
                    }
                    else
                    {
                        Debug.LogError("Chilled activated but not detected from actrors");
                    }
                }
                talkRefreshTimer  = talkRefresh;
                talkCooldownTimer = talkCooldown;
                ResetTalkingActor();
                state = ACTOR_STATE.CHILLED;
                break;

            default:
                break;
            }
        }
        else if (state == ACTOR_STATE.CHILLED)
        {
            if (scaredAnimation != string.Empty)
            {
                gameObject.GetComponent <Animator>().Play(scaredAnimation);
            }

            if (deActivateChilled)
            {
                deActivateChilled        = false;
                roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
                roamingT                 = 0f;
                currIdleAnimationPlaying = Random.Range(1, 5);
                state = ACTOR_STATE.CHOOSING;
            }
        }
        else if (state == ACTOR_STATE.NONE)
        {
            talkCooldownTimer        = talkCooldown;
            talkRefreshTimer         = talkRefresh;
            roamingWaitTime          = Random.Range(minRoamingWaitTime, maxRoamingWaitTime);
            roamingT                 = 0f;
            currIdleAnimationPlaying = Random.Range(1, 5);
            state = ACTOR_STATE.CHOOSING;
        }
    }