Esempio n. 1
0
    public void Update(float deltaTime, PlayerInputScript player)
    {
        AttackTimer += deltaTime;
        player.UpdateAttackInputVariables(AttackTimer >= blockAttackInputTime, AttackTimer > -blockNewAttackTime);
        if (!hasDamaged && AttackTimer >= damageTime)
        {
            Collider2D[] hits = player.ThrowAttack(attackPosition, attackSize);
            foreach (Collider2D hit in hits)
            {
                HealthComponent healthComponent = hit.GetComponent <HealthComponent>();
                if (healthComponent != null)
                {
                    healthComponent.Damage(damage, Vector2.zero);
                }
                EnemyHand enemyHand = hit.GetComponent <EnemyHand>();
                if (enemyHand != null)
                {
                    //Debug.Log("Test");
                    enemyHand.Damage(damage);
                }
            }
            hasDamaged = true;
        }

        if (AttackTimer >= attackLength)
        {
            player.EndAttack();
        }
    }
Esempio n. 2
0
    // Start is called before the first frame update
    void Start()
    {
        nextActionTime = Time.time + periodmax;
        GameObject audior = GameObject.Find("AudioManager");

        audio     = audior.GetComponent <AudioManager>();
        enemyHand = transform.parent.gameObject.GetComponent <EnemyHand>();
    }
 void Start()
 {
     board        = GameObject.Find("Board").GetComponent <Board>();
     playerHand   = GameObject.Find("Hand").GetComponent <PlayerHand>();
     enemyHand    = GameObject.Find("EnemyDeck");
     computerHand = GameObject.Find("EnemyDeck").GetComponent <EnemyHand>();
     turnState    = GameObject.Find("TurnBasedMachine").GetComponent <TurnBasedStateMachine>();
     discardPile  = GameObject.Find("EnemyDiscardPile").GetComponent <DiscardPile>();
     gameProgress = startGame;
 }
Esempio n. 4
0
 private void HandleActionMessage(ActionMessage message)
 {
     if (message.RecepientId == CurrentPlayer.Id)
     {
         MyHand.UpdateEquipment(message.Players.First(pl => pl.Id == CurrentPlayer.Id).BrokenEquipments);
     }
     else
     {
         EnemyHand.UpdateEquipment(message.Players.First(pl => pl.Id == message.RecepientId).BrokenEquipments);
     }
 }
Esempio n. 5
0
        public override Transform PlayEnemyCard()
        {
            string     spyRowName  = this.ToRow.name.Substring(5);
            GameObject enemySpyRow = GameObject.Find(spyRowName);

            this.ToRow = enemySpyRow.GetComponent <DropZone>();

            EnemyHand ehnd = GameObject.Find("EnemyDeck").GetComponent <EnemyHand>();

            SpyEffect(ehnd);

            return(enemySpyRow.transform);
        }
Esempio n. 6
0
    public void BattleSetup(float setupTimeInSeconds)
    {
        configData = FindObjectOfType <ConfigData>();
        configData.SetupPipManagers(this);
        healthPipManager = configData.GetEnemyHealthPipManager();
        energyPipManager = configData.GetEnemyEnergyPipManager();
        SetupHealthAndEnergyText();

        enemyDeck = FindObjectOfType <EnemyDeck>();
        enemyDeck.SetupDeck(shuffleDeck);

        enemyDiscard = FindObjectOfType <EnemyDiscard>();
        enemyHand    = FindObjectOfType <EnemyHand>();
    }
Esempio n. 7
0
        /// <summary>
        /// Immediately cleans-up the match, destroying all cards in hands, decks and boards.
        /// Prepares everything for new match.
        /// </summary>
        public void CleanUpMatch()
        {
            GameQueue.CleanUp();

            PlayerHand.CleanUp();
            EnemyHand.CleanUp();

            PlayerDeck.CleanUp();
            EnemyDeck.CleanUp();

            CardManager.CleanUp();

            MatchInfo       = null;
            PlayerTurnCount = 0;
            EnemyTurnCount  = 0;
        }
