Ejemplo n.º 1
0
        // Update is called once per frame
        void Update()
        {
            switch (m_ProcessingTurn)
            {
            case TurnType.OrderPlayer:
                // プレイヤーを一定の条件でシャッフルする
                m_ProcessingTurn = TurnType.SelectCard;
                break;

            case TurnType.SelectCard:
                // どのカードでゲーム開始を行うか
                foreach (var cardData in m_DatabaseController.SelectCardMaster())
                {
                    var cardBuilder = new CardBuilder();
                    var card        = cardBuilder.CreateCard(cardData);
                    m_Supply.AddSupply(card);
                }
                m_ProcessingTurn = TurnType.PlayerTurn;
                break;

            case TurnType.PlayerTurn:
                // ゲーム開始を行う

                // プレイヤーがターン終了するまで他のプレイヤーは待機
                Player nowPlayer = m_PlayerList[0];

                break;
            }
        }
Ejemplo n.º 2
0
 public KnowExpression(string expression, ushort indexer, bool isReverse, TurnType turnType)
 {
     Expression = expression;
     Indexer    = indexer;
     IsReverse  = isReverse;
     TurnType   = turnType;
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Sets new turn.
        /// Saves the current player block and disables its controller.
        /// Restores the next-player's block and enables its controller.
        /// Activates the corresponding icon.
        /// If next turn if Result, deactivates both controllers.
        /// </summary>
        public void SetTurn(TurnType turn)
        {
            CurrentTurn = turn;
            controllerManager.SetCurrentController(turn);
            if (turn == TurnType.FIRST)
            {
                boardManager.SavePlayerBlock(TurnType.SECOND);
                controllerManager.DisableController(TurnType.SECOND);

                boardManager.SetPlayerBlockActive(TurnType.FIRST);
                controllerManager.EnableController(TurnType.FIRST);

                secondIcon.SetActive(false);
                firstIcon.SetActive(true);
            }
            else if (turn == TurnType.SECOND)
            {
                boardManager.SavePlayerBlock(TurnType.FIRST);
                controllerManager.EnableController(TurnType.SECOND);

                boardManager.SetPlayerBlockActive(TurnType.SECOND);
                controllerManager.DisableController(TurnType.FIRST);

                secondIcon.SetActive(true);
                firstIcon.SetActive(false);
            }
            else if (turn == TurnType.RESULT)
            {
                controllerManager.DeactivateAll();
            }
        }
Ejemplo n.º 4
0
 public void InitiatePack(List <GameObject> cards)
 {
     if (isMyTurn)
     {
         if (turnType == TurnType.none || turnType == TurnType.pick)
         {
             if (cards.Count > 0)
             {
                 packInitiator.InitiatePack(cards);
                 //					if(!firstCheckDone)
                 //						turnType = TurnType.through;
                 //					else{
                 //						turnType = TurnType.throughtorshow;
                 //					}
                 turnType = TurnType.throughtorshow;
             }
         }
         else
         {
             if (!showChangeTurn)
             {
                 dialog = "Cant pick card,\n" + turnType.ToString() + " one card to pick";
             }
             else
             {
                 dialog = "Cant Pick card,\n" + " Press Change Turn Button";
             }
             UIEventHandler.Ins.OpenMenu("PickCardNotification");
             UIEventHandler.Ins.pickNotificationText.text = dialog;
             //showDialogBox = true;
         }
     }
 }
Ejemplo n.º 5
0
    public void CalculateScore(int destroyNum, TurnType turntype)
    {
        switch (turntype)
        {
        case TurnType.Aturn:
            if (destroyNum < 7)
            {
                score += 5 * destroyNum * destroyNum * MULTIPLE;
            }
            else
            {
                score += 7 * destroyNum * destroyNum * MULTIPLE;
            }
            break;

        case TurnType.Bturn:
            if (destroyNum < 7)
            {
                Bscore += 5 * destroyNum * destroyNum * MULTIPLE;
            }
            else
            {
                Bscore += 7 * destroyNum * destroyNum * MULTIPLE;
            }
            break;
        }
    }
    private void TeleportToPoint()
    {
        int           index          = currentPoint.BoardModel.BoardNumber;
        TeleportModel teleportModel  = teleporter.Teleports.FindTeleportByTrigger(index);
        Vector2       playerPosition = transform.position;

        Vector2 startPosition   = boardManagerPosition + playerPosition;
        Vector2 nextPosition    = boardManagerPosition + teleportModel.BoardPoint.finalPoint.BoardPosition;
        Vector3 vectorDirection = nextPosition - startPosition;

        vectorDirection.Normalize();

        if (Vector2.Distance(transform.position, nextPosition) > stoppedDistance)
        {
            transform.position += vectorDirection * speed * Time.deltaTime;
        }
        else
        {
            currentPoint = teleportModel.BoardPoint.finalPoint;
            nextPoint    = NextBoardPosition();
            numberOfMove = 0;
            diceNumber   = 0;
            turnType     = TurnType.Wating;
            CallFinishMoveDelegate();
        }
    }
Ejemplo n.º 7
0
        public void SendCommand(MoveType move, TurnType turn)
        {
            if (!Connected)
            {
                return;
            }

            string command = "";

            if (move == MoveType.Accelerate)
            {
                command += "a";
            }
            else if (move == MoveType.Brake)
            {
                command += "b";
            }
            if (turn == TurnType.Left || turn == TurnType.HardLeft)
            {
                command += "l";
            }
            else if (turn == TurnType.Right || turn == TurnType.HardRight)
            {
                command += "r";
            }
            command += ";";
            SendMessage(command);
        }
Ejemplo n.º 8
0
    void UpdateBrakingForIntersection(Collider other)
    {
        try
        {
            IntersectionLightSingleton intersection = other.transform.gameObject.GetComponentInChildren <IntersectionLightSingleton>();
            TargetNavigation           tv           = GetComponent <TargetNavigation>();
            TurnType         turnType = tv.CurrentTrajectory.Turn;
            IntersectionRoad road     = tv.CurrentTrajectory.Road;
            LightPhase       phase    = (road == IntersectionRoad.Road1) ? intersection.phase.road1 : intersection.phase.road2;
            switch (phase)
            {
            case LightPhase.Green:
                _brakingForRedLight = false;
                break;

            case LightPhase.Yellow:
                _brakingForRedLight = true;
                break;

            case LightPhase.Red:
                _brakingForRedLight = true;
                break;
            }

            Debug.Log("Vehicle performing " + turnType.ToString() + " movement on " + road.ToString() + " has entered IntersectionInteriorVolume when light is " + phase.ToString());
        }
        catch (NullReferenceException ex)
        {
            Debug.Log(ex.Message);
        }

        return;
    }
Ejemplo n.º 9
0
        public void RemoveTurnType(int Id)
        {
            TurnType temp = context.TurnTypes.SingleOrDefault(t => t.Id == Id);

            context.TurnTypes.Remove(temp);
            context.SaveChanges();
        }
Ejemplo n.º 10
0
 public TurnResp(bool success, PlayerColor currentPlayer, TurnType type)
     : base(MessageType.Info)
 {
     this.turnType = type;
     this.success  = success;
     this.player   = currentPlayer;
 }
Ejemplo n.º 11
0
        public static MatchSettings CreateSettingsWithHost(Mode mode = Mode.OneUp, TurnType type = TurnType.Classic)
        {
            var settings = CreateSettings(mode, type);

            settings.Host = UserMockCreator.CreateHost();
            return(settings);
        }
Ejemplo n.º 12
0
 /// <summary>
 /// Collects input from user for passive turn, ensures legality, then executes move.
 /// Also updates Turn properties to reflect upcoming aggressive turn.
 /// </summary>
 private void ExecutePassiveTurn()
 {
     while (!PassiveTurnDone)
     {
         while (!GetUserInputForTurn())
         {
             CurrentGame.Refresh();
         }
         if (MoveLogic.MoveIsLegal(this.CurrentMove))
         {
             ExecuteCurrentMove(this.CurrentMove);
             CurrentPlayer.LastMoveMade = CurrentMove;
             TurnIsPassive        = false;
             PassiveTurnDone      = true;
             this.currentTurnType = TurnType.Aggressive;
         }
         else
         {
             Console.WriteLine(MoveLogic.PrintErrorMessage(this.CurrentMove) + "  Press enter to continue...");
             Console.ReadLine();
             PassiveTurnDone = false;
         }
         CurrentGame.Refresh();
     }
 }
Ejemplo n.º 13
0
 public static MatchSettings CreateSettings(Mode mode = Mode.OneUp, TurnType type = TurnType.Classic) =>
 new MatchSettings
 {
     Mode     = mode,
     TurnType = type,
     TurnTime = 1,
 };
Ejemplo n.º 14
0
        const int Turn_Manual_Down = 493; //D-1

        //手动转动
        public static void Turn(TurnType fx)
        {
            int adr = 0;

            switch (fx)
            {
            case TurnType.Up:
                adr = Turn_Manual_Up;
                break;

            case TurnType.Down:
                adr = Turn_Manual_Down;
                break;
            }
            string send     = "";
            string response = "";

            if (fx == TurnType.Stop)
            {
                send = RegDMW + GetAdrD_1000(Turn_Manual_Up) + "000204" + "00000000";
            }
            else
            {
                send = RegDSW + GetAdrD_1000(adr) + "0001";
            }
            SendPLC(send, "手动转动", out response);
        }
Ejemplo n.º 15
0
        /*public override void LateJoinGame(NetworkReader messageReader)
         * {
         *  // TODO
         * }*/

        protected override void OnStartTurn(TBPlayer player)
        {
            if (tt != TurnType.None)
            {
                Log.Warn("Unexpected TurnType {0} (A)", tt);
            }

            int role = player.GetRole();

            var turtles      = Match.GetTurtlesForRole(role);
            var aliveTurtles = turtles.FindAll(t => !t.dead);

            if (/*turtles == null || */ aliveTurtles.Count == 0)
            {
                Log.Warn("No alive turtles with role {0}", role);
                tt        = TurnType.Wait;
                turnEnded = false;
                StartCoroutine(EndTurnDelayed());
                return;
            }

            tt = TurnType.Keyboard;

            targetTurtle = GetNextTurtle(aliveTurtles);

            targetTurtle.SetPlaying(true);
        }
        public void CreatesOneUp_WhenModeSetToOneUp(Mode mode, TurnType type)
        {
            var match = MatchMockCreator.CreateSettingsWithHost(mode, type)
                        .CreateMatch();

            Assert.Equal(mode, match.Mode);
        }
Ejemplo n.º 17
0
    public void ShowTurn(TurnType current, float time)
    {
        turnText.text = current.ToString();
        float widthScale;

        switch (current)
        {
        case TurnType.MovePiece:
            turnTime        = 0;
            widthScale      = 1 - time / GameManager.inst.turnSystem.turnTimers[current];
            turnImage.color = new Color(0, 1, 0.5f);
            break;

        case TurnType.Attack:
        case TurnType.AttackReady:
            turnTime        = turnTime > 1 ? time + 1 : time;
            widthScale      = turnTime * 0.5f;
            turnImage.color = Color.red;
            break;

        default:
            Debug.LogError("[ERR-ShowTurn] default called");
            widthScale = 1;
            break;
        }
        turnImage.fillAmount = widthScale;
    }
Ejemplo n.º 18
0
        List <PanelAreaType> GetReachPanelAreaTypeList(TurnType turnType)
        {
            var area1 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area1);
            var area2 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area2);
            var area3 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area3);
            var area4 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area4);
            var area5 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area5);
            var area6 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area6);
            var area7 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area7);
            var area8 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area8);
            var area9 = PanelAreaList.FirstOrDefault(x => x.PanelAreaType == PanelAreaType.Area9);

            List <PanelAreaType> reachPanelAreaTypeList = new List <PanelAreaType>();

            // Vertical
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area1, area2, area3);
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area4, area5, area6);
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area7, area8, area9);

            // Horizontal
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area1, area4, area7);
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area2, area5, area8);
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area3, area6, area9);

            // Diagonal
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area1, area5, area9);
            addPanelAreaTypeWhenReach(reachPanelAreaTypeList, turnType, area3, area5, area7);

            return(reachPanelAreaTypeList);
        }
