Example #1
0
 private void RaiseScreenLoseEnd(DynamicScreen loser, bool twoPlayerSetup)
 {
     if (ScreenLoseEnd != null)
     {
         ScreenLoseEnd(loser, twoPlayerSetup);
     }
 }
Example #2
0
 private void RaiseScreenLoseStart(DynamicScreen loser)
 {
     if (ScreenLoseStart != null)
     {
         ScreenLoseStart(loser, loseTime, loseRate);
     }
 }
Example #3
0
        public void TestLineWrap()
        {
            var          testLine = "01";
            IAnsiDecoder vt100    = new AnsiDecoder();

            vt100.Encoding = Encoding.UTF8;

            DynamicScreen screen;

            // If a file has a single \n in it, it has two lines.
            screen = new DynamicScreen(testLine.Length);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes("\n"));
            Assert.AreEqual(2, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);

            // If a file has a one line that is small + a \n in it, it has two lines.
            screen = new DynamicScreen(testLine.Length);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"0\n"));
            Assert.AreEqual(2, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);

            // If a file has a one line that fits + a \n in it, it has two lines.
            screen = new DynamicScreen(testLine.Length);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"{testLine}\n"));
            Assert.AreEqual(2, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);

            // A full width line, one line
            screen = new DynamicScreen(testLine.Length);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes(testLine));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(1, screen.Lines.Count);

            // Two full width lines, two lines
            screen = new DynamicScreen(testLine.Length);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"{testLine}\n{testLine}"));
            Assert.AreEqual(2, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);

            // wrapping scenarios

            // a full width line + 1 char, two lines
            screen = new DynamicScreen(testLine.Length);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes(testLine + "!"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);

            // one full width line + one full width line + 1 char, three lines
            screen = new DynamicScreen(testLine.Length);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"{testLine}\n{testLine}!"));
            Assert.AreEqual(2, screen.NumLines);
            Assert.AreEqual(3, screen.Lines.Count);
        }
Example #4
0
 void OnDeathStart(DynamicScreen loser, float loseTime, AnimationCurve loseRate)
 {
     if (loser.screenIndex == instanceIndex)
     {
         StartCoroutine(DeathRoutine(loseTime));
     }
 }
Example #5
0
        public void TestCreate()
        {
            var screen = new DynamicScreen(80);

            Assert.AreEqual(80, screen.Width);
            Assert.AreEqual(1, screen.Lines.Count);
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(new System.Drawing.Point(0, 0), screen.CursorPosition);
        }