Esempio n. 8
0
        public override void OnResurrect()
        {
            IHand hand;

            if (this.ToRow.name.StartsWith("Enemy"))
            {
                PlayerHand playerHand = GameObject.Find("Hand").GetComponent <PlayerHand>();
                hand = playerHand;
            }
            else
            {
                EnemyHand enemyHand = GameObject.Find("EnemyDeck").GetComponent <EnemyHand>();
                hand = enemyHand;
            }
            SpyEffect(hand);
        }
Esempio n. 9
0
    //when bullet hits enemy
    void OnTriggerEnter2D(Collider2D hitInfo)
    {
        EnemyHand enemyHand = hitInfo.GetComponent <EnemyHand>();

        if (enemyHand != null)
        {
            //Debug.Log("Test");
            enemyHand.Damage(dmg);
        }
        //gets info of object we hit
        Debug.Log(hitInfo.name);
        //once we have an enemy time this will call it's take damage function
        //it takes damage


        Destroy(gameObject);
    }
Esempio n. 10
0
    void Start()
    {
        //Inicialización de general
        general = GameObject.FindGameObjectWithTag("General").GetComponent <General>();

        //Inicialización de las variables de verificación
        bloqueando = false;

        //Inicialización de la dificultad del Enemy
        dificultad = PlayerPrefs.GetFloat("EnemyLevel");

        //Inicialización de velocidad de movimiento
        velocidadMovimiento = 0.05f;

        //Inicialización d la vida
        vida = 10;

        //Inicialización del componente de TextMesh Vida
        vidaText      = gameObject.transform.Find("Vida").GetComponent <TextMesh>();
        vidaText.text = vida.ToString();

        //Inicialización de los Componentes del player
        player         = GameObject.FindGameObjectWithTag("Player");
        handPlayer     = player.transform.Find("Hand").gameObject;
        playerMovement = player.GetComponent <PlayerMovement>();

        //Inicialización de los Componentes de este gameobject (Enemy)
        animator = gameObject.GetComponent <Animator>();
        rg       = gameObject.GetComponent <Rigidbody2D>();

        //Inicialización de los Componentes de Hand de este gameobject (Enemy)
        hand                         = gameObject.transform.Find("Hand").gameObject;
        enemyHand                    = hand.GetComponent <EnemyHand>();
        enemyHand.animator           = animator;
        enemyHand.dificultad         = dificultad;
        enemyHand.segundosEntreGolpe = (1f / 10f) * (10 - dificultad) + 0.1f;

        //Inicialización de los Componentes de AttackArea de este gameobject (Enemy)
        attackArea                          = gameObject.transform.Find("AttackArea").gameObject;
        enemyAttackArea                     = attackArea.GetComponent <EnemyAttackArea>();
        enemyAttackArea.player              = player;
        enemyAttackArea.enemyHand           = enemyHand;
        enemyAttackArea.playerMovement      = playerMovement;
        enemyAttackArea.tiempoReaccionGolpe = (1f / 10f) * (10 - dificultad) + 0.1f;
    }
Esempio n. 11
0
        /// <summary>
        /// Starts a match. Creates all necessary game objects and cards.
        /// </summary>
        /// <param name="matchInfo">Information about initial state of the match. See MatchInfo.</param>
        public void StartMatch(MatchInfo matchInfo)
        {
            MatchInfo = matchInfo;

            CreateBoardObjects();
            PlayerDeck.FillWithCards(matchInfo.PlayerDeckCards);
            EnemyDeck.FillWithCards(matchInfo.EnemyDeckCards);
            PlayerHand.FillWithCards(matchInfo.PlayerStartingHandCards);
            EnemyHand.FillWithCards(matchInfo.EnemyStartingHandCards);

            PlayerHero.MaxHealth = PlayerHero.CurrentHealth = matchInfo.PlayerHealth;
            EnemyHero.MaxHealth  = EnemyHero.CurrentHealth = matchInfo.EnemyHealth;

            PlayerResources.Init(matchInfo.PlayerStartingResource);
            EnemyResources.Init(matchInfo.EnemyStartingResource);


            if (matchInfo.PlayerAmountOfCardDrawBeforeGame > 0)
            {
                PlayerHand.ImmidiatelyTakeCardsFromDeck(PlayerDeck, matchInfo.PlayerAmountOfCardDrawBeforeGame);
            }

            if (matchInfo.EnemyAmountOfCardDrawBeforeGame > 0)
            {
                EnemyHand.ImmidiatelyTakeCardsFromDeck(EnemyDeck, matchInfo.EnemyAmountOfCardDrawBeforeGame);
            }

            if (matchInfo.PlayerGoesFirst)
            {
                StartPlayerTurn();
            }
            else
            {
                StartEnemyTurn();
            }
        }
