private void RaiseScreenLoseEnd(DynamicScreen loser, bool twoPlayerSetup) { if (ScreenLoseEnd != null) { ScreenLoseEnd(loser, twoPlayerSetup); } }
private void RaiseScreenLoseStart(DynamicScreen loser) { if (ScreenLoseStart != null) { ScreenLoseStart(loser, loseTime, loseRate); } }
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); }
void OnDeathStart(DynamicScreen loser, float loseTime, AnimationCurve loseRate) { if (loser.screenIndex == instanceIndex) { StartCoroutine(DeathRoutine(loseTime)); } }
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: // [01musing[00m [38;2;85;85;85mSystem[39m; // | 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("[01musing[00m [38;2;85;85;85mSystem[39m;")); 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)]);
/// <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); }
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(); }
/// <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); }
/// <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; }
/// <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; } } }
void RaiseScreenLoseEnd(DynamicScreen loser) { if (ScreenLoseEnd != null) { ScreenLoseEnd(loser); } }
/// <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); }
/// <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)); }
/// <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); } }
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--; } }
/// <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; }
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); }
/// <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)); } }
/// <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; }
/// <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); }
/// <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)); } }
/// <summary> /// stops listening to a screen for damage taking /// </summary> private void StopListeningForDamage(DynamicScreen d) { d.ChangeSize -= ChangeScreenSize; }
void RaiseScreenLoseStart(DynamicScreen loser) { loser.lost = true; if (ScreenLoseStart != null) { ScreenLoseStart(loser); } }
/// <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(); } }
/// <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); } }
/// <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; }
/// <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; } }
/// <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; }
/// <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; }
public void OnDeathStart(DynamicScreen loser, float time, AnimationCurve loseCurve) { on = false; }