public void Setup()
{
InitializeMocks();
InitializeLoggerMock(new RoadMapsService(null, null, null));
_staff = new Staff
{
Id = 1,
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
PersonId = 1,
PositionId = 1,
};
_roadMap = new RoadMap
{
Id = 1,
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
StaffId = _staff.Id,
Staff = _staff,
Status = Enums.RoadMapStatus.InProgress,
Tasks = "test"
};
_staff.RoadMapId = _roadMap.Id;
_staff.RoadMap = _roadMap;
_dbContext.RoadMaps.Add(_roadMap);
_dbContext.Staff.Add(_staff);
_roadMapsService = new RoadMapsService(_roadMapRepository, _logger, _dateTimeUtil);
}
public ActionResult Edit(ManageRoadMapViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
RoadMap roadMap = null;
if (model.Id != null)
{
roadMap = Db.RoadMaps.FirstOrDefault(p => p.Id == model.Id);
if (roadMap != null)
{
roadMap.Name = model.Name;
roadMap.Description = model.Description;
}
}
else
{
var currentUserId = User.Identity.GetUserId();
roadMap = new RoadMap(model.Name, model.Description, currentUserId);
Db.RoadMaps.Add(roadMap);
}
Db.SaveChanges();
return(RedirectToAction("List"));
}
private static void RoadMapTest()
{
var map = new MockTrapezoidalMap();
var forbidden = new HashSet <ITrapezoid>();
foreach (var trapezoid in map.Trapezoids)
{
var lefts = trapezoid.LeftEdges;
var rights = trapezoid.RightEdges;
if (lefts != null && lefts.Count() == 0 || rights != null && rights.Count() == 0)
{
forbidden.Add(trapezoid);
}
}
var roadMap = new RoadMap(map, forbidden);
var start = new Vector2(0.5, 0.5);
var goal = new Vector2(3.5, 3.5);
var path = roadMap.CalculatePath(start, goal);
string result = "";
foreach (var point in path)
{
result += point.ToString() + " ";
}
string correct = "(0.5, 0.5) (0.5, 2) (1, 0.5) (2, 0.5) (3, 0.5) (3.5, 2) (3.5, 3.5) ";
Debug.Assert(result == correct);
}
public void InsertRoadMap(RoadMap roadMap)
{
OracleCommand command = null;
try
{
using (command = getCmdInsertRoadMap(roadMap))
{
if (command.Connection.State == System.Data.ConnectionState.Closed)
{
command.Connection.Open();
}
command.ExecuteNonQuery();
}
}
catch
{
throw;
}
finally
{
if (command != null && command.Connection.State == System.Data.ConnectionState.Open)
{
command.Connection.Close();
}
}
}
/// <summary>
/// Creates a HMM map matching filter for some map, router, cost function, and spatial operator.
/// </summary>
/// <param name="map">map <see cref="RoadMap" /> object of the map to be matched to.</param>
/// <param name="router">router <see cref="IGraphRouter{TEdge, TPoint}"/> object to be used for route estimation.</param>
/// <param name="cost">Cost function to be used for routing.</param>
/// <param name="spatial">Spatial operator for spatial calculations.</param>
public Matcher(RoadMap map, IGraphRouter <Road, RoadPoint> router, Func <Road, double> cost, ISpatialOperation spatial)
{
this._map = map;
this._router = router;
this._cost = cost;
this._spatial = spatial;
}
public async Task <IActionResult> PutRoadMap([FromRoute] string id, [FromBody] RoadMap roadMap)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != roadMap.GroupName)
{
return(BadRequest());
}
//_context.Entry(roadMap).State = EntityState.Modified;
_context.RoadMap.Update(roadMap);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoadMapExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Setup()
{
this.DataDirPath = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "../../../../../../../../../", "data"));
var spatial = new GeographySpatialOperation();
var roads = this.ReadRoads(spatial);
var mapBuilder = new RoadMapBuilder(spatial);
_roadMap = mapBuilder.AddRoads(roads).Build();
{
var naiveDijkstraRouter = new DijkstraRouter <Road, RoadPoint>();
_naiveDijkstraMatcher = new Matcher <MatcherCandidate, MatcherTransition, MatcherSample>(
_roadMap, naiveDijkstraRouter, Costs.TimePriorityCost, spatial);
_naiveDijkstraMatcher.MaxDistance = MaxDistance; // set maximum searching distance between two GPS points to 1000 meters.
_naiveDijkstraMatcher.MaxRadius = MaxGpsRadius; // sets maximum radius for candidate selection to 200 meters
}
{
var precomputedDijkstraRouter = new PrecomputedDijkstraRouter <Road, RoadPoint>(_roadMap, Costs.TimePriorityCost, Costs.DistanceCost, MaxDistance);
_precomputedDijkstraMatcher = new Matcher <MatcherCandidate, MatcherTransition, MatcherSample>(
_roadMap, precomputedDijkstraRouter, Costs.TimePriorityCost, spatial);
_precomputedDijkstraMatcher.MaxDistance = MaxDistance; // set maximum searching distance between two GPS points to 1000 meters.
_precomputedDijkstraMatcher.MaxRadius = MaxGpsRadius; // sets maximum radius for candidate selection to 200 meters
}
_samples = ReadSamples().OrderBy(s => s.Time).ToArray();
}
public void GetByStaffId_should_return_road_map_by_staff_id()
{
// Act
RoadMap actual = _roadMapRepository.GetByStaffId(_staff1.Id);
// Assert
Assert.AreEqual(_roadMap, actual, "Returned road map by staff id as expected");
}
public void WrongRootElement()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-wrong-root-element.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
}
public void WrongNodeState()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-wrong-node-state.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
}
public void SomeWeightMissed()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-some-weight-missed.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
}
public void NoNodes()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-no-nodes.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
}
public TrainingMessage(string content, AspNetUsers sender, AspNetUsers recipient, Road road, RoadMap roadMap, RoadStep roadStep)
{
Content = content;
Sender = sender;
Recipient = recipient;
Road = road;
RoadMap = roadMap;
RoadStep = roadStep;
}
public virtual async Task <int> UpdateAsync(RoadMap roadMap)
{
if (string.IsNullOrWhiteSpace(roadMap.Tasks))
{
throw new ArgumentException("Tasks for road map was not provided");
}
roadMap.CreatedOn = _dateTimeUtil.GetCurrentDateTime();
_context.RoadMaps.Update(roadMap);
return(await _context.SaveChangesAsync());
}
public Form1()
{
InitializeComponent();
map = new RoadMap();
List <(string, string, int)> towns = map.print_towns();
foreach ((string, string, int)x in towns)
{
listView1.Items.Add(x.ToString());
}
}
private static RoadMapData ToRpcModel(RoadMap roadMap)
{
return(new RoadMapData
{
Id = roadMap.Id,
CreatedOn = Timestamp.FromDateTime(roadMap.CreatedOn),
Tasks = roadMap.Tasks,
Status = (int)roadMap.Status,
StaffId = roadMap.StaffId
});
}
public void EverythingOk()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-everything-is-ok.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
Assert.AreNotEqual(roadMap, null);
PathFinder pathFinder = new PathFinder(roadMap);
List <RoadPath> paths = pathFinder.FindAllPaths().OrderBy(p => p.Length).ToList();
Assert.AreEqual(paths.Count, 7);
Assert.AreEqual(paths[0].Length, 22);
Assert.AreEqual(paths[0].ToList()[0].Id, 1);
Assert.AreEqual(paths[0].ToList()[1].Id, 6);
Assert.AreEqual(paths[0].ToList()[2].Id, 8);
Assert.AreEqual(paths[0].ToList()[3].Id, 9);
Assert.AreEqual(paths[0].ToList()[4].Id, 10);
Assert.AreEqual(paths[1].Length, 25);
Assert.AreEqual(paths[2].Length, 28);
Assert.AreEqual(paths[3].Length, 35);
Assert.AreEqual(paths[4].Length, 38);
Assert.AreEqual(paths[4].ToList()[0].Id, 1);
Assert.AreEqual(paths[4].ToList()[1].Id, 6);
Assert.AreEqual(paths[4].ToList()[2].Id, 8);
Assert.AreEqual(paths[4].ToList()[3].Id, 9);
Assert.AreEqual(paths[4].ToList()[4].Id, 5);
Assert.AreEqual(paths[4].ToList()[5].Id, 4);
Assert.AreEqual(paths[4].ToList()[6].Id, 10);
Assert.AreEqual(paths[5].Length, 58);
Assert.AreEqual(paths[6].Length, 59);
Assert.AreEqual(paths[6].ToList()[0].Id, 1);
Assert.AreEqual(paths[6].ToList()[1].Id, 2);
Assert.AreEqual(paths[6].ToList()[2].Id, 3);
Assert.AreEqual(paths[6].ToList()[3].Id, 4);
Assert.AreEqual(paths[6].ToList()[4].Id, 5);
Assert.AreEqual(paths[6].ToList()[5].Id, 6);
Assert.AreEqual(paths[6].ToList()[6].Id, 8);
Assert.AreEqual(paths[6].ToList()[7].Id, 9);
Assert.AreEqual(paths[6].ToList()[8].Id, 10);
}
private void Start()
{
segFactory = GetComponent <SegmentFactory>();
globalGoals = GetComponent <GlobalGoals>();
localConstraints = GetComponent <LocalConstraints>();
map = GetComponent <RoadMap>();
lotsGenerator = GetComponent <LotsGenerator>();
seed = 8;
//seed = Random.Range(0, 65536);
Generate(seed);
}
void SnapToNewJunction(Road road, Road otherRoad, Vector3 intersection, RoadMap roadMap)
{
Junction j = segFactory.CreateJunction(intersection, Quaternion.identity);
j.SetColor(Color.yellow);
road.attachedSegments.Add(j);
road.MoveEnd(intersection);
road.severed = true;
otherRoad.severed = true;
SetUpNewIntersection(road, otherRoad, intersection, j, roadMap);
}
public async Task <IActionResult> PostRoadMap([FromBody] RoadMap roadMap)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.RoadMap.Add(roadMap);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRoadMap", new { id = roadMap.GroupName }, roadMap));
}
public void FinishNodeIsCrashed()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-finish-node-is-crashed.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
Assert.AreNotEqual(roadMap, null);
PathFinder pathFinder = new PathFinder(roadMap);
List <RoadPath> paths = pathFinder.FindAllPaths().OrderBy(p => p.Length).ToList();
}
public void WrongBackLinkWeight()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-wrong-back-link-weight.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
Assert.AreNotEqual(roadMap, null);
PathFinder pathFinder = new PathFinder(roadMap);
List <RoadPath> paths = pathFinder.FindAllPaths().OrderBy(p => p.Length).ToList();
}
public RoadMapView(RoadMap roadMap)
{
Id = roadMap.Id;
HeadOfDepartment = roadMap.Group.Department.HeadOfDepartmentNavigation.Surname;
DepartmentName = roadMap.Group.Department.Name;
GroupSpeciality = roadMap.Group.GroupSpeciality.Description;
GroupName = roadMap.Group.GroupName;
DisciplineName = roadMap.Attestation.DisciplineEmployee.Discipline.Name;
IndexDiscipline = roadMap.Attestation.DisciplineEmployee.Discipline.DisciplineIndex.Name;
EmployeeSurname = roadMap.Attestation.DisciplineEmployee.Employee.Surname;
MonthName = roadMap.Attestation.Month.Name;
FormAttestation = roadMap.Attestation.Form.Name;
Year = roadMap.Year;
}
public static RoadTile Create(int x, int y, RoadMap parent)
{
GameObject obj = Instantiate<GameObject>(Resources.Load<GameObject>("RoadTile"));
obj.transform.SetParent(parent.transform);
obj.transform.localScale = Vector3.one;
obj.transform.position = new Vector3(x,y) * parent.transform.localScale.x * 0.5f;
RoadTile tile = obj.GetComponent<RoadTile>();
tile.X = x;
tile.Y = y;
tile.Parent = parent;
return tile;
}
public bool Create(RoadMapCreateModel model)
{
var entity = new RoadMap()
{
Name = model.Name,
Speed = model.Speed,
IsActive = model.IsActive,
ChallengeScoreIncrease = model.ChallengeScoreIncrease,
Experiences = model.Experiences,
Comments = model.Comments,
};
_ctx.RoadMaps.Add(entity);
return(_ctx.SaveChanges() == 1);
}
public void NoPathBecauseOfCrashNode()
{
XmlDocument roadMapXmlDocument = new XmlDocument();
roadMapXmlDocument.Load(@".\UnitTests\TestXmlData\test-no-path-because-of-crash-node.xml");
RoadMap roadMap = XmlRoadDataParser.ParseRoadMapXml(roadMapXmlDocument);
Assert.AreNotEqual(roadMap, null);
PathFinder pathFinder = new PathFinder(roadMap);
List <RoadPath> paths = pathFinder.FindAllPaths().OrderBy(p => p.Length).ToList();
Assert.AreEqual(paths.Count, 0);
}
void Start()
{
m_Renderer = GetComponentInChildren <MeshRenderer>();
m_OriginalColor = m_Renderer.material.color;
myRoadMap = GameObject.FindObjectOfType <RoadMap>();
nodeOrigin = gameObject;
myCollectorInitate = FindObjectOfType <CollectorInitiate>();
myDepotManager = FindObjectOfType <DepotManager>();
myGameManager = FindObjectOfType <GameManager>();
myAudioManager = FindObjectOfType <AudioManager>();
myZoneManager = GetComponentInParent <ZoneManager>();
foreach (RoadHub roadHub in myZoneManager.myRoadHubs)
{
myZoneRoadHubs.Add(roadHub);
}
}
public override Task <RoadMapResponse> GetByStaffId(ByStaffRequest request, ServerCallContext context)
{
try
{
RoadMap roadMap = _roadMapRepository.GetByStaffId(request.StaffId);
RoadMapResponse response = new()
{
Status = new BaseResponse
{
Code = Code.Success,
ErrorMessage = string.Empty
},
Data = ToRpcModel(roadMap)
};
LogData log = new()
{
CallSide = nameof(RoadMapsService),
CallerMethodName = nameof(GetByStaffId),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = response
};
_logger.AddLog(log);
return(Task.FromResult(response));
}
catch (Exception ex)
{
LogData log = new()
{
CallSide = nameof(RoadMapsService),
CallerMethodName = nameof(GetByStaffId),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = ex
};
_logger.AddErrorLog(log);
return(Task.FromResult(new RoadMapResponse
{
Status = new BaseResponse
{
Code = Code.UnknownError,
ErrorMessage = "An error occured while loading Road Map"
}
}));
}
}
public bool SaveRoadMap(RoadMap roadMap)
{
bool isSuccess = false;
try
{
mapRepo = new MapRepository();
mapRepo.InsertRoadMap(roadMap);
isSuccess = true;
}
catch (Exception ex)
{
isSuccess = false;
}
return(isSuccess);
}
public virtual async Task <int> AddAsync(RoadMap roadMap)
{
if (!_context.Staff.Any(e => e.Id == roadMap.StaffId))
{
throw new ArgumentException("Cannot create road map for non-existent work period");
}
if (_context.Staff.FirstOrDefault(e => e.Id == roadMap.StaffId).RoadMapId != 0)
{
throw new InvalidOperationException("Road map already exists");
}
if (string.IsNullOrWhiteSpace(roadMap.Tasks))
{
throw new ArgumentException("Tasks for road map was not provided");
}
roadMap.CreatedOn = _dateTimeUtil.GetCurrentDateTime();
_context.RoadMaps.Add(roadMap);
return(await _context.SaveChangesAsync());
}
public void Generate()
{
DensityMap = (DensityMap)FindObjectOfType(typeof(DensityMap));
RoadMap = (RoadMap)FindObjectOfType(typeof(RoadMap));
DensityMap.Initialize(Width, Length);
DensityMap.Generate();
DensityMap.Draw();
if (RoadMap.Lines != null)
{
RoadMap.Clear();
}
RoadMap.Initialize();
RoadMap.Generate(DensityMap.MaxPosition, DensityMap.MapData);
RoadMap.Draw();
}
public TilePath(int[][] waypoints, RoadMap roadMap, Vehicle vehicle, int skipWaypoints = 1)
{
tilePath = new List<Tile>();
var from = roadMap.tileAt(vehicle.position);
var dir = vehicle.forward;
int waypointsCount = waypoints.Length;
for (int waypointIndex = skipWaypoints, end = waypointsCount * 2 + 1; waypointIndex < end && tilePath.Count < 10; ++waypointIndex) {
Tile to = roadMap.tileAt(waypoints[waypointIndex % waypointsCount][0], waypoints[waypointIndex % waypointsCount][1]);
dir = addPathBetween(from, to, dir);
from = to;
if (waypointIndex == end - 1) {
Tile preLast;
if (tilePath.Count >= 2) {
preLast = tilePath[tilePath.Count - 2];
} else {
preLast = roadMap.tileAt(vehicle.position);
}
Tile last = tilePath[tilePath.Count - 1];
var finishDir = preLast.directionForTile(last);
if (finishDir != null) {
var tile = last;
for (int i = 0; i < 4; ++i) {
var next = tile.nextTileInDirection(finishDir.Value);
if (next == null)
break;
tilePath.Add(next);
tile = next;
}
}
}
}
}
public void Move(Car self, World world, Game game, Move move)
{
Debug.beginPost();
Constants.setConstants(game, world);
currentTick = world.Tick;
if (map == null) {
waypoints = world.Waypoints;
map = new RoadMap(world.Width, world.Height);
map.updateMap(world.TilesXY);
}
if (currentVehicle == null) {
currentVehicle = new ManagedVehicle();
}
currentVehicle.setCar(self);
currentVehicle.tick(move);
Debug.endPost();
}
public static LinkedList<TilePathNode> findPathFromWaypoints(int[][] waypoints, RoadMap roadMap, Vector startPosition, Vector startForward, int skipWaypoints = 1)
{
var path = new LinkedList<TilePathNode>();
var lastTile = roadMap.tileAt(startPosition);
for (int i = skipWaypoints, iend = waypoints.Length * 2 + 1; i < iend; ++i) {
var currentTile = roadMap.tileAt(waypoints[i % waypoints.Length][0], waypoints[i % waypoints.Length][1]);
Vector startDir;
if (i == skipWaypoints) { //initial
startDir = startForward;
} else {
startDir = new Vector(0, 0);
}
var mpath = findPathBetween(lastTile, currentTile, startDir);
foreach (TilePathNode node in mpath) {
path.AddLast(node);
}
if (path.Last != null) {
var lastNode = path.Last.Value;
lastNode.waypointIndex = i % waypoints.Length;
path.Last.Value = lastNode;
}
lastTile = currentTile;
}
return path;
}
public Tile(RoadMap roadMap, int posX, int posY)
{
this.posX = posX;
this.posY = posY;
this.roadMap = roadMap;
}
void BuildPathsFromTiles()
{
// Start from human base and built from there
var humanBaseTile = GetObjectAt(GatherPoints[PlayerTeam.Humans]);
// TODO: For now, only 3 way tile is supported
if (humanBaseTile.Tag != "esw") throw new NotSupportedException("Only 3 way base tiles are supported in the prototype");
for (int i = 0; i < 3; i++)
{
List<Vector> naviPts = new List<Vector>();
Vector toPt = humanBaseTile.Position;
do {
// 1. Get next path tile
GameObject tile = null;
foreach (var go in GetObjectsAt(toPt))
{
string pathImageName = String.Concat(((string)go.Tag).OrderBy(c => c));
if (preloadedPathImages.Keys.Contains(pathImageName))
{
tile = go;
break;
}
}
if (tile==null)
{
throw new NotSupportedException("All paths must be continuous from human base to monster base.");
}
// 2.Generate a navigation point for the tile for a RoadMap
toPt = tile.Position; // Avoid straying from the grid
char direction = ((string)tile.Tag)[1];
if (tile.Tag=="esw")
{
if (i==0)
direction = 'e';
else if (i==1)
direction = 's';
else if (i==2)
direction = 'w';
}
switch ( direction )
{
case 'n':
toPt = toPt + new Vector(0, +60);// to north
break;
case 'e':
toPt = toPt + new Vector(-60, 0);// to east
break;
case 'w':
toPt = toPt + new Vector(+60, 0);// to west
break;
case 's':
toPt = toPt + new Vector(0, -60);// to south
break;
default:
break;
}
naviPts.Add(tile.Position);
} while (toPt!=GatherPoints[PlayerTeam.Monsters]);
// Needs one more point, which should not be exactly the same!
naviPts.Add(GatherPoints[PlayerTeam.Monsters] + new Vector(0.01, 0.01));
naviPts.Add(GatherPoints[PlayerTeam.Monsters]);
RoadMap path = new RoadMap(naviPts);
path.DefaultWidth = 10.0;
path.Insert();
paths.Add(path);
foreach (var segment in path.Segments)
{
// used only for guiding units
segment.IsVisible = false;
}
}
}
void CreateRandomLevel()
{
double PATH_SEG_LEN_MIN = 60;
double PATH_SEG_LEN_MAX = 110;
double TO_SIDE_ANGLE = 60;
double ANGLE_DEV = 20;
var fromHumansToMonsters = GatherPoints[PlayerTeam.Monsters] - GatherPoints[PlayerTeam.Humans];
var fromMonstersToHumans = GatherPoints[PlayerTeam.Humans] - GatherPoints[PlayerTeam.Monsters];
// TODO: Load these from files OR generate progomatically
List<Vector[]> pathsPts = new List<Vector[]>();
for (int i = -1; i <= 1; i++)
{
pathsPts.Add(
new Vector[] // first path
{
GatherPoints[PlayerTeam.Humans],
GatherPoints[PlayerTeam.Humans] + Vector.FromLengthAndAngle( RandomGen.NextDouble(PATH_SEG_LEN_MIN,PATH_SEG_LEN_MAX),
fromHumansToMonsters.Angle+Angle.FromDegrees(i*TO_SIDE_ANGLE)),
GatherPoints[PlayerTeam.Humans] + Vector.FromLengthAndAngle( RandomGen.NextDouble(PATH_SEG_LEN_MIN*2,PATH_SEG_LEN_MAX*2),
fromHumansToMonsters.Angle+RandomGen.NextAngle(Angle.FromDegrees(i*TO_SIDE_ANGLE-ANGLE_DEV), Angle.FromDegrees(i*TO_SIDE_ANGLE+ANGLE_DEV)) ),
GatherPoints[PlayerTeam.Humans] + Vector.FromLengthAndAngle( RandomGen.NextDouble(PATH_SEG_LEN_MIN*3,PATH_SEG_LEN_MAX*3),
fromHumansToMonsters.Angle+RandomGen.NextAngle(Angle.FromDegrees(i*TO_SIDE_ANGLE-ANGLE_DEV), Angle.FromDegrees(i*TO_SIDE_ANGLE+ANGLE_DEV)) ), // midp
GatherPoints[PlayerTeam.Monsters] + Vector.FromLengthAndAngle( RandomGen.NextDouble(PATH_SEG_LEN_MIN*2,PATH_SEG_LEN_MAX*2),
fromMonstersToHumans.Angle+RandomGen.NextAngle(Angle.FromDegrees(-i*TO_SIDE_ANGLE-ANGLE_DEV), Angle.FromDegrees(-i*TO_SIDE_ANGLE+ANGLE_DEV)) ),
GatherPoints[PlayerTeam.Monsters] + Vector.FromLengthAndAngle( RandomGen.NextDouble(PATH_SEG_LEN_MIN,PATH_SEG_LEN_MAX),
fromMonstersToHumans.Angle+Angle.FromDegrees(-i*TO_SIDE_ANGLE)),
GatherPoints[PlayerTeam.Monsters]+new Vector(0.01,0.01),
GatherPoints[PlayerTeam.Monsters],
}
);
}
foreach (var pathPoints in pathsPts)
{
RoadMap path = new RoadMap(pathPoints);
path.DefaultWidth = 10.0;
path.Insert();
paths.Add(path);
// Add Path as overlay
// TODO: Use CreateSegmentFunction to create path with path texture
Vector? fromPt = null;
Vector? toPt = null;
foreach (var segment in path.Segments)
{
fromPt = toPt;
toPt = segment.Position;
if (fromPt != null)
{
Vector fromToVec = toPt.Value - fromPt.Value;
if (fromToVec != Vector.Zero)
{
var pathSkin = new GameObject(10, fromToVec.Magnitude);
pathSkin.Image = pathSkinImage;
pathSkin.Position = fromPt.Value + fromToVec / 2;
pathSkin.TextureFillsShape = true;
pathSkin.TextureWrapSize = new Vector(1.0, fromToVec.Magnitude / pathSkinImage.Height);
pathSkin.Angle = fromToVec.Angle + Angle.FromDegrees(90);
Add(pathSkin, -2);
}
}
segment.IsVisible = false;
}
for (int i = 2; i < pathPoints.Length-2; i++)
{
var point = pathPoints[i];
RandomTrees(point, 3);
}
}
StartGame();
}
void OnMoveUnit(PhysicsObject unit, int index, RoadMap path)
{
// Already fleeing
if (unit.IgnoresCollisionResponse)
return;
// determine in which turn to traverse the path
int increment = +1;
if (unit.Tag == "m")
increment = -1;
if (unit.Image == hPreparer)
{
if (MoveToClosestTree(unit, treeImage)) return;
}
if (unit.Image == mGatherer)
{
if (MoveToClosestTree(unit, saplingImage)) return;
}
if (unit.Image == hGatherer)
{
if (MoveToClosestTree(unit, logImage)) return;
}
if (unit.Image == mPreparer)
{
if (MoveToClosestTree(unit, stumpImage)) return;
}
Vector moveToPos = path.Segments[index].Position;
if (index + increment >= 0 && index + increment < path.Segments.Length)
{
Action afterMove = () => OnMoveUnit(unit, index + increment, path);
unit.MoveTo(moveToPos, unitMoveSpeed, afterMove);
moveOrStayTarget[unit] = new Tuple<Vector,Action>(moveToPos, afterMove);
}
else
{
// Stop at the end of the path
unit.MoveTo(moveToPos, unitMoveSpeed);
moveOrStayTarget[unit] = new Tuple<Vector, Action>(moveToPos, null);
}
}
