//Function for finishing the match public void FinishMatch(BaseCharStateMachine Winner, BaseCharStateMachine Loser, string WinReason) { Winner.TurnState = BaseCharStateMachine.CharTurnState.WIN; Loser.TurnState = BaseCharStateMachine.CharTurnState.LOSS; TheTurn = TurnStates.MATCHFINISHED; this.WinReason = WinReason; }
void MoveCharacter(GameObject Character) { print("111111111"); for (int i = 0; i < ActionPoints; i++) { if (grid.path.Count > i) { Vector3 MoveDirection; MoveDirection = grid.path[i].worldPosition - Character.transform.position; MoveDirection.x *= 0.1f; MoveDirection.y *= 0.1f; MoveDirection.z *= 0.1f; for (int j = 0; j < 10; j++) { Character.transform.position += MoveDirection; } } } State = TurnStates.EnemyTurn; }
public IEnumerator DQStrikeChar() { //Incrament strikes CurrentChar.DQ_Strikes++; //Write Note string ReffMessage = CurrentChar.Stats.Name + "! That is strike " + CurrentChar.DQ_Strikes.ToString() + "!"; //If Strikes = 3, Ring the Bell if (CurrentChar.DQ_Strikes >= 3) { ReffMessage += " Ring the Bell!"; } //Display Note DisplayNote(ReffMessage); yield return(new WaitForSeconds(2)); if (CurrentChar.DQ_Strikes >= 3) { FinishMatch(ThisTurn.Target, ThisTurn.Actor, "Disqualification"); } else { TheTurn = TurnStates.DONE; } }
void Start() { //Find and assign script variables pauseMenu = gameObject.GetComponent <GUIPauseMenu> (); optionsMenu = gameObject.GetComponent <GUIOptionsMenu> (); gridScript = (GameObject.Find("Grid Controller")).GetComponent <GridCS> (); gridScript.CreateGrid(); //Tell the grid to spawn //GridCS.Instance.CreateGrid (); //Set the currently loaded layer to the one designated by the grid script LayerSwitcher.Instance.CurrentLayer = GridCS.coreLayer; for (int layer = 0; layer <= GridCS.layerCount; layer++) { if (layer != GridCS.coreLayer) { LayerSwitcher.Instance.HideLayer(layer); } } //Go and find the main camera MainCamera = GameObject.Find("Main Camera").GetComponent <Camera> (); //Assign states, enter into the Insert phase turnState = TurnStates.InsertPhase; menuState = MenuStates.NullState; _EnterInsertPhase(); //Put the Layer Switcher button into the main GUI guiFunction += LayerSwitcher.Instance.GUIFunction; }
void OnGUI() { if(GUILayout.Button("Next State")) { currentState += 1; Debug.Log(currentState); } if (GUILayout.Button("Spawn Blue")) { string teamColour = "BlueTroop"; Vector3 position = new Vector3(0, 0, 0); Quaternion rotation = new Quaternion(0, 0, 0, 0); sT.TroopSpawn(teamColour, position, rotation); } if (GUILayout.Button("Spawn Red")) { string teamColour = "RedTroop"; Vector3 position = new Vector3(0, 0, 0); Quaternion rotation = new Quaternion(0, 0, 0, 0); sT.TroopSpawn(teamColour, position, rotation); } }
//null or end phase to insert phase public void _EnterInsertPhase() { //If the OnTurnBegin delegate isn't empty, activate it. Good for effects that happen early in the turn. if (OnTurnBegin != null) { OnTurnBegin(); } //Clear the UnitChoice list that contains all of the spawnable units in one team. UnitChoice.Instance.AllSpawnableUnits.Clear(); //Set the camera to perspective view. CameraPerspective(); //set the cursor selection script to its ordinary function CursorSelection.Instance.mouseFunction = CursorSelection.Instance.InsertMouseFunction; //Show which spaces can be spawned in for this turn SwitchButton.Instance.EnableSpawnableArea(); //Set the phase state turnState = TurnStates.InsertPhase; //TODO: Remove this SelectionBoxSize = UnitChoice.Instance.NumberOfButtons * 200 + 50; //Insert all of the GUI buttons. TODO: Move this stuff to NGUI guiFunction += TurnActionOrderHandler.Instance.UndoGUI; guiFunction += GUISelectionBox; guiFunction += SwitchButton.Instance.GUIPlayerStats; //guiFunction += UnitChoice.Instance.SpawnButton; phaseGUIFunction = guiFunction; UnitChoice.Instance.GUISelectionBoxInsert(); }
private void UpdateTurnState(TurnStates newTurnState) { currentTurnState = newTurnState; switch (currentTurnState) { case TurnStates.ROLLING: rollButton.interactable = true; rollText.text = string.Empty; RollUI.SetActive(true); break; case TurnStates.SELECTING: // Now the game should allow the player to select one of their Pieces to move // by calling PieceSelection from Update() // Maybe show some UI here break; case TurnStates.MOVING: RollUI.SetActive(false); StartCoroutine(WaitForMove()); break; default: break; } }
public void Changestate(TurnStates NewState) { currentstate = NewState; switch (NewState) { case TurnStates.PlayerTurn: { player.GetComponent <PlayerController>().playerturn(); } break; case TurnStates.EnemyTurn: { //if(enemydostuff != null) //enemydostuff(); GetComponent <EnemySpawner>().spawnenemy(); enemyturn(); } break; case TurnStates.NoCombat: { player.GetComponent <PlayerController>().playerturn(); } break; default: break; } }
public void _EnterResolvePhase() { //If there's anything loaded into the OnResolveTransitionInitial delegate, run it. This is useful for loading animations? if (OnResolveTransitionInitial != null) { OnResolveTransitionInitial(); } //Disable the spawn indicator SwitchButton.Instance.DisableSpawnableArea(); //Drop cursor selection functionality CursorSelection.Instance.mouseFunction = null; //Make a temp tile slot, fill it with the currently-selected tile. If such a tile exists, deselect it. Tile TileScript; TileScript = CursorSelection.Instance.selectedTile; if (TileScript != null) { if (TileScript.LoadedUnitScript != null) { TileScript.LoadedUnitScript.OnActionDeselect(); } if (TileScript != null) { TileScript.TileSelectionType = Tile.OverlayType.Unselected; } } CursorSelection.Instance.selectedTile = null; //If there was a tile that had a mouseover, then unload the mouseover as well. if (CursorSelection.Instance.tileMouseOverScript != null) { CursorSelection.Instance.tileMouseOverScript.IsMouseOver = false; } //Set the turn state turnState = TurnStates.ResolutionPhase; //Drop the buttons out of the buttonsGUIFunction, which loads into the GUI master buttonsGUIFunction = null; //Drop the layer, undo, scrollbox, and player stats from the master GUI. guiFunction -= LayerSwitcher.Instance.GUIFunction; guiFunction -= TurnActionOrderHandler.Instance.UndoGUI; guiFunction -= GUISelectionBox; guiFunction -= SwitchButton.Instance.GUIPlayerStats; //If there are any functions to drop actions into the front or the back of the GUI stack, resolve them here. if (StackInsertFinalActions != null) { StackInsertFinalActions(); } if (StackInsertInitialActions != null) { StackInsertInitialActions(); } //Resolve and empty the Action list. TurnActionOrderHandler.Instance.ResolveActions(); TurnActionOrderHandler.Instance.InitializeList(); //If there's anything that should happen after the action stack has resolved and emptied, it should happen here. if (OnResolveTransitionFinal != null) { OnResolveTransitionFinal(); } }
public void _EnterEndPhase() { //Add in the layer buttons for viewing. guiFunction += LayerSwitcher.Instance.GUIFunction; //Change the phase turnState = TurnStates.EndPhase; //If anything happens at the beginning of the End phase, that should happen here. if (OnEndPhaseTransition != null) { OnEndPhaseTransition(); } }
void UpdateActionBar() { CurrentActionCD = CurrentActionCD + Time.deltaTime; float CalculateCD = CurrentActionCD / MaxActionCD; ActionBar.transform.localScale = new Vector3(Mathf.Clamp(CalculateCD, 0, 1), ActionBar.transform.localScale.y, ActionBar.transform.localScale.z); if (CurrentActionCD >= MaxActionCD) { currentState = TurnStates.addtolist; } }
void Update() { if (Input.GetKeyDown(KeyCode.Space)) { if (Moving == 0) { Moving = 1; } else if (Moving == 1) { Moving = 0; } } switch (State) { case (TurnStates.PlayerTurn): Ray ray = cam.ScreenPointToRay(Input.mousePosition); Vector3 mousePosition = Input.mousePosition; mousePosition.z = 18f; target = Camera.main.ScreenToWorldPoint(mousePosition); FindPathA_M2(Player.transform.position, target); if (Input.GetMouseButtonDown(0)) { print("HELLO"); MoveCharacter(Player); Destroy(pathHolder); } break; case (TurnStates.EnemyTurn): if (WhichEnemy < Enemies.Length) { if (EnemiesCheckSurrounding(WhichEnemy)) { FindPathA_M2(Enemies[WhichEnemy].transform.position, Player.transform.position); MoveCharacter(Enemies[WhichEnemy]); } else { EnemiesPatrol(WhichEnemy); } WhichEnemy++; } else { WhichEnemy = 0; State = TurnStates.PlayerTurn; } break; } }
public void StartTwoPlayer() { state = TurnStates.Player1; player1.state = Player.PlayerStates.MyTurn; player1.isAI = false; player2.state = Player.PlayerStates.OpponentsTurn; player2.isAI = false; player1.gameObject.SetActive(true); player2.gameObject.SetActive(true); MenuPanel.gameObject.SetActive(false); GamePanel.SetActive(true); }
public void OnTrackableStateChanged(TrackableBehaviour.Status previousStatus, TrackableBehaviour.Status newStatus) { if (newStatus == TrackableBehaviour.Status.DETECTED || newStatus == TrackableBehaviour.Status.TRACKED || newStatus == TrackableBehaviour.Status.EXTENDED_TRACKED) { status = TurnStates.TRACK; } else { status = TurnStates.LOST; } }
public void ClickDefendButton() { //Turn on the defend status CurrentChar.Status_Defend = true; //Deactivate the UI APM.DeactivateAllPanel(); //Move Target Arrow PlayerChars[0].GetComponent <PlayerStateMachine>().TargetArrow.transform.position = new Vector3(0, -5f, 0); //Immediatly go on to next turn TheTurn = TurnStates.WHOSNEXT; }
public void changeTurn() { if (state == TurnStates.Player1) //change to player 2 { state = TurnStates.Player2; player1.state = Player.PlayerStates.OpponentsTurn; player2.state = Player.PlayerStates.MyTurn; } else if (state == TurnStates.Player2) //change to player 1 { state = TurnStates.Player1; player1.state = Player.PlayerStates.MyTurn; player2.state = Player.PlayerStates.OpponentsTurn; } }
private void Start() { if (player1 != null && player2 != null && player1.isX != player2.isX)//not same player { state = TurnStates.None; player1.state = Player.PlayerStates.None; player2.state = Player.PlayerStates.None; player1.gameObject.SetActive(false); player2.gameObject.SetActive(false); MenuPanel.SetActive(true); GamePanel.SetActive(false); GameOverPanel.SetActive(false); PauseGamePanel.SetActive(false); } else { Debug.LogWarning("Error with Players"); } }
/////////////////////////////////////////////////////////////////////////////////////// public void CheckForDQ() { //Check if match has DQs if (Refferee.DQ == true) { //Check if Refferee is down if (Refferee.Down == false) { StartCoroutine(DQStrikeChar()); TheTurn = TurnStates.WAIT; } else { TheTurn = TurnStates.DONE; } } else { TheTurn = TurnStates.DONE; } }
/**********************************************************************************************************/ //Put BattleState Machine Constructor here with info inside /**********************************************************************************************************/ // Use this for initialization void Start() { //Initialize States TheTurn = TurnStates.WHOSNEXT; ReffObj = Instantiate(ReffObj); Refferee = ReffObj.GetComponent <ReffSM>(); //Load Match Rules Refferee.LoadRulesAtStart(this); //Assign Character Positions AssignPositions(); //Assign State Machines AssignStateMachines(); //Add State Machines to list AddSMsToList(); //Set up UI AssignStatPanels(); }
ResetTurnBasedGame() { TurnState = TurnStates.NotTurn; }
void Start() { currentState = TurnStates.START; }
private void startTurn() { curTurnState = TurnStates.TURN_START; }
void Awake() { grid = GetComponent <Grid>(); pathHolder = new GameObject("PathHolder"); State = TurnStates.PlayerTurn; }
public void OnChangeState(TurnStates newState) { //Set the new state state = newState; }
public override void _Ready() { state = TurnStates.PLAYER_TURN; }
// Use this for initialization void Start() { currentState = TurnStates.processing; }
// Update is called once per frame void Update() { switch (TheTurn) { case (TurnStates.WAIT): { //idle state break; } case (TurnStates.WHOSNEXT): { //Disable NotePanel DeactivateNote(); CurrentChar = GetNextTurn(); if (CurrentChar.Status_Down == true) { TheTurn = TurnStates.ISDOWNED; } else { TheTurn = TurnStates.GETACTION; } break; } case (TurnStates.GETACTION): { CurrentChar.TurnState = BaseCharStateMachine.CharTurnState.GETACTION; TheTurn = TurnStates.WAIT; break; } case (TurnStates.PERFORMACTION): { //Take cost from currentchar once if (ThisTurn.Action.ActionStarted == false) { CurrentChar.TakeCostOfAction(ThisTurn.Action); DisplayNote(); } // Perform Chosen Action StartCoroutine(ThisTurn.Action.PerformAction(ThisTurn.Actor, ThisTurn.Target)); break; } case (TurnStates.REFFCHECK): { CheckForDQ(); break; } case (TurnStates.DONE): { // If Character was Downed this turn, change their state and CurrentTurn gets another turn if (ThisTurn.Target.Status_Down == false && ThisTurn.Target.Stats.HP.Current == 0f) { DisplayNote(ThisTurn.Target.Stats.Name + " is Down!"); ThisTurn.Target.Status_Down = true; if (ThisTurn.Target.Status_Defend == true) { ThisTurn.Target.Status_Defend = false; } ThisTurn.Target.StartWP = ThisTurn.Target.Stats.WP.Current; TheTurn = TurnStates.GETACTION; } // Else, End turn else { TheTurn = TurnStates.WHOSNEXT; } Destroy(GameObject.Find(ThisTurn.Action.name)); break; } case (TurnStates.ISDOWNED): { // This character tries to get up. CurrentChar.TurnState = BaseCharStateMachine.CharTurnState.DOWN; //Wait for update from Character State Maching TheTurn = TurnStates.WAIT; break; } case (TurnStates.MATCHFINISHED): { //For now, just check who won. Add character specific stuff later. bool pWin = false; foreach (BaseCharStateMachine Character in AllChars) { if (Character.TurnState == BaseCharStateMachine.CharTurnState.WIN && Character.type == "PLAYER") { pWin = true; } } //Create Win Message string WinMessage = PlayerChars[0].GetComponent <PlayerStateMachine>().Stats.Name; for (int x = 1; x < PlayerChars.Count; x++) { if (x < PlayerChars.Count - 1) { WinMessage = WinMessage + " and " + PlayerChars[x].GetComponent <PlayerStateMachine>().Stats.Name; } else { WinMessage = WinMessage + ", " + PlayerChars[x].GetComponent <PlayerStateMachine>().Stats.Name; } } //If the player won, have that appear if (pWin) { WinMessage += " Win"; } else { WinMessage += " Lose"; } //Display Win Message DisplayNote(WinMessage + " by " + WinReason + "!"); //Wait for scene transition StartCoroutine(EndOfMatch()); TheTurn = TurnStates.WAIT; break; } } }