Ejemplo n.º 19
0
 public TurnResp(ErrorCode errorCode, PlayerColor currentPlayer, TurnType type)
     : base(MessageType.Info)
 {
     this.turnType  = type;
     this.success   = false;
     this.errorCode = errorCode;
     this.player    = currentPlayer;
 }
Ejemplo n.º 20
0
    AgentActionType GetTurnedHeading()
    {
        turnIndex += 1;
        turnIndex %= turnPatternLength;
        TurnType turn = turnPattern[turnIndex];

        return(Agent.Turn(heading, turn));
    }
Ejemplo n.º 21
0
    public void ReplaceTurn(TurnType newType)
    {
        var index     = GameComponentsLookup.Turn;
        var component = CreateComponent <TurnComponent>(index);

        component.type = newType;
        ReplaceComponent(index, component);
    }
Ejemplo n.º 22
0
        protected override bool TurnIsOn()
        {
            if (tt == TurnType.Wait)
            {
                if (turnEnded)
                {
                    tt = TurnType.None;
                    return(false);
                }
                else
                {
                    return(true);
                }
            }
            else if (tt != TurnType.Keyboard)
            {
                Log.Warn("Unexpected TurnType {0} (A)", tt);
                return(false);
            }

            if (Time.frameCount % FrameStep == 0)
            {
                SendToServer(MsgType.ClientUpdate, Match.GetState());
            }

            if (targetTurtle.dead)
            {
                tt = TurnType.None;
                return(false);
            }

            float hor   = Input.GetAxis("Horizontal");
            float fire3 = Input.GetAxis("Fire3");

            if (hor > 0)
            {
                targetTurtle.AddTorque(-torque);
            }
            else if (hor < 0)
            {
                targetTurtle.AddTorque(+torque);
            }

            if (fire3 > 0)
            {
                targetTurtle.SetPlaying(false);
                tt = TurnType.None;
                return(false);
            }

            foreach (var t in Match.GetAllTurtles())
            {
                t.SetDead(t.transform.position.y < -1.5f);
            }

            return(true);
        }
