public static void LoadSwitches(List <PowerEntity> elements, double newX, double newY, List <double> xPoints, List <double> yPoints)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load("Geographic.xml");
XmlNodeList nodeList;
nodeList = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Switches/SwitchEntity");
foreach (XmlNode node in nodeList)
{
SwitchEntity sw = new SwitchEntity();
sw.Id = long.Parse(node.SelectSingleNode("Id").InnerText);
sw.Name = node.SelectSingleNode("Name").InnerText;
sw.X = double.Parse(node.SelectSingleNode("X").InnerText);
sw.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
sw.Status = node.SelectSingleNode("Status").InnerText;
sw.ToolTip = "Switch\nID: " + sw.Id + " \n Name: " + sw.Name + "\n Status: " + sw.Status;
elements.Add(sw);
Converter.ToLatLon(sw.X, sw.Y, 34, out newX, out newY);
xPoints.Add(newX);
yPoints.Add(newY);
}
}
public Button MapButton(ButtonEntity src, SwitchEntity liveSwitch, Button dest)
{
var mapped = mapper.Map(src, dest);
mapped.ButtonStates?.Sort((i, j) => i.Order - j.Order);
SetCurrentIcon(mapped, liveSwitch?.Value ?? GetSwitchValue(mapped));
return(mapped);
}
public void setSwitchCheckpoints()
{
foreach (Entity e in GlobalVars.nonGroundEntities.Values)
{
if (e is SwitchEntity)
{
SwitchEntity mySwitch = ( SwitchEntity )e;
SwitchComponent switchComp = (SwitchComponent)e.getComponent(GlobalVars.SWITCH_COMPONENT_NAME);
mySwitch.lastCheckpointState = switchComp.active;
}
}
}
public static int AdditionalTask8SW(SwitchEntity item)
{
int counter = 0;
foreach (var line in DataContainers.Containers.GetLines)
{
if (line.FirstEnd == item.Id || line.SecondEnd == item.Id)
{
++counter;
}
}
return(counter);
}
private static void LoadSwitcheEntities(XmlNodeList nodeList)
{
foreach (XmlNode node in nodeList)
{
SwitchEntity s = new SwitchEntity();
s.Id = long.Parse(node.SelectSingleNode("Id").InnerText);
s.Name = node.SelectSingleNode("Name").InnerText;
s.Status = node.SelectSingleNode("Status").InnerText;
s.X = double.Parse(node.SelectSingleNode("X").InnerText);
s.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
switchEntities.Add(s);
}
}
public async Task <Button> Get(Guid buttonId, bool getLive = false)
{
SwitchEntity liveSwitch = null;
var entity = await this.Entity(buttonId);
if (getLive)
{
var switchEntity = entity.ButtonStates.FirstOrDefault()?.SwitchSettings.FirstOrDefault()?.Switch;
if (switchEntity != null)
{
liveSwitch = await switchRepo.Get(switchEntity.Subsystem, switchEntity.Bridge, switchEntity.Id);
}
}
return(mapper.MapButton(entity, liveSwitch, new Button()));
}
private void LoadSwitches(XmlDocument xmlDoc)
{
double noviX, noviY;
SwitchEntity switchobj;
XmlNodeList nodeList = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Switches/SwitchEntity");
foreach (XmlNode node in nodeList)
{
switchobj = new SwitchEntity();
switchobj.Id = long.Parse(node.SelectSingleNode("Id").InnerText);
switchobj.Name = node.SelectSingleNode("Name").InnerText;
switchobj.X = double.Parse(node.SelectSingleNode("X").InnerText);
switchobj.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
switchobj.Status = node.SelectSingleNode("Status").InnerText;
ToLatLon(switchobj.X, switchobj.Y, 34, out noviX, out noviY);
switchobj.TranslatedX = noviX;
switchobj.TranslatedY = noviY;
PowerGrid.PowerEntities.Add(switchobj.Id, switchobj);
}
}
private void ParseSwitches()
{
double newX, newY;
foreach (XmlNode node in switchNodeList)
{
SwitchEntity sw = new SwitchEntity();
sw.Id = long.Parse(node.SelectSingleNode("Id").InnerText);
sw.Name = node.SelectSingleNode("Name").InnerText;
sw.X = double.Parse(node.SelectSingleNode("X").InnerText);
sw.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
sw.Status = node.SelectSingleNode("Status").InnerText;
ToLatLon(sw.X, sw.Y, 34, out newX, out newY);
sw.X = newX;
sw.Y = newY;
if (sw.X > maxCoordX)
{
maxCoordX = sw.X;
}
if (sw.X < minCoordX)
{
minCoordX = sw.X;
}
if (sw.Y > maxCoordY)
{
maxCoordY = sw.Y;
}
if (sw.Y < minCoordY)
{
minCoordY = sw.Y;
}
allSwitches.Add(sw);
}
}
public static void GetSwitches(XmlDocument xmlDocument, double boundaryMaxX, double boundaryMinX, double boundaryMaxY, double boundaryMinY,
List <Point> points, List <SwitchEntity> switchEntities)
{
var nodeList = xmlDocument.DocumentElement.SelectNodes("/NetworkModel/Switches/SwitchEntity");
foreach (XmlNode node in nodeList)
{
SwitchEntity switchEntity = new SwitchEntity();
switchEntity.Id = long.Parse(node.SelectSingleNode("Id").InnerText);
switchEntity.Name = node.SelectSingleNode("Name").InnerText;
switchEntity.X = double.Parse(node.SelectSingleNode("X").InnerText);
switchEntity.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
switchEntity.State = node.SelectSingleNode("Status").InnerText;
Converter.ToLatLon(switchEntity.X, switchEntity.Y, 34, out double newX, out double newY);
if (newX < boundaryMaxX && newX > boundaryMinX && newY < boundaryMaxY && newY > boundaryMinY)
{
points.Add(new Models.Point(newX, newY, switchEntity.Id, switchEntity.Name, ""));
switchEntities.Add(switchEntity);
}
}
}
public static Ellipse DrawSwitchImage(int indexI, int indexJ, Canvas myCanvas, SwitchEntity switchEntity)
{
Ellipse element = new Ellipse()
{
Width = 3, Height = 3, Fill = Brushes.LightSkyBlue
};
element.ToolTip = $"ID: {switchEntity.Id}\nSwitch Entity\nName: {switchEntity.Name}\nStatus: {switchEntity.Status}";
Canvas.SetLeft(element, ((double)indexJ - MinJ) / (MaxJ - MinJ) * myCanvas.Width);
Canvas.SetTop(element, ((double)indexI - MinI) / (MaxI - MinI) * myCanvas.Height);
return(element);
}
public void gotoCheckpoint()
{
if (!hasHadCheckpoint)
{
resetLevel();
}
paused = true;
if (levelNum == 1)
{
if (!checkpointData.colorOrbObtained())
{
setToPreColors();
}
else
{
setToPostColors();
}
}
//Deactivate the vision orb if it's active
if (sysManager.visSystem.orbActive)
{
sysManager.visSystem.destroyVisionOrb();
}
//Remove border
if (sysManager.drawSystem.getMainView().hasBorder)
{
sysManager.drawSystem.getMainView().hasBorder = false;
}
Dictionary <int, Entity> toRestore = GlobalVars.removedStartingEntities.Where(x => !checkpointData.getRemovedEnts().ContainsKey(x.Key)).ToDictionary(x => x.Key, x => x.Value);
//Remove non-starting entities, and restore starting entities to their initial state
//Set switches to their last checkpnt state
Entity[] ents = GlobalVars.nonGroundEntities.Values.ToArray();
for (int i = 0; i < ents.Length; i++)
{
if (ents[i] is SwitchEntity)
{
SwitchEntity switchEnt = (SwitchEntity)ents[i];
SwitchComponent switchComp = ( SwitchComponent )switchEnt.getComponent(GlobalVars.SWITCH_COMPONENT_NAME);
switchComp.setActive(switchEnt.lastCheckpointState, switchEnt);
}
if (!ents[i].isStartingEntity)
{
removeEntity(ents[i]);
}
else if (ents[i].resetOnCheckpoint)
{
ents[i].revertToStartingState();
}
}
//Do the same for ground
Entity[] grndents = GlobalVars.groundEntities.Values.ToArray();
for (int i = 0; i < grndents.Length; i++)
{
if (!grndents[i].isStartingEntity)
{
removeEntity(grndents[i]);
}
else if (grndents[i].resetOnCheckpoint)
{
grndents[i].revertToStartingState();
}
}
foreach (Entity e in toRestore.Values)
{
e.revertToStartingState();
addEntity(e.randId, e);
GlobalVars.removedStartingEntities.Remove(e.randId);
}
Player player = getPlayer();
if (player == null)
{
Console.WriteLine("Error, trying to go to checkpoint with no player");
resetLevel();
}
PositionComponent playerPos = (PositionComponent)player.getComponent(GlobalVars.POSITION_COMPONENT_NAME);
getMovementSystem().changePosition(playerPos, checkpointData.getPlayerLoc().X, checkpointData.getPlayerLoc().Y, false, false);
paused = false;
}
public void ParseXML(string xmlPath, out List <SubstationEntity> subList, out List <NodeEntity> nodeList, out List <SwitchEntity> switchList, out List <LineEntity> lineList) //cita sve korisnika iz xml-a
{
XmlDocument doc = new XmlDocument();
doc.Load(xmlPath);
SubstationEntity sub = new SubstationEntity();
NodeEntity ne = new NodeEntity();
SwitchEntity se = new SwitchEntity();
LineEntity le = new LineEntity();
MyPoint p = new MyPoint();
double tempX, tempY;
subList = new List <SubstationEntity>();
nodeList = new List <NodeEntity>();
switchList = new List <SwitchEntity>();
lineList = new List <LineEntity>();
foreach (XmlNode node in doc.DocumentElement.ChildNodes) //uzima sve cvorove
{
foreach (XmlNode item in node.ChildNodes) //uzima sve child cvorove prvih cvorova (tu su konkretni elementi)
{
if (item.Name.Equals("SubstationEntity")) //za svaki element konkretnog taga, pravi istancu tog elementa i dodaje je u odgovarajucu grupu
{
sub = new SubstationEntity();
sub.ID = long.Parse(item.ChildNodes[0].InnerText);
sub.Name = item.ChildNodes[1].InnerText;
UTMtoDecimal.ToLatLon(double.Parse(item.ChildNodes[2].InnerText), double.Parse(item.ChildNodes[3].InnerText), 34, out tempX, out tempY); //odmah pretvara u decimalne vrednosti i takve cuva u x i y
sub.X = tempX;
sub.Y = tempY;
subList.Add(sub);
}
if (item.Name.Equals("NodeEntity"))
{
ne = new NodeEntity();
ne.ID = long.Parse(item.ChildNodes[0].InnerText);
ne.Name = item.ChildNodes[1].InnerText;
UTMtoDecimal.ToLatLon(double.Parse(item.ChildNodes[2].InnerText), double.Parse(item.ChildNodes[3].InnerText), 34, out tempX, out tempY);
ne.X = tempX;
ne.Y = tempY;
nodeList.Add(ne);
}
if (item.Name.Equals("SwitchEntity"))
{
se = new SwitchEntity();
se.ID = long.Parse(item.ChildNodes[0].InnerText);
se.Name = item.ChildNodes[1].InnerText;
se.Status = item.ChildNodes[2].InnerText;
UTMtoDecimal.ToLatLon(double.Parse(item.ChildNodes[3].InnerText), double.Parse(item.ChildNodes[4].InnerText), 34, out tempX, out tempY);
se.X = tempX;
se.Y = tempY;
switchList.Add(se);
}
if (item.Name.Equals("LineEntity"))
{
le = new LineEntity();
le.ID = long.Parse(item.ChildNodes[0].InnerText);
le.Name = item.ChildNodes[1].InnerText;
le.IsUnderground = bool.Parse(item.ChildNodes[2].InnerText);
le.R = double.Parse(item.ChildNodes[3].InnerText);
le.ConductorMaterial = item.ChildNodes[4].InnerText;
le.LineType = item.ChildNodes[5].InnerText;
le.TerminalConstantHeat = int.Parse(item.ChildNodes[6].InnerText);
le.FirstEnd = double.Parse(item.ChildNodes[7].InnerText);
le.SecondEnd = double.Parse(item.ChildNodes[8].InnerText);
foreach (XmlNode pointItem in item.ChildNodes[9].ChildNodes)
{
p = new MyPoint();
UTMtoDecimal.ToLatLon(double.Parse(pointItem.ChildNodes[0].InnerText), double.Parse(pointItem.ChildNodes[1].InnerText), 34, out tempX, out tempY);
p.X = tempX;
p.Y = tempY;
le.Vertices.Add(p);
}
lineList.Add(le);
}
}
}
}
public static void LoadModel(string path)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
XmlNodeList nodeList;
nodeList = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Substations/SubstationEntity");
foreach (XmlNode node in nodeList)
{
SubstationEntity substationEntity = new SubstationEntity();
substationEntity.Id = UInt64.Parse(node.SelectSingleNode("Id").InnerText);
substationEntity.Name = node.SelectSingleNode("Name").InnerText;
substationEntity.X = double.Parse(node.SelectSingleNode("X").InnerText);
substationEntity.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
double newX, newY;
ToLatLonConverter.ToLatLon(substationEntity.X, substationEntity.Y, 34, out newX, out newY);
substationEntity.X = newX;
substationEntity.Y = newY;
MinMaxCoordCheck.Check(newX, newY);
NetworkModel.substationEntities.Add(substationEntity);
}
nodeList = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Nodes/NodeEntity");
foreach (XmlNode node in nodeList)
{
NodeEntity nodeEntity = new NodeEntity();
nodeEntity.Id = UInt64.Parse(node.SelectSingleNode("Id").InnerText);
nodeEntity.Name = node.SelectSingleNode("Name").InnerText;
nodeEntity.X = double.Parse(node.SelectSingleNode("X").InnerText);
nodeEntity.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
double newX, newY;
ToLatLonConverter.ToLatLon(nodeEntity.X, nodeEntity.Y, 34, out newX, out newY);
nodeEntity.X = newX;
nodeEntity.Y = newY;
MinMaxCoordCheck.Check(newX, newY);
NetworkModel.nodeEntities.Add(nodeEntity);
}
nodeList = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Switches/SwitchEntity");
foreach (XmlNode node in nodeList)
{
SwitchEntity switchEntity = new SwitchEntity();
switchEntity.Id = UInt64.Parse(node.SelectSingleNode("Id").InnerText);
switchEntity.Name = node.SelectSingleNode("Name").InnerText;
switchEntity.X = double.Parse(node.SelectSingleNode("X").InnerText);
switchEntity.Y = double.Parse(node.SelectSingleNode("Y").InnerText);
switchEntity.Status = node.SelectSingleNode("Status").InnerText;
double newX, newY;
ToLatLonConverter.ToLatLon(switchEntity.X, switchEntity.Y, 34, out newX, out newY);
switchEntity.X = newX;
switchEntity.Y = newY;
MinMaxCoordCheck.Check(newX, newY);
NetworkModel.switchEntities.Add(switchEntity);
}
nodeList = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Lines/LineEntity");
foreach (XmlNode node in nodeList)
{
LineEntity lineEntity = new LineEntity();
lineEntity.Id = ulong.Parse(node.SelectSingleNode("Id").InnerText);
lineEntity.Name = node.SelectSingleNode("Name").InnerText;
if (node.SelectSingleNode("IsUnderground").InnerText.Equals("true"))
{
lineEntity.IsUnderground = true;
}
else
{
lineEntity.IsUnderground = false;
}
lineEntity.R = float.Parse(node.SelectSingleNode("R").InnerText);
lineEntity.ConductorMaterial = node.SelectSingleNode("ConductorMaterial").InnerText;
lineEntity.LineType = node.SelectSingleNode("LineType").InnerText;
lineEntity.ThermalConstantHeat = long.Parse(node.SelectSingleNode("ThermalConstantHeat").InnerText);
lineEntity.FirstEnd = ulong.Parse(node.SelectSingleNode("FirstEnd").InnerText);
lineEntity.SecondEnd = ulong.Parse(node.SelectSingleNode("SecondEnd").InnerText);
foreach (XmlNode pointNode in node.ChildNodes[9].ChildNodes) // 9 posto je Vertices 9. node u jednom line objektu
{
Point point = new Point();
point.X = double.Parse(pointNode.SelectSingleNode("X").InnerText);
point.Y = double.Parse(pointNode.SelectSingleNode("Y").InnerText);
double newX, newY;
ToLatLonConverter.ToLatLon(point.X, point.Y, 34, out newX, out newY);
point.X = newX;
point.Y = newY;
//NetworkModel.vertices.Add(lineEntity);
}
NetworkModel.vertices.Add(lineEntity);
}
}
public static NetworkModel LoadModelToMap(NetworkModel networkModel, ModelVisual3D myModel)
{
networkModel = XmlHandler.Load <NetworkModel>(@"..\..\Geographic.xml");
// SUBSTATIONS
for (int i = 0; i < networkModel.Substations.Count; i++)
{
SubstationEntity s = networkModel.Substations[i];
double latitude, longitude, mapX, mapY;
CoordinatesHandler.ToLatLon(networkModel.Substations[i].X, networkModel.Substations[i].Y, 34, out latitude, out longitude);
networkModel.Substations[i].X = latitude;
networkModel.Substations[i].Y = longitude;
CoordinatesHandler.FromCoordinatesToMapPosition(latitude, longitude, out mapX, out mapY);
networkModel.Substations[i].MapX = mapX;
networkModel.Substations[i].MapY = mapY;
if (mapX != -1 && mapY != -1)
{
double z = 0;
if (Points.Count != 0 || i != 0)
{
int index = 0;
double x;
double y;
if (HasEntityInRadius(mapX, mapY, out index, out x, out y))
{
s.MapX = x;
s.MapY = y;
mapX = x;
mapY = y;
Points[index].Count++;
z = 0.05 * Points[index].Count;
}
else
{
z = 0;
Points.Add(new PointStack(mapX, mapY, 0));
}
}
else
{
z = 0;
Points.Add(new PointStack(mapX, mapY, 0));
}
GeometryModel3D model3D = ScreenHandler.Make3DCube(mapX, mapY, z, 0.05, EntityType.Substation);
TransformationHandler.models.Add(model3D);
Entities.Add(TransformationHandler.models.Count - 1, s);
ScreenHandler.Draw3DCube(model3D, myModel);
}
}
// NODES
for (int i = 0; i < networkModel.Nodes.Count; i++)
{
NodeEntity n = networkModel.Nodes[i];
double latitude, longitude, mapX, mapY;
CoordinatesHandler.ToLatLon(networkModel.Nodes[i].X, networkModel.Nodes[i].Y, 34, out latitude, out longitude);
networkModel.Nodes[i].X = latitude;
networkModel.Nodes[i].Y = longitude;
CoordinatesHandler.FromCoordinatesToMapPosition(latitude, longitude, out mapX, out mapY);
networkModel.Nodes[i].MapX = mapX;
networkModel.Nodes[i].MapY = mapY;
if (mapX != -1 && mapY != -1)
{
double z = 0;
if (i != 0)
{
int index = 0;
double x;
double y;
if (HasEntityInRadius(mapX, mapY, out index, out x, out y))
{
n.MapX = x;
n.MapY = y;
mapX = x;
mapY = y;
Points[index].Count++;
z = 0.05 * Points[index].Count;
}
else
{
z = 0;
Points.Add(new PointStack(mapX, mapY, 0));
}
}
else
{
z = 0;
Points.Add(new PointStack(mapX, mapY, 0));
}
GeometryModel3D model3D = ScreenHandler.Make3DCube(mapX, mapY, z, 0.05, EntityType.Node);
TransformationHandler.models.Add(model3D);
Entities.Add(TransformationHandler.models.Count - 1, n);
ScreenHandler.Draw3DCube(model3D, myModel);
}
}
// SWITCHES
for (int i = 0; i < networkModel.Switches.Count; i++)
{
SwitchEntity s = networkModel.Switches[i];
double latitude, longitude, mapX, mapY;
CoordinatesHandler.ToLatLon(networkModel.Switches[i].X, networkModel.Switches[i].Y, 34, out latitude, out longitude);
networkModel.Switches[i].X = latitude;
networkModel.Switches[i].Y = longitude;
CoordinatesHandler.FromCoordinatesToMapPosition(latitude, longitude, out mapX, out mapY);
networkModel.Switches[i].MapX = mapX;
networkModel.Switches[i].MapY = mapY;
if (mapX != -1 && mapY != -1)
{
double z = 0;
if (i != 0)
{
int index = 0;
double x;
double y;
if (HasEntityInRadius(mapX, mapY, out index, out x, out y))
{
s.MapX = x;
s.MapY = y;
mapX = x;
mapY = y;
Points[index].Count++;
z = 0.05 * Points[index].Count;
}
else
{
z = 0;
Points.Add(new PointStack(mapX, mapY, 0));
}
}
else
{
z = 0;
Points.Add(new PointStack(mapX, mapY, 0));
}
GeometryModel3D model3D = ScreenHandler.Make3DCube(mapX, mapY, z, 0.05, EntityType.Switch);
TransformationHandler.models.Add(model3D);
Entities.Add(TransformationHandler.models.Count - 1, s);
ScreenHandler.Draw3DCube(model3D, myModel);
}
}
// LINES
int cnt = 0;
for (int i = 0; i < networkModel.Lines.Count; i++)
{
Entity entityStart = null;
Entity entityEnd = null;
entityStart = Entities.Values.ToList().Where(x => x.Id == networkModel.Lines[i].FirstEnd).FirstOrDefault();
entityEnd = Entities.Values.Where(x => x.Id == networkModel.Lines[i].SecondEnd).FirstOrDefault();
if (entityStart == null || entityEnd == null)
{
continue;
}
entityStart.NumConnctions++;
entityEnd.NumConnctions++;
cnt++;
GeometryModel3D model3D = ScreenHandler.Make3DTube(entityStart.MapX + 0.025, entityStart.MapY + 0.025, entityEnd.MapX + 0.025, entityEnd.MapY + 0.025, 0, 0.05, EntityType.Switch);
TransformationHandler.models.Add(model3D);
ScreenHandler.Draw3DCube(model3D, myModel);
Entities.Add(TransformationHandler.models.Count - 1, networkModel.Lines[i]);
}
return(networkModel);
}
//Reads in a paint image and adds all entities to the level.
public void readImage(Level level)
{
for (int y = 0; y < img.Height; y++)
{
for (int x = 0; x < img.Width; x++)
{
//Get the color of the pixel
Color col = img.GetPixel(x, y);
float levelX = x;
float levelY = y;
//First check for cases which have some variation in possible color values
//i.e. something identified with only it's RG, or GB, or RB, or just R or G or B
if (col.R == switchReserveRed)
{
Entity s = null;
if (col.G == permSwitchG)
{
s = new SwitchEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight);
}
else if (col.G == presSwitchG)
{
//Pressure Switch
s = new PressureSwitchEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileWidth);
TimedSwitchComponent timeComp = ( TimedSwitchComponent )s.getComponent(GlobalVars.TIMED_SWITCH_COMPONENT_NAME);
timeComp.baseTime = 0;
}
else
{
s = new TimedSwitchEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileWidth);
TimedSwitchComponent timeComp = ( TimedSwitchComponent )s.getComponent(GlobalVars.TIMED_SWITCH_COMPONENT_NAME);
timeComp.baseTime = col.G / 10;
}
s.isStartingEntity = true;
adjustLocation(s, level);
switches.Add(col.B, s);
level.addEntity(s.randId, s);
}
else if (col.R == spikeSwitchReserveRed)
{
float time = -1;
if (col.G < 255)
{
time = col.G / 10;
}
Entity s = new SpikeSwitchEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight, time);
s.isStartingEntity = true;
adjustLocation(s, level);
switches.Add(col.B, s);
level.addEntity(s.randId, s);
}
else if (col.R == shooterRedUp || col.R == shooterRedRight || col.R == shooterRedDown || col.R == shooterRedLeft)
{
float betweenBursts = ( float )col.B / ( float )10;
int switchId = col.G;
TimedShooterEntity shooter = new TimedShooterEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight, betweenBursts, 1, col.R - 110, switchId);
if (switchId == 0)
{
shooter.removeComponent(GlobalVars.SWITCH_LISTENER_COMPONENT_NAME);
}
else
{
SwitchListenerComponent slComp = ( SwitchListenerComponent )shooter.getComponent(GlobalVars.SWITCH_LISTENER_COMPONENT_NAME);
if (switches.ContainsKey(switchId))
{
slComp.switchId = switches[switchId].randId;
}
else
{
unmachedSwitchListeners.Add(slComp, switchId);
}
}
adjustLocation(shooter, level);
shooter.isStartingEntity = true;
level.addEntity(shooter);
}
else if (col.R == smushRed && (col.B - 4 <= 0))
{
int switchId = col.G;
SmushBlockEntity smush = new SmushBlockEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight, col.B, switchId);
if (switchId == 0)
{
smush.removeComponent(GlobalVars.SWITCH_LISTENER_COMPONENT_NAME);
}
else
{
SwitchListenerComponent slComp = ( SwitchListenerComponent )smush.getComponent(GlobalVars.SWITCH_LISTENER_COMPONENT_NAME);
if (switches.ContainsKey(switchId))
{
slComp.switchId = switches[switchId].randId;
}
else
{
unmachedSwitchListeners.Add(slComp, switchId);
}
}
adjustLocation(smush, level);
smush.isStartingEntity = true;
level.addEntity(smush);
}
else if (col.G == tallDoorReserveGreen || col.G == wideDoorReserveGreen || col.G == openTallDoorReserveGreen || col.G == openWideDoorReserveGreen)
{
float width = tallDoorWidth;
float height = tallDoorHeight;
if (col.G == wideDoorReserveGreen || col.G == openWideDoorReserveGreen)
{
width = wideDoorWidth;
height = wideDoorHeight;
}
DoorEntity door = new DoorEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight, width, height, (col.G % 100 == 0 || col.G % 100 == 1));
adjustLocation(door, level);
SwitchListenerComponent slComp = ( SwitchListenerComponent )door.getComponent(GlobalVars.SWITCH_LISTENER_COMPONENT_NAME);
door.isStartingEntity = true;
//check for its switch
if (switches.ContainsKey(col.B))
{
slComp.switchId = switches[col.B].randId;
}
else
{
unmachedSwitchListeners.Add(slComp, col.B);
}
level.addEntity(door);
}
else if (col.R == spikeRed && col.G == spikeGreen && (col.B - 4 <= 0))
{
SpikeEntity spike = new SpikeEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight, col.B);
adjustLocation(spike, level);
spike.isStartingEntity = true;
level.addEntity(spike);
}
else if (col.R == signRed && col.G == signGreen)
{
SignEntity signEnt = new SignEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight, col.B);
adjustLocation(signEnt, level);
signEnt.isStartingEntity = true;
level.addEntity(signEnt);
}
//Now just check for the specific colors
else if (col == playerCol)
{
Player player = new Player(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight);
adjustLocation(player, level);
PositionComponent posComp = ( PositionComponent )player.getComponent(GlobalVars.POSITION_COMPONENT_NAME);
level.getMovementSystem().teleportToNoCollisionCheck(posComp, posComp.x, posComp.y - GlobalVars.MIN_TILE_SIZE / 2);
posComp.setCurrentLocToStartingLoc();
player.isStartingEntity = true;
level.addEntity(player.randId, player);
}
else if (col == movePlatformTurn)
{
PlatformTurnEntity platTurn = new PlatformTurnEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight);
adjustLocation(platTurn, level);
platTurn.isStartingEntity = true;
level.addEntity(platTurn.randId, platTurn);
}
else if (col == basicGroundCol)
{
float groundX = (levelX) * tileWidth;
float groundWidth = tileWidth;
BasicGround ground = new BasicGround(level, rand.Next(Int32.MinValue, Int32.MaxValue), groundX, (levelY) * tileHeight, groundWidth, tileHeight);
adjustLocation(ground, level);
ground.isStartingEntity = true;
level.addEntity(ground.randId, ground);
if (!GlobalVars.fullForegroundImage)
{
//If no ground above it, change to a grass sprite
List <Entity> above = level.getCollisionSystem().findObjectAtPoint((levelX) * tileWidth, (levelY - 1) * tileWidth);
if (above.Count <= 0 || !(above[0] is BasicGround))
{
ground.changeSprite(false);
}
}
}
else if (col == testEntityColor)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
TestEntity test = new TestEntity(level, id, xLoc, yLoc);
adjustLocation(test, level);
test.isStartingEntity = true;
level.addEntity(test.randId, test);
}
else if (col == simpleEnemyColor)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
SimpleEnemyEntity enemy = new SimpleEnemyEntity(level, id, xLoc, yLoc, false);
adjustLocation(enemy, level);
enemy.isStartingEntity = true;
level.addEntity(enemy.randId, enemy);
}
else if (col == flyingEnemyColor)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
FlyingEnemyEntity enemy = new FlyingEnemyEntity(level, id, xLoc, yLoc, false);
adjustLocation(enemy, level);
enemy.isStartingEntity = true;
level.addEntity(enemy.randId, enemy);
}
else if (col == shieldWalkingEnemyColor)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
SimpleEnemyEntity enemy = new SimpleEnemyEntity(level, id, xLoc, yLoc, true);
adjustLocation(enemy, level);
enemy.isStartingEntity = true;
level.addEntity(enemy.randId, enemy);
}
else if (col == shieldFlyingEnemyColor)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
FlyingEnemyEntity enemy = new FlyingEnemyEntity(level, id, xLoc, yLoc, true);
adjustLocation(enemy, level);
enemy.isStartingEntity = true;
level.addEntity(enemy.randId, enemy);
}
else if (col == checkPointCollider)
{
CheckPointEntity checkEnt = new CheckPointEntity(level, rand.Next(Int32.MinValue, Int32.MaxValue), levelX * tileWidth, levelY * tileHeight);
adjustLocation(checkEnt, level);
checkEnt.isStartingEntity = true;
level.addEntity(checkEnt.randId, checkEnt);
}/*else if ( col == checkPointCollider ) {
*
* float xLoc = ( levelX ) * tileWidth;
* float yLoc = ( levelY ) * tileHeight;
* int id = rand.Next( Int32.MinValue, Int32.MaxValue );
* EndLevelEntity lvlEnd = new EndLevelEntity( level, id, xLoc, yLoc );
* adjustLocation( lvlEnd, level );
* lvlEnd.isStartingEntity = true;
* level.addEntity( lvlEnd.randId, lvlEnd );
*
* }*/
else if (col == vertMovPlatCol)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
MovingPlatformEntity plat = new MovingPlatformEntity(level, id, xLoc, yLoc);
adjustLocation(plat, level);
plat.isStartingEntity = true;
level.addEntity(plat);
} /*else if ( col == horizMovPlatCol ) {
*
* float xLoc = ( levelX ) * tileWidth;
* float yLoc = ( levelY ) * tileHeight;
* int id = rand.Next( Int32.MinValue, Int32.MaxValue );
*
* MovingPlatformEntity plat = new MovingPlatformEntity( level, id, xLoc, yLoc );
* adjustLocation( plat, level );
*
* plat.isStartingEntity = true;
* MovingPlatformComponent movPlatComp = ( MovingPlatformComponent )plat.getComponent( GlobalVars.MOVING_PLATFORM_COMPONENT_NAME );
* movPlatComp.vertical = false;
* VelocityComponent velComp = ( VelocityComponent )plat.getComponent( GlobalVars.VELOCITY_COMPONENT_NAME );
* velComp.y = 0;
* level.addEntity( plat );
*
* }*/
else if (col == bouncePickup)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
PowerupPickupEntity pickup = new PowerupPickupEntity(level, id, xLoc, yLoc, GlobalVars.BOUNCE_NUM);
adjustLocation(pickup, level);
pickup.isStartingEntity = true;
level.addEntity(pickup);
}
else if (col == speedyPickup)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
PowerupPickupEntity pickup = new PowerupPickupEntity(level, id, xLoc, yLoc, GlobalVars.SPEED_NUM);
adjustLocation(pickup, level);
pickup.isStartingEntity = true;
level.addEntity(pickup);
}
else if (col == jmpPickup)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
PowerupPickupEntity pickup = new PowerupPickupEntity(level, id, xLoc, yLoc, GlobalVars.JMP_NUM);
adjustLocation(pickup, level);
pickup.isStartingEntity = true;
level.addEntity(pickup);
}
else if (col == glidePickup)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
PowerupPickupEntity pickup = new PowerupPickupEntity(level, id, xLoc, yLoc, GlobalVars.GLIDE_NUM);
adjustLocation(pickup, level);
pickup.isStartingEntity = true;
level.addEntity(pickup);
}
else if (col == spawnPickup)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
PowerupPickupEntity pickup = new PowerupPickupEntity(level, id, xLoc, yLoc, GlobalVars.SPAWN_NUM);
adjustLocation(pickup, level);
pickup.isStartingEntity = true;
level.addEntity(pickup);
}
else if (col == grapPickup)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
PowerupPickupEntity pickup = new PowerupPickupEntity(level, id, xLoc, yLoc, GlobalVars.GRAP_NUM);
adjustLocation(pickup, level);
pickup.isStartingEntity = true;
level.addEntity(pickup);
}
else if (col == visionOrbUnlock)
{
float xLoc = (levelX) * tileWidth;
float yLoc = (levelY) * tileHeight;
int id = rand.Next(Int32.MinValue, Int32.MaxValue);
VisionOrbUnlock visUnlock = new VisionOrbUnlock(level, id, xLoc, yLoc);
adjustLocation(visUnlock, level);
visUnlock.isStartingEntity = true;
level.addEntity(visUnlock);
}
}
}
//Match any unmatched switch listeners to their switch
foreach (SwitchListenerComponent sc in unmachedSwitchListeners.Keys)
{
if (switches.ContainsKey(unmachedSwitchListeners[sc]))
{
SwitchListenerComponent slComp = sc;
slComp.switchId = switches[unmachedSwitchListeners[sc]].randId;
}
else
{
Console.WriteLine("Unmatched Switch Listener - B: " + unmachedSwitchListeners[sc]);
}
}
}
void LoadData()
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load("Geographic.xml");
if (xmlDoc.DocumentElement == null)
{
return;
}
var nodeListSubstation = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Substations/SubstationEntity");
var nodeListSwitch = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Switches/SwitchEntity");
var nodeListLines = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Lines/LineEntity");
var nodeListNode = xmlDoc.DocumentElement.SelectNodes("/NetworkModel/Nodes/NodeEntity");
foreach (XmlNode node in nodeListSubstation)
{
var entity = new SubstationEntity();
ParsePowerEntity(node, entity);
var spot = Create3DObject(entity, System.Windows.Media.Color.FromRgb(255, 0, 0), .1);
}
foreach (XmlNode node in nodeListNode)
{
var entity = new NodeEntity();
ParsePowerEntity(node, entity);
var spot = Create3DObject(entity, System.Windows.Media.Color.FromRgb(255, 0, 0), .1);
}
foreach (XmlNode node in nodeListSwitch)
{
var entity = new SwitchEntity();
ParsePowerEntity(node, entity);
var spot = Create3DObject(entity, System.Windows.Media.Color.FromRgb(255, 0, 0), .1);
}
foreach (XmlNode item in nodeListLines)
{
var line = new LineEntity
{
Id = long.Parse(item.SelectSingleNode("Id")?.InnerText ?? string.Empty),
Name = item.SelectSingleNode("Name")?.InnerText,
IsUnderground = bool.Parse(item.SelectSingleNode("IsUnderground")?.InnerText ?? string.Empty),
LineType = item.SelectSingleNode("LineType")?.InnerText,
R = float.Parse(item.SelectSingleNode("R")?.InnerText ?? string.Empty),
FirstEnd = long.Parse(item.SelectSingleNode("FirstEnd")?.InnerText ?? string.Empty),
SecondEnd = long.Parse(item.SelectSingleNode("SecondEnd")?.InnerText ?? string.Empty),
ConductorMaterial = item.SelectSingleNode("ConductorMaterial")?.InnerText,
ThermalConstantHeat = long.Parse(item.SelectSingleNode("ThermalConstantHeat")?.InnerText ?? string.Empty),
Vertices = new List <Point>()
};
foreach (XmlNode pointNode in item.ChildNodes[9].ChildNodes)
{
var xRaw = double.Parse(pointNode.SelectSingleNode("X")?.InnerText ?? string.Empty);
var yRaw = double.Parse(pointNode.SelectSingleNode("Y")?.InnerText ?? string.Empty);
Utility.ToLatLon(xRaw, yRaw, 34, out var lat, out var lon);
line.Vertices.Add(new Point()
{
X = lat,
Y = lon
});
}
var firstEnd = instantiatedObject.FirstOrDefault(x => x.Entity.Id == line.FirstEnd);
var secondEnd = instantiatedObject.FirstOrDefault(x => x.Entity.Id == line.SecondEnd);
if (firstEnd == null || secondEnd == null)
{
continue;
}
firstEnd.ConnectionCount++;
secondEnd.ConnectionCount++;
Utility.ToLatLon(firstEnd.Entity.X, firstEnd.Entity.Y, 34, out var xFirst, out var yFirst);
Utility.ToLatLon(secondEnd.Entity.X, secondEnd.Entity.Y, 34, out var xSecond, out var ySecond);
if (mapper.IsInRange(xFirst, yFirst) == false || mapper.IsInRange(xSecond, ySecond) == false)
{
continue;
}
var v1 = mapper.Convert(line.Vertices[0].X, line.Vertices[0].Y);
var vn = mapper.Convert(line.Vertices[line.Vertices.Count - 1].X, line.Vertices[line.Vertices.Count - 1].Y);
#region hideTHis
vertexId = 0;
var mesh = new MeshGeometry3D();
CreateLineSegment(firstEnd.X,
firstEnd.Y,
v1.X,
v1.Y,
mesh);
for (int i = 0; i < line.Vertices.Count - 1; i++)
{
var p1 = mapper.Convert(line.Vertices[i].X, line.Vertices[i].Y);
var p2 = mapper.Convert(line.Vertices[i + 1].X, line.Vertices[i + 1].Y);
CreateLineSegment(p1.X,
p1.Y,
p2.X,
p2.Y,
mesh);
}
CreateLineSegment(vn.X,
vn.Y,
secondEnd.X,
secondEnd.Y,
mesh);
var mat = new DiffuseMaterial {
Brush = new SolidColorBrush(Colors.DarkRed)
};
var surfaceModel = new GeometryModel3D(mesh, mat)
{
BackMaterial = mat,
Transform = new Transform3DGroup()
{
Children = new Transform3DCollection()
{
new TranslateTransform3D(0, 0, 0.01)
}
}
};
mainModel3DGroup.Children.Add(surfaceModel);
var lineComponent = new LineContainer(firstEnd, secondEnd, line, surfaceModel);
lines.Add(line.Id, lineComponent);
#endregion
}
// foreach (var path in iterator.FindPaths(entities, spots, lines.Values.ToList()))
{
//#region Sa prekalapanjem
//// Ovde je sa preklapanjem
////Polyline s = new Polyline();
////s.Stroke = new SolidColorBrush(Color.FromRgb(0, 0, 0));
////s.StrokeThickness = 0.5;
////foreach (var pat in paths.spots)
////{
//// s.Points.Add(new System.Windows.Point(pat.X, pat.Y));
////}
////canvas.Children.Add(s);
//#endregion
//entityLineLines[path.lineEntityId] = new List<LineSegmentContainer>();
//for (int i = 0; i < path.spots.Count - 1; i++)
//{
// if (path.spots[i].IsOccupied == false || path.spots[i + 1].IsOccupied == false) // overlap check
// {
// Polyline s = new Polyline();
// var p1 = new System.Windows.Point(path.spots[i].X, path.spots[i].Y);
// var p2 = new System.Windows.Point(path.spots[i + 1].X, path.spots[i + 1].Y);
// s.Points.Add(p1);
// s.Points.Add(p2);
// path.spots[i].AssignLinePart(path.lineEntityId);
// entityLineLines[path.lineEntityId].Add(new LineSegmentContainer() { line = s, p1 = path.spots[i], p2 = path.spots[i + 1] });
// if (path.spots[i].IsOccupied && path.spots[i].Entities.Count == 0)
// {
// path.spots[i].AssignCross();
// }
// path.spots[i].IsOccupied = true;
// s.Stroke = new SolidColorBrush(Color.FromRgb(0, 0, 0));
// s.StrokeThickness = 0.5;
// canvas.Children.Add(s);
// s.MouseRightButtonDown += path.spots[i].RightClickOnThis;
// s.MouseEnter += OnHoverOverLine;
// }
// else
// {
// bool found = false;
// foreach (var item in entityLineLines.Values)
// {
// if (found)
// break;
// foreach (var l in item)
// {
// if (path.spots[i] == l.p1 && path.spots[i + 1] == l.p2)
// {
// found = true;
// entityLineLines[path.lineEntityId].Add(l);
// break;
// }
// }
// }
// }
//}
}
foreach (var obj in instantiatedObject)
{
if (obj.ConnectionCount < 3)
{
obj.Model.Material = new DiffuseMaterial {
Brush = new SolidColorBrush(Color.FromRgb(255, 127, 127))
};
}
else if (obj.ConnectionCount >= 3 && obj.ConnectionCount < 5)
{
obj.Model.Material = new DiffuseMaterial {
Brush = new SolidColorBrush(Color.FromRgb(255, 70, 70))
};
}
else
{
obj.Model.Material = new DiffuseMaterial {
Brush = new SolidColorBrush(Color.FromRgb(255, 0, 0))
};
}
}
}
public static IObservable <StateChange <SwitchEntity, EntityState <SwitchAttributes> > > StateAllChangesWithCurrent(this SwitchEntity entity)
{
return(entity.StateAllChangesWithCurrent <SwitchEntity, EntityState <SwitchAttributes>, SwitchAttributes>());
}
public static NetworkModel LoadModelToMap(NetworkModel networkModel, ModelVisual3D myModel)
{
networkModel = XmlHandler.Load <NetworkModel>(@"..\..\Geographic.xml");
// SUBSTATIONS
for (int i = 0; i < networkModel.Substations.Count; i++)
{
SubstationEntity s = networkModel.Substations[i];
double latitude, longitude, mapX, mapY;
// preracunavanje u koordinate
CoordinatesHandler.ToLatLon(networkModel.Substations[i].X, networkModel.Substations[i].Y, 34, out latitude, out longitude);
networkModel.Substations[i].X = latitude;
networkModel.Substations[i].Y = longitude;
// preracunavanje u poziciju na mapi
CoordinatesHandler.FromCoordinatesToMapPosition(latitude, longitude, out mapX, out mapY);
networkModel.Substations[i].MapX = mapX;
networkModel.Substations[i].MapY = mapY;
// crtanje cvora koji je u opsegu mape
if (mapX != -1 && mapY != -1)
{
// provera da li postoji cvorova na toj lokaciji, redjanje na spratove
// u prvom prolazu se sigurno crta
double z = 0;
if (Points.Count != 0 || i != 0)
{
int index = 0;
double x;
double y;
// ako postoji objekat unutar definisanog precnika, uvecava se brojac i definise se visina na kojoj je potrebno nacrtati sledeci objekat
if (HasEntityInRadius(mapX, mapY, out index, out x, out y))
{
s.MapX = x;
s.MapY = y;
mapX = x;
mapY = y;
//Points[new Tuple<double, double>(mapX, mapY)].Count++;
//z = 0.05 * Points[new Tuple<double, double>(mapX, mapY)].Count;
Points[index].Count++;
z = 0.05 * Points[index].Count;
}
else
{
z = 0;
//Points.Add(new Tuple<double, double>(mapX, mapY), new PointStack(mapX, mapY, 0));
Points.Add(new PointStack(mapX, mapY, 0));
}
}
else
{
z = 0;
//EntitiesDict.Add(new Tuple<double, double>(roundLat, roundLog), 0);
//Points.Add(new Tuple<double, double>(mapX, mapY), new PointStack(mapX, mapY, 0));
Points.Add(new PointStack(mapX, mapY, 0));
}
// kreiranje 3D modela kocke i dodavanje u ArrayList models, zbog Hit Testing-a
GeometryModel3D model3D = ScreenHandler.Make3DCube(mapX, mapY, z, 0.05, EntityType.Substation);
Transformation.models.Add(model3D);
// dodavanje entiteta u recnik, kljuc je njegov redni broj u okviru ArrayList-e models
Entities.Add(Transformation.models.Count - 1, s);
ScreenHandler.Draw3DCube(model3D, myModel);
}
}
// NODES
for (int i = 0; i < networkModel.Nodes.Count; i++)
{
NodeEntity n = networkModel.Nodes[i];
double latitude, longitude, mapX, mapY;
// preracunavanje u koordinate
CoordinatesHandler.ToLatLon(networkModel.Nodes[i].X, networkModel.Nodes[i].Y, 34, out latitude, out longitude);
networkModel.Nodes[i].X = latitude;
networkModel.Nodes[i].Y = longitude;
// preracunavanje u poziciju na mapi
CoordinatesHandler.FromCoordinatesToMapPosition(latitude, longitude, out mapX, out mapY);
networkModel.Nodes[i].MapX = mapX;
networkModel.Nodes[i].MapY = mapY;
// crtanje c vora koji je u opsegu mape
if (mapX != -1 && mapY != -1)
{
/// provera da li postoji cvorova na toj lokaciji, redjanje na spratove
// u prvom prolazu se sigurno crta
double z = 0;
if (i != 0)
{
int index = 0;
double x;
double y;
// ako postoji objekat unutar definisanog precnika, uvecava se brojac i definise se visina na kojoj je potrebno nacrtati sledeci objekat
if (HasEntityInRadius(mapX, mapY, out index, out x, out y))
{
n.MapX = x;
n.MapY = y;
mapX = x;
mapY = y;
//z = 0.05 * EntitiesDict[new Tuple<double, double>(roundLat, roundLog)];
//Points[new Tuple<double, double>(mapX, mapY)].Count++;
Points[index].Count++;
z = 0.05 * Points[index].Count;
}
else
{
z = 0;
//Points.Add(new Tuple<double, double>(mapX, mapY), new PointStack(mapX, mapY, 0));
Points.Add(new PointStack(mapX, mapY, 0));
}
}
else
{
z = 0;
//EntitiesDict.Add(new Tuple<double, double>(roundLat, roundLog), 0);
//Points.Add(new Tuple<double, double>(mapX, mapY), new PointStack(mapX, mapY, 0));
Points.Add(new PointStack(mapX, mapY, 0));
}
// kreiranje 3D modela kocke i dodavanje u ArrayList models, zbog Hit Testing-a
GeometryModel3D model3D = ScreenHandler.Make3DCube(mapX, mapY, z, 0.05, EntityType.Node);
Transformation.models.Add(model3D);
// dodavanje entiteta u recnik, kljuc je njegov redni broj u okviru ArrayList-e models
Entities.Add(Transformation.models.Count - 1, n);
ScreenHandler.Draw3DCube(model3D, myModel);
}
}
// SWITCHES
for (int i = 0; i < networkModel.Switches.Count; i++)
{
SwitchEntity s = networkModel.Switches[i];
double latitude, longitude, mapX, mapY;
// preracunavanje u koordinate
CoordinatesHandler.ToLatLon(networkModel.Switches[i].X, networkModel.Switches[i].Y, 34, out latitude, out longitude);
networkModel.Switches[i].X = latitude;
networkModel.Switches[i].Y = longitude;
// preracunavanje u poziciju na mapi
CoordinatesHandler.FromCoordinatesToMapPosition(latitude, longitude, out mapX, out mapY);
networkModel.Switches[i].MapX = mapX;
networkModel.Switches[i].MapY = mapY;
// crtanje cvora koji je u opsegu mape
if (mapX != -1 && mapY != -1)
{
// provera da li postoji cvorova na toj lokaciji, redjanje na spratove
// u prvom prolazu se sigurno crta
double z = 0;
if (i != 0)
{
int index = 0;
double x;
double y;
// ako postoji objekat unutar definisanog precnika, uvecava se brojac i definise se visina na kojoj je potrebno nacrtati sledeci objekat
if (HasEntityInRadius(mapX, mapY, out index, out x, out y))
{
s.MapX = x;
s.MapY = y;
mapX = x;
mapY = y;
//Points[new Tuple<double, double>(mapX, mapY)].Count++;
//z = 0.05 * Points[new Tuple<double, double>(mapX, mapY)].Count;
Points[index].Count++;
z = 0.05 * Points[index].Count;
}
else
{
z = 0;
//EntitiesDict.Add(new Tuple<double, double>(roundLat, roundLog), 0);
//Points.Add(new Tuple<double, double>(mapX, mapY), new PointStack(mapX, mapY, 0));
Points.Add(new PointStack(mapX, mapY, 0));
}
}
else
{
z = 0;
//EntitiesDict.Add(new Tuple<double, double>(roundLat, roundLog), 0);
//Points.Add(new Tuple<double, double>(mapX, mapY), new PointStack(mapX, mapY, 0));
Points.Add(new PointStack(mapX, mapY, 0));
}
// kreiranje 3D modela kocke i dodavanje u ArrayList models, zbog Hit Testing-a
GeometryModel3D model3D = ScreenHandler.Make3DCube(mapX, mapY, z, 0.05, EntityType.Switch);
Transformation.models.Add(model3D);
// dodavanje entiteta u recnik, kljuc je njegov redni broj u okviru ArrayList-e models
Entities.Add(Transformation.models.Count - 1, s);
ScreenHandler.Draw3DCube(model3D, myModel);
}
}
// LINES
int cnt = 0;
for (int i = 0; i < networkModel.Lines.Count; i++)
{
Entity entityStart = null;
Entity entityEnd = null;
entityStart = Entities.Values.ToList().Where(x => x.Id == networkModel.Lines[i].FirstEnd).FirstOrDefault();
entityEnd = Entities.Values.Where(x => x.Id == networkModel.Lines[i].SecondEnd).FirstOrDefault();
if (entityStart == null || entityEnd == null)
{
continue;
}
entityStart.NumConnctions++;
entityEnd.NumConnctions++;
cnt++;
GeometryModel3D model3D = ScreenHandler.Make3DTube(entityStart.MapX + 0.025, entityStart.MapY + 0.025, entityEnd.MapX + 0.025, entityEnd.MapY + 0.025, 0, 0.05, EntityType.Switch);
Transformation.models.Add(model3D);
ScreenHandler.Draw3DCube(model3D, myModel);
Entities.Add(Transformation.models.Count - 1, networkModel.Lines[i]);
}
return(networkModel);
}