Esempio n. 12
0
    // Use this for initialization
    void Start()
    {
        gameplay = this;

        _MainCamera = (Camera)gameObject.GetComponent("Camera");

        _SelectionListWindow = new SelectionListWindow(Screen.width / 2, Screen.height / 2 + 100);

        _AbilityManagerList = new SelectionListGenericWindow(Screen.width / 2, Screen.height / 2 + 100);

        _SelectionCardNameWindow = new SelectionCardNameWindow(Screen.width / 2 - 50, Screen.height / 2);
        _SelectionCardNameWindow.CreateCardList();
        _SelectionCardNameWindow.SetGame(this);

        _DecisionWindow = new DecisionWindow(Screen.width / 2, Screen.height / 2 + 100);
        _DecisionWindow.SetGame(this);

        _NotificationWindow = new NotificacionWindow(Screen.width / 2, Screen.height / 2 + 100);
        _NotificationWindow.SetGame(this);

        FromHandToBindList = new List<Card>();

        AttackedList = new List<Card>();

        UnitsCalled = new List<Card>();

        EnemySoulBlastQueue = new List<Card>();

        _PopupNumber = new PopupNumber();

        _MouseHelper = new MouseHelper(this);
        GameChat = new Chat();

        opponent = PlayerVariables.opponent;

        playerHand = new PlayerHand();
        enemyHand = new EnemyHand();

        field = new Field(this);
        enemyField = new EnemyField(this);
        guardZone = new GuardZone();
        guardZone.SetField(field);
        guardZone.SetEnemyField(enemyField);
        guardZone.SetGame(this);

        fieldInfo = new FieldInformation();
        EnemyFieldInfo = new EnemyFieldInformation();

        Data = new CardDataBase();
        List<CardInformation> tmpList = Data.GetAllCards();
        for(int i = 0; i < tmpList.Count; i++)
        {
            _SelectionCardNameWindow.AddNewNameToTheList(tmpList[i]);
        }

        //camera = (CameraPosition)GameObject.FindGameObjectWithTag("MainCamera").GetComponent("CameraPosition");
        //camera.SetLocation(CameraLocation.Hand);

        LoadPlayerDeck();
        LoadEnemyDeck();

        gamePhase = GamePhase.CHOOSE_VANGUARD;

        bDrawing = true;
        bIsCardSelectedFromHand = false;
        bPlayerTurn = false;

        bDriveAnimation = false;
        bChooseTriggerEffects = false;
        DriveCard = null;

        //Texture showed above a card when this is selected for an action (An attack, for instance)
        CardSelector = GameObject.FindGameObjectWithTag("CardSelector");
        _CardMenuHelper = (CardHelpMenu)GameObject.FindGameObjectWithTag("CardMenuHelper").GetComponent("CardHelpMenu");
        _GameHelper = (GameHelper)GameObject.FindGameObjectWithTag("GameHelper").GetComponent("GameHelper");

        bPlayerTurn = PlayerVariables.bFirstTurn;

        //ActivePopUpQuestion(playerDeck.DrawCard());
        _CardMenu = new CardMenu(this);

        _AbilityManager = new AbilityManager(this);
        _AbilityManagerExt = new AbilityManagerExt();

        _GameHelper.SetChat(GameChat);
        _GameHelper.SetGame(this);

        EnemyTurnStackedCards = new List<Card>();

        dummyUnitObject = new UnitObject();
        dummyUnitObject.SetGame(this);

        stateDynamicText = new DynamicText();
    }