public static PudgeSensorsData GoTo(this PudgeClientLevel3 client, PudgeSensorsData data, Point2D end, WorldInfo visited, WorldInfo killed)
{
var old = data.SelfLocation;
var dx = end.X - data.SelfLocation.X;
var dy = end.Y - data.SelfLocation.Y;
var distance = Movement.GetDistance(dx, dy);
data = client.RotateTo(data, dx, dy);
data = MoveByLine(client, data, distance, visited, killed);
if (!data.IsDead)
{
if (!AfterHook && Movement.ApproximatelyEqual(old, data.SelfLocation, 2))
{
data = client.Rotate(180);
data = client.MoveByLine(data, 10, visited, killed);
visited.Check(data.WorldTime);
killed.Check(data.WorldTime);
}
AfterHook = false;
if (!Movement.ApproximatelyEqual(data.SelfLocation, end, 7))
{
return(client.GoTo(data, end, visited, killed));
}
}
return(data);
}
public static double AngleToVictim(PudgeSensorsData data, Pudge pudge, PudgeClientLevel3 client)
{
foreach (var enemy in data.Map.Heroes)
{
var targetRotate = new Vector(new Node(new Point((int)data.SelfLocation.X, (int)data.SelfLocation.Y)),
new Node(new Point((int)enemy.Location.X, (int)enemy.Location.Y)));
var rotationAngle = GetRotationAngle(pudge.Direction, targetRotate);
return(rotationAngle);
}
return(0);
}
public static PudgeSensorsData HookEnemy(PudgeClientLevel3 client, PudgeSensorsData data)
{
var old = data.SelfLocation;
var enemy = data.Map.Heroes.Where(x => x.Type == HeroType.Slardar || x.Type == HeroType.Pudge).Single();
var dx = enemy.Location.X - data.SelfLocation.X;
var dy = enemy.Location.Y - data.SelfLocation.Y;
var angle = Movement.FindAngle(data, dx, dy);
data = client.Rotate(angle);
data = client.Hook();
AfterHook = !AfterHook;
data = client.Rotate(-angle);
while (data.Events.Select(x => x.Event).Contains(PudgeEvent.HookThrown))
{
data = client.Wait(0.05);
}
return(data);
}
public static PudgeSensorsData PartWalking(PudgeSensorsData data, PudgeClientLevel3 client, IEnumerable <Node> path, WorldInfo visited, WorldInfo killed)
{
foreach (var node in path)
{
visited.Check(data.WorldTime);
killed.Check(data.WorldTime);
data = client.GoTo(data, node.Location, visited, killed);
if (data.IsDead)
{
for (int i = 0; i < 1; i++)
{
data = client.Wait(PudgeRules.Current.PudgeRespawnTime);
visited.Check(data.WorldTime);
killed.Check(data.WorldTime);
}
return(data);
}
}
var destination = path.Last().Location;
visited.Add(destination);
data = client.Wait(0.1);
return(data);
}
public static PudgeSensorsData MoveByLine(this PudgeClientLevel3 client, PudgeSensorsData data, double distance, WorldInfo visited, WorldInfo killed)
{
double speed;
if (data.Events.Select(x => x.Event).Contains(PudgeEvent.Hasted))
{
var hasteDuration = data.Events.Select(x => x).Where(x => x.Event == PudgeEvent.Hasted).First().Duration;
if (hasteDuration > distance / 80)
{
speed = 80;
}
else
{
speed = distance / (hasteDuration + (distance - hasteDuration * 80) / 40);
}
}
else
{
speed = 40;
}
var count = Math.Floor((distance / speed) * 4.5);
var step = distance / count;
for (var i = 0; i < count; i++)
{
if (data.IsDead)
{
break;
}
var check = CheckEnemy(data);
if (check != "")
{
if (!data.Events.Select(x => x.Event).Contains(PudgeEvent.HookCooldown))
{
if (check == "Slardar")
{
killed.Add(SlardarSpots.Where(x => Movement.ApproximatelyEqual(data.SelfLocation, x, 100)).Single());
}
data = HookEnemy(client, data);
break;
}
}
#region MaybeNextTime
//if (CheckRune(data))
// if (!OnMove)
// {
// var loc = data.Map.Runes.First().Location;
// var min = Points.Select(x => Movement.GetDistance(x, data.SelfLocation)).Min();
// var toGo = Points.Where(x => Movement.GetDistance(x, data.SelfLocation) == min).First();
// OnMove = !OnMove;
// data = client.GoTo(data, toGo, visited);
// data = client.GoTo(data, loc, visited);
// visited.Add(loc);
// OnMove = !OnMove;
// break;
// }
#endregion
data = client.Move(step);
visited.Check(data.WorldTime);
killed.Check(data.WorldTime);
}
return(data);
}
public static PudgeSensorsData RotateTo(this PudgeClientLevel3 client, PudgeSensorsData data, double dx, double dy)
{
var angle = Movement.FindAngle(data, dx, dy);
return(client.Rotate(angle));
}
static void Main(string[] args)
{
if (args.Length == 0)
{
args = new[] { "127.0.0.1", "14000" }
}
;
var ip = args[0];
var port = int.Parse(args[1]);
// Каждую неделю клиент будет новый. Соотетственно Level1, Level2 и Level3.
var client = new PudgeClientLevel3();
var graph = CreateWayGraph();
var dict = GetEdgesWeight(graph);
// У этого метода так же есть необязательные аргументы:
// timeLimit -- время в секундах, сколько будет идти матч (по умолчанию 90)
// operationalTimeLimit -- время в секундах, отображающее ваш лимит на операции в сумме за всю игру
// По умолчанию -- 1000. На турнире будет использоваться значение 5. Подробнее про это можно прочитать в правилах.
// isOnLeftSide -- предпочитаемая сторона. Принимается во внимание во время отладки. По умолчанию true.
// seed -- источник энтропии для случайного появления рун. По умолчанию -- 0.
// При изменении руны будут появляться в другом порядке
// speedUp -- ускорение отладки в два раза. Может вызывать снижение FPS на слабых машинах
var sensorData = client.Configurate(ip, port, CvarcTag);
// Пудж узнает о всех событиях, происходящих в мире, с помощью сенсоров.
// Для передачи и представления данных с сенсоров служат объекты класса PudgeSensorsData.
Print(sensorData);
// Каждое действие возвращает новые данные с сенсоров.
//sensorData = client.Move();
//Print(sensorData);
// Для удобства, можно подписать свой метод на обработку всех входящих данных с сенсоров.
// С этого момента любое действие приведет к отображению в консоли всех данных
client.SensorDataReceived += Print;
var pudge = new Pudge(sensorData);
// Угол поворота указывается в градусах, против часовой стрелки.
// Для поворота по часовой стрелке используйте отрицательные значения.
//client.Rotate(-45);
//client.Move(100);
//lient.Wait(45);
// Так можно хукать, но на первом уровне эта команда будет игнорироваться.
//client.Hook();
// Пример длинного движения. Move(100) лучше не писать. Мало ли что произойдет за это время ;)
//var previousVector = new Vector(new Node(new Point(0, 0)), graph[0]);
//var angle = 180.0;
//for (var i = 0; i < graph.Length - 1; i++)
//{
// var vect = new Vector(graph[i], graph[i + 1]);
// angle -= GetRotationAngle(previousVector, vect);
// previousVector = vect;
// client.Rotate(-angle);
// client.Move(vect.Length);
//}
/*bool exit = false;
* while (!exit)
* {
* for (var i = 0; i < graph.Length - 1; i++)
* {
* var nextDirection = new Vector(graph[i], graph[i + 1]);
* var rotationAngle = GetRotationAngle(pudge.Direction, nextDirection);
* pudge.Direction = nextDirection;
* sensorData = client.Rotate(rotationAngle);
* while (SegmentLength(pudge.Location, graph[i + 1].Position) > 7.8)
* {
* if (sensorData.WorldTime > 85)
* {
* exit = true;
* break;
* }
* sensorData = client.Move(8);
* pudge.Location = new Point((int)sensorData.SelfLocation.X, (int)sensorData.SelfLocation.Y);
* }
*
* if (i == 5)
* client.Wait(5);
* }
* }*/
var edgWeights = GetEdgesWeight(graph);
var targets = getTargetNodes();
var target_index = 0;
var path = Graph.Dijkstra(graph, edgWeights, graph[0], targets[target_index]);
var i = 0;
while (true)
{
if (sensorData.WorldTime > 85)
{
break;
}
if (i < path.Count)
{
if (path[i].Equals(targets[target_index]))
{
if (target_index == targets.Count - 1)
{
target_index = 0;
}
else
{
target_index++;
}
//edgWeights = GetEdgesWeight(graph);
path = Graph.Dijkstra(graph, edgWeights, path[i], targets[target_index]);
i = 0;
continue;
}
var nextDirection = new Vector(path[i], path[i + 1]);
var rotationAngle = GetRotationAngle(pudge.Direction, nextDirection);
pudge.Direction = nextDirection;
sensorData = client.Rotate(rotationAngle);
while (SegmentLength(pudge.Location, path[i + 1].Position) >= 12)
{
//if (search_rune(path[i], sensorData))
//{
// edgWeights = GetEdgesWeight(graph);
// path = Graph.Dijkstra(graph, edgWeights, path[i], targets[target_index]);
// i = 0;
//}
if (sensorData.Map.Heroes.Count > 0)
{
var ang = AngleToVictim(sensorData, pudge, client);
sensorData = client.Rotate(ang);
sensorData = client.Hook();
sensorData = client.Rotate(-ang);
}
sensorData = client.Move(8);
if (sensorData.WorldTime > 85)
{
break;
}
pudge.Location = new Point((int)sensorData.SelfLocation.X, (int)sensorData.SelfLocation.Y);
}
i++;
}
}
client.Exit();
}
static void Main(string[] args)
{
if (args.Length == 0)
{
args = new[] { "127.0.0.1", "14000" }
}
;
var ip = args[0];
var port = int.Parse(args[1]);
Node previousNode = null;
//foreach (var node in World.Nodes.OrderByDescending(c => c.Y).ThenBy(c => c.X))
//{
// if (previousNode != null && node.Y < previousNode.Y)
// {
// Console.WriteLine();
// }
// if (node.IsWalkable)
// {
// Console.Write("·");
// }
// else
// {
// Console.Write("†");
// }
// previousNode = node;
//}
Console.WriteLine();
while (true)
{
var client = new PudgeClientLevel3();
// У метода Configurate так же есть необязательные аргументы:
// timeLimit -- время в секундах, сколько будет идти матч (по умолчанию 90)
// operationalTimeLimit -- время в секундах, отображающее ваш лимит на операции в сумме за всю игру
// По умолчанию -- 1000. На турнире будет использоваться значение 5. Подробнее про это можно прочитать в правилах.
// isOnLeftSide -- предпочитаемая сторона. Принимается во внимание во время отладки. По умолчанию true.
// seed -- источник энтропии для случайного появления рун. По умолчанию -- 0.
// При изменении руны будут появляться в другом порядке
// speedUp -- ускорение отладки в два раза. Может вызывать снижение FPS на слабых машинах
var sensorData = client.Configurate(ip, port, CvarcTag);
var targetNode = World.GetNode(0, 90);
while (true)
{
Print(sensorData);
var nodeX = sensorData.SelfLocation.X;
var nodeY = sensorData.SelfLocation.Y;
var currentNode = World.GetNode(nodeX, nodeY);
if (currentNode == targetNode)
{
sensorData = client.Wait(Strategy.DefaultWaitTime);
continue;
}
var path = AStar.FindPath(currentNode, targetNode,
(previous, possibleNext) => Distance(previous, possibleNext),
(current, destination) => Heuristic(current, destination))?.ToList();
if (path == null)
{
sensorData = client.Wait(Strategy.DefaultWaitTime);
continue;
}
if (path.Count < 2)
{
sensorData = client.Wait(Strategy.DefaultWaitTime);
continue;
}
var nextNode = path[path.Count - 2];
var turnAngle = CalculateTurnAngle(currentNode, nextNode, sensorData.SelfLocation.Angle);
if (Math.Abs(turnAngle) > TurnAngleThreshold)
{
sensorData = client.Rotate(turnAngle);
// wait rotation
client.Wait(Math.Abs(turnAngle / PudgeRules.Current.RotationVelocity));
}
else
{
sensorData = client.Move(Strategy.DefaultStepSize);
}
}
client.Wait(1);
// Корректно завершаем работу
client.Exit();
Thread.Sleep(1000);
}
}
static void Main(string[] args)
{
if (args.Length == 0)
{
args = new[] { "127.0.0.1", "14000" }
}
;
//args = new[] { "87.224.245.130", "14001" };
var ip = args[0];
var port = int.Parse(args[1]);
// Каждую неделю клиент будет новый. Соотетственно Level1, Level2 и Level3.
var client = new PudgeClientLevel3();
// У этого метода так же есть необязательные аргументы:
// timeLimit -- время в секундах, сколько будет идти матч (по умолчанию 90)
// operationalTimeLimit -- время в секундах, отображающее ваш лимит на операции в сумме за всю игру
// По умолчанию -- 1000. На турнире будет использоваться значение 5. Подробнее про это можно прочитать в правилах.
// isOnLeftSide -- предпочитаемая сторона. Принимается во внимание во время отладки. По умолчанию true.
// seed -- источник энтропии для случайного появления рун. По умолчанию -- 0.
// При изменении руны будут появляться в другом порядке
// speedUp -- ускорение отладки в два раза. Может вызывать снижение FPS на слабых машинах
var data = client.Configurate(ip, port, CvarcTag, seed: 119, operationalTimeLimit: 1000);
// Пудж узнает о всех событиях, происходящих в мире, с помощью сенсоров.
// Для передачи и представления данных с сенсоров служат объекты класса PudgeSensoвс rsData.
Print(data);
// Каждое действие возвращает новые данные с сенсоров.
// Для удобства, можно подписать свой метод на обработку всех входящих данных с сенсоров.
// С этого момента любое действие приведет к отображению в консоли всех данных
client.SensorDataReceived += Print;
var rules = PudgeRules.Current;
var points = PrepareForBattle.GetPoints();
var graph = PrepareForBattle.MakeGraph(points);
var excNodes = new int[] { 10, 11, 13, 20, 6, 7, 3, 15 };
var excluded = graph.Nodes.Where(x => excNodes.Contains(x.NodeNumber)).ToList();
var runes = PrepareForBattle.GetRunes();
var specRunes = PrepareForBattle.GetSpecialRunes();
var visited = new WorldInfo(rules.RuneRespawnTime);
var killed = new WorldInfo(rules.SlardarRespawnTime);
var slardarSpots = PrepareForBattle.GetSlardars();
var central = new Point2D(0, 0);
while (true)
{
var choices = new List <DijkstraAnswer>();
choices.Add(InvestigateWorld(data, graph, new Point2D[] { central }, visited, Empty));
var slPath = (InvestigateWorld(data, graph, slardarSpots, killed, Empty));
var specPath = (InvestigateWorld(data, graph, specRunes, visited, Empty));
EventData hookData;
if (data.Events.Select(x => x.Event).Contains(PudgeEvent.HookCooldown))
{
hookData = data.Events.Select(x => x).Where(x => x.Event == PudgeEvent.HookCooldown).First();
var time = hookData.Duration - (data.WorldTime - hookData.Start);
if (time < slPath.PathLength / rules.MovementVelocity)
{
choices.Add(slPath);
choices.Add(specPath);
}
}
else
{
choices.Add(slPath);
choices.Add(specPath);
}
var chosen = InvestigateWorld(data, graph, runes, visited, excluded);
if (choices.Any(x => x.PathLength != 0))
{
var min = choices.Where(x => x.PathLength != 0).Min(x => x.PathLength);
chosen = choices.Where(x => x.PathLength == min).Single();
}
var slCD = killed.GetCooldown(data.WorldTime);
if (slCD < 4.5)
{
var nearest = slardarSpots.Where(x => Movement.ApproximatelyEqual(data.SelfLocation, x, 50)).SingleOrDefault();
var hookCD = double.Epsilon;
if (nearest != default(Point2D))
{
foreach (var eventData in data.Events)
{
if (eventData.Event == PudgeEvent.HookCooldown)
{
hookCD = eventData.Duration - (data.WorldTime - eventData.Start);
break;
}
}
if (hookCD < slCD)
{
client.GoTo(data, nearest, visited, killed);
var dist = Movement.GetDistance(nearest, data.SelfLocation);
client.Wait(slCD - dist / rules.MovementVelocity - 0.5);
}
}
}
var path = chosen.Path.Skip(1);
if (path.Count() == 0)
{
data = client.Wait(0.2);
continue;
}
data = PartWalking(data, client, path, visited, killed);
}
}
