Cross

151     void Update()
152     {
153         if (isControllable)
154         {
155             if (Input.GetButtonDown("Jump"))
156             {
157                 lastJumpButtonTime = Time.time;
158             }
159
160             UpdateSmoothedMovementDirection();
161
162             // Apply gravity
163             // - extra power jump modifies gravity
164             // - controlledDescent mode modifies gravity
165             ApplyGravity();
166
167             // Apply jumping logic
168             ApplyJumping();
169
170
171             // Calculate actual motion
172             Vector3 movement = moveDirection * moveSpeed + new Vector3(0, verticalSpeed, 0) + inAirVelocity;
173             movement *= Time.deltaTime;
174
175             //Debug.Log(movement.x.ToString("0.000") + ":" + movement.z.ToString("0.000"));
176
177             // Move the controller
178             CharacterController controller = GetComponent();
179             collisionFlags = controller.Move(movement);
180
181         }
182
183         // PUN: if a remote position is known, we smooth-move to it (being late(r) but smoother)
184         if (this.remotePosition != Vector3.zero)
185         {
186             transform.position = Vector3.Lerp(transform.position, this.remotePosition, Time.deltaTime * this.RemoteSmoothing);
187         }
188
189         velocity = (transform.position - lastPos)*25;
190
191         // ANIMATION sector
192         if (_animation)
193         {
194             if (_characterState == PickupCharacterState.Jumping)
195             {
196                 if (!jumpingReachedApex)
197                 {
198                     _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
199                     _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
200                     _animation.CrossFade(jumpPoseAnimation.name);
201                 }
202                 else
203                 {
204                     _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
205                     _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
206                     _animation.CrossFade(jumpPoseAnimation.name);
207                 }
208             }
209             else
210             {
211                 if (_characterState == PickupCharacterState.Idle)
212                 {
213                     _animation.CrossFade(idleAnimation.name);
214                 }
215                 else if (_characterState == PickupCharacterState.Running)
216                 {
217                     _animation[runAnimation.name].speed = runMaxAnimationSpeed;
218                     if (this.isControllable)
219                     {
220                         _animation[runAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, runMaxAnimationSpeed);
221                     }
222                     _animation.CrossFade(runAnimation.name);
223                 }
224                 else if (_characterState == PickupCharacterState.Trotting)
225                 {
226                     _animation[walkAnimation.name].speed = trotMaxAnimationSpeed;
227                     if (this.isControllable)
228                     {
229                         _animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, trotMaxAnimationSpeed);
230                     }
231                     _animation.CrossFade(walkAnimation.name);
232                 }
233                 else if (_characterState == PickupCharacterState.Walking)
234                 {
235                     _animation[walkAnimation.name].speed = walkMaxAnimationSpeed;
236                     if (this.isControllable)
237                     {
238                         _animation[walkAnimation.name].speed = Mathf.Clamp(velocity.magnitude, 0.0f, walkMaxAnimationSpeed);
239                     }
240                     _animation.CrossFade(walkAnimation.name);
241                 }
242
243                 if (_characterState != PickupCharacterState.Running)
244                 {
245                     _animation[runAnimation.name].time = 0.0f;
246                 }
247             }
248         }
249         // ANIMATION sector
250
251         // Set rotation to the move direction
252         if (IsGrounded())
253         {
254             // a specialty of this controller: you can disable rotation!
255             if (DoRotate)
256             {
257                 transform.rotation = Quaternion.LookRotation(moveDirection);
258             }
259         }
260         else
261         {
262             /* This causes choppy behaviour when colliding with SIDES
263              * Vector3 xzMove = velocity;
264             xzMove.y = 0;
265             if (xzMove.sqrMagnitude > 0.001f)
266             {
267                 transform.rotation = Quaternion.LookRotation(xzMove);
268             }*/
269         }
270
271         // We are in jump mode but just became grounded
272         if (IsGrounded())
273         {
274             lastGroundedTime = Time.time;
275             inAirVelocity = Vector3.zero;
276             if (jumping)
277             {
278                 jumping = false;
279                 SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
280             }
281         }
282
283         lastPos = transform.position;
284     }

41         private void OnGameResult(Game game)
42         {
43             switch (game.CurrentState)
44             {
45                 case GameState.CrossWin:
46                     label.text = "X WIN!";
47                     break;
48                 case GameState.NoughtWin:
49                     label.text = "O WIN!";
50                     break;
51                 case GameState.Draw:
52                     label.text = "DRAW!";
53                     break;
54             }
55
56             Show();
57         }