Ejemplo n.º 23
0
 // unfortunately this doesn't work out
 public void DoShortTurn(TurnType direction, double time)
 {
     //DoTurn(direction);
     // m_spinTime += time;
     //Stopwatch s = Stopwatch.StartNew();
     //while (s.Elapsed.TotalMilliseconds < time + m_msPadding) ; // spin
     DoTurn(TurnType.Straight);
     m_pendingTurn = TurnType.Straight;
 }
Ejemplo n.º 24
0
        private void OnPlayerTurnEnded(TurnType turnType, int amount)
        {
            Debug.Log("OnPlayerTurnEnded");
            if (turnType == TurnType.Invalid)
            {
                Debug.Log("OnPlayerTurnEnded: invalid turn type.");
                return;
            }

            if (turnType == TurnType.Fold)
            {
                CurrentHand.RemovePlayer(CurrentPlayer);
            }
            else if (turnType == TurnType.Call)
            {
                PutChipsToPot(CurrentPlayer, amount);
                GameController.Instance.UpdatePlayerCard(CurrentPlayerIndex, CurrentPlayer);
                GameController.Instance.UpdatePotSizeTexts(CurrentHand.Pots);
            }
            else if (turnType == TurnType.Raise)
            {
                PutChipsToPot(CurrentPlayer, amount);
                GameController.Instance.UpdatePlayerCard(CurrentPlayerIndex, CurrentPlayer);
                GameController.Instance.UpdatePotSizeTexts(CurrentHand.Pots);
            }
            else if (turnType == TurnType.Bet)
            {
                PutChipsToPot(CurrentPlayer, amount);
                GameController.Instance.UpdatePlayerCard(CurrentPlayerIndex, CurrentPlayer);
                GameController.Instance.UpdatePotSizeTexts(CurrentHand.Pots);
            }
            else if (turnType == TurnType.Check)
            {
                // TODO
            }

            CurrentPlayer.LastTurn = turnType;

            GameController.Instance.HighlightActivePlayer(false);
            GameController.Instance.StopTurnTimer();

            if (!HandHasWinner(CurrentHand))
            {
                if (NeedToDealNextStreet())
                {
                    DealNextStreet();
                }
                else
                {
                    PlayTurn();
                }
            }
            else
            {
                EndHand(CurrentHand);
            }
        }