Example #6
0
        // Example:
        // using System;
        // |    1    |  2  |        3            |  4
        // <bold>using</bold><normal> </normal><color>System</color><normal>;</normal>
        public void TestAttributeRuns()
        {
            IAnsiDecoder vt100 = new AnsiDecoder();

            vt100.Encoding = Encoding.UTF8;

            DynamicScreen screen;

            screen = new DynamicScreen(100);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes("using System;"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(1, screen.Lines.Count);
            Assert.AreEqual(4, screen.Lines[0].Runs.Count);

            Screen.Character c;
            // Test using grid based API
            c = screen[0, 0];
            Assert.AreEqual('u', c.Char);
            Assert.AreEqual(true, c.Attributes.Bold);
            Assert.AreEqual(Color.White, c.Attributes.ForegroundColor);

            c = screen[1, 0];
            Assert.AreEqual('s', c.Char);
            Assert.AreEqual(true, c.Attributes.Bold);
            Assert.AreEqual(Color.White, c.Attributes.ForegroundColor);

            c = screen[2, 0];
            Assert.AreEqual('i', c.Char);
            Assert.AreEqual(true, c.Attributes.Bold);
            Assert.AreEqual(Color.White, c.Attributes.ForegroundColor);

            c = screen[3, 0];
            Assert.AreEqual('n', c.Char);
            Assert.AreEqual(true, c.Attributes.Bold);
            Assert.AreEqual(Color.White, c.Attributes.ForegroundColor);

            c = screen[4, 0];
            Assert.AreEqual('g', c.Char);
            Assert.AreEqual(true, c.Attributes.Bold);
            Assert.AreEqual(Color.White, c.Attributes.ForegroundColor);

            c = screen[5, 0];
            Assert.AreEqual(' ', c.Char);
            Assert.AreEqual(false, c.Attributes.Bold);
            Assert.AreEqual(Color.White, c.Attributes.ForegroundColor);

            c = screen[6, 0];
            Assert.AreEqual('S', c.Char);
            Assert.AreEqual(false, c.Attributes.Bold);
            Assert.AreEqual(Color.FromArgb(85, 85, 85), c.Attributes.ForegroundColor);
            // Test using Run-based API

            var run = screen.Lines[0].Runs[0];

            Assert.AreEqual("using", screen.Lines[0].Text[run.Start..(run.Start + run.Length)]);
Example #7
0
    /// <summary>
    /// fires the DeathStart event
    /// also Raises the state change into InDeath
    /// </summary>
    public static void RaiseDeathStart(DynamicScreen loser, float loseTime, AnimationCurve loseRate)
    {
        // death event?
        if (DeathStart != null)
        {
            DeathStart(loser, loseTime, loseRate);
        }

        // change state
        RaiseStateChange(GameState.InDeath);
    }
Example #8
0
        private void Load()
        {
            _screen           = new DynamicScreen((ClientSize.Width - _lineNumberWidth - (_border * 2)) / _charSize.Width);
            _screen.TabSpaces = 4;
            _vt100.Encoding   = Encoding.UTF8;
            _vt100.Subscribe(_screen);

            _vt100.Input(System.IO.File.ReadAllBytes(File));
            _screen.CursorPosition = new Point(0, 0);

            Text = $" - {File}  ({_screen.Width}x{_screen.Height})";

            Invalidate();
        }
Example #9
0
    /// <summary>
    /// 
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    public void Init(Border a, Border b, Vector2 borderDir)
    {
        // fill borders
        borderA = a;
        borderB = b;
        aDiff = borderA.outerPointTarget - borderA.centerPointTarget;
        bDiff = borderB.outerPointTarget - borderB.centerPointTarget;

        // find last two screens
        DynamicScreen[] screens = new DynamicScreen[2];
        int i = 0;
        foreach (DynamicScreen screen in GameData.instance.allScreens)
        {
            if (!screen.lost)
            {
                screens[i] = screen;
                i++;
            }
        }

        // set location
        location = currentCenter;

        // rotate the border direction by 90 to get the moveDir
        moveDir = borderDir;
        float sin = Mathf.Sin(-90 * Mathf.Deg2Rad);
        float cos = Mathf.Cos(-90 * Mathf.Deg2Rad);

        float tx = moveDir.x;
        float ty = moveDir.y;
        moveDir.x = (cos * tx) - (sin * ty);
        moveDir.y = (sin * tx) + (cos * ty);

        // set A and B screen
        if (Vector2.Dot(screens[0].GetCenterPoint(), moveDir) > Vector2.Dot(screens[1].GetCenterPoint(), moveDir))
        {
            screenA = screens[0];
            screenB = screens[1];
        }
        else
        {
            screenA = screens[1];
            screenB = screens[0];
        }

        // find the distance of the screen slice of moveDir
        totalDistance = ScreenUtilities.DistanceOfScreenSlice(moveDir);
    }
Example #10
0
    /// <summary>
    /// Creates an array of points for ContainsPoint and then runs contains point
    /// </summary>
    /// <param name="d"></param>
    /// <param name="p"></param>
    /// <returns></returns>
    public static bool ScreenContainsPoint(DynamicScreen d, Vector2 p)
    {
        int cornerNum = d.corners.Count;

        poly = new Vector2[cornerNum + 4];

        poly[0] = d.cwBorder.centerPoint;
        poly[1] = d.cwBorder.outerPoint;
        for (int _count = 0; _count < cornerNum; _count++)
        {
            poly[2 + _count] = d.corners[_count];
        }
        poly[cornerNum + 2] = d.ccwBorder.outerPoint;
        poly[cornerNum + 3] = d.ccwBorder.centerPoint;
        bool result = ContainsPoint(poly, p);
        return result;
    }
Example #11
0
    /// <summary>
    /// 
    /// </summary>
    /// <param name="loser"></param>
    /// <param name="loseTime"></param>
    /// <param name="loseRate"></param>
    IEnumerator ScreenLoseRoutine(DynamicScreen loser, float loseTime, AnimationCurve loseRate)
    {
        // TODO remove this, probs different just for tug of war
        if (sideCount <= 2) { yield break; }

        // default rate is linear
        if (loseRate == null)
        {
            loseRate = AnimationCurve.Linear(0, 0, 1, 1);
        }

        #region setup
        Border cwBorder = loser.cwBorder;
        Border ccwBorder = loser.ccwBorder;

        // center mesh points
        int mergeVertIndex = -1;
        Vector3[] startCenterVerts = new Vector3[0];
        CenterMeshInfo targetMeshInfo = new CenterMeshInfo();

        // find the ccw merging vert index of center mesh
        float min = Mathf.Infinity;
        for (int k = 1; k < verts.Length; k++)
        {
            // grab screen point of vert from overlay (main) camera
            float tempDistance = Vector2.Distance(GetScreenPointFromVert(k), ccwBorder.centerPointTarget);
            if (tempDistance < min)
            {
                min = tempDistance;
                mergeVertIndex = k;
            }
        }

        // start/target CenterMeshInfo
        startCenterVerts = (Vector3[])verts.Clone();
        Vector3 targetMeshStartVector = Camera.main.ScreenToWorldPoint((ccwBorder.centerPointTarget + cwBorder.centerPointTarget) / 2);
        targetMeshInfo = new CenterMeshInfo(sideCount - 1, targetMeshStartVector, meshSize);
        #endregion

        #region move over time
        // time data
        float elapsedTime = 0;
        float t = 0;

        // lerpz over time
        while (elapsedTime < loseTime)
        {
            elapsedTime += Time.deltaTime;
            t = loseRate.Evaluate(elapsedTime / loseTime);


            int startingVertIndex;
            int targetVertIndex = 0;
            Border tempBorder = ccwBorder;
            // loop from the cw merging vert (mergeVertIndex) around the center mesh
            for (int i = mergeVertIndex; i < mergeVertIndex + sideCount; i++)
            {
                // clamp i within verts
                startingVertIndex = (i < verts.Length) ? i : i - sideCount;

                if (sideCount > 3)
                {
                    // make sure the two merging verts merge to the same center target point
                    if (startingVertIndex == mergeVertIndex)
                    {
                        verts[startingVertIndex] = Vector3.Lerp(startCenterVerts[startingVertIndex], targetMeshInfo.verts[1], t);
                    }
                    else
                    {
                        verts[startingVertIndex] = Vector3.Lerp(startCenterVerts[startingVertIndex], targetMeshInfo.verts[targetVertIndex], t);
                    }
                }
                else
                {
                    verts[startingVertIndex] = Vector3.Lerp(startCenterVerts[startingVertIndex], Vector3.zero, t);
                }

                // redraw
                Redraw();

                // connect border center points
                tempBorder.centerPointTarget = GetScreenPointFromVert(startingVertIndex);
                tempBorder = tempBorder.cwBorder;

                targetVertIndex++;
            }

            yield return null;
        }
        #endregion

        sideCount--;

        // if more than two sides (not 2 players) double check data
        if (sideCount > 2)
        {
            Redraw(targetMeshInfo);
            Border b = ccwBorder;
            for (int i = 0; i < sideCount - 1; i++)
            {
                b.centerPointTarget = GetScreenPointFromVert(i + 1);
                b = b.cwBorder;
            }
        }
    }
Example #12
0
 void RaiseScreenLoseEnd(DynamicScreen loser)
 {
     if (ScreenLoseEnd != null) { ScreenLoseEnd(loser); }
 }
Example #13
0
 /// <summary>
 /// Main function for checking if the object is visible
 /// </summary>
 /// <returns></returns>
 public bool CheckIfVisible(DynamicScreen d)
 {
     Vector2 p = myProperties.myGameInstance.gameCam.WorldToScreenPoint(this.gameObject.transform.position);
     return ScreenUtilities.ScreenContainsPoint(d, p);
 }
Example #14
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="loser"></param>
 /// <param name="loseTime"></param>
 /// <param name="loseRate"></param>
 public void OnScreenLoseStart(DynamicScreen loser, float loseTime, AnimationCurve loseRate)
 {
     StartCoroutine(ScreenLoseRoutine(loser, loseTime, loseRate));
 }
Example #15
0
    /// <summary>
    /// 
    /// </summary>
    void OnDeathEnd(DynamicScreen loser)
    {
        if (loser.screenIndex == instanceIndex)
        {
            // unsubscribe for target offset change
            if (gameCam.updateMaskOffset)
            {
                GameData.instance.allScreens[instanceIndex].CenterPointChange -= gameCam.UpdateTargetOffset;
            }

            // stop listening to the GameObserver
            StopListening();

            // turn off
            GameData.instance.allInstances[loser.screenIndex].gameObject.SetActive(false);
        }
    }
Example #16
0
 public void OnDeathEnd(DynamicScreen loser)
 {
     int enemyNum = GameData.instance.allInstances[loser.screenIndex].enemyCount;
     for (int count = 0; count < enemyNum; count++)
     {
         Enemy e = (Enemy)GameData.instance.allInstances[loser.screenIndex].enemies[count];
         factories["Basic Enemy Factory"].GetComponent<BasicEnemyFactory>().basicEnemyList.Add(e);
         e.transform.SetParent(factories["Basic Enemy Factory"].transform, false);
         e.transform.position = new Vector3(0, -9000, 0);
         e.gameObject.SetActive(false);
         enemyCount--;
     }
 }
Example #17
0
    /// <summary>
    /// 
    /// </summary>
    /// <param name="loser"></param>
    /// <param name="percentMove"></param>
    public void MoveBorder(DynamicScreen loser, float percentMove)
    {
        percentMove = (loser == screenA) ? percentMove / 100f : -percentMove / 100f;

        location += moveDir * percentMove * totalDistance;
    }
Example #18
0
        public void TestTabs()
        {
            IAnsiDecoder vt100 = new AnsiDecoder();

            vt100.Encoding = Encoding.UTF8;

            DynamicScreen screen;

            screen = new DynamicScreen(4);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes("\t"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(1, screen.Lines.Count);
            Assert.AreEqual(1, screen.Lines[0].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);

            screen = new DynamicScreen(4);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"012\t"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(1, screen.Lines.Count);
            Assert.AreEqual(2, screen.Lines[0].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);

            // \t
            // 012
            screen = new DynamicScreen(4);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"\t012"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);
            Assert.AreEqual(1, screen.Lines[0].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);

            // 0\t
            // 12
            screen = new DynamicScreen(4);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"0\t12"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);
            Assert.AreEqual(2, screen.Lines[0].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);

            // 01\t
            // 2
            screen = new DynamicScreen(4);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"01\t2"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);
            Assert.AreEqual(2, screen.Lines[0].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);

            // 0123
            // \t
            screen = new DynamicScreen(4);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"0123\t"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);
            Assert.AreEqual(1, screen.Lines[0].Runs.Count);
            Assert.AreEqual(1, screen.Lines[1].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);

            // 0123
            // 4\t
            screen = new DynamicScreen(4);
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"01234\t"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);
            Assert.AreEqual(1, screen.Lines[0].Runs.Count);
            Assert.AreEqual(1, screen.Lines[0].Runs.Count);
            Assert.AreEqual(4, screen.Lines[0].Text.Length);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[1].Text.Length);

            // Odd TabSpaces
            screen           = new DynamicScreen(3);
            screen.TabSpaces = 3;
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes("\t"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(1, screen.Lines.Count);
            Assert.AreEqual(1, screen.Lines[0].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);

            screen           = new DynamicScreen(3);
            screen.TabSpaces = 3;
            vt100.Subscribe(screen);
            vt100.Input(Encoding.UTF8.GetBytes($"023\t"));
            Assert.AreEqual(1, screen.NumLines);
            Assert.AreEqual(2, screen.Lines.Count);
            Assert.AreEqual(1, screen.Lines[0].Runs.Count);
            Assert.AreEqual(screen.TabSpaces, screen.Lines[0].Text.Length);
        }
