public void Restore(Memory memory)
{
loadOnExit = memory.Get <string>("zone_control_loadonexit");
zoneid = memory.Get <string>("zone_control_id");
zone = Game.Instance.GameState.FindElement <GeoElement>(zoneid).Geometries.Checked().FirstOrDefault();
transitionTime = memory.Get <float>("zone_control_transitiontime");
}
public void Restore()
{
// TODO use PlayerPrefs in settings
loadOnExit = PlayerPrefs.GetString("zone_control_loadonexit");
zone = Game.Instance.GameState.FindElement <GeoElement>(PlayerPrefs.GetString("zone_control_id")).Geometry;
transitionTime = PlayerPrefs.GetFloat("zone_control_transitiontime");
}
private void DumpGML(XmlNode parent, string name, GMLGeometry content)
{
var doc = Writer.GetDoc();
// base element
var elem = doc.CreateElement(name);
parent.AppendChild(elem);
elem.SetAttribute("influence", content.Influence.ToString());
// Dump geometry type
XmlNode gmlElement;
switch (content.Type)
{
case GMLGeometry.GeometryType.Point:
gmlElement = doc.CreateElement("gml:Point");
DumpPosList(gmlElement, content.Points);
break;
case GMLGeometry.GeometryType.LineString:
gmlElement = doc.CreateElement("gml:LineString");
DumpPosList(gmlElement, content.Points);
break;
default: // case GMLGeometry.GeometryType.Polygon:
gmlElement = doc.CreateElement("gml:Polygon");
var exterior = doc.CreateElement("gml:exterior");
gmlElement.AppendChild(exterior);
var linearRing = doc.CreateElement("gml:LinearRing");
exterior.AppendChild(linearRing);
DumpPosList(linearRing, content.Points);
break;
}
elem.AppendChild(gmlElement);
}
public AddRemovePointTool(GMLGeometry gmlGeometry, int index, Vector2d point)
{
this.gmlGeometry = gmlGeometry;
this.add = true;
this.index = index;
this.point = point;
}
public object DOMParse(XmlElement element, params object[] parameters)
{
var gmlNode = element.FirstChild;
var geometry = new GMLGeometry();
geometry.Influence = float.Parse(element.GetAttribute("influence"), CultureInfo.InvariantCulture);
XmlNode pointsNode;
switch (gmlNode.Name)
{
default: // case "Point":
geometry.Type = GMLGeometry.GeometryType.Point;
pointsNode = gmlNode.FirstChild;
break;
case "LineString":
geometry.Type = GMLGeometry.GeometryType.LineString;
pointsNode = gmlNode.FirstChild;
break;
case "Polygon":
geometry.Type = GMLGeometry.GeometryType.Polygon;
pointsNode = gmlNode.FirstChild.FirstChild.FirstChild; // Polygon -> external -> Ring -> points
break;
}
geometry.Points = UnzipPoints(pointsNode.InnerText);
return(geometry);
}
public AddRemovePointTool(GMLGeometry gmlGeometry, int index)
{
this.gmlGeometry = gmlGeometry;
this.add = false;
this.index = index;
this.point = gmlGeometry.Points[index];
}
public ChangeGeometryTypeTool(GMLGeometry gmlGeometry, GMLGeometry.GeometryType geometryType)
{
this.gmlGeometry = gmlGeometry;
this.previousPoints = gmlGeometry.Points.ToArray();
this.previousGeometryType = gmlGeometry.Type;
this.newGeometryType = geometryType;
}
private GMLGeometry ParseGeometry(XmlNode node)
{
var gmlNode = node.FirstChild;
var geometry = new GMLGeometry();
geometry.Influence = float.Parse((node as XmlElement).GetAttribute("influence"));
XmlNode pointsNode;
switch (gmlNode.Name)
{
default:
case "Point":
geometry.Type = GMLGeometry.GeometryType.Point;
pointsNode = gmlNode.FirstChild;
break;
case "LineString":
geometry.Type = GMLGeometry.GeometryType.LineString;
pointsNode = gmlNode.FirstChild;
break;
case "Polygon":
geometry.Type = GMLGeometry.GeometryType.Polygon;
pointsNode = gmlNode.FirstChild.FirstChild.FirstChild; // Polygon -> external -> Ring -> points
break;
}
geometry.Points = UnzipPoints(pointsNode.InnerText);
return(geometry);
}
public AddRemovePointTool(GMLGeometry gmlGeometry, Vector2d point)
{
this.gmlGeometry = gmlGeometry;
this.add = true;
this.index = GetIndex(point);
this.point = point;
this.previousType = gmlGeometry.Type;
}
public ChangeGeometryTypeTool(GMLGeometry gmlGeometry, GMLGeometry.GeometryType geometryType, MapEditor mapEditor)
{
this.gmlGeometry = gmlGeometry;
this.previousPoints = gmlGeometry.Points.ToArray();
this.previousGeometryType = gmlGeometry.Type;
this.newGeometryType = geometryType;
this.mapEditor = mapEditor;
zoom = mapEditor.Zoom;
center = mapEditor.Center;
}
public ChangePointTool(GMLGeometry geometry, int index, Vector2d newValue)
{
this.geometry = geometry;
this.index = index;
this.newValue = newValue;
if (index >= 0 && index < geometry.Points.Length)
{
work = true;
this.oldValue = geometry.Points[index];
}
}
public GeoElement(string id)
{
Id = id;
Geometry = new GMLGeometry();
Name = "";
DetailedDescription = "";
FullDescription = "";
BriefDescription = "";
Geometry.Influence = 0f;
Image = "";
Actions = new List <GeoAction>();
}
private void ReasignType(GMLGeometry gmlGeometry)
{
if (gmlGeometry.Points.Length <= 1)
{
gmlGeometry.Type = GMLGeometry.GeometryType.Point;
}
else if (gmlGeometry.Points.Length == 2)
{
gmlGeometry.Type = GMLGeometry.GeometryType.LineString;
}
else if (previousType != GMLGeometry.GeometryType.Point)
{
gmlGeometry.Type = previousType;
}
}
private void DrawGMLGeometry(Rect rect, int index, bool active, bool focused)
{
GMLGeometry geo = (GMLGeometry)geometriesReorderableList.list[index];
EditorGUI.LabelField(infoRect.GUIAdapt(rect), "Points: " + geo.Points.Count);
geo.Type = (GMLGeometry.GeometryType)EditorGUI.EnumPopup(typePopupRect.GUIAdapt(rect), geo.Type);
if (GUI.Button(centerButtonRect.GUIAdapt(rect), "Center") && geo.Points.Count > 0)
{
location = geo.Points.Aggregate(new Vector2(), (p, n) => p + n.ToVector2()) / geo.Points.Count;
map.Center = location.ToVector2d();
}
if (GUI.Button(editButtonRect.GUIAdapt(rect), editing != geo ? "Edit" : "Finish"))
{
editing = editing == geo ? null : geo;
}
}
public MoveTool(GMLGeometry geometry, Vector2d delta)
{
this.geometry = geometry;
this.delta = delta;
}
/* -----------------------------
* Main method
*-----------------------------*/
public bool DrawMap(Rect area)
{
bool r = false;
GUI.BeginGroup(area);
area = new Rect(Vector2.zero, area.size);
// update the pixel absolute to relative convert variable
PATR = -(centerPixel - (area.size / 2f).ToVector2d() - area.position.ToVector2d());
var mousePos = Event.current.mousePosition.ToVector2d();
var delta = new Vector2d(Event.current.delta.x, Event.current.delta.y);
if (Event.current.type != EventType.Layout)
{
GeoMousePosition = GM.MetersToLatLon(GM.PixelsToMeters(RelativeToAbsolute(mousePos), Zoom));
}
switch (Event.current.type)
{
case EventType.Repaint:
{
// Draw the tiles
DrawTiles(area);
// Draw the GeoShapes
DrawGeometries(area);
// Draw the Resources
DrawResources(area);
if (selectedGeometry != null && selectedGeometry.Points.Count > 0)
{
var pixels = PixelsToRelative(LatLonToPixels(selectedGeometry.Points)).ConvertAll(p => p.ToVector2());
var v2mousepos = mousePos.ToVector2();
// Find the closest index
var min = pixels.Min(p => (p - v2mousepos).magnitude);
var closest = pixels.FindIndex(p => (p - v2mousepos).magnitude == min);
// Fix the previous and next
var prev = closest == 0 ? pixels.Count - 1 : closest - 1;
var next = (closest + 1) % pixels.Count;
// Calculate the normal to both adjacent axis to closest point
var c = pixels[closest];
var v1 = (pixels[closest] - pixels[prev]).normalized;
var v2 = (pixels[closest] - pixels[next]).normalized;
var closestNormal = (v1 + v2).normalized;
var convex = Vector3.Cross(v1, v2).z > 0;
var mouseVector = (v2mousepos - c);
var left = Vector3.Cross(closestNormal, mouseVector).z > 0;
Handles.DrawLine(pixels[closest], v2mousepos);
if ((left && convex) || (!left && !convex))
{
Handles.DrawLine(pixels[prev], v2mousepos);
}
else
{
Handles.DrawLine(pixels[next], v2mousepos);
}
}
}
break;
case EventType.ScrollWheel:
{
// Changezoom
Zoom += Mathf.FloorToInt(-Event.current.delta.y / 3f);
Event.current.Use();
}
break;
case EventType.MouseDrag:
{
// MoveLatLon or center var
if (area.Contains(Event.current.mousePosition))
{
if (selectedGeometry != null)
{
var pixels = LatLonToPixels(selectedGeometry.Points);
// If there's a point, move the point
if (selectedPoint != -1)
{
pixels[selectedPoint] += delta;
}
// Otherwise, move the pixel
else
{
pixels = pixels.ConvertAll(p => p + delta);
}
// Then update the points
selectedGeometry.Points = PixelsToLatLon(pixels);
}
else
{
Center = GM.MetersToLatLon(GM.PixelsToMeters(centerPixel - delta, Zoom));
}
Event.current.Use();
}
}
break;
case EventType.MouseDown:
{
selectedGeometry = Geometries.Find(g =>
{
List <Vector2d> points = PixelsToRelative(LatLonToPixels(g.Points))
.ConvertAll(p => p - Event.current.mousePosition.ToVector2d());
selectedPoint = points.FindIndex(p => p.magnitude < SelectPointDistance);
var marginMeters = (GM.PixelsToMeters(-PATR, Zoom) - GM.PixelsToMeters(-PATR + new Vector2d(SelectPointDistance, 0), Zoom)).magnitude;
var i = g.InsideMargin(GeoMousePosition, (float)marginMeters);
return(i || selectedPoint != -1);
});
if (area.Contains(Event.current.mousePosition))
{
GUI.FocusControl(null);
r = true;
}
}
break;
}
GUI.EndGroup();
return(r);
}
/* ----------------------------------
* ON GUI: Used for drawing the window every unity event
* ----------------------------------*/
void OnGUI()
{
if (addressDropdown == null)
{
Init();
}
var prevAddress = address;
address = addressDropdown.LayoutBegin();
if (address != prevAddress)
{
timeSinceLastWrite = 0;
}
// Location control
location = EditorGUILayout.Vector2Field("Location", location);
var lastRect = GUILayoutUtility.GetLastRect();
if (location != map.Center.ToVector2())
{
map.Center = new Vector2d(location.x, location.y);
}
GUILayout.BeginHorizontal();
// Geometries control
var geometriesWidth = 150;
geometriesReorderableList.elementHeight = geometriesReorderableList.list.Count == 0 ? 20 : 70;
var rect = GUILayoutUtility.GetRect(geometriesWidth, position.height - lastRect.y - lastRect.height);
geometriesReorderableList.DoList(rect);
// Map drawing
map.selectedGeometry = geometriesReorderableList.index >= 0 ? geometries[geometriesReorderableList.index] : null;
if (map.DrawMap(GUILayoutUtility.GetRect(position.width - geometriesWidth, position.height - lastRect.y - lastRect.height)))
{
Debug.Log(map.GeoMousePosition);
if (editing != null)
{
switch (editing.Type)
{
case GMLGeometry.GeometryType.Point:
if (editing.Points.Count == 1)
{
editing.Points[0] = map.GeoMousePosition;
}
else
{
editing.Points.Add(map.GeoMousePosition);
}
break;
case GMLGeometry.GeometryType.LineString:
editing.Points.Add(map.GeoMousePosition);
break;
case GMLGeometry.GeometryType.Polygon:
if (editing.Points.Count <= 1)
{
editing.Points.Add(map.GeoMousePosition);
}
else
{
// Find the closest index
var min = editing.Points.Min(p => (p - map.GeoMousePosition).magnitude);
var closest = editing.Points.FindIndex(p => (p - map.GeoMousePosition).magnitude == min);
// Fix the previous and next
var prev = closest == 0 ? editing.Points.Count - 1 : closest - 1;
var next = (closest + 1) % editing.Points.Count;
// Calculate the normal to both adjacent axis to closest point
var c = editing.Points[closest];
var v1 = (editing.Points[closest] - editing.Points[prev]).normalized;
var v2 = (editing.Points[closest] - editing.Points[next]).normalized;
var closestNormal = (v1 + v2).normalized;
var convex = Vector3.Cross(v1.ToVector2(), v2.ToVector2()).z > 0;
var mouseVector = (map.GeoMousePosition - c);
var left = Vector3.Cross(closestNormal.ToVector2(), mouseVector.ToVector2()).z > 0;
Debug.Log(convex ? "Convex" : "Concave");
if ((left && convex) || (!left && !convex))
{
Debug.Log("Prev");
// We insert at the closest
editing.Points.Insert(closest, map.GeoMousePosition);
}
else
{
Debug.Log("Next");
// We insert at the next
editing.Points.Insert(next, map.GeoMousePosition);
}
}
break;
}
}
}
location = map.Center.ToVector2();
geometriesReorderableList.index = map.selectedGeometry != null?geometries.IndexOf(map.selectedGeometry) : -1;
GUILayout.EndHorizontal();
if (addressDropdown.LayoutEnd())
{
// If new Location is selected from the dropdown
lastSearch = address = addressDropdown.Value;
foreach (var l in place.DataStructure.dataChache)
{
if (l.label == address)
{
location = l.coordinates;
}
}
var geometry = new GMLGeometry();
geometry.Type = GMLGeometry.GeometryType.Polygon;
var points = 5f;
var radius = 0.00005;
for (float i = 0; i < 5; i++)
{
geometry.Points.Add(new Vector2d(location.x + radius * Mathf.Sin(i * 2f * Mathf.PI / points) * 1.33333f, location.y + radius * Mathf.Cos(i * 2f * Mathf.PI / points)));
}
geometries.Add(geometry);
place.DataStructure.dataChache.Clear();
Repaint();
}
}
public GMLGeometryDataControl(GMLGeometry gmlGeometry)
{
this.gmlGeometry = gmlGeometry;
this.conditionsController = new ConditionsController(gmlGeometry.Conditions);
}
