Ejemplo n.º 1
0
 public override void Update(GameTime gameTime, Player player)
 {
     camera.Update(gameTime);
     if (health < 0)
     {
         Console.WriteLine("Veikejas padvese");
         if (!eventCalled)
         {
             OnChanged(EventArgs.Empty);
             eventCalled = true;
         }
     }
     floatDamage.Update(gameTime);
 }
Ejemplo n.º 2
0
        public override void Update(GameTime gameTime, Player player)
        {
            if (health > 0)
            {
                if (this.BoundingBox.Intersects(player.BoundingBox) && Vector2.Distance(moveSprite.Position, player.Sprite.Position) < 10)
                {
                    attacking = true;
                }
                if (!beenHit && !attacking)
                {
                    deathSprite.IsAnimating = false;
                    hitSprite.IsAnimating   = false;

                    //---------------------------------------------
                    //Meginimas padaryti ai
                    Vector2 enemyPosition = moveSprite.Position;
                    enemyPosition.X += 24;
                    enemyPosition.Y += 40;

                    Vector2 playerPosition = player.Sprite.Position;
                    playerPosition.X += 24;
                    playerPosition.Y += 40;

                    int degrees = GetDegrees(enemyPosition, playerPosition);

                    if (Vector2.Distance(enemyPosition, playerPosition) < visionRange)
                    {
                        path.EnemyPosition  = Engine.VectorToCellIso(enemyPosition);
                        path.PlayerPosition = Engine.VectorToCellIso(playerPosition);
                        if (Engine.VectorToCellIso(enemyPosition) == Engine.VectorToCellIso(playerPosition))
                        {
                            Vector2 direction = playerPosition - enemyPosition;
                            direction.Normalize();

                            moveSprite.IsAnimating = true;
                            moveSprite.Position   += direction * moveSprite.Speed;
                        }
                        else
                        {
                            pathDelayCounter--;
                            if (pathDelayCounter <= 0)
                            {
                                path.FindPath();
                                pathDelayCounter = 20;
                            }

                            Vector2 lastNodeCenter = GetNodeCenterPosition(path.LastPosition);
                            Vector2 prevLastNodeCenter;
                            Vector2 goToPosition;
                            if (path.PreviousLastPosition.X != -1)
                            {
                                prevLastNodeCenter = GetNodeCenterPosition(path.PreviousLastPosition);
                                goToPosition.X     = (prevLastNodeCenter.X + lastNodeCenter.X) / 2;
                                goToPosition.Y     = (prevLastNodeCenter.Y + lastNodeCenter.Y) / 2;
                            }
                            else
                            {
                                goToPosition = lastNodeCenter;
                            }

                            Vector2 direction = goToPosition - enemyPosition;
                            direction.Normalize();

                            moveSprite.IsAnimating = true;
                            moveSprite.Position   += direction * moveSprite.Speed;
                        }
                    }
                    else
                    {
                        moveSprite.IsAnimating = false;
                    }
                    //---------------------------------------
                    hitSprite.Position    = moveSprite.Position;
                    attackSprite.Position = moveSprite.Position;
                    deathSprite.Position  = moveSprite.Position;

                    moveSprite.LockToMap();
                    SetCurrentAnimation(moveSprite, degrees);
                    moveSprite.Update(gameTime);
                }
                else if (beenHit)
                {
                    if (enemyAttackSoundBank.IsInUse == false)
                    {
                        enemyAttackSoundBank.PlayCue(hitCue);
                    }

                    hitSprite.AnimateOnceAndResume = true;

                    deathSprite.IsAnimating = false;
                    moveSprite.IsAnimating  = false;
                    hitSprite.IsAnimating   = true;

                    int degrees = GetDegrees(moveSprite.Position, player.Sprite.Position);

                    hitSprite.LockToMap();
                    SetCurrentAnimation(hitSprite, degrees);
                    hitSprite.Update(gameTime);
                    if (!hitSprite.AnimateOnceAndResume)
                    {
                        beenHit = false;
                    }
                }
                else if (attacking)
                {
                    if (enemyAttackSoundBank.IsInUse == false)
                    {
                        enemyAttackSoundBank.PlayCue(attackCue);
                    }
                    attackSprite.AnimateOnceAndResume = true;

                    deathSprite.IsAnimating  = false;
                    moveSprite.IsAnimating   = false;
                    hitSprite.IsAnimating    = false;
                    attackSprite.IsAnimating = true;

                    int degrees = GetDegrees(moveSprite.Position, player.Sprite.Position);

                    if (attackSprite.CurrentAnimationFrame > attackDelayCounter && hasAttacked == false)
                    {
                        hasAttacked = true;
                        if (this.BoundingBox.Intersects(player.BoundingBox))
                        {
                            if (IntersectsPixel(this.BoundingBox, this.TextureData, player.BoundingBox, player.TextureData))
                            {
                                player.TakeDamage(damage);
                            }
                        }
                    }

                    attackSprite.LockToMap();
                    SetCurrentAnimation(attackSprite, degrees);
                    attackSprite.Update(gameTime);
                    if (!attackSprite.AnimateOnceAndResume)
                    {
                        attacking   = false;
                        hasAttacked = false;
                    }
                }
            }
            else
            {
                if (!eventCalled)
                {
                    OnChanged(EventArgs.Empty);
                    enemyAttackSoundBank.PlayCue(deathCue);
                    eventCalled = true;
                    timeOfDeath = gameTime.TotalGameTime.Seconds;
                }
                if ((gameTime.TotalGameTime.Seconds - timeOfDeath) > 10)
                {
                    removeThisElement = true;
                }
                deathSprite.AnimateOnce = true;

                moveSprite.IsAnimating  = false;
                hitSprite.IsAnimating   = false;
                deathSprite.IsAnimating = true;



                deathSprite.LockToMap();
                deathSprite.Update(gameTime);
            }
            enemyAttack.Update();
            floatDamage.Update(gameTime);
        }