Example #19
0
    /// <summary>
    /// 
    /// </summary>
    public void OnLoseStart(DynamicScreen loser, float loseTime, AnimationCurve loseRate)
    {
        if (GameData.instance.playerCount <= 2 && FindObjectOfType<ScreenManager>().twoPlayerMode == ScreenManager.TwoPlayerMode.TugOfWar)
        {
            // dont do anything on two player tug of war death.. twoplayerborder handles it
            return;
        }

        // freeze borders besides the ones being merged
        cwBorder.locked = !(cwBorder == loser.cwBorder || cwBorder == loser.ccwBorder);
        ccwBorder.locked = !(ccwBorder == loser.cwBorder || ccwBorder == loser.ccwBorder);

        cwBorder.moveType = Border.MoveType.Exact;
        ccwBorder.moveType = Border.MoveType.Exact;

        // if this screen is losing, start the lose routine
        if (loser == this)
        {
            //cwBorder.followEdges = false;
            //ccwBorder.followEdges = false;

            // find closest screenpoints to targets
            int closestCCW = loser.ccwBorder.currentScreenPointIndex;
            int closestCW = loser.cwBorder.currentScreenPointIndex;

            // average ccwBorder between the current target points
            int pointIndexDelta = ((closestCCW - closestCW) + GameData.instance.screenData.totalScreenPoints) % GameData.instance.screenData.totalScreenPoints;
            int targetPointIndex = ((closestCCW - pointIndexDelta / 2) + GameData.instance.screenData.totalScreenPoints) % GameData.instance.screenData.totalScreenPoints;

            // stop reading player damage
            StopListeningForDamage();

            StartCoroutine(LoseRoutine(targetPointIndex, loseTime, loseRate));
        }
    }
