void Awake()
 {
     decision_grid  = FindObjectOfType <DecisionGrid>();
     game_settings  = FindObjectOfType <GameSettings>();
     my_characters  = gameObject.GetComponent <MyCharacters>();
     curr_char_text = FindObjectOfType <CurrCharText>();
     status_text    = FindObjectOfType <StatusText>();
 }
Exemplo n.º 2
0
 void Awake()
 {
     my_text_obj      = GetComponentInChildren <Text>();
     curr_char_text   = FindObjectOfType <CurrCharText>();
     event_controller = FindObjectOfType <EventControllerMain>();
     my_transform     = gameObject.transform;
     my_characters    = FindObjectOfType <MyCharacters>();
     background       = GetComponentInChildren <CharacterBackground>();
 }
Exemplo n.º 3
0
        public IEnumerable <MyCharacters> GetCharactersByUserName([FromRoute] string username)
        {
            Users user = _context.Users.SingleOrDefault(e => e.Username == username);


            List <Characters> userCharacters = _context.Characters.ToList().FindAll(m => m.UserIdFk == user.UserId);

            //creates a list of player characters formatted for a table  without keys
            List <MyCharacters> playerCharacters = new List <MyCharacters>();

            foreach (Characters character in userCharacters)
            {
                MyCharacters characters = new MyCharacters();
                characters.Class         = _context.Classes.ToList().Find(m => m.ClassId == character.ClassIdFk).ClassName;
                characters.CharacterName = character.FullName;
                playerCharacters.Add(characters);
            }

            return(playerCharacters);
        }
