Beispiel #1
0
    void InLevelUpdate()
    {
        if (!InputStack.IsActive(this))
        {
            return;
        }

        //----------------------------------------
        //  Reverse key
        //----------------------------------------
        if (Input.GetKeyDown(KeyCode.R))
        {
            if (activeWorm.Count == 1)
            {
                AudioSource.PlayClipAtPoint(error, transform.position);
            }
            else
            {
                // reverse head/tail
                activeWorm.GetFirst().isHead = false;
                activeWorm.Reverse();
                activeWorm.GetFirst().isHead = true;
                AudioSource.PlayClipAtPoint(reverse, transform.position);
            }
        }

        if (Input.GetKeyDown(KeyCode.Space))
        {
            if (activeWorm.Count == 1)
            {
                AudioSource.PlayClipAtPoint(error, transform.position);
            }
            else
            {
                // split in two!
                int        totalSegs = activeWorm.Count;
                int        numInNew  = totalSegs / 2;
                int        numInOld  = totalSegs - numInNew;
                List <Seg> newWorm   = new List <Seg>();
                for (int i = 0; i < numInNew; i++)
                {
                    newWorm.Add(activeWorm[numInOld + i]);
                    newWorm.GetLast().isHead   = false;
                    newWorm.GetLast().isActive = false;
                }
                worms.Add(newWorm);
                activeWorm.RemoveRange(numInOld, numInNew);
                AudioSource.PlayClipAtPoint(split, transform.position);

                // assign a key
                int key = GetFreeWormKey();

                if (key != -1)
                {
                    key2worm[key]     = newWorm;
                    worm2key[newWorm] = key;
                }
            }
        }

        for (int key = 1; key < 9; key++)
        {
            if (Input.GetKeyDown("" + key) && key2worm.ContainsKey(key))
            {
                // switch to this worm
                foreach (var seg in activeWorm)
                {
                    seg.isActive = false;
                    seg.isHead   = false;
                }

                activeWorm = key2worm[key];
                foreach (var seg in activeWorm)
                {
                    seg.isActive = true;
                    seg.isHead   = false;
                }
                activeWorm.GetFirst().isHead = true;
            }
        }

        repeatTimer -= Time.deltaTime;

        int dr = 0;
        int dc = 0;

        if (repeatTimer < 0)
        {
            KeyCode moveKey = keyMgr.GetActiveKey();

            if (moveKey == KeyCode.W)
            {
                dr -= 1;
            }
            else if (moveKey == KeyCode.S)
            {
                dr += 1;
            }
            else if (moveKey == KeyCode.A)
            {
                dc -= 1;
            }
            else if (moveKey == KeyCode.D)
            {
                dc += 1;
            }
        }

        if (dr != 0 || dc != 0)
        {
            var head  = activeWorm.GetFirst();
            var other = head.ent.Peek(dr, dc);

            if (other != null && other.GetComponent <LevelExit>() != null)
            {
                if (worms.Count > 1)
                {
                    AudioSource.PlayClipAtPoint(error, transform.position);
                    ThrobOutstandingItems();
                    Debug.Log("detached worms in level!");
                }
                // check for remaining fruits..
                else if (map.entsRoot.GetComponentsInChildren <Fruit>().Length > 0)
                {
                    AudioSource.PlayClipAtPoint(error, transform.position);
                    ThrobOutstandingItems();
                    Debug.Log("fruits remain!");
                }
                else
                {
                    AudioSource.PlayClipAtPoint(beatlevel, transform.position);

                    if (currLevel + 1 < levelOrder.Length)
                    {
                        SwitchLevel(currLevel + 1);
                    }
                    else
                    {
                        // beat!
                        map.Clear();
                        startScreen.SetActive(true);
                        state = "start";
                    }
                }
            }
            else if (other != null && other.GetComponent <Seg>() != null &&
                     !other.GetComponent <Seg>().isActive)
            {
                var hitBit = other.GetComponent <Seg>();
                if (RemergeTail(hitBit))
                {
                    AudioSource.PlayClipAtPoint(merge, transform.position);
                }
                else
                {
                    // hit a non-head or tail of the inactive worm. can't merge there.
                    AudioSource.PlayClipAtPoint(error, transform.position);
                }
            }
            else
            {
                // do move

                bool grew = false;
                // but maybe eating a fruit?
                if (other != null && other.GetComponent <Fruit>() != null)
                {
                    AudioSource.PlayClipAtPoint(grow, transform.position);

                    map.RemoveEntity(other);
                    Destroy(other.gameObject);

                    // create new worm segment at end later
                    grew = true;
                }

                Int2 endPos = activeWorm.GetLast().ent.pos;

                if (!TryMoveWorm(activeWorm, new Int2(dr, dc)))
                {
                    AudioSource.PlayClipAtPoint(bump, transform.position);
                }
                else
                {
                    if (grew)
                    {
                        var newSeg = map.SpawnPrefab(wormSegPrefab, endPos.row, endPos.col);
                        activeWorm.Add(newSeg.GetComponent <Seg>());
                    }
                    else
                    {
                        AudioSource.PlayClipAtPoint(move, transform.position);
                    }
                }
            }

            //----------------------------------------
            //  reset timer
            //  Do NOT do this if we did not move..
            //----------------------------------------
            if (repeatTimer < 0)
            {
                repeatTimer = repeatPeriod;
            }
        }
    }
Beispiel #2
0
    // Update is called once per frame
    void Update()
    {
        if (state == "start")
        {
            if (InputStack.IsActive(this) && Input.GetKeyDown(KeyCode.Space))
            {
                state = "level";
                startScreen.SetActive(false);
                SwitchLevel(0);
            }
        }
        else if (state == "level")
        {
            //----------------------------------------
            //  Handle player input
            //----------------------------------------
            InLevelUpdate();

            //----------------------------------------
            //  Cheats
            //----------------------------------------
            if (Input.GetKeyDown(KeyCode.Equals))
            {
                SwitchLevel(currLevel + 1);
            }
            if (Input.GetKeyDown(KeyCode.Minus))
            {
                SwitchLevel(currLevel - 1);
            }
            if (Input.GetKeyDown(KeyCode.Alpha0))
            {
                SwitchLevel(currLevel);
            }
        }
        else if (state == "dead")
        {
            if (InputStack.IsActive(this) && Input.GetKeyDown(KeyCode.Space))
            {
                deathScreen.SetActive(false);
                SwitchLevel(currLevel, false);
            }
        }
        else if (state == "debrief")
        {
            if (InputStack.IsActive(this) && Input.GetKeyDown(KeyCode.Space))
            {
                debriefScreen.SetActive(false);
                if (currLevel + 1 < levelOrder.Length)
                {
                    SwitchLevel(currLevel + 1);
                }
                else
                {
                    // beat game!
                    map.Clear();
                    startScreen.SetActive(true);
                    state = "start";
                }
            }
        }
        else if (state == "ending")
        {
        }
    }