Example #20
0
    /// <summary>
    /// actions following a loss completion
    /// </summary>
    public void OnScreenLoseEnd(DynamicScreen loser)
    {
        //Debug.Log("lose end on " + loser);
        int newPointIndex = loser.ccwBorder.currentTargetScreenPointIndex;
        MergeBorderData(loser.ccwBorder, loser.cwBorder, newPointIndex);

        // unflag loss routine
        canTakeDamage = true;

        // decrement player count
        DecrementPlayerCount();

        // unsubscribe to lose end event on other objects 
        if (tugOfWarBorder != null)
        {
            tugOfWarBorder.ScreenLoseEnd -= OnScreenLoseEnd;
        }
        else
        {
            loser.ScreenLoseEnd -= OnScreenLoseEnd;
        }

        // setup two playermode if 2 players remain
        if (playerCount == 2)
        {
            StartCoroutine(SetupTwoPlayerRoutine(3));
            RaiseScreenLoseEnd(loser, true);
            GameObserver.RaiseTwoPlayerSetup();
        }
        // end game if one player remains
        else if (playerCount == 1)
        {
            // find winner
            for (int i = 0; i < allScreens.Length; i++)
            {
                if (allScreens[i].lost == false)
                {
                    RaiseGameOver(i);
                    break;
                }
            }
        }
        else
        {
            // if nothing else, raise the loss has ended
            RaiseScreenLoseEnd(loser, false);
        }

        // finally, unsubscribe the screen that lost from the manager
        ScreenLoseEnd -= loser.OnLoseEnd;
    }