Ejemplo n.º 25
0
        public void  MakeTurn(Point coordinates, TurnType turnType)
        {
            if (coordinates.X > _gameBoardSize || coordinates.Y > _gameBoardSize)
            {
                throw new IndexOutOfRangeException("Coordinats are out of range");
            }

            GameMap[coordinates.X][coordinates.Y] = (int)turnType;
        }
Ejemplo n.º 26
0
    public void StartBombardmentTurn()
    {
        turnType = TurnType.bombardment;

        UI_Manager.instance.boatPanel.SetUpBoatUI();

        UI_Manager.instance.timelinePanel.NextIconTurn();
        BombardmentManager.Instance.StartBombardment();
    }
Ejemplo n.º 27
0
        // This routine is used to get the graphics path for the page under the current page and the page on the
        // backside of the turning page.  It will return either a triangle or trapezoid graphics path.
        private GraphicsPath GetPageUnderGraphicsPath(int x,
                                                      ref double a,
                                                      int height,
                                                      int width,
                                                      bool isUnderSide,
                                                      TurnType type)
        {
            double radians;
            double calculated_x;
            double calculated_y    = 0d;
            int    undersideOffset = 0;

            GraphicsPath gp = new GraphicsPath();

            if ((type == TurnType.RightPageTurn && isUnderSide) || (type == TurnType.LeftPageTurn && !isUnderSide))
            {
                undersideOffset = width;
            }

            // This is the angle formed at the bottom of the rectangle just under the line of symmetry
            a       = 45d + ((45d * x) / width);
            radians = a * (Math.PI / 180); // convert to radians for the math function

            if (isPathTrapezoid == false)
            {
                calculated_y = (x) * (Math.Tan(radians));
                if (calculated_y > height)
                {
                    isPathTrapezoid = true;
                }
            }

            if (isPathTrapezoid == true)
            {
                gp.AddLine(new PointF(Math.Abs(width - x - undersideOffset), height), new PointF(width - undersideOffset, height));
                gp.AddLine(new PointF(width - undersideOffset, height), new PointF(width - undersideOffset, 0));



                calculated_x = height / Math.Tan(radians);
                // This adds a line to the top of the trapezoid, this is the distance in the horizontal direction
                // that the line of symmetry has traveled.
                gp.AddLine(new Point(width - undersideOffset, 0), new PointF(Math.Abs(width - (x - (float)calculated_x) - undersideOffset), 0));
                gp.CloseFigure();
            }
            else
            {
                // Still a triangle
                calculated_y = (x) * (Math.Tan(radians));
                gp.AddLine(new PointF(Math.Abs(width - x - undersideOffset), height), new PointF(width - undersideOffset, height));
                gp.AddLine(new PointF(width - undersideOffset, height), new PointF(width - undersideOffset, (height - (float)calculated_y)));

                gp.CloseFigure();
            }

            return(gp);
        }
 public void Input(TurnType value)
 {
     foreach (var binding in bindings)
     {
         if (binding.id == value)
         {
             Output.Invoke(GetDirection(binding));
         }
     }
 }
Ejemplo n.º 29
0
    public void Roll()
    {
        var player = Players[CurrentPlayerIndex];

        player.Roll();
        AddText("你投出了" + player.Movement.Vatality);
        AddText("选择一个单位行动吧!");
        CurrentTurn = TurnType.WaitForMove;
        SwithButtons(CurrentTurn);//总是在更新内在内容后更新外在表现
    }
Ejemplo n.º 30
0
    void ExtraAI()
    {
        if (currentNode != null)
        {
            Node node = currentNode.gameObject.GetComponent <Node>();
            if (node != null)
            {
                forwardSpeed = node.SpeedLimit;
            }
        }

        if (nextNode.GetComponent <WaysControl>() && !isTurning)
        {
            isTurning = true;
            oldDir    = transform.forward;
            nextWay   = RandomWay(nextNode, currentNode);
            Vector3 dir1 = nextNode.position - currentNode.position;
            Vector3 dir2 = nextWay.position - nextNode.position;
            dir1.y = 0;
            dir2.y = 0;
            if (Vector3.Angle(dir1, dir2) > 20)
            {
                float turn = Vector3.Cross(dir1, dir2).y;
                nextTurn = (turn > 0) ? TurnType.Right : TurnType.Left;
            }
            else
            {
                nextTurn = TurnType.Straight;
            }
        }

        if (isTurning)
        {
            leftIndicator.SetActive(nextTurn == TurnType.Left);
            rightIndicator.SetActive(nextTurn == TurnType.Right);
            if (nextTurn == TurnType.Straight)
            {
                isTurning = currentNode.GetComponent <Node>();
            }
            else
            {
                diff = Vector3.Angle(oldDir, transform.forward);
                if (diff > 42)
                {
                    isTurning = false;
                }
            }
        }
        else
        {
            leftIndicator.SetActive(false);
            rightIndicator.SetActive(false);
        }
    }
