private static void EnemyHorizontalMove(int index, bool direction, Vector pos, Vector size,
int speed, bool wait)
{
if (!lstEnemyData[index].valueSetComp)
{
EnemyBehaviorValuesSetup(index);
}
if (lstEnemyData[index].totalDistance.X < lstEnemyData[index].targetDistance.X)
{
if (!direction)
{
if (!BlockCheck.BlockCheckLeft(pos.X, pos.Y, (int)size.Y, speed) &&
pos.X > 0)
{
if (pos.X - SystemOperator.PixelPerSecond(speed) > 0)
{
pos.X -= SystemOperator.PixelPerSecond(speed);
}
else
{
lstEnemyData[index].targetDistance = new Vector(0, lstEnemyData[index].targetDistance.Y);
lstEnemyData[index].direction = true;
}
}
}
else
{
if (!BlockCheck.BlockCheckRight(pos.X, pos.Y, (int)size.X, (int)size.Y, speed) &&
pos.X + size.X < 1024 - lstEnemyData[index].size.X)
{
if (pos.X + SystemOperator.PixelPerSecond(speed) < 992)
{
pos.X += SystemOperator.PixelPerSecond(speed);
}
else
{
lstEnemyData[index].targetDistance = new Vector(0, lstEnemyData[index].targetDistance.Y);
lstEnemyData[index].direction = false;
}
}
}
lstEnemyData[index].position.X = pos.X;
lstEnemyData[index].totalDistance.X += SystemOperator.PixelPerSecond(speed);
}
else
{
if (wait)
{
lstEnemyData[index].isWaiting = true;
lstEnemyData[index].totalWaitTime = 0;
lstEnemyData[index].targetWaitTime = 2000;
}
lstEnemyData[index].targetDistance = new Vector(0, 0);
lstEnemyData[index].totalDistance = new Vector(0, 0);
lstEnemyData[index].valueSetComp = false;
}
}
public void EnemyJumping(int index, bool direction, Vector pos, int width, int jumpPower, Vector target)
{
if (!BlockCheck.BlockCheckTop(pos.X, pos.Y, width, jumpPower))
{
if (pos.Y - SystemOperator.PixelPerSecond(jumpPower) > 0)
{
lstEnemyData[index].jumpCount++;
lstEnemyData[index].isJumping = true;
}
}
if (lstEnemyData[index].isJumping)
{
if (lstEnemyData[index].jumpTotalLength < lstEnemyData[index].jumpMaxHeight)
{
lstEnemyData[index].position.Y -= SystemOperator.PixelPerSecond(jumpPower);
lstEnemyData[index].jumpTotalLength += SystemOperator.PixelPerSecond(jumpPower);
}
else
{
lstEnemyData[index].isJumping = false;
lstEnemyData[index].jumpTotalLength = 0;
}
}
}
public static void FallingPlayer()
{
if (!isLadder && !isPlat && !jumping)
{
if (!BlockCheck.BlockCheckBottom(playerPos.X, playerPos.Y, (int)playerSize.X, (int)playerSize.Y, weight))
{
if (!isKnockBack)
{
playerPos.Y += SystemOperator.PixelPerSecond(weight);
SystemOperator.moveCommonAmountY = SystemOperator.PixelPerSecond(weight);
}
if (!fallingStart)
{
fallingStartPoint = playerPos.Y;
}
fallingStart = true;
isGround = false;
}
else
{
if (!isGround)
{
playerPos.Y = Math.Floor(playerPos.Y + SystemOperator.PixelPerSecond(weight) / 32) - 1;
}
if (fallingStart)
{
int block = 0;
block = (int)(playerPos.Y - fallingStartPoint) / 32;
if (block > fallingEndure)
{
Sound.SoundEffectSelector(SeName.Player_Damage);
Sound.SoundEffectPlayer(SeName.Player_Damage);
}
}
fallingStart = false;
isGround = true;
jumpCount = 0;
}
}
Canvas.SetTop(ImageData.imgPlayer, playerPos.Y);
}
public static void FallingItems()
{
for (int i = 0; i < lstItemData.Count; i++)
{
double posX = Canvas.GetLeft(lstItemData[i].imgItem);
double posY = Canvas.GetTop(lstItemData[i].imgItem);
if (!BlockCheck.BlockCheckBottom(posX, posY, (int)lstItemData[i].size.X, (int)lstItemData[i].size.Y, lstItemData[i].weight))
{
posY += SystemOperator.PixelPerSecond(lstItemData[i].weight);
}
Canvas.SetTop(lstItemData[i].imgItem, posY);
}
}
private static void EnemyFalling(int index, bool direction, Vector pos, Vector size, int speed, Vector target)
{
if (!lstEnemyData[index].isLadder)
{
if ((!BlockCheck.BlockCheckBottom(pos.X, pos.Y, (int)size.X, (int)size.Y, lstEnemyData[index].weight)))
{
lstEnemyData[index].position.Y += SystemOperator.PixelPerSecond(lstEnemyData[index].weight);
if (!lstEnemyData[index].isFalling)
{
lstEnemyData[index].fallingStartPoint = pos.Y;
}
lstEnemyData[index].isFalling = true;
}
else
{
if (lstEnemyData[index].isFalling)
{
int block = 0;
block = (int)(pos.Y - lstEnemyData[index].fallingStartPoint) / 32;
if (block > lstEnemyData[index].fallingEndure)
{
Sound.SoundEffectSelector(SeName.Shock);
Sound.SoundEffectPlayer(SeName.Shock);
lstEnemyData[index].life -= 1;
}
}
lstEnemyData[index].isFalling = false;
lstEnemyData[index].jumpCount = 0;
}
}
}
public void Around(BlockCheck check)
{
for(var inx = -1; inx < 2; inx++)
{
for (var inz = -1; inz < 2; inz++)
{
//This skips checking of the center block
if (inx == 0 && inz == 0) continue;
//This checks to make sure were not checking corners
if (Math.Abs(inx) == 1 && Math.Abs(inz) == 1) continue;
//Create a new BlockPos struct
BlockPos blockPos = Diff(inx, 0, inz);
//Check if were inbounds, if not we don't check this one
if (!blockPos.InBounds) continue;
//Perform the delegate call!
check(blockPos);
}
}
}
public static void MovePlayer(Canvas canvas)
{
if (KeyController.keyLeft)
{
if (!BlockCheck.BlockCheckLeft(playerPos.X, playerPos.Y, (int)playerSize.Y, moveSpeed) &&
!ObjectChecker.obstacleLeft)
{
if (playerPos.X - SystemOperator.PixelPerSecond(moveSpeed) > 0)
{
playerPos.X -= SystemOperator.PixelPerSecond(moveSpeed);
SystemOperator.moveCommonAmountX = moveSpeed;
}
playerDirection = false;
}
}
if (KeyController.keyRight)
{
if (!BlockCheck.BlockCheckRight(playerPos.X, playerPos.Y, (int)playerSize.X, (int)playerSize.Y, moveSpeed) &&
!ObjectChecker.obstacleRight)
{
if (playerPos.X + SystemOperator.PixelPerSecond(moveSpeed) < 992)
{
playerPos.X += SystemOperator.PixelPerSecond(moveSpeed);
SystemOperator.moveCommonAmountX = moveSpeed;
}
playerDirection = true;
}
}
if (KeyController.keyLeft || KeyController.keyRight)
{
isMove = true;
}
else
{
isMove = false;
}
if (KeyController.keyUp && !TalkCommander.isTalk &&
!ObjectChecker.obstacleUp)
{
if (isLadder)
{
if (playerPos.Y - SystemOperator.PixelPerSecond(moveSpeed) > 0)
{
playerPos.Y -= SystemOperator.PixelPerSecond(moveSpeed);
SystemOperator.moveCommonAmountY = moveSpeed;
}
}
}
if (KeyController.keyDown && !TalkCommander.isTalk &&
!ObjectChecker.obstacleDown)
{
if (isLadder)
{
if (playerPos.Y + SystemOperator.PixelPerSecond(moveSpeed) < 768)
{
playerPos.Y += SystemOperator.PixelPerSecond(moveSpeed);
SystemOperator.moveCommonAmountY = moveSpeed;
}
}
if (isPlat)
{
if (playerPos.Y + SystemOperator.PixelPerSecond(moveSpeed) < 768)
{
playerPos.Y += SystemOperator.PixelPerSecond(moveSpeed);
SystemOperator.moveCommonAmountY = moveSpeed;
}
}
if (!isLadder)
{
isSquat = true;
}
}
else
{
isSquat = false;
}
//jump
if (KeyController.keySpace && jumpCount == 0)
{
if (playerPos.Y - jumpPower > 0)
{
jumpCount++;
jumping = true;
}
}
if (jumping)
{
if (jumpTotalLength < jumpMaxHeight &&
!BlockCheck.BlockCheckTop(playerPos.X, playerPos.Y, (int)playerSize.X, jumpPower) &&
!ObjectChecker.obstacleUp)
{
playerPos.Y -= SystemOperator.PixelPerSecond(jumpPower);
SystemOperator.moveCommonAmountY = SystemOperator.PixelPerSecond(jumpPower);
jumpTotalLength += SystemOperator.PixelPerSecond(jumpPower);
}
else
{
jumping = false;
jumpTotalLength = 0;
}
}
//itemget
if (KeyController.keyA)
{
PlayerItemGetting(canvas);
}
//Attack
if (KeyController.keyS)
{
SubWeapon.SubWeaponGenerate(canvas, playerPos.X, playerPos.Y);
}
if (KeyController.keyD)
{
if (!isMainAttack)
{
MainWeapon.imgMainWeapon.Visibility = Visibility.Visible;
meleeDirection = playerDirection;
isMainAttack = true;
}
}
if (KeyController.keyE)
{
if (ObjectChecker.isTrigger && !TalkCommander.isTalk)
{
ObjectBehavior.OnTriggerReactEvent();
}
}
if (isKnockBack)
{
SystemOperator.BoundObject(ref playerPos, boundDirectionX, ref knockBackTotalDis, knockBackTargetDis,
ref knockBackBps, ref coefficient, ref boundDirectionY,
weight, moveSpeed, jumpPower, playerSize, ref isKnockBack);
}
//image change
if (GameTransition.gameTransition == GameTransitionType.StageDuring)
{
if (KeyController.keyLeft || KeyController.keyRight)
{
if (!playerDirection)
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteMoveL);
}
else
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteMoveR);
}
}
else
{
if (!playerDirection)
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteIdleL);
}
else
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteIdleR);
}
}
if (isSquat)
{
if (!playerDirection)
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteSquatL);
}
else
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteSquatR);
}
}
if (jumping)
{
if (!playerDirection)
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteJumpL);
}
else
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteJumpR);
}
}
if (isLadder && (KeyController.keyUp || KeyController.keyDown))
{
ImageData.imgPlayer.Source = ImageData.ImageSourceSelector(CategoryName.Player, StageData.lstDbPlayer.spriteLadder);
}
}
Canvas.SetLeft(ImageData.imgPlayer, playerPos.X);
Canvas.SetTop(ImageData.imgPlayer, playerPos.Y);
}
public static void BoundObject(ref Vector pos, bool charaDir, ref Vector total, Vector target, ref Vector bps,
ref double coefficient, ref bool boundDir, int weight, int speed, int jumppower,
Vector size, ref bool isKnockBack)
{
double addY = 0;
double radian = 0;
bps.X = target.X / 32 * PixelPerSecond(64);
bps.Y = target.Y * bps.X / target.X;
addY = coefficient * weight / (target.X / 2) * 0.102;
radian = Math.Atan(bps.Y - addY / bps.X) * Math.PI / 180;
if (!boundDir)
{
if (total.Y < target.Y)
{
if (!charaDir)
{
if (!BlockCheck.BlockCheckLeft(pos.X - bps.X, pos.Y, (int)size.Y, speed) &&
pos.X - bps.X > 0)
{
pos.X -= bps.X;
}
}
else
{
if (!BlockCheck.BlockCheckRight(pos.X + bps.X, pos.Y, (int)size.X, (int)size.Y, speed) &&
pos.X + bps.X < 1024 - (int)size.X)
{
pos.X += bps.X;
}
}
if (!BlockCheck.BlockCheckTop(pos.X, pos.Y - bps.Y, (int)size.X, jumppower) &&
pos.Y - bps.Y > 0)
{
pos.Y -= bps.Y;
}
total.X += Math.Sqrt(Math.Pow(bps.X, 2));
total.Y += Math.Sqrt(Math.Pow(bps.Y, 2));
bps.X += bps.X;
bps.Y += bps.Y;
coefficient++;
}
else
{
boundDir = true;
total.Y = target.Y;
}
}
else
{
if (total.Y > 0)
{
if (!charaDir)
{
if (!BlockCheck.BlockCheckLeft(pos.X - bps.X, pos.Y, (int)size.Y, speed) &&
pos.X - bps.X > 0)
{
pos.X -= bps.X;
}
}
else
{
if (!BlockCheck.BlockCheckRight(pos.X + bps.X, pos.Y, (int)size.X, (int)size.Y, speed) &&
pos.X + bps.X < 1024 - (int)size.X)
{
pos.X += bps.X;
}
}
if (!BlockCheck.BlockCheckBottom(pos.X, pos.Y + bps.Y, (int)size.X, (int)size.Y, weight) &&
pos.Y + bps.Y < 768 - (int)size.Y)
{
pos.Y += bps.Y;
}
total.X += Math.Sqrt(Math.Pow(bps.X, 2));
total.Y -= Math.Sqrt(Math.Pow(bps.Y, 2));
bps.X += bps.X;
bps.Y += bps.Y;
coefficient--;
}
else
{
boundDir = false;
isKnockBack = false;
}
}
}