Example #21
0
 /// <summary>
 /// alters the size of last two screens by a percentage
 /// </summary>
 /// <param name="screen"> the screen to alter </param>
 /// <param name="deltaSize"> the percent delta of the screen </param>
 public void ChangeScreenSizeTwoPlayer(DynamicScreen screen, float deltaSize)
 {
     tugOfWarBorder.MoveBorder(screen, -deltaSize * 1.5f);
 }
Example #22
0
    /// <summary>
    /// changes the size of a screen, by a percentage
    /// TODO: event on Players driving this?
    /// </summary>
    /// <param name="screen"> the screen to alter </param>
    /// <param name="deltaSize"> the percent delta of the screen </param>
    public void ChangeScreenSize(DynamicScreen screen, float deltaSize)
    {
        // dont change anything if a screen is currently losing
        if (!canTakeDamage) { return; }

        // call two player version if two players left
        if (playerCount == 2 && twoPlayerMode == TwoPlayerMode.TugOfWar)
        {
            ChangeScreenSizeTwoPlayer(screen, deltaSize);
            return;
        }

        // convert delta 
        float cwDelta = deltaSize / 2;
        float ccwDelta = deltaSize / 2;

        // borders
        Border currentCWB = screen.cwBorder;
        Border currentCCWB = screen.ccwBorder;

        // screenPoints index
        int currentCWP = currentCWB.currentTargetScreenPointIndex;
        int currentCCWP = currentCCWB.currentTargetScreenPointIndex;

        // delta in screenPoint index
        int cwPointDelta, ccwPointDelta;

        // run through borders based on number of players
        for (int i = 0; i < Mathf.CeilToInt(playerCount / 2); i++)
        {
            cwPointDelta = (int)(GameData.instance.screenData.totalScreenPoints * (-cwDelta / 100));
            ccwPointDelta = (int)(GameData.instance.screenData.totalScreenPoints * (ccwDelta / 100));

            // find new screenPoints
            currentCWP = (currentCWP + cwPointDelta + GameData.instance.screenData.totalScreenPoints) % GameData.instance.screenData.totalScreenPoints;
            currentCCWP = (currentCCWP + ccwPointDelta + GameData.instance.screenData.totalScreenPoints) % GameData.instance.screenData.totalScreenPoints;

            // set new points on borders
            currentCWB.SetScreenPoint(currentCWP);
            currentCCWB.SetScreenPoint(currentCCWP);

            // find next borders
            currentCWB = currentCWB.cwBorder;
            currentCCWB = currentCCWB.ccwBorder;

            // update screen points to new borders
            currentCWP = currentCWB.currentTargetScreenPointIndex;
            currentCCWP = currentCCWB.currentTargetScreenPointIndex;

            // update screen size delta
            cwDelta = cwDelta - (deltaSize / (playerCount - 1));
            ccwDelta = ccwDelta - (deltaSize / (playerCount - 1));
        }
    }
