public override void Execute()
        {
            if(startTargetModel.targetingCard.isSpell) return;

            var phantomPiece = pieces.Pieces.FirstOrDefault(p => p.tags.Contains(Constants.targetPieceTag));

            if (phantomPiece != null)
            {
                //skip spawning if there's already the phantom piece out, like in a choose action
                debug.Log("Phantom piece already spawned");
                return;
            }

            var spawnedPiece = new SpawnPieceModel
            {
                cardTemplateId = startTargetModel.targetingCard.cardTemplateId,
                pieceId = -1,
                playerId = startTargetModel.targetingCard.playerId,
                position = startTargetModel.cardDeployPosition.position.ToPositionModel(),
                tags = new List<string>() { Constants.targetPieceTag },
                direction = Direction.South
            };

            var pieceModel = pieceService.CreatePiece(spawnedPiece);
            animationQueue.Add(new PieceView.SpawnAnim() {
                piece = pieceModel.gameObject.GetComponent<PieceView>(),
                map = map,
                mapService = mapService
            });

            //Skip sending out the piece spawned signal since it hasn't actually properly been spawned yet
            //pieceSpawned.Dispatch(pieceModel);
            debug.Log("Spawned phantom target piece");
        }
Esempio n. 2
0
        public override void Execute()
        {
            var leftChoice = chooseModel.choices.choices[0];
            var rightChoice = chooseModel.choices.choices[1];

            //create new card models based on the template id's, with fake real id's since they're not real cards
            var leftCardModel = cardDirectory.NewFromTemplate(998, leftChoice.cardTemplateId, chooseModel.choosingCard.playerId);
            var rightCardModel = cardDirectory.NewFromTemplate(998, rightChoice.cardTemplateId, chooseModel.choosingCard.playerId);

            leftCardModel.tags.Add(Constants.chooseCardTag);
            rightCardModel.tags.Add(Constants.chooseCardTag);

            cardService.CreateCard(leftCardModel, null, rightSpawnPosition);
            cardService.CreateCard(rightCardModel, null, rightSpawnPosition);

            var leftGameObject = leftCardModel.gameObject;
            var rightGameObject = rightCardModel.gameObject;

            leftGameObject.name = "Left Choice Card";
            rightGameObject.name = "Right Choice Card";

            cardService.SetupGameObject(leftCardModel, leftGameObject);
            leftCardModel.SetCardInPlay(contextView);

            cardService.SetupGameObject(rightCardModel, rightGameObject);
            rightCardModel.SetCardInPlay(contextView);

            SetCardXPos(leftCardModel, -140f);
            SetCardXPos(rightCardModel, 140f);

            //spawn phantom piece if needed
            //should dedupe with StartSelectTargetCommand if happens again
            if (chooseModel.choosingCard.isMinion)
            {
                var spawnedPiece = new SpawnPieceModel
                {
                    cardTemplateId = chooseModel.choosingCard.cardTemplateId,
                    pieceId = -1,
                    playerId = chooseModel.choosingCard.playerId,
                    position = chooseModel.cardDeployPosition.position.ToPositionModel(),
                    tags = new List<string>() { Constants.targetPieceTag },
                    direction = Direction.South
                };

                var pieceModel = pieceService.CreatePiece(spawnedPiece);
                animationQueue.Add(new PieceView.SpawnAnim()
                {
                    piece = pieceModel.gameObject.GetComponent<PieceView>(),
                    map = map,
                    mapService = mapService
                });
            }

            debug.Log(string.Format("Choices setup"));
        }
Esempio n. 3
0
        public PieceModel CreatePiece(SpawnPieceModel spawnedPiece, string name = null)
        {
            GameObject pieceModelResource = resourceLoader.Load<GameObject>("Models/" + spawnedPiece.cardTemplateId + "/prefab");

            var piecePrefab = resourceLoader.Load<GameObject>("Piece");

            //position is x and z from server, and y based on the map
            var spawnPosition = map.tiles[spawnedPiece.position.Vector2].fullPosition;

            var newPiece = GameObject.Instantiate(
                piecePrefab,
                spawnPosition,
                Quaternion.identity
            ) as GameObject;
            newPiece.transform.parent = contextView.transform;
            newPiece.name = "Piece " + spawnedPiece.pieceId;

            //Set up new model if we have one
            if (pieceModelResource != null)
            {
                var pieceModelChild = newPiece.transform.FindChild("Model");
                pieceModelChild.DestroyChildren(true);
                var newModelInstance = GameObject.Instantiate(pieceModelResource, pieceModelChild, false) as GameObject;
                newModelInstance.transform.localPosition = Vector3.zero;
                //newModelInstance.transform.localRotation = Quaternion.Euler(new Vector3(-90f, 0, 0));
            }

            var opponentId = gamePlayers.OpponentId(turnModel.currentPlayerId);
            var cardTemplate = cardDirectory.Card(spawnedPiece.cardTemplateId);

            var pieceModel = new PieceModel()
            {
                id = spawnedPiece.pieceId.Value,
                playerId = spawnedPiece.playerId,
                cardTemplateId = spawnedPiece.cardTemplateId,
                currentPlayerHasControl = spawnedPiece.playerId != opponentId,
                gameObject = newPiece,
                attack = cardTemplate.attack,
                health = cardTemplate.health,
                baseAttack = cardTemplate.attack,
                baseHealth = cardTemplate.health,
                tilePosition = spawnPosition.ToTileCoordinates(),
                direction = spawnedPiece.direction,
                movement = cardTemplate.movement,
                baseMovement = cardTemplate.movement,
                range = cardTemplate.range,
                baseRange = cardTemplate.range,
                tags = spawnedPiece.tags,
                buffs = new List<PieceBuffModel>(),
                statuses = cardTemplate.statuses,
            };

            SetInitialMoveAttackStatus(pieceModel);

            var pieceView = newPiece.AddComponent<PieceView>();
            pieceView.piece = pieceModel;
            pieceView.opponentId = opponentId;
            pieceView.currentTurnPlayerId = turnModel.currentPlayerId;

            piecesModel.Pieces.Add(pieceModel);

            return pieceModel;
        }