System.Func <Vector3, Vector2> SwitchDirection(WalkingDirection direction)
{
System.Func <Vector3, Vector2> value;
switch (direction)
{
case WalkingDirection.left:
value = WalkLeft;
break;
case WalkingDirection.right:
value = WalkRight;
break;
case WalkingDirection.up:
value = WalkUp;
break;
case WalkingDirection.down:
value = WalkDown;
break;
default:
return(null);
}
return(value);
}
public override void _PhysicsProcess(float delta)
{
velocity.x = 0;
velocity.y += Overlord.STANDARD_GRAVITY;
if (parent.TestMove(parent.Transform, velocity) &&
!parent.TestMove(parent.Transform, new Vector2(speed * 5 * (int)direction, velocity.y))
)
{
direction = direction == WalkingDirection.Left ? WalkingDirection.Right : WalkingDirection.Left;
changeDirection((int)direction);
}
velocity.x = speed * (int)direction;
var collision = parent.MoveAndSlide(velocity);
if (Math.Abs(collision.x) < speed)
{
direction = direction == WalkingDirection.Left ? WalkingDirection.Right : WalkingDirection.Left;
changeDirection((int)direction);
}
if (collision.y == 0)
{
velocity.y = 0;
}
}
protected CurveWalker(Curve curve, XYZ initPosition = null,
WalkingDirection direction = WalkingDirection.StartToEnd)
{
WalkingCurve = curve;
CurrentPosition = initPosition ?? WalkingCurve.GetEndPoint(0);
Direction = direction;
}
Vector3 VectorDirectiod(WalkingDirection dir)
{
Vector3 tmp;
if (dir == WalkingDirection.up)
{
tmp = Vector3.up;
}
else if (dir == WalkingDirection.down)
{
tmp = Vector3.down;
}
else if (dir == WalkingDirection.left)
{
tmp = Vector3.left;
}
else if (dir == WalkingDirection.right)
{
tmp = Vector3.right;
}
else
{
tmp = Vector3.zero;
}
return(tmp);
}
public void OnFire(int playerIndex, Vector2 position, WalkingDirection walkingDirection)
{
var bullet = new BulletSprite(bulletTexture, position, walkingDirection, playerIndex);
bullet.font = HUDFont;
bulllets.Add(bullet);
}
public void Update(GameTime gameTime, WalkingDirection newWalkingDirection)
{
if (newWalkingDirection == WalkingDirection.Idle)
{
walkingDirection = WalkingDirection.Idle;
currentAnimation.Stop();
}
else if (newWalkingDirection != walkingDirection)
{
walkingDirection = newWalkingDirection;
currentAnimation.Stop();
if (newWalkingDirection == WalkingDirection.Down)
{
currentAnimation = Down;
}
if (newWalkingDirection == WalkingDirection.Up)
{
currentAnimation = Up;
}
if (newWalkingDirection == WalkingDirection.Left)
{
currentAnimation = Left;
}
if (newWalkingDirection == WalkingDirection.Right)
{
currentAnimation = Right;
}
currentAnimation.Start(Repeat.Mode.Loop);
}
currentAnimation.Update(gameTime);
}
public void PlayFootFeedbackSound()
{
WalkingDirection direction = CurrentWalkingDirection;
// FEEDBACK : PLAY WALK SOUND
FxManager.Instance.PlayFx(walkFxTag, transform.position, Quaternion.Euler(0, 0, direction == WalkingDirection.Right ? 135 : 45), Vector3.one);
}
public ChangeDirectionEventArgs(WalkingDirection walkingDirection, int iterUpFrame, int iterDownFrame, int iterRightFrame, int iterLeftFrame)
{
WalkingDirection = walkingDirection;
IterUpFrame = iterUpFrame;
IterDownFrame = iterDownFrame;
IterLeftFrame = iterLeftFrame;
IterRightFrame = iterRightFrame;
}
private void MainCharacter_ChangePosition(object sender, ChangeDirectionEventArgs e)
{
IterUpFrame = e.IterUpFrame;
IterDownFrame = e.IterDownFrame;
IterLeftFrame = e.IterLeftFrame;
IterRightFrame = e.IterRightFrame;
walkingDirection = e.WalkingDirection;
}
public Node(Point position, WalkingDirection walkingDirection)
{
this.Position = position;
this.walkingDirection = walkingDirection;
G = H = F = 0;
parent = null;
}
public BulletSprite(Texture2D texture, Vector2 startingPosition, WalkingDirection direction, int bulletOwner) : base(texture,
startingPosition)
{
this.bulletOwner = bulletOwner;
this.direction = direction;
frameHeight = texture.Height;
frameWidth = texture.Width;
origin = new Vector2(texture.Width / 2f, texture.Height / 2f);
}
public MainCharacter(Game game, Texture2D texture, Vector2 beginPosition, Rectangle window) : base(game)
{
textureMainCharacter = texture;
Position = beginPosition;
this.window = window;
walkingDirection = WalkingDirection.Right;
RectangleInitialize();
sizeOfSprite = new Rectangle(0, 0, upFrameOfTextureMC[0].Width, upFrameOfTextureMC[0].Height);
this.ChangePosition += MainCharacter_ChangePosition;
}
void Start() //вызывается на старте игры
{
countExistenceChangeDirection = 0;
fall = 0;
_direction = WalkingDirection.idle; //присваеваем на старте стоять на месте
changeDirection = WalkingDirection.idle;
_V3Left = new Vector3(-changePos, 0, 0);
_V3Right = new Vector3(changePos, 0, 0);
_V3Up = new Vector3(0, changePos, 0);
_V3Down = new Vector3(0, -changePos, 0);
}
void Update()
{
if (Time.time - fall >= fallspeed && _direction != WalkingDirection.idle)
{
Vector3 updatePosition = transform.localPosition;
Vector3 tempPosition;
bool checkGoSide = false;
if (changeDirection != WalkingDirection.idle && IntegerCheck(updatePosition))
{
if (countExistenceChangeDirection <= 1)
{
tempPosition = goSide(AlignPosition(updatePosition, changeDirection));
if (_borderBlock.CheckWalk(tempPosition, VectorDirectiod(changeDirection)))
{
updatePosition = tempPosition;
checkGoSide = true;
}
countExistenceChangeDirection++;
}
else
{
NullifyTurn();
}
}
if (!checkGoSide)
{
tempPosition = goAhead(updatePosition);
if (_borderBlock.CheckWalk(tempPosition, VectorDirectiod(_direction)))
{
updatePosition = tempPosition;
}
else
{
_direction = WalkingDirection.idle;
NullifyTurn();
updatePosition = new Vector3(Mathf.Round(updatePosition.x), Mathf.Round(updatePosition.y), updatePosition.z);
}
}
else
{
_direction = changeDirection;
goAhead = goSide;
NullifyTurn();
}
transform.localPosition = updatePosition;
fall = Time.time;
}
}
// Update is called once per frame
void Update()
{
if (!m_IsEatingFood)
{
m_WalkingTime -= Time.deltaTime;
int direction = m_WalkingDirection == WalkingDirection.Left ? -1 : 1;
this.transform.Translate(direction * m_WalkingSpeed, 0.0f, 0.0f);
if (m_WalkingTime <= 0.0f)
{
m_WalkingTime = 4.0f;
m_WalkingDirection = (WalkingDirection)(((int)(m_WalkingDirection) + 1) & 1);
m_Animator.SetInteger("walkingDirection", (int)m_WalkingDirection);
}
}
}
/// <summary>
/// Returns movement information according to the current virtual thumbstick input.
/// </summary>
/// <param name="movement">Vector indicating the current beekeeper movement.</param>
/// <param name="tempDirection">Enum describing the inpot direction.</param>
/// <param name="smokeAdjustment">Adjustment to smoke position according to input direction.</param>
private void DetermineDirection(Vector2 movement, ref WalkingDirection tempDirection,
ref Vector2 smokeAdjustment)
{
if (movement == Vector2.Zero)
{
return;
}
if (Math.Abs(movement.X) > Math.Abs(movement.Y))
{
DetermineDirectionDominantX(movement, ref tempDirection, ref smokeAdjustment);
}
else
{
DetermineDirectionDominantY(movement, ref tempDirection, ref smokeAdjustment);
}
}
void updateMovement(GameTime gameTime)
{
var keyboardState = Keyboard.GetState();
var pressedKeys = keyboardState.GetPressedKeys();
int pixelsPerSecond = 100;
float movementSpeed = (float)(pixelsPerSecond * (gameTime.ElapsedGameTime.TotalSeconds));
Vector2 movementVector = Vector2.Zero;
if (pressedKeys.Length == 0)
{
whichFrame = 0;
currentWalkingDirection = WalkingDirection.down;
}
else
{
if (keyboardState.IsKeyDown(Keys.A))
{
if (!isTouchingLeft)
{
movementVector += new Vector2(-movementSpeed, 0);
}
currentWalkingDirection = WalkingDirection.left;
}
else if (keyboardState.IsKeyDown(Keys.D))
{
if (!isTouchingRight)
{
movementVector += new Vector2(movementSpeed, 0);
}
currentWalkingDirection = WalkingDirection.right;
}
if (keyboardState.IsKeyDown(Keys.Space))
{
Jump();
}
position += movementVector;
}
}
protected void MoveDown(Keys keys)
{
if (Keyboard.GetState().IsKeyDown(keys))
{
walkingDirection = WalkingDirection.Down;
if (Position.Y < window.Bottom)
{
Position.Y += 5;
if (IterDownFrame < downFrameOfTextureMC.Length - 1)
{
IterDownFrame++;
}
else
{
IterDownFrame = 0;
}
}
}
}
protected void MoveLeft(Keys keys)
{
if (Keyboard.GetState().IsKeyDown(keys))
{
if (Position.X > window.Left)
{
walkingDirection = WalkingDirection.Left;
Position.X -= 5;
if (IterLeftFrame < leftFrameOfTextureMC.Length - 1)
{
IterLeftFrame++;
}
else
{
IterLeftFrame = 0;
}
}
}
}
protected void MoveRight(Keys keys)
{
if (Keyboard.GetState().IsKeyDown(keys))
{
if (Position.X < window.Right)
{
walkingDirection = WalkingDirection.Right;
Position.X += 5;
if (IterRightFrame < rightFrameOfTextureMC.Length - 1)
{
IterRightFrame++;
}
else
{
IterRightFrame = 0;
}
}
}
}
protected void MoveUp(Keys keys)
{
if (Keyboard.GetState().IsKeyDown(keys))
{
walkingDirection = WalkingDirection.Up;
if (Position.Y > window.Top)
{
Position.Y -= 5;
if (IterUpFrame < upFrameOfTextureMC.Length - 1)
{
IterUpFrame++;
}
else
{
IterUpFrame = 0;
}
}
}
}
/// <summary>
/// Returns movement information according to the current virtual thumbstick input, given that advancement
/// along the Y axis is greater than along the X axis.
/// </summary>
/// <param name="movement">Vector indicating the current beekeeper movement.</param>
/// <param name="tempDirection">Enum describing the input direction.</param>
/// <param name="smokeAdjustment">Adjustment to smoke position according to input direction.</param>
private void DetermineDirectionDominantY(Vector2 movement, ref WalkingDirection tempDirection,
ref Vector2 smokeAdjustment)
{
if (movement.Y > 0)
{
if (movement.X > 0.25f)
{
tempDirection = WalkingDirection.RightDown;
smokeAdjustment = new Vector2(UIConstants.SprayRightOffset, UIConstants.SprayDownOffset);
}
else if (movement.X < -0.25f)
{
tempDirection = WalkingDirection.LeftDown;
smokeAdjustment = new Vector2(-UIConstants.SprayLeftOffset, UIConstants.SprayDownOffset);
}
else
{
tempDirection = WalkingDirection.Down;
smokeAdjustment = Vector2.Zero;
}
}
else
{
if (movement.X > 0.25f)
{
tempDirection = WalkingDirection.RightUp;
smokeAdjustment = new Vector2(UIConstants.SprayRightOffset, UIConstants.SprayUpOffset);
}
else if (movement.X < -0.25f)
{
tempDirection = WalkingDirection.LeftUp;
smokeAdjustment = new Vector2(-UIConstants.SprayLeftOffset, UIConstants.SprayUpOffset);
}
else
{
tempDirection = WalkingDirection.Up;
smokeAdjustment = Vector2.Zero;
}
}
}
/// <summary>
/// Returns movement information according to the current virtual thumbstick input, given that advancement
/// along the Y axis is greater than along the X axis.
/// </summary>
/// <param name="tempDirection">Enum describing the input direction.</param>
/// <param name="smokeAjustment">Adjustment to smoke position according to input direction.</param>
private void DetermineDirectionDominantY(ref WalkingDirection tempDirection, ref Vector2 smokeAjustment)
{
if (VirtualThumbsticks.LeftThumbstick.Y > 0)
{
if (VirtualThumbsticks.LeftThumbstick.X > 0.25f)
{
tempDirection = WalkingDirection.RightDown;
smokeAjustment = new Vector2(85, 0);
}
else if (VirtualThumbsticks.LeftThumbstick.X < -0.25f)
{
tempDirection = WalkingDirection.LeftDown;
smokeAjustment = new Vector2(-85, 0);
}
else
{
tempDirection = WalkingDirection.Down;
smokeAjustment = Vector2.Zero;
}
}
else
{
if (VirtualThumbsticks.LeftThumbstick.X > 0.25f)
{
tempDirection = WalkingDirection.RightUp;
smokeAjustment = new Vector2(85, 30);
}
else if (VirtualThumbsticks.LeftThumbstick.X < -0.25f)
{
tempDirection = WalkingDirection.LeftUp;
smokeAjustment = new Vector2(-85, 30);
}
else
{
tempDirection = WalkingDirection.Up;
smokeAjustment = Vector2.Zero;
}
}
}
internal void DirectionSelection(WalkingDirection direction)
{
if (direction == _direction)
{
return;
}
if (_direction == WalkingDirection.idle)
{
_direction = direction;
goAhead = SwitchDirection(_direction);
}
else
{
if (changeDirection != direction)
{
//checkedChangeDirection = false;
changeDirection = direction;
goSide = SwitchDirection(changeDirection);
}
countExistenceChangeDirection = 0;
}
}
/// <summary>
/// Returns movement information according to the current virtual thumbstick input.
/// </summary>
/// <param name="tempDirection">Enum describing the inpot direction.</param>
/// <param name="smokeAjustment">Adjustment to smoke position according to input direction.</param>
private void DetermineDirection(ref WalkingDirection tempDirection, ref Vector2 smokeAjustment)
{
if (!VirtualThumbsticks.LeftThumbstickCenter.HasValue)
{
return;
}
Rectangle touchPointRectangle = new Rectangle((int)VirtualThumbsticks.LeftThumbstickCenter.Value.X,
(int)VirtualThumbsticks.LeftThumbstickCenter.Value.Y, 1, 1);
if (ThumbStickArea.Intersects(touchPointRectangle))
{
if (Math.Abs(VirtualThumbsticks.LeftThumbstick.X) > Math.Abs(VirtualThumbsticks.LeftThumbstick.Y))
{
DetermineDirectionDominantX(ref tempDirection, ref smokeAjustment);
}
else
{
DetermineDirectionDominantY(ref tempDirection, ref smokeAjustment);
}
}
}
void updateInput()
{
var keyboardState = Keyboard.GetState();
var pressedKeys = keyboardState.GetPressedKeys();
isMoving = false;
isFiring = false;
if (pressedKeys.Length != 0)
{
foreach (var Key in pressedKeys)
{
if (keyMap.left.Equals(Key))
{
currentWalkingDirection = WalkingDirection.left;
isMoving = true;
}
else if (keyMap.right.Equals(Key))
{
currentWalkingDirection = WalkingDirection.right;
isMoving = true;
}
else if (keyMap.down.Equals(Key))
{
currentWalkingDirection = WalkingDirection.down;
isMoving = true;
}
else if (keyMap.up.Equals(Key))
{
currentWalkingDirection = WalkingDirection.up;
isMoving = true;
}
else if (keyMap.fire.Equals(Key))
{
isFiring = true;
}
}
}
}
public void InitGenericWalker(int _maxHealth, int _startingDamage, float _startingSpeed, float _startingAttackSpeed, WalkerType _type, EnemyWalkingTrack _myTrack, LayerMask _attackMask)
{
AttackLayerMask = _attackMask;
myTrack = _myTrack;
maxHealth = _maxHealth;
startingDamage = _startingDamage;
startingSpeed = _startingSpeed;
startingAttackSpeed = _startingAttackSpeed;
myType = _type;
currentHealth = maxHealth;
nextTrackIndex = _type == WalkerType.Enemy ? 0 : _myTrack.Points - 1;
alive = true;
if (myType == WalkerType.Enemy)
{
indexDiff = 1;
if (myTrack.side == EnemyWalkingTrackSide.Left)
{
walkingDirection = WalkingDirection.Right;
}
else
{
walkingDirection = WalkingDirection.Left;
}
}
else
{
indexDiff = -1;
if (myTrack.side == EnemyWalkingTrackSide.Left)
{
walkingDirection = WalkingDirection.Left;
}
else
{
walkingDirection = WalkingDirection.Right;
}
}
}
/// <summary>
/// Renders the beekeeper.
/// </summary>
/// <param name="gameTime">Game Time obj </param>
public override void Draw(GameTime gameTime)
{
if (!(GamePlayScreen.IsActive && GamePlayScreen.IsStarted))
{
base.Draw(gameTime);
return;
}
SpriteBatch.Begin();
bool hadDirectionChanged = false;
WalkingDirection tempDirection = direction;
determineDirection(ref tempDirection);
// Indicate the direction has changed
if (tempDirection != direction)
{
hadDirectionChanged = true;
direction = tempDirection;
}
if (hadDirectionChanged)
{
// Update the animation
lastFrameCounter = 0;
AnimationDefinitions[BOMBER_ANIMATION_KEY].PlayFromFrameIndex(lastFrameCounter + (int)direction);
}
else
{
// Because our animation is 10 cells, and the row is 10 cells,
// we need to reset the counter after 10 rounds
if (lastFrameCounter == 10)
{
lastFrameCounter = 0;
AnimationDefinitions[BOMBER_ANIMATION_KEY].PlayFromFrameIndex(lastFrameCounter + (int)direction);
}
else
{
lastFrameCounter++;
}
}
AnimationDefinitions[BOMBER_ANIMATION_KEY].Draw(SpriteBatch, FramePosition, SpriteEffects.None, new Vector2(20, 5), ColisionAreaRect);
SpriteBatch.End();
base.Draw(gameTime);
}
/// <summary>
/// Renders the beekeeper.
/// </summary>
/// <param name="gameTime"></param>
public override void Draw(GameTime gameTime)
{
if (!(gamePlayScreen.IsActive && gamePlayScreen.IsStarted))
{
base.Draw(gameTime);
return;
}
// Make sure not to draw the beekeeper while flashing
if (isStung || isFlashing)
{
if (stungDrawingCounter != stungDrawingInterval)
{
if (isDrawnLastStungInterval)
{
return;
}
}
}
scaledSpriteBatch.Begin();
// if stung we want to show another animation
if (isStung)
{
scaledSpriteBatch.Draw(Game.Content.Load<Texture2D>("Textures/hit"), position, Color.White);
scaledSpriteBatch.End();
return;
}
// If collecting honey, draw the appropriate animation
if (IsCollectingHoney)
{
AnimationDefinitions[BeekeeperCollectingHoneyAnimationKey].Draw(scaledSpriteBatch, position,
SpriteEffects.None);
scaledSpriteBatch.End();
return;
}
if (isDepositingHoney)
{
if (velocity != Vector2.Zero)
{
isDepositingHoney = false;
AudioManager.StopSound("DepositingIntoVat_Loop");
}
// We want the deposit duration to sync with the deposit
// animation
// So we manage the timing ourselves
if (depositHoneyUpdatingTimer != TimeSpan.Zero &&
depositHoneyUpdatingTimer + depositHoneyUpdatingInterval < gameTime.TotalGameTime)
{
depositHoneyTimerCounter++;
depositHoneyUpdatingTimer = TimeSpan.Zero;
}
AnimationDefinitions[BeekeeperDepositingHoneyAnimationKey].Draw(scaledSpriteBatch, position,
SpriteEffects.None);
if (depositHoneyTimerCounter == honeyDepositFrameCount - 1)
{
isDepositingHoney = false;
depositHoneyCallback.Invoke(null);
AnimationDefinitions[BeekeeperDepositingHoneyAnimationKey].PlayFromFrameIndex(0);
}
scaledSpriteBatch.End();
return;
}
bool hadDirectionChanged = false;
// See if the direction changed
if (newDirection != direction)
{
hadDirectionChanged = true;
direction = newDirection;
}
if (hadDirectionChanged)
{
// Update the animation
lastFrameCounter = 0;
AnimationDefinitions[LegAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
AnimationDefinitions[ShootingAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
AnimationDefinitions[BodyAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
}
else
{
// Because our animation is 8 cells, but the row is 16 cells,
// we need to reset the counter after 8 rounds
if (lastFrameCounter == 8)
{
lastFrameCounter = 0;
AnimationDefinitions[LegAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
AnimationDefinitions[ShootingAnimationKey].PlayFromFrameIndex(
lastFrameCounter + (int)direction);
AnimationDefinitions[BodyAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
}
else
{
lastFrameCounter++;
}
}
AnimationDefinitions[LegAnimationKey].Draw(scaledSpriteBatch, position, 1f, SpriteEffects.None);
if (needToShootSmoke)
{
// Draw the body
AnimationDefinitions[ShootingAnimationKey].Draw(scaledSpriteBatch, position, 1f, SpriteEffects.None);
// If true we need to draw smoke
if (smokeAdjustment != Vector2.Zero)
{
AnimationDefinitions[SmokeAnimationKey].Draw(scaledSpriteBatch, position + smokeAdjustment, 1f,
currentEffect);
}
}
else
{
AnimationDefinitions[BodyAnimationKey].Draw(scaledSpriteBatch, position, 1f, SpriteEffects.None);
}
scaledSpriteBatch.End();
base.Draw(gameTime);
}
/// <summary>
/// Renders the beekeeper.
/// </summary>
/// <param name="gameTime"></param>
public override void Draw(GameTime gameTime)
{
if (!(gamePlayScreen.IsActive))
{
base.Draw(gameTime);
return;
}
// Make sure not to draw the beekeeper while flashing
if (isStung || isFlashing)
{
if (stungDrawingCounter != stungDrawingInterval)
{
if (isDrawnLastStungInterval)
{
return;
}
}
}
spriteBatch.Begin();
// if stung we want to show another animation
if (isStung)
{
spriteBatch.Draw(Game.Content.Load <Texture2D>("Textures/hit"), position, Color.White);
spriteBatch.End();
return;
}
// If collecting honey, draw the appropriate animation
if (IsCollectingHoney)
{
AnimationDefinitions[BeekeeperCollectingHoneyAnimationKey].Draw(spriteBatch, position,
SpriteEffects.None);
spriteBatch.End();
return;
}
if (isDepositingHoney)
{
if (VirtualThumbsticks.LeftThumbstick != Vector2.Zero)
{
isDepositingHoney = false;
AudioManager.StopSound("DepositingIntoVat_Loop");
}
// We want the deposit duration to sync with the deposit
// animation
// So we manage the timing ourselves
if (depositHoneyUpdatingTimer != TimeSpan.Zero &&
depositHoneyUpdatingTimer + depositHoneyUpdatingInterval < gameTime.TotalGameTime)
{
depositHoneyTimerCounter++;
depositHoneyUpdatingTimer = TimeSpan.Zero;
}
AnimationDefinitions[BeekeeperDesposingHoneyAnimationKey].Draw(spriteBatch, position,
SpriteEffects.None);
if (depositHoneyTimerCounter == honeyDepositFrameCount - 1)
{
isDepositingHoney = false;
depositHoneyCallback.Invoke(null);
AnimationDefinitions[BeekeeperDesposingHoneyAnimationKey].PlayFromFrameIndex(0);
}
spriteBatch.End();
return;
}
bool hadDirectionChanged = false;
WalkingDirection tempDirection = direction;
DetermineDirection(ref tempDirection, ref smokeAdjustment);
// Indicate the direction has changed
if (tempDirection != direction)
{
hadDirectionChanged = true;
direction = tempDirection;
}
if (hadDirectionChanged)
{
// Update the animation
lastFrameCounter = 0;
AnimationDefinitions[LegAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
AnimationDefinitions[ShootingAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
AnimationDefinitions[BodyAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
}
else
{
// Because our animation is 8 cells, but the row is 16 cells,
// we need to reset the counter after 8 rounds
if (lastFrameCounter == 8)
{
lastFrameCounter = 0;
AnimationDefinitions[LegAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
AnimationDefinitions[ShootingAnimationKey].PlayFromFrameIndex(
lastFrameCounter + (int)direction);
AnimationDefinitions[BodyAnimationKey].PlayFromFrameIndex(lastFrameCounter + (int)direction);
}
else
{
lastFrameCounter++;
}
}
AnimationDefinitions[LegAnimationKey].Draw(spriteBatch, position, 1f, SpriteEffects.None);
if (needToShootSmoke)
{
// Draw the body
AnimationDefinitions[ShootingAnimationKey].Draw(spriteBatch, position, 1f, SpriteEffects.None);
// If true we need to draw smoke
if (smokeAdjustment != Vector2.Zero)
{
AnimationDefinitions[SmokeAnimationKey].Draw(spriteBatch, position + smokeAdjustment, 1f,
GetSpriteEffect(VirtualThumbsticks.LeftThumbstick));
}
}
else
{
AnimationDefinitions[BodyAnimationKey].Draw(spriteBatch, position, 1f, SpriteEffects.None);
}
spriteBatch.End();
base.Draw(gameTime);
}
public static void Draw(SpriteBatch spriteBatch, GameTime gameTime, MovingEntity movingEntity)
{
var livingEntityType = LivingEntityType.lookup[movingEntity.LivingEntityType];
WalkingDirection newWalkingDirection = MovementUtils.GetWalkingDirectionFromVector(movingEntity.Direction);
movingEntity.RendererInformation.Update(gameTime, newWalkingDirection);
if (!movingEntity.IsWalking)
{
movingEntity.RendererInformation.currentAnimation.Reset();
}
var adjustedYPosition = movingEntity.Position.Y + movingEntity.YPositionDepthOffset;
if (movingEntity.IsDead())
{
movingEntity.RendererInformation.Update(gameTime, WalkingDirection.Left);
movingEntity.RendererInformation.currentAnimation.Reset();
spriteBatch.Draw(movingEntity.RendererInformation.currentAnimation, new Vector2((int)movingEntity.Position.X, (int)movingEntity.Position.Y), rotation: MathHelper.Pi / 2, color: Color.White, layerDepth: GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition));
}
else
{
spriteBatch.Draw(movingEntity.RendererInformation.currentAnimation, new Vector2((int)movingEntity.Position.X, (int)movingEntity.Position.Y), color: Color.White, layerDepth: GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition));
}
// Draw Speech Bubble
if (movingEntity.RendererInformation.SpeechLine != null)
{
var depth = GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition);
var depth2 = GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X + 1, adjustedYPosition);
var bubbleYOffset = (int)movingEntity.Position.Y - livingEntityType.SpriteBounds.Y - 20;
var stringWidth = font.MeasureString(movingEntity.RendererInformation.SpeechLine).X;
var bubbleWidth = stringWidth - 8;
var bubbleStartPos = new Vector2((int)movingEntity.Position.X - 10 - bubbleWidth, bubbleYOffset);
var bubbleContentPos = new Vector2((int)movingEntity.Position.X - bubbleWidth, bubbleYOffset);
var bubbleEndPos = new Vector2((int)movingEntity.Position.X - 10, bubbleYOffset);
// Draw bubble start
spriteBatch.Draw(SimulationGame.ContentManager.Load <Texture2D>(@"GUI\SpeechBubble"), bubbleStartPos, new Rectangle(0, 0, 10, 27), Color.White, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, depth);
// Draw bubble content
spriteBatch.Draw(SimulationGame.ContentManager.Load <Texture2D>(@"GUI\SpeechBubble"), bubbleContentPos, new Rectangle(10, 0, 20, 27), Color.White, 0.0f, Vector2.Zero, new Vector2((stringWidth - 18) / 20.0f, 1.0f), SpriteEffects.None, depth);
// Draw string
spriteBatch.DrawString(font, movingEntity.RendererInformation.SpeechLine, new Vector2(bubbleContentPos.X, bubbleYOffset + 5), Color.White, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, depth2);
// Draw bubble end
spriteBatch.Draw(SimulationGame.ContentManager.Load <Texture2D>(@"GUI\SpeechBubble"), bubbleEndPos, new Rectangle(110, 0, 27, 27), Color.White, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, depth);
}
// Draw Health
if (movingEntity.CurrentLife < movingEntity.MaximumLife)
{
spriteBatch.Draw(healthTexture, new Vector2(movingEntity.Position.X - livingEntityType.SpriteBounds.X / 2, movingEntity.Position.Y - livingEntityType.SpriteBounds.Y),
new Rectangle(0, 0, 1, 1), Color.Red, 0.0f, Vector2.Zero, new Vector2(((float)movingEntity.CurrentLife / (float)movingEntity.MaximumLife) * livingEntityType.SpriteBounds.X, 2.0f), SpriteEffects.None, GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition));
}
if (SimulationGame.IsDebug)
{
if (movingEntity.IsBlocking())
{
SimulationGame.PrimitiveDrawer.Rectangle(movingEntity.UnionBounds.ToXnaRectangle(), Color.Red);
}
else if (movingEntity.IsHitable())
{
SimulationGame.PrimitiveDrawer.Rectangle(movingEntity.HitBoxBounds.ToXnaRectangle(), Color.White);
SimulationGame.PrimitiveDrawer.Rectangle(movingEntity.BlockingBounds.ToXnaRectangle(), Color.Red);
}
}
}
/// <summary>
/// Returns movement information according to the current virtual thumbstick input.
/// </summary>
/// <param name="movement">Vector indicating the current beekeeper movement.</param>
/// <param name="tempDirection">Enum describing the inpot direction.</param>
/// <param name="smokeAdjustment">Adjustment to smoke position according to input direction.</param>
private void DetermineDirection(Vector2 movement, ref WalkingDirection tempDirection,
ref Vector2 smokeAdjustment)
{
if (movement == Vector2.Zero)
{
return;
}
if (Math.Abs(movement.X) > Math.Abs(movement.Y))
{
DetermineDirectionDominantX(movement, ref tempDirection, ref smokeAdjustment);
}
else
{
DetermineDirectionDominantY(movement, ref tempDirection, ref smokeAdjustment);
}
}
/// <summary>
/// Returns movement information according to the current virtual thumbstick input, given that advancement
/// along the Y axis is greater than along the X axis.
/// </summary>
/// <param name="movement">Vector indicating the current beekeeper movement.</param>
/// <param name="tempDirection">Enum describing the input direction.</param>
/// <param name="smokeAdjustment">Adjustment to smoke position according to input direction.</param>
private void DetermineDirectionDominantY(Vector2 movement, ref WalkingDirection tempDirection,
ref Vector2 smokeAdjustment)
{
if (movement.Y > 0)
{
if (movement.X > 0.25f)
{
tempDirection = WalkingDirection.RightDown;
smokeAdjustment = new Vector2(UIConstants.SprayRightOffset, UIConstants.SprayDownOffset);
}
else if (movement.X < -0.25f)
{
tempDirection = WalkingDirection.LeftDown;
smokeAdjustment = new Vector2(-UIConstants.SprayLeftOffset, UIConstants.SprayDownOffset);
}
else
{
tempDirection = WalkingDirection.Down;
smokeAdjustment = Vector2.Zero;
}
}
else
{
if (movement.X > 0.25f)
{
tempDirection = WalkingDirection.RightUp;
smokeAdjustment = new Vector2(UIConstants.SprayRightOffset, UIConstants.SprayUpOffset);
}
else if (movement.X < -0.25f)
{
tempDirection = WalkingDirection.LeftUp;
smokeAdjustment = new Vector2(-UIConstants.SprayLeftOffset, UIConstants.SprayUpOffset);
}
else
{
tempDirection = WalkingDirection.Up;
smokeAdjustment = Vector2.Zero;
}
}
}
Vector3 AlignPosition(Vector3 pos, WalkingDirection dir)
{
return((dir == WalkingDirection.up || dir == WalkingDirection.down) ?
new Vector3(Mathf.Round(pos.x), pos.y, pos.z) : new Vector3(pos.x, Mathf.Round(pos.y), pos.z));
}
/// <summary>
/// Returns movement information according to the current virtual thumbstick input.
/// </summary>
/// <param name="tempDirection">
/// Enum describing the inpot direction.
/// </param>
private void determineDirection(ref WalkingDirection tempDirection)
{
if (!VirtualThumbsticks.LeftThumbstickCenter.HasValue)
{
return;
}
Rectangle touchPointRectangle = new Rectangle((int)VirtualThumbsticks.LeftThumbstickCenter.Value.X, (int)VirtualThumbsticks.LeftThumbstickCenter.Value.Y, 1, 1);
if (ThumbStickArea.Intersects(touchPointRectangle))
{
if (Math.Abs(VirtualThumbsticks.LeftThumbstick.X) > Math.Abs(VirtualThumbsticks.LeftThumbstick.Y))
{
tempDirection = VirtualThumbsticks.LeftThumbstick.X > 0 ? WalkingDirection.Right : WalkingDirection.Left;
}
else
{
tempDirection = VirtualThumbsticks.LeftThumbstick.Y > 0 ? WalkingDirection.Down : WalkingDirection.Up;
}
}
}
public void Walk(WalkingDirection direction)
{
}