Example #23
0
 /// <summary>
 /// stops listening to a screen for damage taking
 /// </summary>
 private void StopListeningForDamage(DynamicScreen d)
 {
     d.ChangeSize -= ChangeScreenSize;
 }
Example #24
0
    void RaiseScreenLoseStart(DynamicScreen loser)
    {
        loser.lost = true;

        if (ScreenLoseStart != null) { ScreenLoseStart(loser); }
    }
Example #25
0
    /// <summary>
    /// specific setup based on setup/mode options
    /// </summary>
    void TwoPlayerSetupSpecifics(Border borderA, Border borderB, Vector2 targetDir, bool instantSetup = false)
    {
        // find last two screens
        DynamicScreen[] screens = new DynamicScreen[2];
        int j = 0;
        for (int i = 0; i < allScreens.Length; i++)
        {
            if (!allScreens[i].lost)
            {
                screens[j] = allScreens[i];
                j++;
            }
        }

        /*if (twoPlayerSetup == TwoPlayerSetup.Dynamic)
        {
            borderA.followEdges = false;
            borderB.followEdges = false;
        }*/

        if (twoPlayerMode == TwoPlayerMode.TugOfWar)
        {
            tugOfWarBorder = gameObject.AddComponent<TugOfWarBorder>();
            tugOfWarBorder.Init(borderA, borderB, targetDir);

            // subscribe to tugOfWar lose
            tugOfWarBorder.ScreenLoseStart += OnScreenLoseStart;
            tugOfWarBorder.ScreenLoseEnd += OnScreenLoseEnd;
            ScreenLoseStart += tugOfWarBorder.OnScreenLoseStart;

            // unsubscribe to screen losses
            screens[0].ScreenLoseStart -= OnScreenLoseStart;
            screens[1].ScreenLoseStart -= OnScreenLoseStart;
            screens[0].ScreenLoseEnd -= OnScreenLoseEnd;
            screens[1].ScreenLoseEnd -= OnScreenLoseEnd;
        }
        else if (twoPlayerMode == TwoPlayerMode.Pacman)
        {
            #region duplicate borders
            // instantiate
            GameObject borderObjA = Instantiate(borderPrefab, Vector3.zero, Quaternion.identity) as GameObject;
            borderObjA.name = "Border_" + allBorders.Count;
            borderObjA.transform.parent = transform.Find("borders");

            // add Border to list
            Border aCopy = borderObjA.GetComponent<Border>();
            allBorders.Add(aCopy);

            // setup the Border
            aCopy.Copy(borderA);

            // instantiate
            GameObject borderObjB = Instantiate(borderPrefab, Vector3.zero, Quaternion.identity) as GameObject;
            borderObjB.name = "Border_" + allBorders.Count;
            borderObjB.transform.parent = transform.Find("borders");

            // add Border to list
            Border bCopy = borderObjB.GetComponent<Border>();
            allBorders.Add(bCopy);

            // setup the Border
            bCopy.Copy(borderB);
            #endregion

            #region setup with new borders
            if (screens[0].ccwBorder == borderA)
            {
                borderA.ccwBorder = aCopy;
                //borderA.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(borderA.outerPointTarget);

                borderB.cwBorder = bCopy;
                //borderB.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(borderB.outerPointTarget);

                screens[1].ccwBorder = bCopy;
                bCopy.ccwBorder = borderB;
                bCopy.cwBorder = aCopy;
                //bCopy.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(bCopy.outerPointTarget);

                screens[1].cwBorder = aCopy;
                aCopy.cwBorder = borderA;
                aCopy.ccwBorder = bCopy;
                //aCopy.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(aCopy.outerPointTarget);
            }
            else
            {
                borderB.ccwBorder = bCopy;
                //borderB.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(borderB.outerPointTarget);

                borderA.cwBorder = aCopy;
                //borderA.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(borderA.outerPointTarget);

                screens[1].ccwBorder = aCopy;
                aCopy.ccwBorder = borderA;
                aCopy.cwBorder = bCopy;
                //aCopy.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(aCopy.outerPointTarget);

                screens[1].cwBorder = bCopy;
                bCopy.cwBorder = borderB;
                bCopy.ccwBorder = aCopy;
                //bCopy.currentTargetScreenPointIndex = GameData.instance.screenData.FindClosestScreenPoint(bCopy.outerPointTarget);
            }
            #endregion
        }

        if (instantSetup)
        {
            GameObserver.RaiseTwoPlayerStartInstant();
        }
        else
        {
            GameObserver.RaiseTwoPlayerStart();
        }
    }
