public static Hockeyist NearestOpponent(this Hockeyist me)
{
var world = Get <World> .Current();
Hockeyist nearestOpponent = null;
double nearestOpponentRange = 0.0D;
foreach (Hockeyist hockeyist in world.Hockeyists)
{
if (hockeyist.IsTeammate ||
hockeyist.Type == HockeyistType.Goalie ||
hockeyist.State == HockeyistState.KnockedDown ||
hockeyist.State == HockeyistState.Resting)
{
continue;
}
double opponentRange = MathUtil.Hypot(me.X - hockeyist.X, me.Y - hockeyist.Y);
if (nearestOpponent == null || opponentRange < nearestOpponentRange)
{
nearestOpponent = hockeyist;
nearestOpponentRange = opponentRange;
}
}
return(nearestOpponent);
}
public My(Hockeyist _self, World _world, Game _game, Move _move)
{
self = _self;
world = _world;
game = _game;
move = _move;
}
public static bool CanStrike(this Hockeyist self, Unit unit)
{
var angle = self.GetAngleTo(unit);
return((Math.Abs(angle) <= 0.5 * Current.Game.StickSector) &&
(self.GetDistanceTo(unit) <= Current.Game.StickLength));
}
private void Init()
{
self = (Hockeyist)args[0];
world = (World)args[1];
game = (Game)args[2];
move = (Move)args[3];
}
private void HasGoalieStrikeLogic(Hockeyist enemyGoalie)
{
Move.Action = Self.SwingTicks < Current.Stratagy.RandomSwingCount
? ActionType.Swing
: ActionType.Strike;
if (Move.Action == ActionType.Swing)
{
var xPossibleConnection = Math.Abs((Self.Y + Self.SpeedY * Current.Game.SwingActionCooldownTicks - enemyGoalie.Y) / Math.Tan(Self.Angle));
double offset = 1.0D;
if (Self.X - enemyGoalie.X > 0.0)
{
offset = -1.0D;
}
var dis = UnitHelper.GetDistance(Self.X + Self.SpeedX * Current.Game.SwingActionCooldownTicks + xPossibleConnection * offset,
enemyGoalie.Y,
enemyGoalie.X + offset * enemyGoalie.Radius * -1.0D,
enemyGoalie.Y);
if (dis < 2.0D * enemyGoalie.Radius)
{
Move.Action = ActionType.Strike;
}
}
}
public void StayOn(Hockeyist self, Point to, Point lookAt)
{
if (!FindPath(self, to, lookAt))
{
DoMove(self, to, GetTicksToUp(new AHock(self), to) < GetTicksToDown(new AHock(self), to) ? 1 : -1);
}
}
private static Hockeyist getNearestOpponent(double x, double y, World world)
{
Hockeyist nearestOpponent = null;
double nearestOpponentRange = 0.0D;
foreach (Hockeyist hockeyist in world.Hockeyists)
{
if (hockeyist.IsTeammate || hockeyist.Type == HockeyistType.Goalie ||
hockeyist.State == HockeyistState.KnockedDown ||
hockeyist.State == HockeyistState.Resting)
{
continue;
}
double opponentRange = hypot(x - hockeyist.X, y - hockeyist.Y);
if (nearestOpponent == null || opponentRange < nearestOpponentRange)
{
nearestOpponent = hockeyist;
nearestOpponentRange = opponentRange;
}
}
return(nearestOpponent);
}
double ProbabStrikeAfter(int swingTime, Hockeyist self, IEnumerable <MoveAction> actions, ActionType actionType)
{
var I = new AHock(self);
if (Math.Abs(My.NetFront - I.X) < RinkWidth / 3)
{
return(0.0);
}
var power = GetPower(I, swingTime);
var totalTime = 0;
var opps = Hockeyists
.Where(x => !x.IsTeammate && IsInGame(x))
.Select(x => new AHock(x))
.ToArray();
var goalie = Get(OppGoalie);
foreach (var action in actions)
{
for (var i = 0; i < action.Ticks; i++)
{
GoalieMove(goalie, 1, I.PuckPos());
I.Move(action.SpeedUp, action.Turn);
if (!Chase(opps, I))
{
return(0.0);
}
}
totalTime += action.Ticks;
}
var passAngle = PassAngleNorm(I.GetAngleTo(GetStrikePoint()));
return(StrikeProbability(I, power, goalie, totalTime, actionType, passAngle, null));
}
public static bool IsHunter(this Hockeyist me)
{
var world = Get <World> .Current();
var teammate = world.MyTeam().First(x => x.Id != me.Id);
return(world.Puck.OwnerHockeyistId == me.Id || me.GetDistanceTo(world.Puck) < teammate.GetDistanceTo(world.Puck));
}
public bool FindPath(Hockeyist self, Point to, Point lookAt)
{
if (lookAt == null)
{
return(StopOn(new AHock(self), to));
}
var okDist = HoRadius * 1.5;
var minTime = Inf;
var selTurn = 0.0;
var selSpUp = 0.0;
for (var dir = -1; dir <= 1; dir += 2)
{
var hock = new AHock(self);
for (var ticksDirect = 0; ticksDirect < 100; ticksDirect++)
{
var curTime = ticksDirect;
var ho = hock.Clone();
while (Math.Abs(ho.GetAngleTo(lookAt)) > Deg(8))
{
ho.Move(0, TurnNorm(ho.GetAngleTo(lookAt), ho.AAgility));
curTime++;
}
if (curTime < minTime && ho.GetDistanceTo(to) < okDist)
{
minTime = curTime;
if (ticksDirect == 0)
{
selSpUp = 0.0;
selTurn = TurnNorm(ho.GetAngleTo(lookAt), hock.AAgility);
}
else if (dir > 0)
{
selTurn = self.GetAngleTo(to.X, to.Y);
selSpUp = GetSpeedTo(selTurn);
}
else
{
selTurn = RevAngle(self.GetAngleTo(to.X, to.Y));
selSpUp = -GetSpeedTo(selTurn);
}
}
if (dir > 0)
{
GetTicksToUpN(hock, to, 0, 1);
}
else
{
GetTicksToDownN(hock, to, 0, 1);
}
}
}
move.SpeedUp = selSpUp;
move.Turn = selTurn;
return(minTime != Inf);
}
public double Stamina; // TODO: учитавать изменение?
public AHock(Hockeyist self) : base(MyStrategy.Get(self), MyStrategy.GetSpeed(self), self.Angle)
{
Base = self;
AngularSpeed = self.AngularSpeed;
Angle = self.Angle;
CoolDown = self.RemainingCooldownTicks;
KnockDown = self.RemainingKnockdownTicks;
Stamina = self.Stamina;
}
public HunterBehaviour(Hockeyist h) : base(h)
{
getThePuck = new GetThePuckBehaviour(h);
strikePoints = new[]
{
new Point(attackLine, 650),
new Point(attackLine, 250)
};
}
private void Init(Hockeyist self, World world, Game game, Move move)
{
this.self = self;
this.world = world;
this.game = game;
this.move = move;
opponentPlayer = world.GetOpponentPlayer();
}
public Point FindWayPoint(Hockeyist self)
{
var okDist = 5 * HoRadius;
var bestTime = Inf;
Point sel = null;
//TimerStart();
var bot = Hockeyists.Count(x => !x.IsTeammate && IsInGame(x) && x.Y > RinkCenter.Y);
var top = Hockeyists.Count(x => !x.IsTeammate && IsInGame(x) && x.Y <= RinkCenter.Y);
foreach (Point p in WayPoints.ToArray().OrderBy(x => ((Point)x).GetDistanceTo(self)).Take(10))
{
var I = new AHock(self);
if (p.GetDistanceTo2(I) <= okDist * okDist || MyRight() && I.X < p.X || MyLeft() && I.X > p.X)
{
continue;
}
var cands = Hockeyists
.Where(x => !x.IsTeammate && IsInGame(x))
.Select(x => new AHock(x)).ToArray();
var time = 0;
var ok = true;
while (p.GetDistanceTo2(I) > okDist * okDist && ok)
{
I.MoveTo(p);
foreach (var c in cands)
{
c.MoveTo(I);
if (CanStrike(c, I.PuckPos()) || // достанет шайбу
CanStrike(c, I) || // достанет меня
I.GetDistanceTo2(c) <= 2 * HoRadius * 2 * HoRadius // столкнется со мной
)
{
ok = false;
break;
}
}
time++;
}
if (ok)
{
if (p.Y > RinkCenter.Y && bot > top || p.Y <= RinkCenter.Y && top > bot)
{
time *= 3;
}
if (time < bestTime)
{
bestTime = time;
sel = p.Clone();
}
}
}
//Log("FindWayPoint " + TimerStop());
return(sel);
}
public void Move(Hockeyist _self, World _world, Game _game, Move _move)
{
args.Add(_self); args.Add(_world); args.Add(_game); args.Add(_move);
Init();
opponentMinions = AllBadGuys();
//Инициализация позиций для удара
opponent = world.GetOpponentPlayer();
if (world.GetMyPlayer().NetFront > world.Width / 2)
{
amIRight = true;
AimGoalPoint[0] = opponent.NetFront + world.Width / 6 + self.Radius;
}
else
{
amIRight = false;
AimGoalPoint[0] = opponent.NetFront - world.Width / 6 - self.Radius;
}
if (self.Y < game.GoalNetTop + game.GoalNetHeight / 4)
{
AimGoalPoint[1] = game.GoalNetTop - self.Radius; // + game.GoalNetHeight/2;
}
else if (self.Y < game.GoalNetTop + game.GoalNetHeight * 3 / 4)
{
}
else
{
AimGoalPoint[1] = game.GoalNetTop + game.GoalNetHeight + self.Radius; // + game.GoalNetHeight/2;
}
//позиции для защиты
myNetDefPointX = 5 * world.GetMyPlayer().NetFront - 2 * world.GetMyPlayer().NetRight - 2 * world.GetMyPlayer().NetLeft;
myNetDefPointY = game.GoalNetTop + game.GoalNetHeight / 2;
bool flag = StrikeOpps();
if (flag)
{
}
else if (self.TeammateIndex == 0)
{
PlayAttack();
}
else if (self.TeammateIndex == 1)
{
PlayDefence();
}
// double x = world.Puck.X;
// double y = world.Puck.Y;
//gotoPuck();
args.Clear();
}
public AHock(Point pos, Point speed, double angle, double angularSpeed, int coolDown, int knockDown, double stamina, Hockeyist from)
: base(pos, speed, angle)
{
Base = from;
AngularSpeed = angularSpeed;
Angle = angle;
CoolDown = coolDown;
KnockDown = knockDown;
Stamina = stamina;
}
public void Move(Hockeyist self, World world, Game game, Move move)
{
Current.Move = move;
Current.World = world;
Current.Hockeyist = self;
Current.Game = game;
Current.Stratagy = this;
GameStates.Play();
}
// Проверка движение хоккеиста
void Research3(Hockeyist self)
{
var range = TurnRange(new AHock(self).AAgility);
move.Turn = range / 2;
move.SpeedUp = 0.8;
var pl = new AHock(self);
pl.Move(0.8, range / 2, 20);
}
// Проверка движение шайбы - OK
void Research4(Hockeyist self)
{
if (TK(190))
{
__puck = new APuck(puck, OppGoalie);
__puck.Move(10);
}
if (TK(190 + 10))
{
}
}
public int GetTicksTo(Point to, Hockeyist my, bool tryDown = true)
{
var ho = new AHock(my);
var up = GetTicksToUp(ho, to);
var down = tryDown ? GetTicksToDown(ho, to) : Inf;
if (up <= down)
{
return(up);
}
return(-down);
}
public void Move(Hockeyist self, World world, Game game, Move move)
{
if (self.State == HockeyistState.Swinging)
{
move.Action = ActionType.Strike;
return;
}
Init(self, world, game, move);
if (PuckUnderOurControl)
{
if (ThisHasPuck)
{
if (InStrikeZone())
{
if (Hypot(self.SpeedX, self.SpeedY) > 0.069)
{
move.SpeedUp = -1;
}
if (Math.Abs(TurnToNetFarCorner(self, move)) < STRIKE_ANGLE)
{
move.Action = ActionType.Swing;
}
}
else
{
GoToNearestStrikeZone();
}
}
else
{
var nearestOpponent = GetNearestOpponent();
if (nearestOpponent != null)
{
if (self.GetDistanceTo(nearestOpponent) > game.StickLength)
{
move.SpeedUp = 1.0D;
}
else if (Math.Abs(self.GetAngleTo(nearestOpponent)) < 0.5D * game.StickSector)
{
move.Action = ActionType.Strike;
}
move.Turn = self.GetAngleTo(nearestOpponent);
}
}
}
else
{
move.SpeedUp = 1.0D;
move.Turn = self.GetAngleTo(world.Puck);
move.Action = ActionType.TakePuck;
}
}
private double TurnToNetFarCorner(Hockeyist self, Move move)
{
double x;
double y;
GetNetFarCorner(out x, out y);
var angleToNet = self.GetAngleTo(x, y);
move.Turn = angleToNet;
return(angleToNet);
}
void DoMove(Hockeyist self, Point to, int direction)
{
if (direction > 0)
{
move.Turn = self.GetAngleTo(to.X, to.Y);
move.SpeedUp = GetSpeedTo(move.Turn);
}
else
{
move.Turn = RevAngle(self.GetAngleTo(to.X, to.Y));
move.SpeedUp = -GetSpeedTo(move.Turn);
}
}
private static Hockeyist GetGoalie(bool isTeammate)
{
Hockeyist goalie = null;
foreach (var hockeyist in Current.World.Hockeyists)
{
if (hockeyist.IsTeammate == isTeammate && hockeyist.Type == HockeyistType.Goalie)
{
goalie = hockeyist;
break;
}
}
return(goalie);
}
public void Move(Hockeyist self, World world, Game game, Move move)
{
if (self.State == HockeyistState.Swinging)
{
move.Action = ActionType.Strike;
return;
}
if (world.Puck.OwnerPlayerId == self.PlayerId)
{
if (world.Puck.OwnerHockeyistId == self.Id)
{
Player opponentPlayer = world.GetOpponentPlayer();
double netX = 0.5D * (opponentPlayer.NetBack + opponentPlayer.NetFront);
double netY = 0.5D * (opponentPlayer.NetBottom + opponentPlayer.NetTop);
netY += (self.Y < netY ? 0.5D : -0.5D) * game.GoalNetHeight;
double angleToNet = self.GetAngleTo(netX, netY);
move.Turn = angleToNet;
if (Math.Abs(angleToNet) < STRIKE_ANGLE)
{
move.Action = ActionType.Swing;
}
}
else
{
Hockeyist nearestOpponent = getNearestOpponent(self.X, self.Y, world);
if (nearestOpponent != null)
{
if (self.GetDistanceTo(nearestOpponent) > game.StickLength)
{
move.SpeedUp = 1.0D;
}
else if (Math.Abs(self.GetAngleTo(nearestOpponent)) < 0.5D * game.StickSector)
{
move.Action = ActionType.Strike;
}
move.Turn = self.GetAngleTo(nearestOpponent);
}
}
}
else
{
move.SpeedUp = 1.0D;
move.Turn = self.GetAngleTo(world.Puck);
move.Action = ActionType.TakePuck;
}
}
private Hockeyist[] AllBadGuys()
{
Hockeyist[] allguys = world.Hockeyists;
Hockeyist[] badguys = new Hockeyist[6];
int j = 0;
for (int i = 0; i < allguys.Length; i++)
{
if (allguys[i].Type != HockeyistType.Goalie && !allguys[i].IsTeammate)
{
badguys[j] = allguys[i];
j++;
}
}
return(badguys);
}
private void WriteHockeyist(Hockeyist hockeyist)
{
if (hockeyist == null)
{
WriteBoolean(false);
}
else
{
WriteBoolean(true);
WriteLong(hockeyist.Id);
WriteLong(hockeyist.PlayerId);
WriteInt(hockeyist.TeammateIndex);
WriteDouble(hockeyist.Mass);
WriteDouble(hockeyist.Radius);
WriteDouble(hockeyist.X);
WriteDouble(hockeyist.Y);
WriteDouble(hockeyist.SpeedX);
WriteDouble(hockeyist.SpeedY);
WriteDouble(hockeyist.Angle);
WriteDouble(hockeyist.AngularSpeed);
WriteBoolean(hockeyist.IsTeammate);
WriteEnum((sbyte?)hockeyist.Type);
WriteInt(hockeyist.Strength);
WriteInt(hockeyist.Endurance);
WriteInt(hockeyist.Dexterity);
WriteInt(hockeyist.Agility);
WriteDouble(hockeyist.Stamina);
WriteEnum((sbyte?)hockeyist.State);
WriteInt(hockeyist.OriginalPositionIndex);
WriteInt(hockeyist.RemainingKnockdownTicks);
WriteInt(hockeyist.RemainingCooldownTicks);
WriteInt(hockeyist.SwingTicks);
WriteEnum((sbyte?)hockeyist.LastAction);
if (hockeyist.LastActionTick == null)
{
WriteBoolean(false);
}
else
{
WriteBoolean(true);
WriteInt((int)hockeyist.LastActionTick);
}
}
}
private Hockeyist[] ReadHockeyists()
{
int hockeyistCount = ReadInt();
if (hockeyistCount < 0)
{
return(null);
}
Hockeyist[] hockeyists = new Hockeyist[hockeyistCount];
for (int hockeyistIndex = 0; hockeyistIndex < hockeyistCount; ++hockeyistIndex)
{
hockeyists[hockeyistIndex] = ReadHockeyist();
}
return(hockeyists);
}
private Hockeyist GetNearestOpponent()
{
Hockeyist nearestOpponent = null;
var nearestOpponentRange = 0.0D;
foreach (var hockeyist in world.Hockeyists.Where(h => !(h.IsTeammate || h.Type == HockeyistType.Goalie || h.State == HockeyistState.KnockedDown || h.State == HockeyistState.Resting)))
{
var opponentRange = Hypot(self.X - hockeyist.X, self.Y - hockeyist.Y);
if (nearestOpponent == null || opponentRange < nearestOpponentRange)
{
nearestOpponent = hockeyist;
nearestOpponentRange = opponentRange;
}
}
return(nearestOpponent);
}
protected override void Do()
{
if (Current.SaferCount > 0)
{
var distance = 0.0;
Hockeyist passer = null;
foreach (var friend in Current.World.Hockeyists)
{
if (friend.IsTeammate && friend.Type != HockeyistType.Goalie)
{
var dis = friend.GetDistanceTo(Self);
if (dis > distance)
{
distance = dis;
passer = friend;
}
}
}
if (passer != null)
{
var angle = Self.GetAngleTo(passer);
if (angle <= Current.Game.PassSector / 2.0D)
{
Move.PassPower = 1.0D;
Move.PassAngle = angle;
}
else
{
Move.Turn = angle;
}
}
}
else
{
if (TakePossition == null)
{
TakePossition = new TakeShotPossition();
}
TakePossition.Decide();
}
}
