コード例 #1
0
 public void RpcHauntEnded()
 {
     foreach (GamePlayer player in NetworkGame.GetPlayers())
     {
         if (player.isLocalPlayer)
         {
             player.DisplayHauntInfo(gameHaunt.GetComponent <Haunt>());
         }
     }
 }
コード例 #2
0
 public void RpcPrepEnd()
 {
     Time.timeScale = 1;
     foreach (GamePlayer player in NetworkGame.GetPlayers())
     {
         if (player.isLocalPlayer)
         {
             player.StopHauntPrep();
         }
     }
 }
コード例 #3
0
 public void RpcHauntStarted(GameObject haunt)
 {
     gameHaunt      = haunt;
     Time.timeScale = 0;
     foreach (GamePlayer player in NetworkGame.GetPlayers())
     {
         if (player.isLocalPlayer)
         {
             player.DisplayHauntInfo(gameHaunt.GetComponent <Haunt>());
         }
     }
 }
コード例 #4
0
    // Update is called once per frame
    void Update()
    {
        if (!isServer)
        {
            gameState = currState;
        }
        else
        {
            currState = gameState;
        }
        ///Check if the haunt has started yet.
        if (isServer && gameState == HauntState.EXPLORE)
        {
            elapsed += Time.deltaTime;
            if (elapsed >= checkInterval)
            {
                //Debug.Log ("Checking Haunts");
                foreach (Haunt haunt in haunts)
                {
                    if (haunt.CanStartHaunt())
                    {
                        //Debug.Log ("Started Haunt");
                        gameHaunt = GameObject.Instantiate(haunt.gameObject);
                        NetworkServer.Spawn(gameHaunt);
                        gameState = HauntState.PREP;

                        RpcHauntStarted(gameHaunt);
                        return;
                    }
                }
                elapsed = 0;
            }
        }
        else if (isServer && gameState == HauntState.PREP)
        {
            if (ready.Count == NetworkGame.GetPlayers().Length)
            {
                gameState = HauntState.HAUNT;
                RpcPrepEnd();
            }
        }
        else if (isServer && gameState == HauntState.END)
        {
            if (prevState != HauntState.END)
            {
                RpcHauntEnded();
            }
        }
        prevState = gameState;
    }
コード例 #5
0
ファイル: Haunt.cs プロジェクト: nicholas-maltbie/Treachery
    // Use this for initialization
    void Start()
    {
        if (isServer)
        {
            //Debug.Log ("Starting haunt");
            GamePlayer[] players = NetworkGame.GetPlayers();
            switch (type)
            {
            case HauntType.Tratior:
                for (int i = 0; i < players.Length; i++)
                {
                    players [i].RpcSetPlayerState(GamePlayer.PlayerType.HERO);
                }
                SelectTratior(players).RpcSetPlayerState(GamePlayer.PlayerType.TRAITOR);
                break;

            case HauntType.Cooperative:
                for (int i = 0; i < players.Length; i++)
                {
                    players [i].RpcSetPlayerState(GamePlayer.PlayerType.HERO);
                }
                break;

            case HauntType.HiddenTratior:
                for (int i = 0; i < players.Length; i++)
                {
                    players [i].RpcSetPlayerState(GamePlayer.PlayerType.HERO);
                }
                SelectTratior(players).RpcSetPlayerState(GamePlayer.PlayerType.TRAITOR);
                break;

            case HauntType.FreeForAll:
                for (int i = 0; i < players.Length; i++)
                {
                    players [i].RpcSetPlayerState(GamePlayer.PlayerType.MADMAN);
                }
                break;

            case HauntType.Mixed:
                for (int i = 0; i < players.Length; i++)
                {
                    players [i].RpcSetPlayerState(GamePlayer.PlayerType.HERO);
                }
                break;
            }
            HauntStarted();
        }
    }
