コード例 #1
0
ファイル: TurnComponent.cs プロジェクト: Kabuh/Shamanica
    //dafault game turn behaviour
    public void MakeGameTurn()
    {
        //placeholder for battle ending
        if (PlayerList.Count == 0 || AIList.Count == 0)
        {
            gameOverTextGO.SetActive(true);
            return;
        }

        classTurnCounter++;
        if (classTurnCounter > turnList.Count)
        {
            classTurnCounter = 1;
        }

        currentTurnHero = turnList[classTurnCounter - 1];

        CurrentTurnIndicator.SetActive(true);
        Vector3 indicatorSetter = currentTurnHero.gameObject.transform.position;

        CurrentTurnIndicator.transform.position = new Vector3(indicatorSetter.x, 2, indicatorSetter.z);



        if (currentTurnHero.mySlot.side == Affiliation.Enemy)
        {
            AIHandler.ChooseBehaviour(currentTurnHero, AIList, PlayerList, out targetsAmount);
        }
    }
コード例 #2
0
    private void EnemySpawnHandler()
    {
        if ((Time.time - timeSinceLastSpawn) >= spawnCheck && !(currEntities >= maxEntities))
        {
            Vector3 spawnPoint = spawnPoints[Random.Range(0, spawnPoints.Count)].transform.position;

            EnemyData chosenData = enemyTypes[Random.Range(0, enemyTypes.Count)];

            GameObject refr     = Instantiate(enemyObject, spawnPoint, Quaternion.identity, entityParent.transform);
            AIHandler  refrData = refr.GetComponent <AIHandler>();

            refrData.sr.sprite      = chosenData.enemySprite;
            refrData._type          = chosenData.enemyType;
            refrData.target         = _player.transform;
            refrData.maxHealth      = chosenData.MaxHealth;
            refrData.moveSpeed      = chosenData.MovementSpeed;
            refrData.minDistance    = chosenData.MinFollowDistance;
            refrData.damageAmount   = chosenData.Damage;
            refrData.damageTickRate = chosenData.DamageRate;
            refrData._dataContainer = chosenData;

            // refrData._wake = true;

            spawnCheck         = Random.Range(minSpawnRate, maxSpawnRate);
            currEntities       = Mathf.Clamp((currEntities + 1), 0, maxEntities);
            timeSinceLastSpawn = Time.time;
        }
    }
コード例 #3
0
ファイル: Node.cs プロジェクト: PepperTiger/Shogunity-Sandbox
 /// <summary>
 /// Create root Node
 /// </summary>
 /// <param name="player"></param>
 /// <param name="opponentPlayer"></param>
 public Node(Player player, Player opponentPlayer)
 {
     board                      = AIHandler.CloneBoard(_GameManager.board);
     this.player                = AIHandler.ClonePlayer(player);
     this.opponentPlayer        = AIHandler.ClonePlayer(opponentPlayer);
     captureBoxesPlayer         = (player == _GameManager.players[0] ? AIHandler.CloneCaptureBoxesInitial(_GameManager.players[0].captureBench) : AIHandler.CloneCaptureBoxesInitial(_GameManager.players[1].captureBench));
     captureBoxesOpponentPlayer = (opponentPlayer == _GameManager.players[0] ? AIHandler.CloneCaptureBoxesInitial(_GameManager.players[0].captureBench) : AIHandler.CloneCaptureBoxesInitial(_GameManager.players[1].captureBench));
     isInitialPlayer            = true;
 }
コード例 #4
0
        public override IEnumerator Enter()
        {
            yield return(base.Enter());

            //Show the trump selector if the active player is a human player
            if (owner.Memory.GetData <Player>("Player" + owner.Memory.GetData <int>("ActivePlayer")).isHuman)
            {
                Card revealedCard = owner.Memory.GetData <Card>("RevealedCardFromKittie");
                if (GameManager.AnimateGame)
                {
                    //Ensure that other parts of the game are finished animating before we cary on
                    while (revealedCard.animating)
                    {
                        yield return(null);
                    }
                }
                //Show Trump Selector
                TrumpSelector tS = owner.Memory.GetData <TrumpSelector>("TrumpSelector");
                tS.gameObject.SetActive(true);

                Dictionary <Card.Suit, UnityEngine.UI.Button> buttons = new Dictionary <Card.Suit, UnityEngine.UI.Button>();
                buttons.Add(Card.Suit.Clubs, tS.clubs);
                buttons.Add(Card.Suit.Hearts, tS.hearts);
                buttons.Add(Card.Suit.Diamonds, tS.diamonds);
                buttons.Add(Card.Suit.Spades, tS.spades);

                //Hide the pass button if we are screwing the dealer
                if (GameManager.ScrewTheDealer && revealedCard.faceDown)
                {
                    tS.aloneToggle.gameObject.SetActive(false);
                }
                else
                {
                    tS.aloneToggle.gameObject.SetActive(true);
                }

                foreach (var suit in buttons.Keys)
                {
                    if (revealedCard.faceDown)
                    {
                        //Only show the ones that do not match the turned down suit
                        buttons[suit].interactable = (suit != revealedCard.suit);
                    }
                    else
                    {
                        //Set only the suit-button for the reveleaved card as showing
                        buttons[suit].interactable = (suit == revealedCard.suit);
                    }
                }
            }
            else
            {
                yield return(AIHandler.MakeTrumpOrderingDecision(owner.Memory.GetData <int>("ActivePlayer"), owner.Memory.GetData <PointSpread>("Player" + owner.Memory.GetData <int>("ActivePlayer") + "PointSpread"), owner));
            }
        }