Ejemplo n.º 31
0
        public void HandlePacket(Byte[] buf, int nStreamLength)
        {
            remains.ForcedEncode(buf, nStreamLength);

            while (true)
            {
                if (_curTurn == TurnType.HEADER)
                {
                    if (remains.GetRemainLength() < kHEADER_LENGTH)
                    {
                        break;
                    }
                    else
                    {
                        String type = remains.DecodeString(8);
                        String bodyLength = remains.DecodeString(8);
                        String packetID = remains.DecodeString(8);

                        SetCurPacketTypeAndBodyLength(type, bodyLength, packetID);
                        _curTurn = TurnType.BODY;
                    }
                }

                if (_curTurn == TurnType.BODY)
                {
                    if (remains.GetRemainLength() >= _curBodyLength)
                    {
                        String pbPacket = remains.DecodeString(_curBodyLength);

                        if (_curPacketType == TossPacketType.HTS)
                        {
                            KBHTSTossClient.Ins().HandlePacket(_curPacketID, pbPacket);
                        }
                        else
                        {
                            logger.Error("예상하지 못한 패킷타입 ({0})", _curPacketType);
                            Util.KillWithNotice("Unexpected packet type");
                        }

                        _curTurn = TurnType.HEADER;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            remains.AdvancePivot();
            remains.Shrimp();
        }
Ejemplo n.º 32
0
        public MapCell.FlowDirectionType TurnFlow(MapCell.FlowDirectionType type, TurnType turn)
        {
            switch (type)
            {
                case MapCell.FlowDirectionType.North:
                    return turn == TurnType.Right
                               ? MapCell.FlowDirectionType.NorthEast
                               : MapCell.FlowDirectionType.NorthWest;
                case MapCell.FlowDirectionType.NorthEast:
                    return turn == TurnType.Right
                               ? MapCell.FlowDirectionType.SouthEast
                               : MapCell.FlowDirectionType.North;
                case MapCell.FlowDirectionType.SouthEast:
                    return turn == TurnType.Right
                               ? MapCell.FlowDirectionType.South
                               : MapCell.FlowDirectionType.NorthEast;
                case MapCell.FlowDirectionType.South:
                    return turn == TurnType.Right
                               ? MapCell.FlowDirectionType.SouthWest
                               : MapCell.FlowDirectionType.SouthEast;
                case MapCell.FlowDirectionType.SouthWest:
                    return turn == TurnType.Right
                              ? MapCell.FlowDirectionType.NorthWest
                              : MapCell.FlowDirectionType.South;
                case MapCell.FlowDirectionType.NorthWest:
                    return turn == TurnType.Right
                               ? MapCell.FlowDirectionType.North
                               : MapCell.FlowDirectionType.SouthWest;
            }

            return MapCell.FlowDirectionType.NoFlowdirection;
        }
Ejemplo n.º 33
0
 private void NotifyOnTurnChanged(TurnType _currentTurn)
 {
     if (OnTurnChanged != null)
     {
         OnTurnChanged(_currentTurn);
     }
 }
Ejemplo n.º 34
0
        private void RotateCubeByZAxis(TurnType type)
        {
            Dictionary<CubeFace, CubeFaceType> newCube = new Dictionary<CubeFace, CubeFaceType>();

            if (type.Equals(TurnType.HalfTurnRight))
            {
                newCube.Add(this[CubeFaceType.F], CubeFaceType.L);
                newCube.Add(this[CubeFaceType.L], CubeFaceType.B);
                newCube.Add(this[CubeFaceType.B], CubeFaceType.R);
                newCube.Add(this[CubeFaceType.R], CubeFaceType.F);
                newCube.Add(this[CubeFaceType.U], CubeFaceType.U);
                newCube.Add(this[CubeFaceType.D], CubeFaceType.D);
            }
            else if (type.Equals(TurnType.HalfTurnLeft))
            {
                newCube.Add(this[CubeFaceType.F], CubeFaceType.R);
                newCube.Add(this[CubeFaceType.R], CubeFaceType.B);
                newCube.Add(this[CubeFaceType.B], CubeFaceType.L);
                newCube.Add(this[CubeFaceType.L], CubeFaceType.F);
                newCube.Add(this[CubeFaceType.U], CubeFaceType.U);
                newCube.Add(this[CubeFaceType.D], CubeFaceType.D);
            }
            else
            {
                newCube.Add(this[CubeFaceType.F], CubeFaceType.B);
                newCube.Add(this[CubeFaceType.L], CubeFaceType.R);
                newCube.Add(this[CubeFaceType.B], CubeFaceType.F);
                newCube.Add(this[CubeFaceType.R], CubeFaceType.L);
                newCube.Add(this[CubeFaceType.U], CubeFaceType.U);
                newCube.Add(this[CubeFaceType.D], CubeFaceType.D);
            }

            CubeMap.Clear();
            CubeMap = newCube;
        }
Ejemplo n.º 35
0
 public GameflowModel()
 {
     m_lastNotifiedTime = 0;
     m_currentTurn = TurnType.Pc;
 }
Ejemplo n.º 36
0
 public NeatAiTurnChoice(double weight, int index, TurnType turnType)
 {
     Weight = weight;
     Index = index;
     TurnType = turnType;
 }
    /// <summary>
    /// Alimenta as variáveis de direção para movimentar, pular e as variáveis de animação
    /// </summary>
    private void Setup()
    {
        //animation.wrapMode = WrapMode.Loop;
        //animation["AxeSlash"].layer = 1;
        //animation["AxeSlash"].wrapMode = WrapMode.Once;
        //animation.Play("CombatStance");

        this._currentDirection = DirectionType.NONE;
        this._jumping = false;
        this._run = false;
        this._currentTurn = TurnType.NONE;
        this._currentState = State.RUN;
    }
Ejemplo n.º 38
0
 public void ToogleTurn()
 {
     m_currentTurn = (m_currentTurn == TurnType.Pc) ? TurnType.Player : TurnType.Pc;
     NotifyOnTurnChanged(m_currentTurn);
 }
Ejemplo n.º 39
0
    public void CheckDashboard()
    {
        print("checking dashboard");
        int points = 0;
        bool isSequenceCorrect = true;
        bool lessThanThreePairCards = false;
        int lessThanThreePairCardsCount = 0;

        if (!firstCheckDone)
        {
            print("frist check");
            for (int i = 0; i < dashBoardCardHolder.Count; i++)
            {
                dashBoardCardHolder[i].doNotCheckforsequence = true;
                if (dashBoardCardHolder[i].cardsPositionPoints.Count >= 3)
                {
                    bool numberCheck = true;
                    bool sequenceCheck = true;

                    int number = dashBoardCardHolder[i].cardsPositionPoints[0].cards.number;
                    List<string> cardNames = new List<string>();
                    List<string> tempCardNames = new List<string>();
                    int tempPoints = number;

                    cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[0].cards.cardName);
                    for (int j = 1; j < dashBoardCardHolder[i].cardsPositionPoints.Count; j++)
                    {
                        if (dashBoardCardHolder[i].cardsPositionPoints[j].cards.number == number)
                        {
                            tempPoints += number;
                            cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[j].cards.cardName);
                        }
                        else
                        {
                            print("no number match");
                            numberCheck = false;
                            isSequenceCorrect = false;
                            dashBoardCardHolder[i].doNotCheckforsequence = false;
                            break;
                        }
                    }

                    for (int a = 0; a < cardNames.Count; a++)
                    {
                        if (!ExistInNameList(tempCardNames, cardNames[a]))
                        {
                            tempCardNames.Add(cardNames[a]);
                        }
                        else
                        {
                            print("same color card twice");
                            numberCheck = false;
                            isSequenceCorrect = false;
                            dashBoardCardHolder[i].doNotCheckforsequence = false;
                            break;
                        }
                    }

                    if (numberCheck)
                    {
                        points += tempPoints;
                        print("number match found points = " + points);
                    }
                    else
                    {

                        isSequenceCorrect = true;
                        dashBoardCardHolder[i].doNotCheckforsequence = true;
                        ArrangeCardsByNumber();

                        number = dashBoardCardHolder[i].cardsPositionPoints[0].cards.number;
                        cardNames.Clear();
                        cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[0].cards.cardName);
                        for (int j = 1; j < dashBoardCardHolder[i].cardsPositionPoints.Count; j++)
                        {
                            if ((dashBoardCardHolder[i].cardsPositionPoints[j].cards.number - number) == 1)
                            {
                                number = dashBoardCardHolder[i].cardsPositionPoints[j].cards.number;
                                tempPoints += number;
                                cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[j].cards.cardName);
                            }
                            else
                            {
                                print("no color match");
                                sequenceCheck = false;
                                isSequenceCorrect = false;
                                dashBoardCardHolder[i].doNotCheckforsequence = false;
                                break;
                            }
                        }

                        if (!AreAllElementsSame(cardNames, cardNames[0]))
                        {
                            print("different color card found , no sequence match");
                            sequenceCheck = false;
                            isSequenceCorrect = false;
                            dashBoardCardHolder[i].doNotCheckforsequence = false;
                        }

                        if (sequenceCheck)
                        {
                            points += tempPoints;
                            print("sequence match found points = " + points);
                        }
                    }
                }
                else if (dashBoardCardHolder[i].cardsPositionPoints.Count < 3)
                {
                    print("count less than 3 in i = " + i);
                    lessThanThreePairCards = true;
                    lessThanThreePairCardsCount++;
                    //if(lessThanThreePairCardsCount > 2 || packInitiator.cardsPositionPoints.Count > 0)
                    //dashBoardCardHolder[i].doNotCheckforsequence = false;
                }
            }

            if (points >= 51 && isSequenceCorrect)
            {
                if (lessThanThreePairCards && lessThanThreePairCardsCount <= 2)
                {

                    if (packInitiator.cardsPositionPointsList.Count <= 2)
                    {
                        print("count less than 3 packInitiator.cardsPositionPoints.Count <= 0");
                        turnType = TurnType.none;
                        UIEventHandler.Ins.OpenMenu("GameOverNotification");
                        GameManager.Ins.showGameFinish = true;
                    }
                    else
                    {
                        print("count less than 3 packInitiator.cardsPositionPoints.Count > 0");
                        turnType = TurnType.none;
                        GameManager.Ins.ChangeTurn();
                        firstCheckDone = true;
                    }
                }
                else
                {

                    if (lessThanThreePairCardsCount > 2)
                    {
                        print("lessThanThreePairCardsCount > 2");
                        //dashBoardCardHolder[i].doNotCheckforsequence = false;
                        canTouch = false;
                        showFalseCombinationMenu = true;
                        UIEventHandler.Ins.OpenMenu("WronOrderNotification");
                        UIEventHandler.Ins.arrangementIssueText.text = "You should arrange cards properly, and atleast have 51 points";
                    }
                    else
                    {
                        if (packInitiator.cardsPositionPointsList.Count <= 2)
                        {
                            print("gameover");
                            UIEventHandler.Ins.OpenMenu("GameOverNotification");
                            //dashBoardCardHolder[i].doNotCheckforsequence = true;
                            turnType = TurnType.none;
                            GameManager.Ins.ChangeTurn();
                            firstCheckDone = true;
                        }
                        else
                        {
                            print("count less than 3 packInitiator.cardsPositionPoints.Count > 0");
                            turnType = TurnType.none;
                            GameManager.Ins.ChangeTurn();
                            firstCheckDone = true;
                        }

                    }
                }
            }
            else
            {
                //dashBoardCardHolder[i].doNotCheckforsequence = false;
                for (int i = 0; i < dashBoardCardHolder.Count; i++)
                    dashBoardCardHolder[i].doNotCheckforsequence = false;
                canTouch = false;
                showFalseCombinationMenu = true;
                UIEventHandler.Ins.OpenMenu("WronOrderNotification");
                UIEventHandler.Ins.arrangementIssueText.text = "You should arrange cards properly, and atleast have 51 points";
            }
        }
        else
        {

            for (int i = 0; i < dashBoardCardHolder.Count; i++)
            {
                dashBoardCardHolder[i].doNotCheckforsequence = true;
                if (dashBoardCardHolder[i].cardsPositionPoints.Count >= 3)
                {
                    bool numberCheck = true;
                    bool sequenceCheck = true;

                    int number = dashBoardCardHolder[i].cardsPositionPoints[0].cards.number;
                    List<string> cardNames = new List<string>();
                    List<string> tempCardNames = new List<string>();

                    cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[0].cards.cardName);
                    for (int j = 1; j < dashBoardCardHolder[i].cardsPositionPoints.Count; j++)
                    {
                        if (dashBoardCardHolder[i].cardsPositionPoints[j].cards.number == number)
                        {

                            cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[j].cards.cardName);
                        }
                        else
                        {
                            //print ("no number match");
                            numberCheck = false;
                            isSequenceCorrect = false;
                            dashBoardCardHolder[i].doNotCheckforsequence = false;
                            break;
                        }
                    }

                    for (int a = 0; a < cardNames.Count; a++)
                    {
                        if (!ExistInNameList(tempCardNames, cardNames[a]))
                        {
                            tempCardNames.Add(cardNames[a]);
                        }
                        else
                        {
                            //print("same color card twice");
                            numberCheck = false;
                            isSequenceCorrect = false;
                            dashBoardCardHolder[i].doNotCheckforsequence = false;
                            break;
                        }
                    }

                    if (numberCheck)
                    {

                        //print ("number match found points = "+points);
                    }
                    else
                    {

                        isSequenceCorrect = true;
                        dashBoardCardHolder[i].doNotCheckforsequence = true;
                        ArrangeCardsByNumber();

                        number = dashBoardCardHolder[i].cardsPositionPoints[0].cards.number;
                        cardNames.Clear();
                        cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[0].cards.cardName);
                        for (int j = 1; j < dashBoardCardHolder[i].cardsPositionPoints.Count; j++)
                        {
                            if ((dashBoardCardHolder[i].cardsPositionPoints[j].cards.number - number) == 1)
                            {
                                number = dashBoardCardHolder[i].cardsPositionPoints[j].cards.number;
                                cardNames.Add(dashBoardCardHolder[i].cardsPositionPoints[j].cards.cardName);
                            }
                            else
                            {
                                //print ("no color match");
                                sequenceCheck = false;
                                isSequenceCorrect = false;
                                dashBoardCardHolder[i].doNotCheckforsequence = false;
                                break;
                            }
                        }

                        if (!AreAllElementsSame(cardNames, cardNames[0]))
                        {
                            //print("different color card found , no sequence match");
                            sequenceCheck = false;
                            isSequenceCorrect = false;
                            dashBoardCardHolder[i].doNotCheckforsequence = false;
                        }

                        if (sequenceCheck)
                        {

                            //print ("sequence match found points = "+points);
                        }
                    }
                }
                else if (dashBoardCardHolder[i].cardsPositionPoints.Count < 3)
                {
                    print("count less than 3 in i = " + i);
                    //showFalseCombinationMenu = true;
                    lessThanThreePairCards = true;
                    lessThanThreePairCardsCount++;
                    if (lessThanThreePairCardsCount > 2)
                        dashBoardCardHolder[i].doNotCheckforsequence = false;
                }
            }

            if (isSequenceCorrect)
            {
                //print ("seq correct ");
                if (lessThanThreePairCards && lessThanThreePairCardsCount <= 2)
                {
                    //dashBoardCardHolder[i].doNotCheckforsequence = true;
                    if (packInitiator.cardsPositionPointsList.Count <= 0)
                    {
                        //print ("count less than 3 packInitiator.cardsPositionPoints.Count <= 0");
                        turnType = TurnType.none;
                        //GameManager.Ins.showGameFinish = true;
                        UIEventHandler.Ins.OpenMenu("GameOverNotification");
                        GameManager.Ins.ShowGameOverGUI();
                    }
                    else
                    {
                        //print ("count less than 3 packInitiator.cardsPositionPoints.Count >= 0");
                        if (packInitiator.cardsPositionPointsList.Count <= 2)
                        {
                            UIEventHandler.Ins.OpenMenu("GameOverNotification");
                            turnType = TurnType.none;
                            GameManager.Ins.ChangeTurn();
                        }
                        else
                        {
                            print("count less than 3 packInitiator.cardsPositionPoints.Count > 0");
                            turnType = TurnType.none;
                            GameManager.Ins.ChangeTurn();
                            firstCheckDone = true;
                        }
                    }
                }
                else
                {

                    if (lessThanThreePairCardsCount > 2)
                    {
                        print("greaterThanThreePairCardsCount > 2");
                        //dashBoardCardHolder[i].doNotCheckforsequence = false;
                        canTouch = false;
                        showFalseCombinationMenu = true;
                        UIEventHandler.Ins.OpenMenu("WronOrderNotification");
                        UIEventHandler.Ins.arrangementIssueText.text = "You should arrange cards properly";
                    }
                    else
                    {
                        if (packInitiator.cardsPositionPointsList.Count <= 2)
                        {
                            print("gameover");
                            UIEventHandler.Ins.OpenMenu("GameOverNotification");
                            //dashBoardCardHolder[i].doNotCheckforsequence = true;
                            turnType = TurnType.none;
                            GameManager.Ins.ChangeTurn();
                            firstCheckDone = true;
                        }
                        else
                        {
                            print("count less than 3 packInitiator.cardsPositionPoints.Count > 0");
                            turnType = TurnType.none;
                            GameManager.Ins.ChangeTurn();
                            firstCheckDone = true;
                        }
                    }
                }
            }
            else
            {
                //dashBoardCardHolder[i].doNotCheckforsequence = false;
                canTouch = false;
                showFalseCombinationMenu = true;
                UIEventHandler.Ins.OpenMenu("WronOrderNotification");
                UIEventHandler.Ins.arrangementIssueText.text = "You should arrange cards properly";
            }
        }
    }