Example #26
0
    /// <summary>
    /// fires the DeathStart event
    /// also Raises the state change into InGame
    /// </summary>
    public static void RaiseDeathEnd(DynamicScreen loser, bool twoPlayerStart)
    {
        // death event
        if (DeathEnd != null)
        {
            DeathEnd(loser);
        }

        // change state 
        if (!twoPlayerStart)
        {
            RaiseStateChange(GameState.InGame);
        }
    }
Example #27
0
    /// <summary>
    /// movement routine for a two player border loss
    /// TODO first frame glitch
    /// </summary>
    public IEnumerator LoseRoutine(DynamicScreen loser, float lossTime, AnimationCurve lossRate)
    {
        Vector2 startLocation = currentCenter;
        location = startLocation;

        Vector2 targetLocation = (loser == screenA) ? ScreenUtilities.screenCenter + (moveDir * (totalDistance / 2f)) : ScreenUtilities.screenCenter - (moveDir * (totalDistance / 2f));

        // time data
        float elapsedTime = 0;
        float t = 0;

        yield return null;

        // lerpz over time
        borderA.moveType = Border.MoveType.Exact;
        borderB.moveType = Border.MoveType.Exact;

        while (elapsedTime < lossTime)
        {
            elapsedTime += Time.deltaTime;
            t = lossRate.Evaluate(elapsedTime / lossTime);

            location = Vector2.Lerp(startLocation, targetLocation, t);
            yield return null;
        }

        RaiseScreenLoseEnd(loser);
        yield return null;
        loser.active = false;
    }