コード例 #5
0
    public void StartTurn()
    {
        for (int i = 0; i < Characters.Count; i++)
        {
            Characters[i].StartTurn();
        }
        AIHandler.StartAIActions();

        IsActive = true;
        Changed();
    }
コード例 #6
0
ファイル: Node.cs プロジェクト: PepperTiger/Shogunity-Sandbox
    /// <summary>
    /// Create a children node, and apply the move given to get to the new state of the game
    /// </summary>
    /// <param name="parentNode">the parent node of this node</param>
    /// <param name="move">the move to get to the new state from parentNode</param>
    /// <param name="player">the current player in this node</param>
    /// <param name="opponentPlayer">the opponent player</param>
    ///  <param name="makeTree"> will parent and children be insitialised</param>
    public Node(Node parentNode, Move move, Player player, Player opponentPlayer)
    {
        board                      = AIHandler.CloneBoard(parentNode.board);
        this.player                = AIHandler.ClonePlayer(player);
        this.opponentPlayer        = AIHandler.ClonePlayer(opponentPlayer);
        captureBoxesPlayer         = AIHandler.CloneCaptureBoxesNode(parentNode.captureBoxesPlayer);
        captureBoxesOpponentPlayer = AIHandler.CloneCaptureBoxesNode(parentNode.captureBoxesOpponentPlayer);
        isInitialPlayer            = parentNode.isInitialPlayer;
        Move m = AIHandler.CloneMove(move);

        m.play(this);
        _GameManager.AIupdateAllTokenMoves(this);
        isInitialPlayer = isInitialPlayer == true ? false : true;
    }
コード例 #7
0
    // Use this for initialization
    void Awake()
    {
        ui         = GetComponent <UIHandler>();
        animations = GetComponent <AnimationHandler>();
        player     = GameObject.Find("PlayerController").GetComponent <PlayerHandler>();
        ai         = GameObject.Find("AIController").GetComponent <PlayerHandler>();
        aiHandler  = GameObject.Find("AIController").GetComponent <AIHandler>();

        player.isPlayer = true;
        ai.isPlayer     = false;

        cardBack            = Resources.Load <Sprite>("Images/card_back");
        discardPilePosition = GameObject.Find("DiscardPile").transform.position;

        Initialize();
    }
コード例 #8
0
        public GameManager(IGameCallback gameCallback)
        {
            this.gameCallback = gameCallback;

            // Load Creatures
            this.Friends = new List <FDCreature>();
            this.Enemies = new List <FDCreature>();
            this.Npcs    = new List <FDCreature>();
            this.Deads   = new List <FDCreature>();

            eventManager = new GameEventManager(this);

            dispatcher = new GameStateDispatcher(this);

            enemyAIHandler = new AIHandler(this, CreatureFaction.Enemy);
            npcAIHandler   = new AIHandler(this, CreatureFaction.Npc);
        }
コード例 #9
0
 public void InformAIsSkillPicked()
 {
     if (singlePlayer)
     {
         for (int i = 0; i < numberOfPlayers; i++)
         {
             if (!players[i])
             {
                 continue;
             }
             if (myPlayerId != i)
             {
                 AIHandler handler = players[i].GetComponent <AIHandler>();
                 if (handler.DontUpdateDest)
                 {
                     handler.DontUpdateDest = false;
                     handler.SetRandomDestination();
                 }
             }
         }
     }
 }
コード例 #10
0
    void Start()
    {
        animatorAK47           = AK47.GetComponent <Animator>();
        animatorRocketLauncher = RocketLauncher.GetComponent <Animator>();
        animatorHands          = Hands.GetComponent <Animator>();
        animatorBoxGloves      = BoxGloves.GetComponent <Animator>();
        rb   = GetComponent <Rigidbody>();
        posY = transform.position.y;
        if (botPlayer)
        {
            navMeshAgent  = GetComponent <NavMeshAgent>();
            botAiHandler  = GetComponent <AIHandler>();
            navmeshSpeed  = navMeshAgent.speed;
            navmeshASpeed = navMeshAgent.angularSpeed;
        }

        if (IsMyChar)
        {
            isMyChar = true;
            gm.gfButton.CharController = GetComponent <CharacterController>();
            myPhotonView = GetComponent <PhotonView>();
        }
        PhotonNetwork.AddCallbackTarget(this);
    }
