public void Update(PudgeSensorsData data)
{
var Location = new Location(data.SelfLocation);
/*foreach (var rune in data.Map.Runes)
* {
* var curRune = new Rune(rune.Location.X, rune.Location.Y);
* if (!graph.edges.ContainsKey(curRune))
* {
* graph.edges.Add(curRune, curRune.Edges);
* graph.runes.Add(curRune);
* graph.AddEdges(curRune, true);
* }
* }*/
var runesAround = graph.runes
.Where(x => x.GetDistance(Location) <= PudgeRules.Current.VisibilityRadius - 1);
var seeRunes = data.Map.Runes.Select(x => new Rune(x.Location.X, x.Location.Y));
var runesVisited = runesAround
.Where(x => !seeRunes.Contains(x));
foreach (var rune in runesVisited)
{
rune.visited = true;
}
}
public static bool Search_rune(Node current_node, PudgeSensorsData data)
{
bool result = false;
foreach (var node in current_node.IncidentNodes)
{
foreach (var rune in data.Map.Runes)
{
if (rune.Location.X == node.Position.X && rune.Location.Y == node.Position.Y)
{
switch (rune.Type.ToString())
{
case "Invisibility":
node.Type = NodeType.invisibility;
break;
case "Haste":
node.Type = NodeType.haste;
break;
case "GoldXP":
node.Type = NodeType.bounty;
break;
}
result = true;
}
}
}
return(result);
}
public static DijkstraAnswer InvestigateWorld(PudgeSensorsData data, Graph graph, IEnumerable <Point2D> runes, WorldInfo visited, List <Node> excluded)
{
var toGo = new List <DijkstraAnswer>();
foreach (var rune in runes)
{
if (visited.HashSet.Contains(rune))
{
continue;
}
var loc = data.SelfLocation;
var minimal = graph.Nodes.Select(x => Movement.GetDistance(x.Location, loc)).Min();
var start = graph.Nodes.Where(x => Movement.GetDistance(x.Location, loc) == minimal).Single();
var finish = graph.Nodes.Where(x => x.Location == rune).Single();
if (start != finish)
{
var path = PathFinder.DijkstraAlgo(graph, start, finish, excluded);
if (path != null)
{
toGo.Add(path);
}
}
}
if (toGo.Count == 0)
{
return(new DijkstraAnswer(new List <Node>(), 0));
}
var min = toGo.Select(x => x.PathLength).Min();
var choice = toGo.Where(x => x.PathLength == min).First();
return(choice);
}
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 void PrintData(PudgeSensorsData data)
{
Console.WriteLine("---------------------------------");
if (data.IsDead)
{
Console.WriteLine("Ooops, i'm dead :(");
return;
}
Console.WriteLine("I'm here: " + data.SelfLocation);
Console.WriteLine("My score now: {0}", data.SelfScores);
Console.WriteLine("Current time: {0:F}", data.WorldTime);
foreach (var rune in data.Map.Runes)
{
Console.WriteLine("Rune! Type: {0}, Size = {1}, Location: {2}", rune.Type, rune.Size, rune.Location);
}
foreach (var heroData in data.Map.Heroes)
{
Console.WriteLine("Enemy! Type: {0}, Location: {1}, Angle: {2:F}", heroData.Type, heroData.Location,
heroData.Angle);
}
foreach (var eventData in data.Events)
{
Console.WriteLine("I'm under effect: {0}, Duration: {1}", eventData.Event,
eventData.Duration - (data.WorldTime - eventData.Start));
}
Console.WriteLine("---------------------------------");
Console.WriteLine();
}
public void UpdateData(PudgeSensorsData data)
{
this.data = data;
decider.data = data;
while (data.IsDead)
{
UpdateData(client.Wait(PudgeRules.Current.PudgeRespawnTime));
}
//graphUpdater.Update(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 PudgeIntellect(PudgeClient <PudgeSensorsData> client, IEnumerable <Point> trees)
{
Client = client;
Client.SensorDataReceived += data => this.data = data;
Client.SensorDataReceived += PrintData;
Trees = trees.ToArray();
Graph = BuildWaypointsGraph().ToArray();
RunesUsedCount = new Dictionary <Point, int>();
InitRunesUsedCount();
}
public static double FindAngle(PudgeSensorsData data, double dx, double dy)
{
var angle = Math.Atan2(dy, dx) * 180 / Math.PI;
var rAngle = (angle - data.SelfLocation.Angle) % 360;
if (Math.Abs(rAngle) > 180)
{
rAngle -= Math.Sign(rAngle) * 360;
}
return(rAngle);
}
public static string CheckEnemy(PudgeSensorsData data)
{
if (data.Map.Heroes.Select(x => x.Type).Contains(HeroType.Pudge))
{
return("Pudge");
}
else if (data.Map.Heroes.Select(x => x.Type).Contains(HeroType.Slardar) &&
!data.Events.Select(x => x.Event).Contains(PudgeEvent.Invisible))
{
return("Slardar");
}
return("");
}
MyPudge(PudgeSensorsData data)
{
foreach (var effect in data.Events)
{
if (effect.ToString() == "Hasted")
{
hasteStart = effect.Start;
hasteDuration = effect.Duration;
}
if (effect.ToString() == "Invisible")
{
inviseStart = effect.Start;
inviseDuration = effect.Duration;
}
}
}
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 Mover(Graph graph, PudgeSensorsData data, PudgeClientLevel2 client)
{
decider = new Decider(graph, data, seenNetwork);
pathFinder = new PathFinder(graph);
graphUpdater = new GraphUpdater(graph);
graphUpdater.Update(data);
this.graph = graph;
this.data = data;
this.client = client;
executeCommand = new Dictionary <string, Action <Command> >
{
{ HookCommand.TypeName, x => ExecuteHook((x as HookCommand).Target) },
{ MoveCommand.TypeName, x => ExecuteMove((x as MoveCommand).Destination) },
{ WaitCommand.TypeName, x => ExecuteWait((x as WaitCommand).Time) },
{ LongMoveCommand.TypeName, x => ExecuteLongMove((x as LongMoveCommand).Destination) },
{ LongKillMoveCommand.TypeName, x => ExecuteLongKillMove((x as LongKillMoveCommand).Destination, out hooked) },
{ MoveAndReturnCommand.TypeName, x => ExecuteMoveAndReturn((x as MoveAndReturnCommand).Destination) },
{ HookAroundCommand.TypeName, x => ExecuteHookAround() },
{ MeetSlardarCommand.TypeName, x => ExecuteMeetSlardar((x as MeetSlardarCommand).Destination) }
};
}
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 Pudge(PudgeSensorsData data)
{
Location = new Point((int)data.SelfLocation.X, (int)data.SelfLocation.Y);
Angle = data.SelfLocation.Angle;
Direction = new Vector(new Node(new Point(0, 0)), new Node(new Point(1, 1)));
}
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));
}
public static bool CheckRune(PudgeSensorsData data)
{
return(data.Map.Runes.Count != 0);
}
public Decider(Graph graph, PudgeSensorsData data, SeenNetwork network)
{
this.data = data;
this.graph = graph;
this.network = network;
}