Example #28
0
    /// <summary>
    /// 
    /// </summary>
    /// <param name="loser"></param>
    public void OnLoseEnd(DynamicScreen loser, bool twoPlayerSetup)
    {
        if (loser.screenIndex == screenIndex)
        {
            active = false;
            gameObject.SetActive(false);
        }
        else
        {
            // unlock borders
            cwBorder.locked = false;
            ccwBorder.locked = false;

            // reset move type
            // TODO speed with IListener??
            cwBorder.moveType = cwBorder.initialMoveType;
            ccwBorder.moveType = ccwBorder.initialMoveType;

            // follow those screen edges!
            //cwBorder.followEdges = true;
            //ccwBorder.followEdges = true;
        }
    }
Example #29
0
    /// <summary>
    /// initialize the camera for masking
    /// </summary>
    /// <param name="targetScreen"> the screen to initialize for </param>
    public void InitMaskOffset(DynamicScreen targetScreen)
    {
        // flag for offsetting
        updateMaskOffset = true;

        // subscribe for target offset change
        targetScreen.CenterPointChange += UpdateTargetOffset;

        // setup initial offset
        UpdateTargetOffset(targetScreen.GetCenterPoint());

        // display the offset immediately
        localPosition = targetMaskingOffset;
    }
Example #30
0
    /// <summary>
    /// actions following a screen reading a loss
    /// </summary>
    public void OnScreenLoseStart(DynamicScreen loser)
    {
        //Debug.Log("lose start on: " + loser);
        // flag a loss so any possible new damage is halted
        canTakeDamage = false;

        // fire event
        RaiseScreenLoseStart(loser);

        // unsubscribe
        StopListeningForDamage(loser);
        if (tugOfWarBorder != null)
        {
            // tug of war border
            ScreenLoseStart -= tugOfWarBorder.OnScreenLoseStart;
            tugOfWarBorder.ScreenLoseStart -= OnScreenLoseStart;
        }
        else
        {
            // unsubscribe loser's lose start event
            loser.ScreenLoseStart -= OnScreenLoseStart;
        }

        // unsubscribe loser from manager events
        ScreenLoseStart -= loser.OnLoseStart;
        GameOver -= loser.OnGameOver;
    }
Example #31
0
 public void OnDeathStart(DynamicScreen loser, float time, AnimationCurve loseCurve)
 {
     on = false;
 }