public static Vec2Double GetTargetWithSafeArea(int saveArea, Vec2Double mePosition, Vec2Double meTarget, Game game)
{
double x;
if (mePosition.X > meTarget.X)
{
x = meTarget.X + saveArea > Constants.MaxXArrayTile
? meTarget.X - saveArea
: meTarget.X + saveArea;
}
else
{
x = meTarget.X - saveArea < 0
? meTarget.X + saveArea
: meTarget.X - saveArea;
if (x < 1)
{
x = 1;
}
}
var y = FindYOnGround(x, game);
return(new Vec2Double(x, y));
}
public static Unit ReadFrom(System.IO.BinaryReader reader)
{
var result = new Unit();
result.PlayerId = reader.ReadInt32();
result.Id = reader.ReadInt32();
result.Health = reader.ReadInt32();
result.Position = Vec2Double.ReadFrom(reader);
result.Size = Vec2Double.ReadFrom(reader);
result.JumpState = JumpState.ReadFrom(reader);
result.WalkedRight = reader.ReadBoolean();
result.Stand = reader.ReadBoolean();
result.OnGround = reader.ReadBoolean();
result.OnLadder = reader.ReadBoolean();
result.Mines = reader.ReadInt32();
if (reader.ReadBoolean())
{
result.Weapon = Model.Weapon.ReadFrom(reader);
}
else
{
result.Weapon = null;
}
return(result);
}
public static Vec2Double ReadFrom(System.IO.BinaryReader reader)
{
var result = new Vec2Double();
result.X = reader.ReadDouble();
result.Y = reader.ReadDouble();
return(result);
}
public static Vec2Double AsHalf(this Vec2Double a, bool rightToLeft = false)
{
if (rightToLeft)
{
return(new Vec2Double(a.X * 2, a.Y));
}
return(new Vec2Double(a.X / 2, a.Y));
}
public static LootBox ReadFrom(System.IO.BinaryReader reader)
{
var result = new LootBox();
result.Position = Vec2Double.ReadFrom(reader);
result.Size = Vec2Double.ReadFrom(reader);
result.Item = Item.ReadFrom(reader);
return(result);
}
private void DoPath(Map map, Unit unit, Vec2Double target)
{
var pathF = new PathFinderFast(map.MGrid, map);
_path = pathF.FindPath(new Vector2I((int)unit.Position.X, (int)unit.Position.Y), new Vector2I((int)target.X, (int)target.Y), 1, 2, 5, 10);
_path?.Reverse();
_i = 0;
_pathLength = 0;
}
public static double Build(Strategy strategy, Unit player, Vec2Double target, Tile[][] tiles)
{
if (strategy.Type == StrategyType.Kill && (player.OnLadder(tiles) == false && player.OnJumper(tiles) == false))
{
return(target.X - player.Position.X);
}
return(target.X < player.Position.X ? double.MinValue : double.MaxValue);
}
public Mine(int playerId, Vec2Double position, Vec2Double size, MineState state, double?timer, double triggerRadius, ExplosionParameters explosionParameters)
{
PlayerId = playerId;
Position = position;
Size = size;
State = state;
Timer = timer;
TriggerRadius = triggerRadius;
ExplosionParameters = explosionParameters;
}
private static bool IsHit(double bulletX, double bulletY, Vec2Double unitPos)
{
if (bulletX >= unitPos.X - _properties.UnitSize.X / 2 && bulletX <= unitPos.X + _properties.UnitSize.X / 2 &&
bulletY >= unitPos.Y && bulletY <= unitPos.Y + _properties.UnitSize.Y)
{
return(true);
}
return(false);
}
public Bullet(WeaponType weaponType, int unitId, int playerId, Vec2Double position, Vec2Double velocity, int damage, double size, ExplosionParameters?explosionParameters)
{
WeaponType = weaponType;
UnitId = unitId;
PlayerId = playerId;
Position = position;
Velocity = velocity;
Damage = damage;
Size = size;
ExplosionParameters = explosionParameters;
}
public UnitAction(double velocity, bool jump, bool jumpDown, Vec2Double aim, bool shoot, bool reload, bool swapWeapon, bool plantMine)
{
Velocity = velocity;
Jump = jump;
JumpDown = jumpDown;
Aim = aim;
Shoot = shoot;
Reload = reload;
SwapWeapon = swapWeapon;
PlantMine = plantMine;
}
public Bullet(WeaponType weaponType, int unitId, int playerId, Vec2Double position, Vec2Double velocity, int damage, double size, ExplosionParameters explosionParameters)
{
WeaponType = weaponType;
UnitId = unitId;
PlayerId = playerId;
Position = position ?? throw new System.ArgumentNullException(nameof(position));
Velocity = velocity ?? throw new System.ArgumentNullException(nameof(velocity));
Damage = damage;
Size = size;
ExplosionParameters = explosionParameters;
}
public static Properties ReadFrom(System.IO.BinaryReader reader)
{
var result = new Properties();
result.MaxTickCount = reader.ReadInt32();
result.TeamSize = reader.ReadInt32();
result.TicksPerSecond = reader.ReadDouble();
result.UpdatesPerTick = reader.ReadInt32();
result.LootBoxSize = Vec2Double.ReadFrom(reader);
result.UnitSize = Vec2Double.ReadFrom(reader);
result.UnitMaxHorizontalSpeed = reader.ReadDouble();
result.UnitFallSpeed = reader.ReadDouble();
result.UnitJumpTime = reader.ReadDouble();
result.UnitJumpSpeed = reader.ReadDouble();
result.JumpPadJumpTime = reader.ReadDouble();
result.JumpPadJumpSpeed = reader.ReadDouble();
result.UnitMaxHealth = reader.ReadInt32();
result.HealthPackHealth = reader.ReadInt32();
int WeaponParametersSize = reader.ReadInt32();
result.WeaponParameters = new System.Collections.Generic.Dictionary <WeaponType, WeaponParameters>(WeaponParametersSize);
for (int i = 0; i < WeaponParametersSize; i++)
{
WeaponType WeaponParametersKey;
switch (reader.ReadInt32())
{
case 0:
WeaponParametersKey = WeaponType.Pistol;
break;
case 1:
WeaponParametersKey = WeaponType.AssaultRifle;
break;
case 2:
WeaponParametersKey = WeaponType.RocketLauncher;
break;
default:
throw new System.Exception("Unexpected discriminant value");
}
WeaponParameters WeaponParametersValue;
WeaponParametersValue = Model.WeaponParameters.ReadFrom(reader);
result.WeaponParameters.Add(WeaponParametersKey, WeaponParametersValue);
}
result.MineSize = Vec2Double.ReadFrom(reader);
result.MineExplosionParameters = ExplosionParameters.ReadFrom(reader);
result.MinePrepareTime = reader.ReadDouble();
result.MineTriggerTime = reader.ReadDouble();
result.MineTriggerRadius = reader.ReadDouble();
result.KillScore = reader.ReadInt32();
return(result);
}
public static UnitAction ReadFrom(System.IO.BinaryReader reader)
{
var result = new UnitAction();
result.Velocity = reader.ReadDouble();
result.Jump = reader.ReadBoolean();
result.JumpDown = reader.ReadBoolean();
result.Aim = Vec2Double.ReadFrom(reader);
result.Shoot = reader.ReadBoolean();
result.Reload = reader.ReadBoolean();
result.SwapWeapon = reader.ReadBoolean();
result.PlantMine = reader.ReadBoolean();
return(result);
}
public Unit(int playerId, int id, int health, Vec2Double position, Vec2Double size, JumpState jumpState, bool walkedRight, bool stand, bool onGround, bool onLadder, int mines, Weapon weapon)
{
PlayerId = playerId;
Id = id;
Health = health;
Position = position ?? throw new System.ArgumentNullException(nameof(position));
Size = size ?? throw new System.ArgumentNullException(nameof(size));
JumpState = jumpState ?? throw new System.ArgumentNullException(nameof(jumpState));
WalkedRight = walkedRight;
Stand = stand;
OnGround = onGround;
OnLadder = onLadder;
Mines = mines;
Weapon = weapon;
}
public Unit(int playerId, int id, int health, Vec2Double position, Vec2Double size, JumpState jumpState, bool walkedRight, bool stand, bool onGround, bool onLadder, int mines, Weapon?weapon)
{
PlayerId = playerId;
Id = id;
Health = health;
Position = position;
Size = size;
JumpState = jumpState;
WalkedRight = walkedRight;
Stand = stand;
OnGround = onGround;
OnLadder = onLadder;
Mines = mines;
Weapon = weapon;
}
private UnitAction GetOldAction(Unit unit, Game game, Unit enemy, Vec2Double target, Vec2Double aim, bool shoot, WeaponType weaponType)
{
var jumpData = _jumpProvider.GetJump(unit, game, target, enemy);
return(new UnitAction
{
Velocity = 0.5d >= unit.Position.X - target.X ? 10 : -10,
Jump = jumpData.jump,
JumpDown = jumpData.jumpDown,
Aim = aim,
Shoot = unit.Weapon.HasValue && shoot,
Reload = false,
SwapWeapon = !unit.Weapon.HasValue || unit.Weapon.Value.Typ != weaponType,
PlantMine = false
});
}
public static Vec2Double CheckSpringsNear(Vec2Double target, Game game)
{
var tileRight = game.Level.Tiles[(int)target.X + 1][(int)target.Y];
var tileLeft = game.Level.Tiles[(int)target.X - 1][(int)target.Y];
if (tileRight == Tile.JumpPad || tileLeft == Tile.JumpPad)
{
Vec2Double fixedTarget;
fixedTarget = tileRight == Tile.JumpPad
? new Vec2Double(target.X - 0.5, target.Y)
: new Vec2Double(target.X + 0.5, target.Y);
return(fixedTarget);
}
return(target);
}
public Vec2Double Shift(Vec2Double target, Game game)
{
var targetX = (int)target.X;
var targetY = (int)target.Y;
if (game.Level.Tiles[targetX + 1][targetY] == Tile.JumpPad)
{
return(new Vec2Double(target.X - 0.45f, target.Y + 1));
}
if (game.Level.Tiles[targetX - 1][targetY] == Tile.JumpPad)
{
return(new Vec2Double(target.X + 0.45f, target.Y + 1));
}
return(target);
}
public static UnitAction ReadFrom(System.IO.BinaryReader reader)
{
if (reader == null)
{
throw new System.ArgumentNullException(nameof(reader));
}
return(new UnitAction(
reader.ReadDouble(),
reader.ReadBoolean(),
reader.ReadBoolean(),
Vec2Double.ReadFrom(reader),
reader.ReadBoolean(),
reader.ReadBoolean(),
reader.ReadBoolean(),
reader.ReadBoolean()));
}
private bool IsCrossTile(double playerX, double playerY, double shootAngle, ref Vec2Double top, ref Vec2Double bot)
{
var topAngle = GetAngle(playerX, playerY, top.X, top.Y);
var botAngle = GetAngle(playerX, playerY, bot.X, bot.Y);
if (double.IsInfinity(topAngle))
{
return(botAngle <= shootAngle);
}
if (double.IsInfinity(botAngle))
{
return(topAngle >= shootAngle);
}
return((topAngle >= shootAngle || topAngle > 1000000 || topAngle < -1000000) && (botAngle <= shootAngle || botAngle > 1000000 || botAngle < -1000000));
}
private static bool IsVisible(Vec2Double mePos, Vec2Double enemyPos)
{
const double step = 0.5;
if (Math.Abs(mePos.X - enemyPos.X) >
Math.Abs(mePos.Y - enemyPos.Y))
{
double startX = mePos.X < enemyPos.X ? mePos.X : enemyPos.X;
double endX = mePos.X < enemyPos.X ? enemyPos.X : mePos.X;
for (double x = startX + step; x < endX; x += step)
{
var y = Y(mePos, enemyPos, x);
if (GetTile(x, y) == Tile.Wall)
{
return(false);
}
if (_friend != null && IsHit(x, y, _friend.Value.Position))
{
return(false);
}
}
}
else
{
double startY = mePos.Y < enemyPos.Y ? mePos.Y : enemyPos.Y;
double endY = mePos.Y < enemyPos.Y ? enemyPos.Y : mePos.Y;
for (double y = startY + step; y < endY; y += step)
{
var x = X(mePos, enemyPos, y);
if (GetTile(x, y) == Tile.Wall)
{
return(false);
}
if (_friend != null && IsHit(x, y, _friend.Value.Position))
{
return(false);
}
}
}
return(true);
}
public static Unit ReadFrom(System.IO.BinaryReader reader)
{
if (reader == null)
throw new System.ArgumentNullException(nameof(reader));
var playerId = reader.ReadInt32();
var id = reader.ReadInt32();
var health = reader.ReadInt32();
var position = Vec2Double.ReadFrom(reader);
var size = Vec2Double.ReadFrom(reader);
var jumpState = JumpState.ReadFrom(reader);
var walkedRight = reader.ReadBoolean();
var stand = reader.ReadBoolean();
var onGround = reader.ReadBoolean();
var onLadder = reader.ReadBoolean();
var mines = reader.ReadInt32();
var weapon = reader.ReadBoolean() ? Weapon.ReadFrom(reader) : null;
return new Unit(playerId, id, health, position, size, jumpState, walkedRight, stand, onGround, onLadder, mines, weapon);
}
public static Mine ReadFrom(System.IO.BinaryReader reader)
{
if (reader == null)
{
throw new System.ArgumentNullException(nameof(reader));
}
var playerId = reader.ReadInt32();
var position = Vec2Double.ReadFrom(reader);
var size = Vec2Double.ReadFrom(reader);
MineState state;
switch (reader.ReadInt32())
{
case 0:
state = MineState.Preparing;
break;
case 1:
state = MineState.Idle;
break;
case 2:
state = MineState.Triggered;
break;
case 3:
state = MineState.Exploded;
break;
default:
throw new System.Exception("Unexpected discriminant value");
}
var timer = reader.ReadBoolean() ? reader.ReadDouble() : (double?)null;
var triggerRadius = reader.ReadDouble();
var explosionParameters = ExplosionParameters.ReadFrom(reader);
return(new Mine(playerId, position, size, state, timer, triggerRadius, explosionParameters));
}
public static Mine ReadFrom(System.IO.BinaryReader reader)
{
var result = new Mine();
result.PlayerId = reader.ReadInt32();
result.Position = Vec2Double.ReadFrom(reader);
result.Size = Vec2Double.ReadFrom(reader);
switch (reader.ReadInt32())
{
case 0:
result.State = MineState.Preparing;
break;
case 1:
result.State = MineState.Idle;
break;
case 2:
result.State = MineState.Triggered;
break;
case 3:
result.State = MineState.Exploded;
break;
default:
throw new System.Exception("Unexpected discriminant value");
}
if (reader.ReadBoolean())
{
result.Timer = reader.ReadDouble();
}
else
{
result.Timer = null;
}
result.TriggerRadius = reader.ReadDouble();
result.ExplosionParameters = ExplosionParameters.ReadFrom(reader);
return(result);
}
private static bool IsPossibleShoot(Vec2Double mePos, Vec2Double enemyPos)
{
if (_me.Weapon == null)
{
return(false);
}
var meWeapon = _me.Weapon.Value;
if (meWeapon.FireTimer != null && meWeapon.FireTimer >= 0.02)
{
return(false);
}
var halfBulletSize = meWeapon.Parameters.Bullet.Size / 2;
var leftBulletPos = new Vec2Double(mePos.X - halfBulletSize, mePos.Y + _properties.UnitSize.Y / 2);
var rightBulletPos = meWeapon.Typ != WeaponType.RocketLauncher
? new Vec2Double(mePos.X + halfBulletSize, mePos.Y + _properties.UnitSize.Y / 2)
: new Vec2Double(mePos.X + halfBulletSize, mePos.Y);
var enemyUp = enemyPos.Y + _properties.UnitSize.Y;
var enemyLeftUpAngle = new Vec2Double(enemyPos.X - _properties.UnitSize.X / 2, enemyUp);
var enemyRightDownAngle = new Vec2Double(enemyPos.X + _properties.UnitSize.X / 2, enemyPos.Y);
if (meWeapon.Typ != WeaponType.RocketLauncher)
{
return((IsVisible(leftBulletPos, enemyRightDownAngle) && IsVisible(rightBulletPos, enemyRightDownAngle)) ||
(IsVisible(leftBulletPos, enemyLeftUpAngle) && IsVisible(rightBulletPos, enemyLeftUpAngle)));
}
var downLeftBulletPos = new Vec2Double(mePos.X - halfBulletSize, mePos.Y);
var upLeftBulletPos = new Vec2Double(mePos.X - halfBulletSize, mePos.Y + _properties.UnitSize.Y);
var downRightBulletPos = new Vec2Double(mePos.X + halfBulletSize, mePos.Y);
var upRightBulletPos = new Vec2Double(mePos.X + halfBulletSize, mePos.Y + _properties.UnitSize.Y);
return(IsVisible(downLeftBulletPos, enemyRightDownAngle) && IsVisible(downRightBulletPos, enemyRightDownAngle) &&
IsVisible(upLeftBulletPos, enemyRightDownAngle) && IsVisible(upRightBulletPos, enemyRightDownAngle) &&
IsVisible(downLeftBulletPos, enemyLeftUpAngle) && IsVisible(downRightBulletPos, enemyLeftUpAngle) &&
IsVisible(upLeftBulletPos, enemyLeftUpAngle) && IsVisible(upRightBulletPos, enemyLeftUpAngle));
}
private static bool SetShootMode(Vec2Double targetPosition, Debug debug = null, bool?shoot = null)
{
if (shoot != null)
{
Me.Shoot = shoot.Value;
}
else
{
if (Me.RLEquiped)
{
if (Me.Health <= Constants.OneShotRLHealth && // not kamikaze shooting
Around.NearestEnemy.Health > 70 &&
Measure.GetDistance(Me.Position, Around.NearestEnemy.Position) <= 5)
{
return(false);
}
if (Around.Teammate != null)
{
if (Measure.GetDistance(Around.Teammate.Position, Around.NearestEnemy.Position) <= 5) // no friedlyfire shooting
{
return(false);
}
}
if (Measure.GetDistance(Me.Position, Around.NearestEnemy.Position) <= 5)
{
return(Measure.IsStraightVisible(Me, targetPosition, Game, Around));
}
return(Measure.RLAimed(Me, targetPosition, Game, Debug) &
Measure.IsStraightVisible(Me, targetPosition, Game, Around, Debug));
}
return(Measure.IsStraightVisible(Me, targetPosition, Game, Around, Debug));
}
return(Me.Shoot);
}
public (bool jump, bool jumpDown) GetJump(Unit unit, Game game, Vec2Double targetPos, Unit enemy)
{
var isOnPlatform = IsOnPlatform(unit, game);
if (_lastTickOnPlatform && !isOnPlatform)
{
_lastTickOnPlatform = false;
return(false, false);
}
_lastTickOnPlatform = isOnPlatform;
bool jump = targetPos.Y > unit.Position.Y;
if (targetPos.X > unit.Position.X && game.Level.Tiles[(int)(unit.Position.X + 1)][(int)(unit.Position.Y)] == Tile.Wall)
{
jump = true;
}
if (targetPos.X < unit.Position.X && game.Level.Tiles[(int)(unit.Position.X - 1)][(int)(unit.Position.Y)] == Tile.Wall)
{
jump = true;
}
if (unit.Position.DistanceSqr(enemy.Position) < 9)
{
jump = true;
}
if (Math.Abs(unit.Position.X - enemy.Position.X) < 0.9 &&
unit.Position.Y - enemy.Position.Y > 1 &&
unit.Position.Y - enemy.Position.Y < 3 &&
unit.Health > Extensions.HealthForRunToMed)
{
jump = false;
}
return(jump, !jump);
}
public static Bullet ReadFrom(System.IO.BinaryReader reader)
{
var result = new Bullet();
switch (reader.ReadInt32())
{
case 0:
result.WeaponType = WeaponType.Pistol;
break;
case 1:
result.WeaponType = WeaponType.AssaultRifle;
break;
case 2:
result.WeaponType = WeaponType.RocketLauncher;
break;
default:
throw new System.Exception("Unexpected discriminant value");
}
result.UnitId = reader.ReadInt32();
result.PlayerId = reader.ReadInt32();
result.Position = Vec2Double.ReadFrom(reader);
result.Velocity = Vec2Double.ReadFrom(reader);
result.Damage = reader.ReadInt32();
result.Size = reader.ReadDouble();
if (reader.ReadBoolean())
{
result.ExplosionParameters = Model.ExplosionParameters.ReadFrom(reader);
}
else
{
result.ExplosionParameters = null;
}
return(result);
}
public static Bullet ReadFrom(System.IO.BinaryReader reader)
{
if (reader == null)
{
throw new System.ArgumentNullException(nameof(reader));
}
WeaponType weaponType;
switch (reader.ReadInt32())
{
case 0:
weaponType = WeaponType.Pistol;
break;
case 1:
weaponType = WeaponType.AssaultRifle;
break;
case 2:
weaponType = WeaponType.RocketLauncher;
break;
default:
throw new System.Exception("Unexpected discriminant value");
}
var unitId = reader.ReadInt32();
var playerId = reader.ReadInt32();
var position = Vec2Double.ReadFrom(reader);
var velocity = Vec2Double.ReadFrom(reader);
var damage = reader.ReadInt32();
var size = reader.ReadDouble();
var explosionParameters = reader.ReadBoolean() ? ExplosionParameters.ReadFrom(reader) : null;
return(new Bullet(weaponType, unitId, playerId, position, velocity, damage, size, explosionParameters));
}