コード例 #11
0
    void SpawnPlayers()
    {
        for (byte i = 0; i < numberOfPlayers; i++)
        {
            //Create instances
            players[i] = Instantiate(CharacterPrefab, PlayerSpawnPositions[i],
                                     Quaternion.Euler(PlayerSpawnRotations[i])).transform;
            players[i].GetComponent <CharacterController>().GM = GetComponent <GameManager>();
            if (!singlePlayer)
            {
                int temp = MultiplayerManager.SetViewId(i, players[i]);
                if (temp != -1)
                {
                    myPlayerId = temp;
                    players[temp].GetComponent <CharacterController>().IsMyChar = true;
                    CharCameraController.MyCharacterRb = players[i].GetComponent <Rigidbody>();
                    CharCameraController.MyCharacterTr = players[i].transform;
                    CharCameraController.Cc            = players[temp].GetComponent <CharacterController>();
                }
            }

            if (myPlayerId != i && singlePlayer)
            {
                NavMeshAgent na = players[i].gameObject.AddComponent <NavMeshAgent>();
                na.radius                = 1.4f;
                na.height                = 2.75f;
                na.agentTypeID           = 0;
                na.obstacleAvoidanceType = ObstacleAvoidanceType.LowQualityObstacleAvoidance;
                na.speed        = 8;
                na.angularSpeed = 400;
                na.autoBraking  = false;
                na.acceleration = 100;
                AIHandler ah = players[i].gameObject.AddComponent <AIHandler>();
                ah.DestMesh = spawnPosMesh;
                players[i].GetComponent <CharacterController>().BotPlayer = true;
            }
            else if (myPlayerId == i && singlePlayer)
            {
                players[i].GetComponent <CharacterController>().IsMyChar = true;
                CharCameraController.MyCharacterRb = players[i].GetComponent <Rigidbody>();
                CharCameraController.MyCharacterTr = players[i].transform;
                CharCameraController.Cc            = players[i].GetComponent <CharacterController>();
            }
            // Assign materials
            MeshRenderer mr = players[i].Find("CharacterEquipments").Find("CharacterShape")
                              .GetComponent <MeshRenderer>();
            mr.sharedMaterials = new Material[] { BodyMaterials[i], EyeMaterials[i], MouthMaterials[i] };
            // Paint color and box gloves color assignments
            switch (i)
            {
            case 0:
                players[i].GetComponent <CharacterController>().PaintColor = Color.red;
                players[i].GetComponent <CollisionPainter>().brush.Color   = Color.red;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("LeftBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.red;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("RightBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.red;
                break;

            case 1:
                players[i].GetComponent <CharacterController>().PaintColor = Color.yellow;
                players[i].GetComponent <CollisionPainter>().brush.Color   = Color.yellow;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("LeftBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.yellow;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("RightBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.yellow;
                break;

            case 2:
                players[i].GetComponent <CharacterController>().PaintColor = Color.green;
                players[i].GetComponent <CollisionPainter>().brush.Color   = Color.green;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("LeftBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.green;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("RightBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.green;
                break;

            case 3:
                players[i].GetComponent <CharacterController>().PaintColor = Color.blue;
                players[i].GetComponent <CollisionPainter>().brush.Color   = Color.blue;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("LeftBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.blue;
                players[i].Find("CharacterEquipments").Find("BoxGloves").Find("RightBoxGlove").Find("Cube")
                .GetComponent <MeshRenderer>().material.color = Color.blue;
                break;
            }
            // Face expression textures assignment
            for (byte j = 0; j < 4; j++)
            {
                switch (i)
                {
                case 0:
                    players[i].GetComponent <FaceExpressionHandler>().EyeExpressions[j] =
                        EyeExpressionsRed[j];
                    break;

                case 1:
                    players[i].GetComponent <FaceExpressionHandler>().EyeExpressions[j] =
                        EyeExpressionsYellow[j];
                    break;

                case 2:
                    players[i].GetComponent <FaceExpressionHandler>().EyeExpressions[j] =
                        EyeExpressionsGreen[j];
                    break;

                case 3:
                    players[i].GetComponent <FaceExpressionHandler>().EyeExpressions[j] =
                        EyeExpressionsBlue[j];
                    break;
                }
            }
            for (byte j = 0; j < 3; j++)
            {
                switch (i)
                {
                case 0:
                    players[i].GetComponent <FaceExpressionHandler>().MouthExpressions[j] = MouthExpressionsRed[j];
                    break;

                case 1:
                    players[i].GetComponent <FaceExpressionHandler>().MouthExpressions[j] = MouthExpressionsYellow[j];
                    break;

                case 2:
                    players[i].GetComponent <FaceExpressionHandler>().MouthExpressions[j] = MouthExpressionsGreen[j];
                    break;

                case 3:
                    players[i].GetComponent <FaceExpressionHandler>().MouthExpressions[j] = MouthExpressionsBlue[j];
                    break;
                }
            }
        }

        for (byte i = 0; i < numberOfPlayers; i++)
        {
            int         index        = 0;
            Transform[] otherPlayers = new Transform[numberOfPlayers - 1];
            for (byte j = 0; j < numberOfPlayers; j++)
            {
                if (i == j)
                {
                    continue;
                }
                otherPlayers[index] = players[j].transform;
                index++;
            }
            players[i].GetComponent <CharacterController>().OtherPlayers = otherPlayers;
        }
    }
コード例 #12
0
        public override IEnumerator Enter()
        {
            yield return(base.Enter());

            string      activePlayerName = "Player" + owner.Memory.GetData <int>("ActivePlayer");
            Player      activePlayer     = owner.Memory.GetData <Player>(activePlayerName);
            List <Card> plays            = owner.Memory.GetData <List <Card> >("Plays");

            //Check if the active player is playing this hand
            if (activePlayer.playingRound == false)
            {
                owner.Transition <Play>();
            }
            //Check if we are done playing cards
            else if (plays.Count >= 4 || (owner.Memory.GetData <bool>("Alone") && plays.Count >= 3))
            {
                //End the trick
                owner.Transition <EndTrick>();
            }
            else
            {
                bool lockout    = true;
                Card playedCard = null;

                //Wait for the active player to make a play
                System.Action <object, object> func = (object sender, object args) => {
                    if (args == null)
                    {
                        return;
                    }

                    object[]   trueArgs = (object[])args;
                    GameObject zone     = (GameObject)trueArgs[0];
                    playedCard = (Card)trueArgs[1];



                    if (zone.tag == "PlayZone" && activePlayer == playedCard.owner && AIHandler.isValidPlay(playedCard, activePlayer, owner))
                    {
                        owner.Memory.GetData <List <Card> >("KnownCards").Add(playedCard);

                        //Remove the card from the players hand.
                        activePlayer.RemoveCard(playedCard);

                        //Ensure card let go visuals are done now
                        CardInteractionHandlers.CardMouseExit(this, playedCard);

                        //Track the played card
                        plays.Add(playedCard);
                        owner.Memory.GetData <Dictionary <Card, int> >("PlaysMap").Add(playedCard, owner.Memory.GetData <int>("ActivePlayer"));



                        //Move it to a resting position
                        if (activePlayer.isHuman == false)
                        {
                            playedCard.StartCoroutine(GameManager.cardAnimator.FlyTo(Vector3.Lerp(Vector3.zero, activePlayer.gameObject.transform.position, 0.55f), playedCard, GameManager.AnimateGame, true));
                        }
                        else
                        {
                            FMODUnity.RuntimeManager.PlayOneShot("event:/cardPlace" + Random.Range(1, 4), playedCard.transform.position);
                        }

                        //Flip the card up if it is face down
                        if (playedCard.faceDown)
                        {
                            playedCard.StartCoroutine(GameManager.cardAnimator.Flip(playedCard, GameManager.AnimateGame));
                        }

                        //Adjust the hand visuals
                        playedCard.StartCoroutine(GameManager.cardAnimator.AdjustHand(activePlayerName, GameManager.AnimateGame, owner));

                        //Advance the coroutine
                        lockout = false;
                    }
                    else
                    {
                        //Debug.Log("Invalid play, returning card");
                        playedCard.StartCoroutine(GameManager.cardAnimator.FlyTo(playedCard.goalPosition, playedCard, GameManager.AnimateGame));
                    }
                };


                this.AddObserver(func, "CardPlayedInZone" + owner.UID);
                if (activePlayer.isHuman)
                {
                    CardInteractionHandlers.CanPlayCard = true;
                }

                if (activePlayer.isHuman == false)
                {
                    if (GameManager.AnimateGame)
                    {
                        yield return(new WaitForSeconds(0.25f));
                    }
                    yield return(AIHandler.MakePlayDecision(owner.Memory.GetData <int>("ActivePlayer"), owner.Memory.GetData <PointSpread>("Player" + owner.Memory.GetData <int>("ActivePlayer") + "PointSpread"), owner));
                }
                while (lockout)
                {
                    yield return(null);
                }
                CardInteractionHandlers.CanPlayCard = false;
                this.RemoveObserver(func, "CardPlayedInZone" + owner.UID);

                owner.Transition <Play>();
            }
            //Advance the active player
            owner.Memory.SetData("ActivePlayer", (owner.Memory.GetData <int>("ActivePlayer") == 3) ? 0 : owner.Memory.GetData <int>("ActivePlayer") + 1);
        }
コード例 #13
0
        public override IEnumerator Exit()
        {
            yield return(base.Exit());

            //Hide the trump selector
            owner.Memory.GetData <TrumpSelector>("TrumpSelector").gameObject.SetActive(false);

            //If we are leaving the Trump round and have selected a trump, prepare regular play
            if (owner.Memory.HasKey <Card.Suit>("Trump"))
            {
                if (owner.Memory.GetData <Player>("Player" + owner.Memory.GetData <int>("ActivePlayer")).isHuman == false && GameManager.AnimateGame)
                {
                    GameManager.AccessInstance().StartCoroutine(HandleAISpeach(GameManager.SpawnAIText(owner.Memory.GetData <int>("ActivePlayer"), 2, owner)));
                    if (owner.Memory.GetData <bool>("Alone"))
                    {
                        GameManager.AccessInstance().StartCoroutine(HandleAISpeach(GameManager.SpawnAIText(owner.Memory.GetData <int>("ActivePlayer"), 3, owner)));
                    }
                }

                //Organize AI and player's hands
                Player[]      players       = new Player[] { owner.Memory.GetData <Player>("Player0"), owner.Memory.GetData <Player>("Player1"), owner.Memory.GetData <Player>("Player2"), owner.Memory.GetData <Player>("Player3") };
                System.Action OrganizeHands = () => {
                    foreach (Player p in players)
                    {
                        if (p.isHuman)
                        {
                            Card.Suit trump = owner.Memory.GetData <Card.Suit>("Trump");
                            System.Func <Card, int> calcVal = (Card c) => {
                                //Intial value is as printed on the card
                                int val = (int)c.value;
                                //Clump up same suits
                                val += ((int)c.suit) * 30;
                                //If on trump, add value
                                if (c.suit == trump)
                                {
                                    val += 500;
                                }
                                //Override on-color Jack
                                if (c.suit == trump.SameColorSuit() && c.value == Card.Value.Jack)
                                {
                                    val = 99995;
                                }
                                //Override on-trump Jack
                                if (c.suit == trump && c.value == Card.Value.Jack)
                                {
                                    val = 99999;
                                }
                                return(val);
                            };
                            p.GetHand().Sort((Card x, Card y) => {
                                if (calcVal(x) < calcVal(y))
                                {
                                    return(-1);
                                }
                                else
                                {
                                    return(1);
                                }
                            });
                            p.GetHand().Reverse();
                        }
                        else
                        {
                            System.Action <List <Card> > ShuffleTheList = (List <Card> shuffleList) => {
                                int n = shuffleList.Count;
                                while (n > 1)
                                {
                                    n--;
                                    int k;
                                    //Shuffle, but don't let things stay in the same spot
                                    do
                                    {
                                        k = Random.Range(0, n + 1);
                                    } while (k == n);
                                    Card value = shuffleList[k];
                                    shuffleList[k] = shuffleList[n];
                                    shuffleList[n] = value;
                                }
                            };
                            ShuffleTheList(p.GetHand());
                        }
                        //Animate the cards where they belong
                        p.StartCoroutine(GameManager.cardAnimator.AdjustHand(p.gameObject.name, GameManager.AnimateGame, owner));
                    }
                };


                //Create a stamp to track what trump is
                if (GameManager.AnimateGame)
                {
                    owner.Memory.SetData <GameObject>("TrumpIndicator", GameManager.SpawnTrumpIndicator(owner.Memory.GetData <Card.Suit>("Trump"), owner.Memory.GetData <int>("ActivePlayer") % 2));
                }
                Deck d = owner.Memory.GetData <Deck>("GameDeck");

                //If the revealed card is still face up, have the dealer switch with it.
                if (owner.Memory.GetData <Card>("RevealedCardFromKittie").faceDown == false &&
                    //The following is some going alone logic. First check if someone went alone.
                    //The specific case is when our partner calls a loner and we are the dealer so we need to skip doing the pickup
                    //So we check for the specific case, and then compare it to false.
                    //First we check for someone having gone alone. Then we check to make sure that was person was on our team, and then we check to see if it was not the dealer.
                    (owner.Memory.GetData <bool>("Alone") &&
                     owner.Memory.GetData <int>("TrumpCaller") % 2 == owner.Memory.GetData <int>("Dealer") % 2 &&
                     owner.Memory.GetData <int>("TrumpCaller") != owner.Memory.GetData <int>("Dealer")) == false)
                {
                    //Add the revealed card to the dealer's hand
                    Card   rCard      = owner.Memory.GetData <Card>("RevealedCardFromKittie");
                    string dealerName = "Player" + owner.Memory.GetData <int>("Dealer");
                    Player dealer     = owner.Memory.GetData <Player>(dealerName);
                    dealer.AddCard(rCard);
                    if (GameManager.AnimateGame)
                    {
                        yield return(GameManager.cardAnimator.Orient(rCard, dealerName, GameManager.AnimateGame, owner));
                    }

                    //Hide the card
                    if (GameManager.AnimateGame)
                    {
                        if (dealer.isHuman == false && GameManager.ShowAllCards == false)
                        {
                            yield return(GameManager.cardAnimator.Flip(rCard, GameManager.AnimateGame));
                        }
                    }

                    if (GameManager.AnimateGame)
                    {
                        yield return(GameManager.cardAnimator.AdjustHand(dealerName, GameManager.AnimateGame, owner));
                    }

                    OrganizeHands();
                    //Wait for the cards to orient
                    if (GameManager.AnimateGame)
                    {
                        foreach (Player player in players)
                        {
                            foreach (Card card in player.GetHand())
                            {
                                while (card.animating)
                                {
                                    yield return(null);
                                }
                            }
                        }
                    }


                    //Add Listeners for Card interaction
                    CardInteractionHandlers.EnableCardInteraction(this);
                    if (dealer.isHuman)
                    {
                        CardInteractionHandlers.CanPlayCard = true;
                    }

                    bool lockout = true;
                    System.Action <object, object> func = (object sender, object args) => {
                        if (args == null)
                        {
                            return;
                        }

                        object[]   trueArgs = (object[])args;
                        GameObject zone     = (GameObject)trueArgs[0];
                        Card       card     = (Card)trueArgs[1];

                        if (zone.tag == "PlayZone")
                        {
                            //Set the played card as the revealed card
                            owner.Memory.SetData("RevealedCardFromKittie", card);

                            //Remove the card from the dealers hand.
                            dealer.RemoveCard(card);
                            //Do exit visuals to signify the card has left hand control
                            CardInteractionHandlers.CardMouseExit(this, card);

                            //Adjust the hand visuals
                            card.StartCoroutine(GameManager.cardAnimator.AdjustHand(dealerName, GameManager.AnimateGame, owner));

                            //Advance the coroutine
                            lockout = false;
                        }
                        else
                        {
                            card.StartCoroutine(GameManager.cardAnimator.FlyTo(card.goalPosition, card, GameManager.AnimateGame));
                        }
                    };
                    this.AddObserver(func, "CardPlayedInZone" + owner.UID);
                    //Run the AI
                    if (owner.Memory.GetData <Player>(dealerName).isHuman == false)
                    {
                        yield return(AIHandler.MakeTrumpDiscardDecision(owner.Memory.GetData <int>("Dealer"), owner.Memory.GetData <PointSpread>("Player" + owner.Memory.GetData <int>("ActivePlayer") + "PointSpread"), owner));
                    }
                    if (GameManager.AnimateGame)
                    {
                        //Yield until the player plays one
                        while (lockout)
                        {
                            yield return(null);
                        }
                    }
                    //Remove listeners for card interaction
                    CardInteractionHandlers.CanPlayCard = false;
                    CardInteractionHandlers.DisableCardInteraction(this);
                    this.RemoveObserver(func, "CardPlayedInZone" + owner.UID);
                }
                else
                {
                    OrganizeHands();
                    //Wait for the cards to orient
                    if (GameManager.AnimateGame)
                    {
                        foreach (Player player in players)
                        {
                            foreach (Card card in player.GetHand())
                            {
                                while (card.animating)
                                {
                                    yield return(null);
                                }
                            }
                        }
                    }
                }
                Card revealedCard = owner.Memory.GetData <Card>("RevealedCardFromKittie");

                //Flip the card over if needed
                if (revealedCard.faceDown == false)
                {
                    revealedCard.StartCoroutine(GameManager.cardAnimator.Flip(revealedCard, GameManager.AnimateGame));
                }

                //Move card to the deck
                if (GameManager.AnimateGame)
                {
                    yield return(GameManager.cardAnimator.FlyTo(d.basePosition, revealedCard, GameManager.AnimateGame));
                }
                //Add revealed card back to deck
                d.Place(new Card[] { revealedCard });

                //Slide the deck these cards offscreen
                foreach (Card card in d)
                {
                    card.SetOrdering(-3);
                    card.StartCoroutine(GameManager.cardAnimator.FlyTo(Vector3.LerpUnclamped(Vector3.zero, owner.Memory.GetData <Player>("Player" + owner.Memory.GetData <int>("Dealer")).gameObject.transform.position, 3.4f), card, GameManager.AnimateGame));
                }

                //Reset active player to right of dealer
                owner.Memory.SetData("ActivePlayer", (owner.Memory.GetData <int>("Dealer") == 3) ? 0 : owner.Memory.GetData <int>("Dealer") + 1);

                //Game should be good to start, wait a moment before starting play
                if (GameManager.AnimateGame)
                {
                    yield return(new WaitForSeconds(0.25f));
                }

                //Enable regular card interaction
                CardInteractionHandlers.EnableCardInteraction(this);
            }
            else
            {
                if (owner.Memory.GetData <Player>("Player" + owner.Memory.GetData <int>("ActivePlayer")).isHuman == false && GameManager.AnimateGame)
                {
                    GameManager.AccessInstance().StartCoroutine(HandleAISpeach(GameManager.SpawnAIText(owner.Memory.GetData <int>("ActivePlayer"), 1, owner)));
                    if (GameManager.AnimateGame)
                    {
                        yield return(new WaitForSeconds(0.5f));
                    }
                }
                //Move on the active player
                owner.Memory.SetData("ActivePlayer", (owner.Memory.GetData <int>("ActivePlayer") == 3) ? 0 : owner.Memory.GetData <int>("ActivePlayer") + 1);
            }
        }
コード例 #14
0
        /// <summary>
        /// Met à jour les informations d'états et d'actions à partir du tableau courant.
        /// </summary>
        public void UpdateSensors(Board board, FOXCSOptions fo)
        {
            this.states.Clear();
            this.actions.Clear();
            this.board = AIHandler.CloneBoard(board);
            this.tokenOnBoard.Clear();
            List <Token> tokenList = _GameManager.GetAllTokens();

            if (_GameManager.toPromoteToken != null)
            {
                this.actions.Add(new Attribute("promote", new string[] { _GameManager.toPromoteToken.ToPrologCode(), FOXCS.ToPrologCode(true) }, fo.actionPredicateOptions["promote"]));
                this.actions.Add(new Attribute("promote", new string[] { _GameManager.toPromoteToken.ToPrologCode(), FOXCS.ToPrologCode(false) }, fo.actionPredicateOptions["promote"]));
            }

            foreach (Token tok in tokenList)
            {
                Attribute acc;

                if (!tok.isCaptured)
                {
                    tokenOnBoard.Add(tok.ToPrologCode());
                    this.states.Add(new Attribute("onTile", new string[] { tok.ToPrologCode(), "c" + tok.box.getCoord().x.ToString(), "l" + tok.box.getCoord().y.ToString() }, fo.statePredicateOptions["onTile"]));
                    List <Coordinates> tokLegalMoves    = !tok.isPromoted ? tok.legalMoves(this.board) : tok.legalMovesPlus(this.board);
                    List <Coordinates> tokPossibleMoves = !tok.isPromoted ? tok.possibleMoves(this.board) : tok.possibleMovesPlus(this.board);

                    foreach (Coordinates cord in tokLegalMoves)
                    {
                        acc = new Attribute("legalMove", new string[] { tok.ToPrologCode(), "c" + cord.x.ToString(), "l" + cord.y.ToString() }, fo.statePredicateOptions["legalMove"]);
                        if (!states.Contains(acc))
                        {
                            this.states.Add(acc);
                        }



                        if (tok.owner.Equals(_GameManager.players[_GameManager.currentPlayerIndex]) && _GameManager.toPromoteToken == null)
                        {
                            acc = new Attribute("move", new string[] { tok.ToPrologCode(), "c" + cord.x.ToString(), "l" + cord.y.ToString() }, fo.actionPredicateOptions["move"]);
                            if (!actions.Contains(acc))
                            {
                                this.actions.Add(acc);
                            }
                        }
                    }

                    /*
                     * tok.getTokensToEat();
                     * foreach (Coordinates cord in tok.possibleEats)
                     * {
                     *  acc = new Attribute("inRange", new string[] { tok.ToPrologCode(), this.board.boxes[cord.getIndex()].getToken().ToPrologCode(), "c" + cord.x.ToString(), "l" + cord.y.ToString() }, fo.statePredicateOptions["inRange"]);
                     *  if (!states.Contains(acc))
                     *      this.states.Add(acc);
                     * }
                     */
                }

                else
                {
                    foreach (Coordinates cord in tok.legalDrops(board))
                    {
                        if (tok.owner.Equals(_GameManager.players[_GameManager.currentPlayerIndex]) && _GameManager.toPromoteToken == null)
                        {
                            acc = new Attribute("drop", new string[] { tok.ToPrologCode(), "c" + cord.x.ToString(), "l" + cord.y.ToString() }, fo.actionPredicateOptions["drop"]);
                            if (!actions.Contains(acc))
                            {
                                this.actions.Add(acc);
                            }
                        }

                        acc = new Attribute("legalDrop", new string[] { tok.ToPrologCode(), "c" + cord.x.ToString(), "l" + cord.y.ToString() }, fo.statePredicateOptions["legalDrop"]);
                        if (!states.Contains(acc))
                        {
                            this.states.Add(acc);
                        }
                    }
                }
            }
        }
コード例 #15
0
        public override IEnumerator Enter()
        {
            yield return(base.Enter());

            //Delay
            if (GameManager.AnimateGame)
            {
                yield return(new WaitForSeconds(1.0f));
            }
            //Debug.Log("---End Trick");
            //Determine Winner
            List <Card> originalPlays = owner.Memory.GetData <List <Card> >("Plays");

            List <Card> plays = AIHandler.CloneListOfCards(originalPlays);

            foreach (Card card in plays)
            {
                while (card.animating)
                {
                    yield return(null);
                }
            }
            Card.Suit trump = owner.Memory.GetData <Card.Suit>("Trump");
            Card      lead  = plays[0];



            plays.Sort((Card x, Card y) => {
                if (AIHandler.ScoreingValue(x, owner) < AIHandler.ScoreingValue(y, owner))
                {
                    return(-1);
                }
                else
                {
                    return(1);
                }
            });
            plays.Reverse();
            //Debug.Log("Trump: " + trump + "\nLead:" + lead.suit);
            string winnerName      = "Player" + owner.Memory.GetData <Dictionary <Card, int> >("PlaysMap")[plays[0]];
            Player winningPlayer   = owner.Memory.GetData <Player>(winnerName);
            int    winnerPlayerNum = 0;

            switch (winnerName.ToLower())
            {
            case "player0":
                winnerPlayerNum = 0;
                break;

            case "player1":
                winnerPlayerNum = 1;
                break;

            case "player2":
                winnerPlayerNum = 2;
                break;

            case "player3":
                winnerPlayerNum = 3;
                break;
            }



            //Set the active player to the winner
            owner.Memory.SetData("ActivePlayer", winnerPlayerNum);
            //Debug Log Trick
            {
                string t = "Trick Winner: Player" + winnerPlayerNum + " with " + plays[0] + "\nOP:";
                for (int i = 0; i < originalPlays.Count; i++)
                {
                    t += originalPlays[i].Shortname() + ",";
                }
                t += "\nP:";
                for (int i = 0; i < plays.Count; i++)
                {
                    t += plays[i].Shortname() + ",";
                }
                //Debug.Log(t);
            }
            //Award trick to the correct team
            owner.Memory.SetData(winnerName + "Tricks", owner.Memory.GetData <int>(winnerName + "Tricks") + 1);

            //Place Trump Indicators
            {
                List <GameObject> indicators = owner.Memory.GetData <List <GameObject> >(winnerName + "TrickIndicators");
                if (GameManager.AnimateGame)
                {
                    indicators.Add(GameManager.SpawnTrickIndicator(winnerPlayerNum % 2));
                }
                float r         = 1.15f;
                float size      = 10.0f;
                float baseAngle = 0.0f;
                switch (winnerName.ToLower())
                {
                case "player0":
                    baseAngle = 270.0f;
                    break;

                case "player1":
                    baseAngle = 180.0f;
                    break;

                case "player2":
                    baseAngle = 90.0f;
                    break;

                case "player3":
                    baseAngle = 0.0f;
                    break;
                }
                float range = size * (indicators.Count / 2.0f);
                float step  = 1.0f / indicators.Count;
                //ret[i] = Vector3.Lerp(point + offset, point - offset, step * i) - (horizAxis * (cardWidth / 2.0f));// - ((amt % 2 != 0) ?  : Vector3.zero);
                for (int i = 0; i < indicators.Count; i++)
                {
                    float placeAngle = Mathf.Lerp(baseAngle + range, baseAngle - range, step * i) - (size / 2.0f);
                    placeAngle *= Mathf.Deg2Rad;
                    indicators[i].transform.position = new Vector3(r * Mathf.Cos(placeAngle), r * Mathf.Sin(placeAngle), 0.0f);
                }
            }
            //Animate Cards
            {
                foreach (Card card in plays)
                {
                    card.SetOrdering(-3);
                    //Flip down the played cards
                    card.StartCoroutine(GameManager.cardAnimator.Flip(card, GameManager.AnimateGame));
                    //Orient towards winning player
                    card.StartCoroutine(GameManager.cardAnimator.Orient(card, winnerName, GameManager.AnimateGame, owner));
                    //Have the cards fly past the winner's hand (from center) as if they are collecting the trick
                    card.StartCoroutine(GameManager.cardAnimator.FlyTo(Vector3.LerpUnclamped(Vector3.zero, winningPlayer.gameObject.transform.position, 3.4f), card, GameManager.AnimateGame));
                }
                foreach (Card card in plays)
                {
                    while (card.animating)
                    {
                        yield return(null);
                    }
                }
            }

            //Return the plays to the deck
            owner.Memory.GetData <Deck>("GameDeck").Place(plays.ToArray());

            //Reset the plays list
            owner.Memory.SetData <List <Card> >("Plays", new List <Card>());

            //Transition
            if (owner.Memory.GetData <int>("Player0Tricks") + owner.Memory.GetData <int>("Player1Tricks") + owner.Memory.GetData <int>("Player2Tricks") + owner.Memory.GetData <int>("Player3Tricks") >= 5)
            {
                //If we have played 5 tricks, go to end of hand
                owner.Transition <EndHand>();
            }
            else
            {
                //Else play a new round
                owner.Transition <Play>();
            }
        }
コード例 #16
0
    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            CharacterController cc = other.GetComponent <CharacterController>();
            switch (skillIndex)
            {
            case 0:
                if (cc.BotPlayer)
                {
                    AIHandler handler = cc.GetComponent <AIHandler>();
                    handler.ClearGunDecisionFlags();
                    handler.AK47Taken = true;
                    gm.CharCameraController.ArmedCharacters.Add(other.transform);
                }
                else
                {
                    gm.CharCameraController.GunPicked = true;
                    gm.gpUI.ChangeGunFistSprite(false);
                }
                cc.AK47Picked = true;
                cc.PickAK47();
                break;

            case 1:
                if (cc.BotPlayer)
                {
                    AIHandler handler = other.GetComponent <AIHandler>();
                    handler.ClearGunDecisionFlags();
                    handler.RocketTaken = true;
                    gm.CharCameraController.ArmedCharacters.Add(other.transform);
                }
                else
                {
                    gm.CharCameraController.GunPicked = true;
                    gm.gpUI.ChangeGunFistSprite(false);
                }
                cc.RocketPicked = true;
                cc.PickRocketLauncher();
                cc.faceExpHandler.ChangeFaceExpression(FaceExpressionHandler.FaceExpressions.ANGRY);
                cc.ReturnToSmile = false;
                break;

            case 2:
                cc.SpeedSkillPicked = true;
                cc.SetDoubleSpeed();
                break;

            case 3:
                cc.GrowSkillPicked = true;
                cc.Grow();
                break;

            case 4:
                cc.IncreaseHealth(25);
                break;

            case 5:
                cc.ActivateBombSkill();
                if (!cc.BotPlayer)
                {
                    gm.CharCameraController.ShakeCameraTrigger = true;
                }
                break;
            }

            if (skillIndex != 5)
            {
                Instantiate(PickableSkillEffect, transform.position + Vector3.up * 1f, PickableSkillEffect.transform.rotation);
            }
            else
            {
                Instantiate(BombSkillEffect, transform.position, BombSkillEffect.transform.rotation);
            }
            cc.PlaySkillSoundFX(skillIndex);
            gm.InformAIsSkillPicked();
            gm.CharCameraController.SkillPositions.Remove(transform.position);
            Destroy(gameObject);
        }
        else if (other.CompareTag("Obstacle"))
        {
            other.transform.position += Vector3.right * 6;
        }
    }
コード例 #17
0
    IEnumerator HandleSkillSpawnProcess()
    {
        if (singlePlayer || PhotonNetwork.IsMasterClient)
        {
            while (true)
            {
                yield return(new WaitForSeconds(skillSpawnFrequence));

                byte    randomSkill = (byte)(Random.Range(0, 70) % 7);
                Vector3 skillPos    = FindRandomPointInMesh();
                if (PhotonNetwork.IsMasterClient)
                {
                    object[]          content = { randomSkill, skillPos };
                    RaiseEventOptions reo     = new RaiseEventOptions()
                    {
                        Receivers = ReceiverGroup.Others
                    };
                    SendOptions so = new SendOptions()
                    {
                        Reliability = true
                    };
                    PhotonNetwork.RaiseEvent(2, content, reo, so);
                }
                if (randomSkill != 3)
                {
                    PickableSkill ps = Instantiate(SkillPrefabs[randomSkill], skillPos,
                                                   SkillPrefabs[randomSkill].transform.rotation)
                                       .GetComponent <PickableSkill>();
                    ps.GM = this;
                    // inform all agents
                    if (singlePlayer)
                    {
                        float[] playerDistacesToSkill = new float[numberOfPlayers];
                        for (int i = 0; i < numberOfPlayers; i++)
                        {
                            if (!players[i])
                            {
                                playerDistacesToSkill[i] = float.PositiveInfinity;
                                continue;
                            }
                            float distance = (players[i].transform.position - skillPos).sqrMagnitude;
                            if (i != 0)
                            {
                                for (int j = 0; j < i; j++)
                                {
                                    if (playerDistacesToSkill[j] + 9 < distance && !float.IsInfinity(playerDistacesToSkill[j]))
                                    {
                                        playerDistacesToSkill[i] = float.PositiveInfinity;
                                        break;
                                    }
                                    else
                                    {
                                        playerDistacesToSkill[i] = distance;
                                    }
                                }
                            }
                            else
                            {
                                playerDistacesToSkill[i] = distance;
                            }
                        }

                        for (int i = 0; i < numberOfPlayers; i++)
                        {
                            if (myPlayerId != i && !float.IsInfinity(playerDistacesToSkill[i]))
                            {
                                AIHandler handler = players[i].GetComponent <AIHandler>();
                                handler.DontUpdateDest = true;
                                handler.SkillPosition  = skillPos;
                                handler.PickSkill      = true;
                            }
                        }
                    }
                    CharCameraController.SkillPositions.Add(ps.transform.position);
                }
                else
                {
                    Transform freezer = Instantiate(SkillPrefabs[randomSkill], skillPos, SkillPrefabs[randomSkill].transform.rotation)
                                        .GetComponent <Transform>();
                    FreezerSkill fs = freezer.Find("Freezer").GetComponent <FreezerSkill>();
                    fs.GM           = GetComponent <GameManager>();
                    fs.SinglePlayer = singlePlayer;
                    if (singlePlayer)
                    {
                        for (int i = 0; i < numberOfPlayers; i++)
                        {
                            if (!players[i])
                            {
                                continue;
                            }
                            if (myPlayerId != i)
                            {
                                AIHandler handler = players[i].GetComponent <AIHandler>();
                                handler.FreezerSkillSpawned = true;
                                handler.FreezerTr           = freezer.Find("Freezer");
                            }
                        }
                    }

                    CharCameraController.FreezerSpawned = true;
                    CharCameraController.FreezerTr      = freezer.Find("Freezer");
                }
            }
        }
    }
コード例 #18
0
 private void Awake()
 {
     instance = this;
 }