34         public void Set(Seed seed)
35         {
36             Content = seed;
37
38             switch (seed)
39             {
40                 case Seed.Empty:
41                     spriteCross.SetActive(false);
42                     spriteNought.SetActive(false);
43                     break;
44                 case Seed.Cross:
45                     spriteCross.SetActive(true);
46                     spriteNought.SetActive(false);
47                     break;
48                 case Seed.Nought:
49                     spriteCross.SetActive(false);
50                     spriteNought.SetActive(true);
51                     break;
52             }
53         }

40         public void NewGame()
41         {
42             board.gameObject.SetActive(true);
43             board.Clear();
44             board.SetPlayer(Seed.Cross);
45             CurrentState = GameState.Playing;
46
47             if (NetworkService.IsConnected)
48             {
49                 if (NetworkService.IsMaster)
50                 {
51                     Player1.Name = NetworkService.PlayerName;
52                     Player2.Name = NetworkService.OpponentName;
53
54                     Player1.Type = Seed.Cross;
55                     Player2.Type = Seed.Nought;
56                     board.SetPlayer(Seed.Cross);
57
58                     NetworkService.SendNewGameStarted();
59                 }
60                 else
61                 {
62                     Player1.Name = NetworkService.OpponentName;
63                     Player2.Name = NetworkService.PlayerName;
64
65                     Player1.Type = Seed.Nought;
66                     Player2.Type = Seed.Cross;
67                     board.SetPlayer(Seed.Empty);
68                 }
69             }
70
71             OnGameStartSignal.Dispatch(this);
72         }

142         private void Reset()
143         {
144             Player1 = new Player("Player X", 0, Seed.Cross);
145             Player2 = new Player("Player O", 0, Seed.Nought);
146         }

169         private void OnBoardChange(Seed player, int row, int col)
170         {
171             Seed nextPlayer = Seed.Empty;
172
173             if (board.HasWon(player))
174             {
175                 switch (player)
176                 {
177                     case Seed.Cross:
178                         CurrentState = GameState.CrossWin;
179                         Player1.Score++;
180                         break;
181                     case Seed.Nought:
182                         CurrentState = GameState.NoughtWin;
183                         Player2.Score++;
184                         break;
185                 }
186
187                 OnGameResultSignal.Dispatch(this);
188             }
189             else if (board.IsDraw())
190             {
191                 CurrentState = GameState.Draw;
192                 OnGameResultSignal.Dispatch(this);
193             }
194             else
195             {
196                 nextPlayer = player == Seed.Cross ? Seed.Nought : Seed.Cross;
197             }
198
199             board.SetPlayer(nextPlayer);
200
201             if (NetworkService.IsConnected && player == Player1.Type)
202             {
203                 board.SetPlayer(Seed.Empty);
204                 NetworkService.SendBoardChange(player, row, col);
205             }
206         }

8  public CrossMovement(GCPlayer player, Piece piece) : base(player,piece) {
9   BoundComputations += ComputeBound;
10  }

7  public static IPieceMovement CreatePieceMovement(MovementType movementType, GCPlayer player, Piece piece) {
8   switch (movementType) {
9    case MovementType.KING:
10     return new KingMovement(player, piece);
11    case MovementType.PAWN:
12     return new PawnMovement(player, piece);
13    case MovementType.ROOK:
14     return new RookMovement(player, piece);
15    case MovementType.BISHOP:
16     return new BishopMovement(player, piece);
17    case MovementType.QUEEN:
18     return new QueenMovement(player, piece);
19    case MovementType.KNIGHT:
20     return new KnightMovement(player, piece);
21    case MovementType.CIRCLE:
22     return new CircleMovement(player, piece);
23    case MovementType.CROSS:
24     return new CrossMovement(player, piece);
25    case MovementType.NONE:
26    default:
27     return new NoMovement(player, piece);
28   }
29  }

24  public static bool CheckKing(GCPlayer player, Node checkedByNode, Node checkedNode) {
25   if (checkedNode.Piece.PieceType == PieceType.CROSS) {
26    GameManager.Instance.Opponent(player).CheckedBy = checkedByNode.Piece;
27    //checkedPiece.Node.HighlightCheck(); //Experimental
28    //checkedBy.Node.HighlightCheck(); //Experimental
29    return true;
30   }
31   return false;
32  }