public EnemyBullet(EnemyDirection pDirection, Level pLevel)
: base("enemybullet.png")
{
_level = pLevel;
direction = pDirection;
_level.enemyBulletList.Add(this);
}
/// <summary>
/// Moves the Enemy in the UpDown movement pattern.
/// </summary>
/// <param name="pathLength">The length of the path for the Enemy to move along.</param>
protected void UDWalk(int pathLength)
{
// Track the number of pixels the Enemy moves
travelled += speed;
// Check direction of Enemy and move appropriately
if (enemyDirection == EnemyDirection.Down)
{
position.Y += speed;
}
else
{
position.Y -= speed;
}
// Change direction if distance has been traveled
if (travelled >= pathLength)
{
// Reset distance traveled
travelled = 0;
// Reverse the Enemy's direction
if (enemyDirection == EnemyDirection.Down)
{
enemyDirection = EnemyDirection.Up;
}
else
{
enemyDirection = EnemyDirection.Down;
}
}
}
// Constructors
/// <summary>
/// Constructs an Enemy Character.
/// </summary>
/// <param name="position">The Rectangle representing the Enemy's position and size.</param>
/// <param name="texture">The Texture2D representing the Enemy's texture.</param>
/// <param name="health">The Enemy's health.</param>
/// <param name="weapon">The Enemy's Weapon.</param>
/// <param name="attackInterval">The time between the Enemy's attacks.</param>
/// <param name="bodyDamage">The damage the Enemy deals with it's body.</param>
/// <param name="maxWidth">The distance the Enemy can walk in the x direction.</param>
/// <param name="maxHeight">The disatance the Enemy can walk in the y direction.</param>
/// <param name="speed">The Enemy's speed.</param>
/// <param name="name">The Enemy's name.</param>
/// <param name="enemyMovementType">The Enemy's type of movement.</param>
/// <param name="player">The Player Character.</param>
/// <param name="random">A Random number generator.</param>
public Enemy(Rectangle position, Texture2D texture, int health, Weapon weapon, int attackInterval, int bodyDamage, int maxWidth, int maxHeight, int speed, string name, EnemyMovementType enemyMovementType, Player player, Random random) : base(position, texture, health, weapon)
{
// Initialize Fields
this.attackInterval = attackInterval;
this.bodyDamage = bodyDamage;
this.currentFrame = random.Next(1000);
this.maxHeight = maxHeight;
this.maxWidth = maxWidth;
this.speed = speed;
this.travelled = 0;
this.name = name;
this.enemyMovementType = enemyMovementType;
this.player = player;
this.random = random;
// Initialize start direction dependent on the EnemyMovementType
if (enemyMovementType == EnemyMovementType.LeftRight)
{
enemyDirection = EnemyDirection.Right;
}
else if (enemyMovementType == EnemyMovementType.Random)
{
randomDirectionNumber = random.Next(0, 8);
}
else if (enemyMovementType == EnemyMovementType.Rectangle)
{
enemyDirection = EnemyDirection.Right;
}
else if (enemyMovementType == EnemyMovementType.UpDown)
{
enemyDirection = EnemyDirection.Down;
}
}
/*
* This function updates the enemy image depending on the direction that the enemy is move. It takes the enemy's
* current facing direction as its argument.
*/
public void SetFacingDirection(EnemyDirection direction)
{
//update enemy's image based on its direction
switch (direction)
{
case EnemyDirection.Down:
paintImage = downImage;
break;
case EnemyDirection.Left:
paintImage = leftImage;
break;
case EnemyDirection.Up:
paintImage = upImage;
break;
case EnemyDirection.Right:
paintImage = rightImage;
break;
default:
break;
}
}
/// <summary>
/// Moves the Enemy in the LeftRight movement pattern.
/// </summary>
/// <param name="pathLength">The length of the path for the Enemy to move along.</param>
protected void LRWalk(int pathLength)
{
// Track the number of pixels the Enemy moves
travelled += speed;
// Check direction for the Enemy and move appropriately
if (enemyDirection == EnemyDirection.Right)
{
position.X += speed;
}
else
{
position.X -= speed;
}
// Checks if Enemy has traveled full distance of pattern direction
if (travelled >= pathLength)
{
// Reset distance traveled
travelled = 0;
// Reverse the Enemy's direction
if (enemyDirection == EnemyDirection.Right)
{
enemyDirection = EnemyDirection.Left;
}
else
{
enemyDirection = EnemyDirection.Right;
}
}
}
/// <summary>
/// Constructs a copy of an Enemy Character.
/// </summary>
/// <param name="enemy">The Enemy to copy.</param>
public Enemy(Enemy enemy) : base(new Rectangle(enemy.Position.X, enemy.Position.Y, enemy.Position.Width, enemy.Position.Height), enemy.Texture, enemy.Health, enemy.Weapon)
{
// Initialize Fields
this.attackInterval = enemy.attackInterval;
this.bodyDamage = enemy.bodyDamage;
this.maxHeight = enemy.maxHeight;
this.maxWidth = enemy.maxWidth;
this.speed = enemy.speed;
this.travelled = 0;
this.name = enemy.name;
this.enemyMovementType = enemy.enemyMovementType;
this.player = enemy.player;
this.random = enemy.random;
this.currentFrame = random.Next(1000);
// Initialize start direction dependent on the EnemyMovementType
if (enemyMovementType == EnemyMovementType.LeftRight)
{
enemyDirection = EnemyDirection.Right;
}
else if (enemyMovementType == EnemyMovementType.Random)
{
randomDirectionNumber = random.Next(0, 8);
}
else if (enemyMovementType == EnemyMovementType.Rectangle)
{
enemyDirection = EnemyDirection.Right;
}
else if (enemyMovementType == EnemyMovementType.UpDown)
{
enemyDirection = EnemyDirection.Down;
}
}
public Enemy(float x = 0, float y = 0)
: base(x, y)
{
onGround = false;
id = 4;
dir = EnemyDirection.StandingRight;
}
// Start is called before the first frame update
void Start()
{
InvokeRepeating("shootBullet", 0.0f, 2.0f);
// init bullet data
bulletPrefab = Resources.Load("Prefabs/Enemy Bullet") as GameObject;
enemySprite = this.GetComponent <SpriteRenderer>();
orientation = EnemyDirection.Right;
//text = text.GetComponent<Unity>
}
/// <summary>
/// Switches the direction of the current enemy.
/// </summary>
/// <param name="direction">The direction to switch to.</param>
void DoDirectionSwitch(EnemyDirection direction)
{
rigidBody.velocity = constantVelocity * (int)direction; // set direction
Vector2 pos = transform.position;
pos.y -= moveDownAmount;
transform.position = pos;
currentDirection = direction;
}
public Enemy(ContentManager Content) : base(Content)
{
Direction = spriteFacing = EnemyDirection.ToLeft;
layerDepth = LayerManager.GetLayerDepth(Layer.Enemies);
EnableHealthBar = true;
GameManager.AddEntity(this);
movingSpeed = 1f;
attackSpeed = 1f;
spaceCash = 10;
}
/// <summary>
/// Switches the directions of all the enemies.
/// </summary>
/// <param name="direction">The direction to switch to.</param>
void SwitchAllDirections(EnemyDirection direction)
{
if (direction != currentDirection) // only switch if it's changed
{
foreach (var en in enemies.Where(e => e != null))
{
en.gameObject.GetComponent <MiniGameEnemy>().DoDirectionSwitch(direction);
}
}
}
void Start()
{
rb = GetComponent <Rigidbody>();
movement = Vector3.zero;
enemyDirection = EnemyDirection.Forward;
rayColor = Color.blue;
}
private void Start()
{
enemyDirection = (EnemyDirection)Random.Range(1, 9);
var dir = DefineDirection();
direction = new Vector2(dir.Item1, dir.Item2);
GameEvents.Current.OnPlayerFuelPickup += OnPlayerFuelPickup;
GameEvents.Current.OnPlayerItemPickup += OnPlayerItemPickup;
GameEvents.Current.OnGameOver += OnGameOver;
GameEvents.Current.OnPaused += OnPaused;
}
void ChangeState()
{
int randState;
do
{
randState = Random.Range(0, (int)EnemyDirection.Search);
}while (randState == (int)enemyDirection);
randState = randState % ((int)EnemyDirection.Search);
enemyDirection = ((EnemyDirection)randState);
}
public Vector3 boundsCenterOffset; //边界中心
void Awake()
{
if (this.transform.position.x < 8)
{
direction = EnemyDirection.LEFT_TO_RIGHT;
}
else
{
direction = EnemyDirection.RIGHT_TO_LEFT;
}
//0f后开始，没2f调用一次CheckOffScreen
//InvokeRepeating ("CheckOffScreen", 0f , 2f);
}
/*
* This function allows the enemy to move down
*/
void MoveDown()
{
//update the y location
y += speed * Main.deltaTime;
boundingBox.Location = new PointF(x, y);
//update the distance enemy has traveled
if (y >= STARTING_Y_LOCATION)
{
distanceTraveled += speed * Main.deltaTime;
}
//update the enemy direction
moveDirection = EnemyDirection.Down;
}
private void SwapDir()
{
if (dir == EnemyDirection.Left)
{
dir = EnemyDirection.Right;
transform.position = new Vector3(horizontalLimits.x + 0.1f, transform.position.y, transform.position.z);
}
else
{
dir = EnemyDirection.Left;
transform.position = new Vector3(horizontalLimits.y - 0.1f, transform.position.y, transform.position.z);
}
}
public BossMech(int x, int y, Texture2D enemyTextureRight, Texture2D enemyTextureLeft, Texture2D enemyTextureDead, Texture2D chargerightsprite, Texture2D chargeleftsprite, Texture2D bullettexture, int windowx, int windowy)
: base(100, 15, 1, new Vector2(x, y), enemyTextureRight, enemyTextureLeft, enemyTextureDead)
{
this.bullettexture = bullettexture;
sheildhitbox = new Rectangle((int)enemyPosition.X + 50 + bosssizex / 2, (int)enemyPosition.Y + 25, bosssizex / 2, bosssizey);
enemyHitBox = new Rectangle((int)enemyPosition.X + 50, (int)enemyPosition.Y + 25, bosssizex / 2, bosssizey);
bullets = new List <EnemyBullet>();
this.windowsizex = windowx;
this.windowsizey = windowy;
prevdirection = EnemyFacing;
deathframes = 0;
this.chargerightsprite = chargerightsprite;
this.chargeleftsprite = chargeleftsprite;
}
public Enemy(string pFileName, int pColumns, int pRows, Level pLevel, EnemyPoints pPoints, EnemyHealth pHealth, EnemyDirection pEnemyDirection = EnemyDirection.left, bool pMirrow = true)
: base(pFileName, pColumns, pRows)
{
_level = pLevel;
_state = EnemyState.idle;
_points = pPoints;
_healthmax = pHealth;
_health = (float)_healthmax;
_enemyDirection = pEnemyDirection;
Mirror(pMirrow, false);
_hitTimer = 0f;
_idleTimer = 0f;
_deathHitAnimationTimer = 0;
}
private void HandleBouncingEnemyFromWall(Enemy enemy)
{
double nextX = enemy.Position.X;
double nextY = enemy.Position.Y;
EnemyDirection currentDir = enemy.MoveDirection;
// left wall
if (nextX == 0 && currentDir == EnemyDirection.SouthWest)
{
currentDir = EnemyDirection.SouthEast;
}
else if (nextX == 0 && currentDir == EnemyDirection.NorthWest)
{
currentDir = EnemyDirection.NorthEast;
}
// up wall
else if (nextY == 0 && currentDir == EnemyDirection.NorthEast)
{
currentDir = EnemyDirection.SouthEast;
}
else if (nextY == 0 && currentDir == EnemyDirection.NorthWest)
{
currentDir = EnemyDirection.SouthWest;
}
// right wall
else if (nextX == GameArea.ActualWidth - CELL_WIDTH && currentDir == EnemyDirection.SouthEast)
{
currentDir = EnemyDirection.SouthWest;
}
else if (nextX == GameArea.ActualWidth - CELL_WIDTH && currentDir == EnemyDirection.NorthEast)
{
currentDir = EnemyDirection.NorthWest;
}
// down wall
else if (nextY == GameArea.ActualHeight - CELL_HEIGHT && currentDir == EnemyDirection.SouthWest)
{
currentDir = EnemyDirection.NorthWest;
}
else if (nextY == GameArea.ActualHeight - CELL_HEIGHT && currentDir == EnemyDirection.SouthEast)
{
currentDir = EnemyDirection.NorthEast;
}
enemy.MoveDirection = currentDir;
}
// Update is called 60 times per frame
void FixedUpdate()
{
this.transform.position =
Vector3.MoveTowards(this.transform.position, GameManager.player.transform.position, SPEED);
enemySprite.flipX = (orientation == EnemyDirection.Left) ? true : false;
this.transform.rotation = Quaternion.identity;
if (GameManager.player.transform.position.x > this.transform.position.x)
{
orientation = EnemyDirection.Right;
}
else
{
orientation = EnemyDirection.Left;
}
}
// Converts an enemy direction into the appropriate Vector2
public Vector2 VectorFromEnemyDirection(EnemyDirection direction)
{
switch (direction)
{
case EnemyDirection.Left:
return(Vector2.left);
case EnemyDirection.Right:
return(Vector2.right);
case EnemyDirection.Up:
return(Vector2.up);
case EnemyDirection.Down:
return(Vector2.down);
default:
return(Vector2.zero);
}
}
public void TurnBullet(PlayerDirection pDirection)
{
if (pDirection == PlayerDirection.left)
{
direction = EnemyDirection.right;
Mirror(false, false);
}
if (pDirection == PlayerDirection.right)
{
direction = EnemyDirection.left;
Mirror(true, false);
}
if (pDirection == PlayerDirection.up)
{
direction = EnemyDirection.up;
}
if (pDirection == PlayerDirection.down)
{
direction = EnemyDirection.down;
}
}
void Start()
{
Red = new Color32(255, 0, 0, 255);
Blue = new Color32(0, 55, 255, 255);
SpawnCounter = -1;
EnemyCounter = 0;
CurrentSpawningUnit = "";
SpawnableEnemyPositionIndexes = new List <EnemyDirection>();
for (int i = 0; i < 32; i++)
{
for (int j = 0; j < 32; j++)
{
if (i == 0 || j == 0 || i == 32 - 1 || j == 32 - 1)
{
EnemyDirection enemyInfo;
if (i == 0)
{
enemyInfo = new EnemyDirection(i * 32 + j, 1);
SpawnableEnemyPositionIndexes.Add(enemyInfo);
//GameObject.Find(SpawnableEnemyPositionIndexes[SpawnableEnemyPositionIndexes.Count-1].ToString()).GetComponent<Renderer>().material.color = Red;
}
else if (j == 0)
{
enemyInfo = new EnemyDirection(i * 32 + j, 2);
SpawnableEnemyPositionIndexes.Add(enemyInfo);
}
else if (i == 32 - 1)
{
enemyInfo = new EnemyDirection(i * 32 + j, 3);
SpawnableEnemyPositionIndexes.Add(enemyInfo);
}
else if (j == 32 - 1)
{
enemyInfo = new EnemyDirection(i * 32 + j, 4);
SpawnableEnemyPositionIndexes.Add(enemyInfo);
}
}
}
}
}
/// <summary>
/// 今の番号と移動先の番号で方向を変える関数
/// </summary>
/// <param name="current_">今の番号x,y</param>
/// <param name="next_">移動先の番号x,y</param>
void directionChange(int current_x_, int current_y_, int next_x_, int next_y_)
{
if (current_y_ > next_y_)
{
direction = EnemyDirection.UP;
return;
}
else if (current_y_ < next_y_)
{
direction = EnemyDirection.DOWN;
return;
}
if (current_x_ < next_x_)
{
direction = EnemyDirection.RIGHT;
return;
}
else if (current_x_ > next_x_)
{
direction = EnemyDirection.LEFT;
}
}
/*protected override void SetUpCollision()
{
SetCollisionUnit(new CollisionUnit(this, image.GetTranslation(), image.GetTranslation() + new Vector2(image.Width, image.Height), CollisionUnit.CollisionType.COLLISION_BOX, null, false));
this.mCollisionUnit.SetSolid(true);
}*/
public override void Update(GameTime gameTime)
{
base.Update(gameTime);
if (this.GetVelocity().X > 0)
{
if(dir != EnemyDirection.Right)
{
dir = EnemyDirection.Right;
this.SpriteImage.SetAnimation("EnemyWalkRight");
}
}
else if (this.GetVelocity().X < 0)
{
if (dir != EnemyDirection.Left)
{
dir = EnemyDirection.Left;
this.SpriteImage.SetAnimation("EnemyWalkLeft");
}
}
else
{
if (dir == EnemyDirection.Right)
dir = EnemyDirection.StandingRight;
else if (dir == EnemyDirection.Left)
dir = EnemyDirection.StandingLeft;
}
}
/// <summary>
/// Moves the Enemy in the Rectangle movement pattern.
/// </summary>
/// <param name="pathXLength">The length of the path for the Enemy to move in the x direction.</param>
/// <param name="pathYLength">The length of the path for the Enemy to move in the y direction.</param>
protected void RectangleWalk(int pathXLength, int pathYLength)
{
// Track the number of pixels the Enemy moves
travelled += speed;
// Check direction for the Enemy and move appropriately
if (enemyDirection == EnemyDirection.Right)
{
// Move in the x direction
position.X += speed;
// Change direction if distance has been traveled
if (travelled >= pathXLength)
{
// Reset distance traveled
travelled = 0;
// Change the Enemy's direction
enemyDirection = EnemyDirection.Down;
}
}
else if (enemyDirection == EnemyDirection.Left)
{
// Move in the x direction
position.X -= speed;
// Change direction if distance has been traveled
if (travelled >= pathXLength)
{
// Reset distance traveled
travelled = 0;
// Change the Enemy's direction
enemyDirection = EnemyDirection.Up;
}
}
else if (enemyDirection == EnemyDirection.Up)
{
// Move in the y direction
position.Y -= speed;
// Change direction if distance has been traveled
if (travelled >= pathYLength)
{
// Reset distance traveled
travelled = 0;
// Change the Enemy's direction
enemyDirection = EnemyDirection.Right;
}
}
else
{
// Move in the y direction
position.Y += speed;
// Change direction if distance has been traveled
if (travelled >= pathYLength)
{
// Reset distance traveled
travelled = 0;
// Change the Enemy's direction
enemyDirection = EnemyDirection.Left;
}
}
}
public void SetEnemyDirection(EnemyDirection enemyDirection_)
{
enemyDirection = enemyDirection_;
}
//Auto Correct enemy movement to Waypoint
IEnumerator ExecuteKnockback()
{
AdjustVertical = true;
VerticalSpeed = 0;
float storeTime = movementActionCountdown;
if (KnockBackDirection.Equals(CollideDirection.RIGHT) || KnockBackDirection.Equals(CollideDirection.LEFT))
{
while (movementActionCountdown >= storeTime / 2)
{
if (KnockBackDirection.Equals(CollideDirection.RIGHT))
{
EnemyRB.velocity = new Vector2(knockBackForce * 1.5f, VerticalSpeed * KnockBackForce);
}
else if (KnockBackDirection.Equals(CollideDirection.LEFT))
{
EnemyRB.velocity = new Vector2(-knockBackForce * 1.5f, VerticalSpeed * KnockBackForce);
}
else if (KnockBackDirection.Equals(CollideDirection.UP))
{
EnemyRB.velocity = new Vector2(EnemyRB.velocity.x, -VerticalSpeed * KnockBackForce);
}
else if (KnockBackDirection.Equals(CollideDirection.DOWN))
{
EnemyRB.velocity = new Vector2(EnemyRB.velocity.x, VerticalSpeed * KnockBackForce);
}
yield return(new WaitForFixedUpdate());
}
VerticalSpeed = 0;
//Debug.Log(movementActionCountdown);
while (movementActionCountdown >= 0)
{
if (KnockBackDirection.Equals(CollideDirection.RIGHT))
{
EnemyRB.velocity = new Vector2(knockBackForce * 1.5f, -VerticalSpeed * KnockBackForce);
}
else if (KnockBackDirection.Equals(CollideDirection.LEFT))
{
EnemyRB.velocity = new Vector2(-knockBackForce * 1.5f, -VerticalSpeed * KnockBackForce);
}
else if (KnockBackDirection.Equals(CollideDirection.UP))
{
EnemyRB.velocity = new Vector2(EnemyRB.velocity.x, -VerticalSpeed * KnockBackForce);
}
else if (KnockBackDirection.Equals(CollideDirection.DOWN))
{
EnemyRB.velocity = new Vector2(EnemyRB.velocity.x, VerticalSpeed * KnockBackForce);
}
yield return(new WaitForFixedUpdate());
}
}
else if (KnockBackDirection.Equals(CollideDirection.UP) || KnockBackDirection.Equals(CollideDirection.DOWN))
{
while (movementActionCountdown >= 0)
{
if (KnockBackDirection.Equals(CollideDirection.UP))
{
EnemyRB.velocity = new Vector2(EnemyRB.velocity.x, -VerticalSpeed * KnockBackForce);
}
else if (KnockBackDirection.Equals(CollideDirection.DOWN))
{
EnemyRB.velocity = new Vector2(EnemyRB.velocity.x, VerticalSpeed * KnockBackForce);
}
yield return(new WaitForFixedUpdate());
}
}
AdjustVertical = false;
VerticalSpeed = 0;
isKnockBack = false;
if (!EnemyDirection.Equals(KnockBackDirection))
{
if (KnockBackDirection.Equals(CollideDirection.LEFT))
{
EnemyDirection = Direction.LEFT;
}
if (KnockBackDirection.Equals(CollideDirection.RIGHT))
{
EnemyDirection = Direction.RIGHT;
}
}
yield break;
}
//임의의 방향과 z 값으로 소환하고 싶을때 사용,
//일반적으로는 SpawnEnemy(prefab,line)을 사용하고 이 함수는 쓰지 않는다.
void SpawnEnemy(GameObject prefab, EnemyDirection direction, float z)
{
int directionSign = (int)direction;
EnemyPool.Spawn(prefab, new Vector3(600 * -directionSign, 0, z), Quaternion.Euler(0f, 90f * directionSign, 0f));
}
public async void MoveEnemies()
{
double EnemyMoveLength = 4;
foreach (Enemy enemies in Enemies)
{
int move = rng.Next(4);
double lastX = Canvas.GetLeft(enemies.UiElement), lastY = Canvas.GetTop(enemies.UiElement);
if (move == 0)
{
enemyDirection = EnemyDirection.Left;
}
else if (move == 1)
{
enemyDirection = EnemyDirection.Down;
}
else if (move == 2)
{
enemyDirection = EnemyDirection.Right;
}
else if (move == 3)
{
enemyDirection = EnemyDirection.Up;
}
switch (enemyDirection)
{
case EnemyDirection.Left:
if (lastX <= enemyHalf.ActualWidth - enemyHalf.ActualWidth)
{
lastX += EnemyMoveLength;
Canvas.SetLeft(enemies.UiElement, lastX);
Canvas.SetLeft(enemies.Healthbar, lastX);
}
else
{
lastX -= EnemyMoveLength;
Canvas.SetLeft(enemies.UiElement, lastX);
Canvas.SetLeft(enemies.Healthbar, lastX);
}
break;
case EnemyDirection.Down:
if (lastY >= enemyHalf.ActualHeight)
{
lastY -= EnemyMoveLength;
Canvas.SetTop(enemies.UiElement, lastY);
Canvas.SetTop(enemies.Healthbar, lastY - barTop);
}
else
{
lastY += EnemyMoveLength;
Canvas.SetTop(enemies.UiElement, lastY);
Canvas.SetTop(enemies.Healthbar, lastY - barTop);
}
break;
case EnemyDirection.Right:
if (lastX >= enemyHalf.ActualWidth)
{
lastX -= EnemyMoveLength;
Canvas.SetLeft(enemies.UiElement, lastX);
Canvas.SetLeft(enemies.UiElement, lastX);
}
else
{
lastX += EnemyMoveLength;
Canvas.SetLeft(enemies.UiElement, lastX);
Canvas.SetLeft(enemies.Healthbar, lastX);
}
break;
case EnemyDirection.Up:
if (lastY <= enemyHalf.ActualHeight - enemyHalf.ActualHeight)
{
lastY += EnemyMoveLength;
Canvas.SetTop(enemies.UiElement, lastY);
Canvas.SetTop(enemies.Healthbar, lastY - barTop);
}
else
{
lastY -= EnemyMoveLength;
Canvas.SetTop(enemies.UiElement, lastY);
Canvas.SetTop(enemies.Healthbar, lastY - barTop);
}
break;
default:
break;
}
}
if (isReach())
{
if (gameTickTimer.IsEnabled)
{
for (int i = Enemies.Count - 1; i >= 0; i--)
{
if (Canvas.GetLeft(Enemies[i].UiElement) >= Canvas.GetLeft(player.UiElement) && Canvas.GetLeft(Enemies[i].UiElement) + Enemies[i].UiElement.DesiredSize.Width <= Canvas.GetLeft(player.UiElement) + player.UiElement.DesiredSize.Width)
{
Rectangle enemyShot = new Rectangle()
{
Width = 5, Height = 5, Fill = Brushes.Black
};
gameField.Children.Add(enemyShot);
Canvas.SetLeft(enemyShot, Canvas.GetLeft(Enemies[i].UiElement) + Enemies[i].UiElement.DesiredSize.Width / 2);
Canvas.SetTop(enemyShot, Canvas.GetTop(Enemies[i].UiElement));
for (double j = Canvas.GetTop(enemyShot); j <= gameField.ActualHeight; j++)
{
await Task.Delay(1);
Canvas.SetTop(enemyShot, j);
}
}
}
}
}
}
//make the enemy turn around
public virtual void TurnAround()
{
x -= _velocityX;
_velocityX *= -1;
//scaleX *= -1;
if (_enemyDirection == EnemyDirection.left)
{
Mirror(false, false);
_enemyDirection = EnemyDirection.right;
}
else
{
Mirror(true, false);
_enemyDirection = EnemyDirection.left;
}
}
// Flips an enemy to face / move the opposite direction
private void FlipEnemy()
{
enemyDirectionVector *= -1;
gameObject.GetComponent <SpriteRenderer>().flipX = !gameObject.GetComponent <SpriteRenderer>().flipX;
enemyDirection = EnemyDirectionFromVector(enemyDirectionVector);
}
public override void Update(Player player, GameTime gameTime)
{
if (Health > 0)
{
CheckAndDealDamage(player);
Console.WriteLine(EnemyFacing);
if (IsDamaged)
{
hurttime += gameTime.ElapsedGameTime.TotalSeconds;
if (hurttime > InvicibilityTimerAfterDamaged)
{
hurttime = 0;
IsDamaged = false;
}
}
foreach (EnemyBullet b in bullets)
{
b.Update(player);
}
if (!charging)
{
if (player.PlayerPosition.X < enemyPosition.X)
{
EnemyFacing = EnemyDirection.Left;
}
else
{
EnemyFacing = EnemyDirection.Right;
}
}
if (bullets.Count > 0)
{
Console.WriteLine(bullets[0].Bullet.X + " " + bullets[0].Bullet.Y);
}
chargecooldown += gameTime.ElapsedGameTime.TotalSeconds;
//checks if the player is directly to the left or right of the boss. If so, then charges in their direction
if (player.PlayerPosition.Y > enemyPosition.Y - player.PlayerHitBox.Height && player.PlayerPosition.Y < enemyHitBox.Y + enemyHitBox.Height && !charging && chargecooldown >= .5)
{
charging = true;
if (player.PlayerHitBox.X > enemyHitBox.X)
{
chargedirection = false;
}
else
{
chargedirection = true;
}
TimeThatHasPassed = 0;
}
//the charge attack
if (charging)
{
TimeThatHasPassed += gameTime.ElapsedGameTime.TotalSeconds; // charge attack takes a set amount of time
if (TimeThatHasPassed >= .5) // after a short wind up
{
int speed = 8;
if (chargedirection) // left charge
{
if (enemyPosition.X - speed > 0)
{
enemyPosition.X -= speed;
enemyHitBox.X -= speed;
sheildhitbox.X -= speed;
}
else
{
chargecooldown = 0;
charging = false;
}
}
else // right charge
{
if (enemyPosition.X + speed + enemyHitBox.Width * 2 < windowsizex)
{
enemyPosition.X += speed;
enemyHitBox.X += speed;
sheildhitbox.X += speed;
}
else
{
chargecooldown = 0;
charging = false;
}
}
}
}
else
{
if (EnemyFacing == EnemyDirection.Right)
{
//can move when it is not stunned
enemyPosition = new Vector2(enemyPosition.X + Math.Sign(player.PlayerHitBox.X - (enemyPosition.X + (enemyHitBox.Width + 40))) * Speed, enemyPosition.Y + Math.Sign(player.PlayerHitBox.Y - enemyPosition.Y - 60) * Speed);
enemyHitBox = new Rectangle((int)enemyPosition.X + 40, (int)enemyPosition.Y, 110, 192);
sheildhitbox = new Rectangle((int)enemyPosition.X + 145, (int)enemyPosition.Y, 30, 192);
}
else if (EnemyFacing == EnemyDirection.Left)
{
enemyPosition = new Vector2(enemyPosition.X + Math.Sign(player.PlayerHitBox.X - enemyPosition.X) * Speed, enemyPosition.Y + Math.Sign(player.PlayerHitBox.Y - enemyPosition.Y - 60) * Speed);
enemyHitBox = new Rectangle((int)enemyPosition.X + 45, (int)enemyPosition.Y, 110, 192);
sheildhitbox = new Rectangle((int)enemyPosition.X + 15, (int)enemyPosition.Y, 30, 192);
}
TimeThatHasPassed += gameTime.ElapsedGameTime.TotalSeconds;
if (TimeThatHasPassed >= .6)
{
ShootBullet(player);
TimeThatHasPassed = 0;
}
}
prevdirection = EnemyFacing;
}
}
//设置敌人的从左向右还是从右向左
public void SetEnemyMovingDirection(EnemyDirection enemy_direction)
{
this.direction = enemy_direction;
}
private IEnumerator SetPosition(EnemyDirection d)
{
switch (d)
{
case EnemyDirection.top:
currentDirection = EnemyDirection.top;
transform.rotation = Quaternion.Euler(0, 0, 0);
GameManager.tileArray[x, y] = TileType.None;
GameManager.tileArray[x, y - 1] = TileType.Enemy;
y--;
break;
case EnemyDirection.bottom:
currentDirection = EnemyDirection.bottom;
transform.rotation = Quaternion.Euler(0, 180f, 0);
GameManager.tileArray[x, y] = TileType.None;
GameManager.tileArray[x, y + 1] = TileType.Enemy;
y++;
break;
case EnemyDirection.left:
currentDirection = EnemyDirection.left;
transform.rotation = Quaternion.Euler(0, -90f, 0);
GameManager.tileArray[x, y] = TileType.None;
GameManager.tileArray[x - 1, y] = TileType.Enemy;
x--;
break;
case EnemyDirection.right:
currentDirection = EnemyDirection.right;
transform.rotation = Quaternion.Euler(0, 90f, 0);
GameManager.tileArray[x, y] = TileType.None;
GameManager.tileArray[x + 1, y] = TileType.Enemy;
x++;
break;
}
isMove = true;
yield return new WaitForSeconds(0.4f);
isMove = false;
MovePosition(x, y);
}
void UpdateEnemies()
{
var enemyModels = GetEnemyModels();
double ellapsed = (DateTime.Now - lastEnemyUpdateTime).TotalMilliseconds;
//We want the enemies to get a little faster each round - and a lot faster when there are few enemies left.
int stepSize = 10; // + (GameInfo.Round / 3); //gradually increase step size.
int threshhold = 700; // - (GameInfo.Round * 30); //start off slowly.
int enemyCount = enemyModels.Count();
//The speed of the enemies is reflected by threshhold, depending on the number of enemies we update the value.
if (enemyCount == 1)
{
threshhold -= 300;
stepSize = 13;
}
else if (enemyCount == 1)
{
threshhold -= 200;
}
else if (enemyCount == 3)
{
threshhold -= 150;
}
else if (enemyCount == 10)
{
threshhold -= 100;
}
else if (enemyCount == 20)
{
threshhold -= 75;
}
else if (enemyCount == 30)
{
threshhold -= 50;
}
if (ellapsed < threshhold)
{
return;
}
lastEnemyUpdateTime = DateTime.Now;
bool newRow = false;
//Check if a change of direction is required. If so we will need to change direction and a newRow so that is set to true.
//Check is done by measuring if the new position will be beyond the window width.
if (enemyDirection == EnemyDirection.Right && enemyModels.Max(x => x.X + x.Width) + stepSize > WindowWidth)
{
enemyDirection = EnemyDirection.Left;
newRow = true;
}
else if (enemyDirection == EnemyDirection.Left && enemyModels.Min(x => x.X) - stepSize < 0)
{
enemyDirection = EnemyDirection.Right;
newRow = true;
}
if (newRow) //If new row is required we drop Y values down and toggle sprite state.
{
foreach (var model in enemyModels)
{
model.Y += 20;
model.SpriteState = model.SpriteState == EnemySpriteState.Closed ? EnemySpriteState.Open : EnemySpriteState.Closed;
}
}
else //New row not required, we move X position by delta X to the left or right and toggle sprite state.
{
int deltaX = enemyDirection == EnemyDirection.Right ? stepSize : -stepSize;
foreach (var model in enemyModels)
{
model.X += deltaX;
//Console.WriteLine($"enemy updated by {deltaX}"); (Debug Output)
model.SpriteState = model.SpriteState == EnemySpriteState.Closed ? EnemySpriteState.Open : EnemySpriteState.Closed;
}
}
audioController.PlayEnemyMove();
}