Exemplo n.º 4
0
        // Use this for initialization
        void Start()
        {
            StartCoroutine(DirectionLoop());

            PunchEnd.SetActive(false);
            DmgEffect.SetActive(false);
            MyTurnLogo.SetActive(false);
            DetailCard.gameObject.SetActive(false);
            OpBuffs.Concat(MeBuffs).ToObservable()
            .Subscribe(buff => buff.SetActive(false));

            NetworkManager.Instance.onGameStartedNotifier
            .Subscribe(msg => {
                GetComponent <AudioSource>().clip = GameBGM;
                GetComponent <AudioSource>().Play();
                NetworkUI.Instance.gameObject.SetActive(false);
                WinUI.SetActive(false);
                LoseUI.SetActive(false);
                MyCostText.text   = $"{msg.cost}";
                OpCostText.text   = $"{msg.enemyCost}";
                MyHp              = msg.hp;
                OpHp              = msg.enemyHP;
                MyHpText.text     = $"{msg.hp}";
                OpHpText.text     = $"{msg.enemyHP}";
                MyPortrait.sprite = Portraits[msg.faceId];
                OpPortrait.sprite = Portraits[msg.enemyFaceId];
                msg.negativeHand.Concat(msg.positiveHand).ToObservable()
                .Subscribe(id => {
                    AddDirection(true, close => {
                        GetComponent <AudioSource>().PlayOneShot(DrawClip);
                        var card = SpawnCard(id);
                        (card.Card.IsNegative ? NegHands : PosHands).Add(card);
                        AlignCards();
                        Timer(0.6f, close);
                    });
                });
            });
            NetworkManager.Instance.onTurnStartedNotifier
            .Subscribe(msg => {
                var isMyTurn = msg.clientId == NetworkManager.Instance.clientId;
                var obj      = isMyTurn ? MyTurn : OpTurn;
                MyTurnLogo.SetActive(isMyTurn);
                msg.negative.Concat(msg.positive).ToObservable()
                .Subscribe(id => {
                    Debug.Log($"draw card {id}");
                    AddDirection(true, close => {
                        GetComponent <AudioSource>().PlayOneShot(DrawClip);
                        var card = SpawnCard(id);
                        (card.Card.IsNegative ? NegHands : PosHands).Add(card);
                        AlignCards();
                        Timer(0.6f, close);
                    });
                });
                AddDirection(true, close => {
                    obj.SetActive(true);
                    Timer(3f, () => {
                        obj.SetActive(false);
                        close();
                    });
                });
            });
            NetworkManager.Instance.onTurnActionRespondedNotifier
            .Subscribe(msg => {
                if (msg.approved)
                {
                    if (pendingCard != null)
                    {
                        (pendingCard.Card.IsNegative ? NegHands : PosHands).Remove(pendingCard);
                        if (pendingCard.Card.Id / 100 == 2 || pendingCard.Card.Id / 100 == 4)
                        {
                            AddDirection(true, close => {
                                pendingCard.transform.DOScale(Vector3.zero, 0.3f);
                                Timer(0.3f, () => {
                                    close();
                                    GameObject.Destroy(pendingCard.gameObject);
                                });
                            });
                            AlignCards();
                        }
                    }
                }
                else
                {
                    pendingCard = null;
                    AlignCards();
                }
                waitActionResponse = false;
            });
            NetworkManager.Instance.onTurnActionEventNotifier
            .Subscribe(msg => {
                switch (msg.turnActionEvent)
                {
                case TurnActionEvent.CardUsed:
                    {
                        if (msg.playerId == NetworkManager.Instance.clientId)
                        {
                            return;
                        }
                        if ((msg.cardId / 100) % 2 != 0)
                        {
                            return;
                        }
                        var card = SpawnCard(msg.cardId);
                        card.transform.position = OpUseCardFrom.transform.position;
                        AddDirection(true, close => {
                            card.transform.DOMove(OpUseCardTo.transform.position, 0.5f);
                            card.transform.DOScale(Vector3.one * 1.3f, 0.5f);
                            Timer(1.5f, close);
                        });
                        AddDirection(true, close => {
                            card.transform.DOScale(Vector3.zero, 0.3f);
                            card.transform.DORotate(new Vector3(0, 0, 720), 0.3f, RotateMode.LocalAxisAdd);
                            Timer(0.3f, () => {
                                GameObject.Destroy(card.gameObject);
                                close();
                            });
                        });
                    }
                    break;

                case TurnActionEvent.PlayerDamaged:
                    {
                        var attacker = MyCharacters.Concat(OpCharacters).FirstOrDefault(c => c.InstanceId == msg.instanceId);
                        if (attacker == null)
                        {
                            return;
                        }
                        var pos    = (msg.playerId == NetworkManager.Instance.clientId ? MyDmgPos : OpDmgPos).position;
                        var oldPos = attacker.transform.position;
                        pos        = pos + (oldPos - pos).normalized * 100;
                        AddDirection(true, close => {
                            attacker.transform.DOMove(pos, 0.4f).SetEase(Ease.InBounce);
                            Timer(0.3f, () => {
                                attacker.transform.DOMove(oldPos, 0.3f);
                                close();
                            });
                        });
                    }
                    break;

                case TurnActionEvent.CharacterDamaged:
                    {
                        var attacker = MyCharacters.Concat(OpCharacters).FirstOrDefault(c => c.InstanceId == msg.instanceIdDamager);
                        var attackee = MyCharacters.Concat(OpCharacters).FirstOrDefault(c => c.InstanceId == msg.instanceIdDamagee);
                        if (attacker == null || attackee == null)
                        {
                            return;
                        }
                        var pos    = attackee.transform.position;
                        var oldPos = attacker.transform.position;
                        pos        = pos + (oldPos - pos).normalized * 100;
                        AddDirection(true, close => {
                            attacker.transform.DOMove(pos, 0.4f).SetEase(Ease.InBounce);
                            Timer(0.3f, () => {
                                attacker.transform.DOMove(oldPos, 0.3f);
                                close();
                            });
                        });
                    }
                    break;

                case TurnActionEvent.Instantiated:
                    {
                        if (pendingCard != null && pendingCard.Card.Id == msg.cardId)
                        {
                            var card             = pendingCard;
                            pendingCard          = null;
                            card.IsCharacterCard = true;
                            card.InstanceId      = msg.instanceId;
                            card.SetHP(msg.hp);
                            card.SetAttack(msg.attack);
                            (msg.playerId == NetworkManager.Instance.clientId ? MyCharacters : OpCharacters)
                            .Add(card);
                            AddDirection(true, close => {
                                AlignCards();
                                Timer(0.6f, close);
                            });
                        }
                        else
                        {
                            var card             = SpawnCard(msg.cardId);
                            card.IsCharacterCard = true;
                            card.InstanceId      = msg.instanceId;
                            card.SetHP(msg.hp);
                            card.SetAttack(msg.attack);
                            (msg.playerId == NetworkManager.Instance.clientId ? MyCharacters : OpCharacters)
                            .Add(card);
                            AddDirection(true, close => {
                                AlignCards();
                                Timer(0.6f, close);
                            });
                        }
                    }
                    break;

                case TurnActionEvent.StateChanged:
                    {
                        Debug.Log($"{msg.playerId} {msg.hp} {msg.cost}");
                        if (msg.playerId == NetworkManager.Instance.clientId)
                        {
                            var dmg         = MyHp - msg.hp;
                            MyHp            = msg.hp;
                            MyHpText.text   = $"<b>{msg.hp}</b>";
                            MyCostText.text = $"<b>{msg.cost}</b>";
                            if (dmg > 0)
                            {
                                AddDirection(true, close => {
                                    GetComponent <AudioSource>().PlayOneShot(AttackClip);
                                    DmgEffect.transform.position = MyDmgPos.position;
                                    DmgText.text = $"{dmg}";
                                    DmgEffect.SetActive(true);
                                    DmgEffect.transform.DOShakePosition(0.6f);
                                    GameUI.transform.DOShakePosition(0.4f, 30, 30);
                                    Timer(0.8f, () => {
                                        DmgEffect.SetActive(false);
                                        close();
                                    });
                                });
                            }
                        }
                        else
                        {
                            var dmg         = OpHp - msg.hp;
                            OpHp            = msg.hp;
                            OpHpText.text   = $"<b>{msg.hp}</b>";
                            OpCostText.text = $"<b>{msg.cost}</b>";
                            if (dmg > 0)
                            {
                                AddDirection(true, close => {
                                    GetComponent <AudioSource>().PlayOneShot(AttackClip);
                                    DmgEffect.transform.position = OpDmgPos.position;
                                    DmgText.text = $"{dmg}";
                                    DmgEffect.SetActive(true);
                                    DmgEffect.transform.DOShakePosition(0.6f);
                                    GameUI.transform.DOShakePosition(0.4f, 30, 30);
                                    Timer(0.8f, () => {
                                        DmgEffect.SetActive(false);
                                        close();
                                    });
                                });
                            }
                            else
                            {
                                GetComponent <AudioSource>().PlayOneShot(HealClip);
                            }
                        }
                    }
                    break;

                case TurnActionEvent.CharacterStateChanged:
                    {
                        var card = OpCharacters.FirstOrDefault(c => c.InstanceId == msg.instanceId);
                        if (card != null)
                        {
                            Debug.Log($"CharacterStateChanged op {card.Card.Name} {msg.hp} {msg.attack}");
                            if (card._HP != msg.hp)
                            {
                                // 데미지
                                AddDirection(true, close => {
                                    GetComponent <AudioSource>().PlayOneShot(AttackClip);
                                    var dmg = card._HP - msg.hp;
                                    DmgEffect.transform.position = card.transform.position;
                                    DmgText.text = $"{dmg}";
                                    DmgEffect.SetActive(true);
                                    DmgEffect.transform.DOShakePosition(0.6f);
                                    GameUI.transform.DOShakePosition(0.4f, 30, 30);
                                    Timer(0.8f, () => {
                                        card.SetHP(msg.hp);
                                        card.SetAttack(msg.attack);
                                        DmgEffect.SetActive(false);
                                        close();
                                    });
                                });
                            }
                            else
                            {
                                card.SetHP(msg.hp);
                                card.SetAttack(msg.attack);
                            }


                            return;
                        }
                        card = MyCharacters.FirstOrDefault(c => c.InstanceId == msg.instanceId);
                        if (card != null)
                        {
                            Debug.Log($"CharacterStateChanged me {card.Card.Name} {msg.hp} {msg.attack}");
                            if (card._HP != msg.hp)
                            {
                                // 데미지
                                AddDirection(true, close => {
                                    GetComponent <AudioSource>().PlayOneShot(AttackClip);
                                    var dmg = card._HP - msg.hp;
                                    DmgEffect.transform.position = card.transform.position;
                                    DmgText.text = $"{dmg}";
                                    DmgEffect.SetActive(true);
                                    DmgEffect.transform.DOShakePosition(0.6f);
                                    GameUI.transform.DOShakePosition(0.4f, 30, 30);
                                    Timer(0.8f, () => {
                                        card.SetHP(msg.hp);
                                        card.SetAttack(msg.attack);
                                        DmgEffect.SetActive(false);
                                        close();
                                    });
                                });
                            }
                            else
                            {
                                card.SetHP(msg.hp);
                                card.SetAttack(msg.attack);
                            }
                        }
                    }
                    break;

                case TurnActionEvent.Destroyed:
                    {
                        var card = OpCharacters.FirstOrDefault(c => c.InstanceId == msg.instanceId);
                        if (card != null)
                        {
                            Debug.Log($"Destroyed op {card.Card.Name}");
                            AddDirection(true, close => {
                                card.transform.DOScale(Vector3.one * 0.1f, 0.5f);
                                Timer(0.6f, () => {
                                    OpCharacters.Remove(card);
                                    GameObject.Destroy(card.gameObject);
                                    close();
                                });
                            });
                            AddDirection(true, close => {
                                AlignCards();
                                Timer(0.6f, close);
                            });
                            return;
                        }
                        card = MyCharacters.FirstOrDefault(c => c.InstanceId == msg.instanceId);
                        if (card != null)
                        {
                            Debug.Log($"Destroyed me {card.Card.Name}");
                            AddDirection(true, close => {
                                card.transform.DOScale(Vector3.one * 0.1f, 0.5f);
                                Timer(0.6f, () => {
                                    MyCharacters.Remove(card);
                                    GameObject.Destroy(card.gameObject);
                                    close();
                                });
                            });
                            AddDirection(true, close => {
                                AlignCards();
                                Timer(0.6f, close);
                            });
                        }
                    }
                    break;

                case TurnActionEvent.BuffAttached:
                    {
                        Debug.Log($"add buff {msg.playerId} {msg.buffName}");
                        var buffs     = msg.playerId == NetworkManager.Instance.clientId ? MeBuffs : OpBuffs;
                        var emptyBuff = buffs.FirstOrDefault(b => !b.activeSelf);
                        if (emptyBuff != null)
                        {
                            emptyBuff.SetActive(true);
                            emptyBuff.GetComponentInChildren <Text>().text = $"<b>{msg.buffName}</b>";
                            emptyBuff.transform.localScale = Vector3.zero;
                            AddDirection(true, close => {
                                emptyBuff.transform.DOScale(Vector3.one, 0.5f);
                                emptyBuff.transform.DOShakeRotation(0.5f, 90, 20);
                                Timer(0.5f, close);
                            });
                        }
                    }
                    break;

                case TurnActionEvent.BuffRemoved:
                    {
                        Debug.Log($"remove buff {msg.playerId} {msg.buffName}");
                        var buffs     = msg.playerId == NetworkManager.Instance.clientId ? MeBuffs : OpBuffs;
                        var emptyBuff = buffs.FirstOrDefault(b => b.activeSelf && b.GetComponentInChildren <Text>().text == $"<b>{msg.buffName}</b>");
                        if (emptyBuff != null)
                        {
                            AddDirection(true, close => {
                                emptyBuff.transform.DOScale(Vector3.zero, 0.5f);
                                emptyBuff.transform.DOShakeRotation(0.5f, 90, 20);
                                Timer(0.5f, () => {
                                    emptyBuff.SetActive(false);
                                    close();
                                });
                            });
                        }
                    }
                    break;
                }
            });
            NetworkManager.Instance.onGameEndedNotifier
            .Subscribe(msg => {
                if (msg.winner == NetworkManager.Instance.clientId)
                {
                    WinUI.SetActive(true);
                    WinUI.transform.DORotate(new Vector3(0, 0, 720), 5, RotateMode.LocalAxisAdd);
                    WinUI.transform.localScale = Vector3.zero;
                    WinUI.transform.DOScale(Vector3.one, 5);

                    GetComponent <AudioSource>().clip = WinBGM;
                    GetComponent <AudioSource>().Play();
                }
                else
                {
                    LoseUI.SetActive(true);
                    LoseUI.transform.DORotate(new Vector3(0, 0, 720), 5, RotateMode.LocalAxisAdd);
                    LoseUI.transform.localScale = Vector3.zero;
                    LoseUI.transform.DOScale(Vector3.one, 5);
                    GetComponent <AudioSource>().clip = LoseBGM;
                    GetComponent <AudioSource>().Play();
                }
            });
        }