コード例 #6
0
 /// <summary>
 /// Determines whether this instance can start haunt. This is determined by the haunt checking
 /// the house for what has happened. This method is called quite often, 10 times a second, for
 /// every haunt so it should not be too intensive of a process.
 /// </summary>
 /// <returns><c>true</c> if this instance can start haunt; otherwise, <c>false</c>.</returns>
 public override bool CanStartHaunt()
 {
     foreach (GamePlayer player in NetworkGame.GetPlayers())
     {
         foreach (GameObject item in player.GetComponent <Inventory>().items)
         {
             if (item != null && item.GetComponent <Item>().itemName == "Ring")
             {
                 theRing                   = item;
                 chosenOne                 = player;
                 traitorSpawns[player]     = player.gameObject.transform.position;
                 traitorDeadTimes [player] = 0;
                 return(true);
             }
         }
     }
     return(false);
 }
コード例 #7
0
    /// <summary>
    /// Starts the haunt. This is used in place of Start() which is used by the abstract Haunt to
    /// setup the default state of the game for the given kind of haunt.
    /// </summary>
    public override void HauntStarted()
    {
        // Restore traitor health
        chosenOne.GetComponent <Damageable>().SetHealth(chosenOne.GetComponent <Damageable>().maxHealth);
        chosenOne.GetComponent <Damageable>().SetSanity(chosenOne.GetComponent <Damageable>().maxSanity);

        // Add speical actions to all Players
        foreach (GamePlayer player in NetworkGame.GetPlayers())
        {
            if (player != chosenOne)
            {
                GameObject visionBox = Instantiate(visionActionBox);
                visionBox.transform.parent        = player.transform.parent;
                visionBox.transform.localPosition = Vector3.zero;
                NetworkServer.Spawn(visionBox);
                RpcAddVisionAction(player.gameObject, visionBox);
            }
        }
    }
コード例 #8
0
    void Update()
    {
        if (isServer && HauntManager.gameState == HauntManager.HauntState.HAUNT)
        {
            //Check if traitor(s) have won
            bool allHeroesDead = true;
            foreach (GamePlayer player in NetworkGame.GetPlayers())
            {
                if (player.playerState == GamePlayer.PlayerType.HERO && player.gameObject.GetComponent <Damageable> ().IsDead() == false)
                {
                    allHeroesDead = false;
                }
            }

            /*if (allHeroesDead) {
             *      //Traitor wins
             *      HauntManager.EndHaunt();
             *      winner = GamePlayer.PlayerType.TRAITOR;
             * }*/

            //Check if heroes have won
            if (theRing == null)
            {
                HauntManager.EndHaunt();
                winner = GamePlayer.PlayerType.HERO;
            }

            //Update ring and invisibility
            foreach (GamePlayer player in NetworkGame.GetPlayers())
            {
                if (player.playerState == GamePlayer.PlayerType.TRAITOR)
                {
                    bool hasRing = false;
                    foreach (GameObject item in player.GetComponent <Inventory>().items)
                    {
                        if (item != null)
                        {
                            if (item.GetComponent <Item> ().itemName == "Ring")
                            {
                                hasRing = true;
                                item.GetComponent <Item> ().canDrop = false;
                            }
                        }
                    }
                    traitorHasRing = hasRing;
                    if (hasRing)
                    {
                        RpcMakeInvisible(chosenOne.gameObject);
                    }
                    else
                    {
                        RpcMakeVisible(chosenOne.gameObject);
                    }
                }
                if (player.playerState == GamePlayer.PlayerType.HERO)
                {
                    foreach (GameObject item in player.GetComponent <Inventory>().items)
                    {
                        if (item != null && item.GetComponent <Item> ().itemName == "Ring")
                        {
                            item.GetComponent <Item> ().canDrop = true;
                        }
                    }
                }
            }

            //Update traitor death times
            foreach (GamePlayer player in NetworkGame.GetPlayers())
            {
                if (player.playerState == GamePlayer.PlayerType.TRAITOR &&
                    player.GetComponent <Damageable>().IsDead())
                {
                    if (traitorDeadTimes [player] == 0)
                    {
                        //If the traitor just died
                        player.AddTimedMessage("You are dead, but it's only temporary", respawnTime);
                    }
                    traitorDeadTimes [player] = traitorDeadTimes [player] + Time.deltaTime;
                    if (traitorDeadTimes [player] >= respawnTime)
                    {
                        traitorDeadTimes [player] = 0;
                        player.ServerRespawn();
                        player.gameObject.transform.position = traitorSpawns [player];
                        player.AddTimedMessage("You are back in the world of the living, for now...", 2.5f);
                    }
                }
            }
        }
    }