Ejemplo n.º 40
0
    public void InitiatePack(List<GameObject> cards)
    {
        if (isMyTurn)
        {
            if (turnType == TurnType.none || turnType == TurnType.pick)
            {
                if (cards.Count > 0)
                {
                    packInitiator.InitiatePack(cards);
                    //					if(!firstCheckDone)
                    //						turnType = TurnType.through;
                    //					else{
                    //						turnType = TurnType.throughtorshow;
                    //					}
                    turnType = TurnType.throughtorshow;
                }
            }
            else
            {
                if (!showChangeTurn)
                {

                    dialog = "Cant pick card,\n" + turnType.ToString() + " one card to pick";
                }
                else
                    dialog = "Cant Pick card,\n" + " Press Change Turn Button";
                UIEventHandler.Ins.OpenMenu("PickCardNotification");
                UIEventHandler.Ins.pickNotificationText.text = dialog;
                //showDialogBox = true;
            }
        }
    }
Ejemplo n.º 41
0
    IEnumerator RevertCardsOnDashboard()
    {
        if (placedDeckCards)
        {
            placedDeckCards.cardType = CardType.hand;
            packInitiator.PlaceDeckCardOnPlayerHands(placedDeckCards);
            ThrownCardsDeck.Ins.RemoveCardFromThrownCards();
            placedDeckCards = null;
        }

        for (int i = 0; i < dashBoardCardHolder.Count; i++)
        {
            // if this dashboard has unmatched cards than revert
            if (!dashBoardCardHolder[i].doNotCheckforsequence)
            {
                for (int j = 0; j < dashBoardCardHolder[i].cardsPositionPoints.Count; j++)
                {
                    if (dashBoardCardHolder[i].cardsPositionPoints[j].transform.childCount >= 1)
                    {
                        dashBoardCardHolder[i].cardsPositionPoints[j].cards.cardType = CardType.hand;
                        packInitiator.PlaceDeckCardOnPlayerHands(dashBoardCardHolder[i].cardsPositionPoints[j].cards);
                    }
                }
            }
        }
        for (int i = dashBoardCardHolder.Count - 1; i > -1; i--)
        {
            if (!dashBoardCardHolder[i].doNotCheckforsequence)
            {
                Destroy(dashBoardCardHolder[i].gameObject);
                dashBoardCardHolder.RemoveAt(i);
            }
        }
        yield return new WaitForSeconds(2.5f);
        if (cardMovementManager.tempCardHolder != null)
            if (pickedDeckCards != null)
                pickedDeckCards.StartAnimation(cardMovementManager.tempCardHolder);
            else
                print("tempCardHolder is null");
        yield return new WaitForSeconds(1f);
        canTouch = true;
        if (pickedDeckCards != null)
        {
            pickedDeckCards.cardType = CardType.deck;
            pickedDeckCards = null;
        }
        if (packInitiator.cardsPositionPointsList.Count >= 15)
            turnType = TurnType.throughtorshow;
        else if (packInitiator.cardsPositionPointsList.Count < 15)
            turnType = TurnType.pick;
    }
 /// <summary>
 /// Altera a variável informa a direção do movimento horizontal, 
 /// é chamada pelo PlayerInput.cs através de um evento do teclado
 /// </summary>
 /// <param name="x"></param>
 public void MovementHorizontal(TurnType x)
 {
     _currentTurn = x;
 }
 /// <summary>
 /// Altera a variável informa a direção do movimento horizontal, 
 /// é chamada pelo PlayerInput.cs através de um evento do teclado
 /// </summary>
 /// <param name="x"></param>
 public void MovementHorizontal(TurnType x)
 {
     _currentTurn = x;
     //if(_currentTurn == TurnType.LEFT)
     //    animation.CrossFade("strafe_left");
     //if (_currentTurn == TurnType.RIGHT)
     //    animation.CrossFade("strafe_right");
 }