} // first dimension is vertical
public void Setup(string name, string id, Sensor[] sensors, int numLayers)
{
ObjectGO = Utilities.GetGameObjectByName(name, new string[] { ">>" });
Name = ObjectGO.name;
ID = id;
Selected = Focussed = false;
ParentGO = new GameObject("SensedObject " + ID);
ParentGO.transform.position = ObjectGO.GetComponent <Renderer>().bounds.center;
ObjectGO.transform.parent = ParentGO.transform;
Sensors = new Sensor[sensors.Length];
Array.Copy(sensors, Sensors, sensors.Length);
for (int s = 0; s < Sensors.Length; s++)
{
Sensors[s].GO.transform.SetParent(ParentGO.transform);
}
LoadIndicator();
LayerCount = numLayers;
SurfaceNormal = -Vector3.forward; // TODO how to make this for general objects
float panelMinX = ObjectGO.GetComponent <Renderer>().bounds.min.x;
float panelMaxX = ObjectGO.GetComponent <Renderer>().bounds.max.x;
float panelMinY = ObjectGO.GetComponent <Renderer>().bounds.min.y;
float panelMaxY = ObjectGO.GetComponent <Renderer>().bounds.max.y;
//PanelGridStep = (panelMaxX - panelMinX) / 20; // 20 points along the x axis
int panelW = (int)System.Math.Floor((panelMaxX - panelMinX) / PanelGridStep);
int panelH = (int)System.Math.Floor((panelMaxY - panelMinY) / PanelGridStep);
InterpolatedValues = new float[panelH, panelW, LayerCount];
}
// get the position of the grid points in the world
public Vector3 GetGridPosition(int i, int j, int k)
{
float xPos, yPos, zPos;
Bounds b = ObjectGO.GetComponent <Renderer>().bounds;
xPos = PanelGridStep / 2 + b.min.x + j * PanelGridStep;
yPos = PanelGridStep / 2 + b.min.y + i * PanelGridStep;
zPos = b.center.z + SurfaceNormal.z * b.extents.z;
return(new Vector3(xPos, yPos, zPos));
}
void LoadIndicator()
{
Bounds bound = ObjectGO.GetComponent <Renderer>().bounds;
//IndicatorPrefab = Resources.Load<GameObject>(@"Prefabs/SensorIndicatorPrefab");
//if (IndicatorPrefab == null)
// IndicatorGO = GameObject.CreatePrimitive(PrimitiveType.Sphere);
//else
IndicatorGO = GameObject.Instantiate <GameObject>(Specs.SensorIndicatorPrefab);
IndicatorGO.transform.position = bound.center + (bound.extents.y + Utilities.Scaled(3)) * Vector3.up;
IndicatorGO.transform.SetParent(ParentGO.transform);
IndicatorGO.AddComponent <MouseHandler>();
IndicatorGO.GetComponent <MouseHandler>().SetHandler(ObjectSelectedByIndicator, MouseHandler.MOUSE_EVENT.DOWN);
}
private void OnTriggerExit2D(Collider2D collision)
{
ObjectGO objgo = collision.gameObject.GetComponent <ObjectGO>();
if ((objgo != null) && (objgo.objectCur.visitState != 2))
{
objgo.SetVisited(2);
}
else
{
TileGO tilego = collision.gameObject.GetComponent <TileGO>();
if ((tilego != null) && (tilego.tileCur.visitState != 2))
{
tilego.SetVisited(2);
}
}
}
public void ObjectSelectedByIndicator()
{
Selected = true;
Camera cam = Camera.main;
Bounds bound = ObjectGO.GetComponent <Renderer>().bounds;
Vector3 desiredPos = bound.center + SurfaceNormal * Utilities.Scaled(30);
cam.GetComponent <AvatarInteraction>().MoveCam(desiredPos, Quaternion.LookRotation(-SurfaceNormal, Vector3.up));
BoxCollider col = ObjectGO.GetComponent <BoxCollider>();
if (col == null)
{
col = ObjectGO.AddComponent <BoxCollider>();
}
col.bounds.SetMinMax(bound.min, bound.max);
if (!ObjectGO.GetComponent <MouseHandler>())
{
MouseHandler mh = ObjectGO.AddComponent <MouseHandler>();
mh.SetHandler(ObjectSelectedByObject, MouseHandler.MOUSE_EVENT.BUTTON);
}
}
/* private void FixedUpdate()
* {
* //RaycastHit hit;
* if (Physics.Raycast(transform.position, Vector3.up, 10))
* {
* // executes if hits a collider
* }
* else
* {
* // executes if it doesnt hit any collider
* }
* }*/
private void OnTriggerEnter2D(Collider2D collision)
{
ObjectGO objgo = collision.gameObject.GetComponent <ObjectGO>();
if ((objgo != null) && (objgo.objectCur.visitState != 1))
{
if (objgo.tag == "Loader")
{
//LoadChunk Load = GameObject.Find("Load_Chunk").GetComponent<LoadChunk>();
GM.LoadManager.LoadChunkedMap(objgo.objectCur.modifiers["chunkfile"]);
// GM.LoadManager.LoadChunkedTiles(GM.LoadManager.chunk2, 10, 0, 10, 10, 0, GM.map.sizey);
// GM.map.maxsizex += 0;
//GM.map.maxsizey += 12;
/*if (objgo.objectCur.modifiers["loadChunk"] != "0")
* {
* //GM.map.sizey += Load.chunk2.sizey;
* //GM.map.sizex += Load.chunk2.sizex;
* GM.map.tilesizey += Load.chunk2.tilesizey;
* GM.map.tilesizex += Load.chunk2.tilesizex;
* }*/
Destroy(collision.gameObject);
}
else
{
objgo.SetVisited(1);
}
}
else
{
TileGO tilego = collision.gameObject.GetComponent <TileGO>();
if ((tilego != null) && (tilego.tileCur.visitState != 1))
{
tilego.SetVisited(1);
}
}
}
public void LoadMapGO(MapSave mapfile, List <GameObject> TilesGO, List <GameObject> ObjectsGO, List <ObjectSave> objectssave, List <GameObject> Ground_Prefabs)
{
GM = GameObject.Find("GameManager").GetComponent <GameManager>();
GameObject emptyMap = new GameObject("Map");
Vector3 placement = Vector3.zero;
for (int y = 0; y < mapfile.sizey; y++)
{
for (int x = 0; x < mapfile.sizex; x++)
{
int drawback = 10;
/* TILES GROUND */
TileSave tileCur = mapfile.layer.tiles[y][x];
TileSetSave tileset = new TileSetSave();
GameObject tilego = null;
if (tileCur.mapid > mapfile.basevalue)
{
foreach (TileSetsSave tss in mapfile.tilesets)
{
foreach (TileSetSave ts in tss.tilesets)
{
if ((tileCur.mapid == tss.first + ts.id))
{
tileset = ts;
int id_min = tileset.spritefile.Substring(0, tileset.spritefile.IndexOf("_")).Length;
string sub = tileset.spritefile.Substring(id_min + 1);
string id = sub.Substring(0, sub.IndexOf("."));
tilego = GameObject.Instantiate(Ground_Prefabs[GM.prefabs_name[id]], Vector3.zero, Quaternion.identity);
tilego.name = "Instantiated : " + x + " / " + y;
// useless but keep just in case
/*switch (mapfile.orientation)
* {
* case "orthogonal":
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround+ drawback);
* break;
* case "staggered":*/
if (y % 2 == 1)
{
placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
}
else
{
placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f + (mapfile.tilesizex / 2.0f / 100.0f), (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
}
/* break;
* case "isometric":
* if (y % 2 == 1)
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
* else
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f + (mapfile.tilesizex / 2.0f / 100.0f), (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
* break;
* default:
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
* break;
* }*/
tilego.GetComponent <Transform>().position = placement;
if (tileset.modifiers.ContainsKey("collider") && (tileset.modifiers["collider"] == "true"))
{
tilego.AddComponent <PolygonCollider2D>();
tilego.AddComponent <PolygonCollider2D>().isTrigger = false;
}
else
{
tilego.AddComponent <BoxCollider2D>();
tilego.GetComponent <BoxCollider2D>().isTrigger = true;
}
tilego.transform.SetParent(emptyMap.GetComponent <Transform>());
TilesGO.Add(tilego);
break;
}
}
if (tileset.id > 0)
{
break;
}
}
}
/* ADDED GROUND */
drawback = 9;
if (mapfile.layer.tiles[y][x].addedid > mapfile.basevalue)
{
TileSetSave tilesetAdded = new TileSetSave();
if (mapfile.layer.tiles[y][x].addedid > mapfile.basevalue)
{
GameObject tilegoAdded = null;
foreach (TileSetsSave tss in mapfile.tilesets)
{
foreach (TileSetSave ts in tss.tilesets)
{
if ((mapfile.layer.tiles[y][x].addedid == tss.first + ts.id))
{
tilesetAdded = ts;
int id_min = tilesetAdded.spritefile.Substring(0, tilesetAdded.spritefile.IndexOf("_")).Length;
string sub = tilesetAdded.spritefile.Substring(id_min + 1);
string id = sub.Substring(0, sub.IndexOf("."));
tilegoAdded = GameObject.Instantiate(Ground_Prefabs[GM.prefabs_name[id]]);
tilegoAdded.name = "Instantiated_Added : " + x + " / " + y;
if (tilesetAdded.modifiers.ContainsKey("collider") && (tilesetAdded.modifiers["collider"] == "true"))
{
tilegoAdded.AddComponent <PolygonCollider2D>();
tilegoAdded.GetComponent <PolygonCollider2D>().isTrigger = false;
}
else
{
tilegoAdded.AddComponent <BoxCollider2D>();
tilegoAdded.GetComponent <BoxCollider2D>().isTrigger = true;
}
placement = Vector3.zero;
// useless but keep just in case
/* switch (mapfile.orientation)
* {
* case "orthogonal":
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
* break;
* case "staggered":*/
if (y % 2 == 1)
{
placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
}
else
{
placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f + (mapfile.tilesizex / 2.0f / 100.0f), (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
}
/* break;
* case "isometric":
* if (y % 2 == 1)
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
* else
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f + (mapfile.tilesizex / 2.0f / 100.0f), (y * mapfile.tilesizey / 2.0f + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
* break;
* default:
* placement = new Vector3((x * mapfile.tilesizex + mapfile.tilesizex / 2.0f) / 100.0f, (y * mapfile.tilesizey + mapfile.tilesizey / 2.0f) / 100.0f, GM.ZGround + drawback);
* break;
* }*/
tilegoAdded.GetComponent <Transform>().position = placement;
// maybe use one day for sorting, but there's an issue with white shader on addedground
// if (tilego == null)
tilegoAdded.GetComponent <Transform>().SetParent(emptyMap.GetComponent <Transform>());
// else
// tilegoAdded.GetComponent<Transform>().SetParent(tilego.GetComponent<Transform>());
}
if (tilesetAdded.id > 0)
{
break;
}
}
}
}
}
}
}
GameObject emptyGO = new GameObject("Objects");
Sprite Radius = Resources.Load <Sprite>("Play/radius_rect");
foreach (ObjectSave obj in mapfile.objects)
{
GameObject curObj = null;
ObjectGO curObjGO = null;
TileSetSave tileset = new TileSetSave();
if (obj.gid > mapfile.basevalue)
{
foreach (TileSetsSave tss in mapfile.tilesets)
{
foreach (TileSetSave ts in tss.tilesets)
{
if ((obj.gid == tss.first + ts.id))
{
tileset = ts;
int id_min = ts.spritefile.Substring(0, ts.spritefile.IndexOf("_")).Length;
string sub = ts.spritefile.Substring(id_min + 1);
string id = sub.Substring(0, sub.IndexOf("."));
foreach (string key in tileset.modifiers.Keys)
{
if (obj.modifiers.ContainsKey(key) == false)
{
obj.modifiers.Add(key, tileset.modifiers[key]);
}
}
curObj = GameObject.Instantiate(Ground_Prefabs[GM.prefabs_name[id]]);
curObj.tag = "object";
curObj.name = "Instantiated_Added : " + obj.x + " / " + obj.y;
if (obj.width != tileset.width)
{
curObj.GetComponent <Transform>().localScale = new Vector3((float)obj.width / tileset.width, (float)obj.height / tileset.height, 0.0f);
}
curObjGO = curObj.GetComponent <ObjectGO>();
curObjGO.objectCur = obj;
break;
}
}
if (tileset.id > 0)
{
break;
}
}
}
if ((curObj != null) && (curObjGO != null))
{
placement = Vector3.zero;
curObjGO.InitObj();
/* switch (mapfile.orientation)
* {
* case "orthogonal":
* placement = new Vector3((obj.x + obj.offsetx + obj.width / 2) / 100.0f, ((mapfile.sizey * mapfile.tilesizey) - ((obj.y + obj.offsety - obj.height / 2.0f))) / 100.0f, GM.ZObjects);
* break;
* case "staggered":*/
if (obj.y % 2 == 1)
{
placement = new Vector3((obj.x + obj.offsetx + obj.width / 2) / 100.0f, ((mapfile.sizey * mapfile.tilesizey / 2) - ((obj.y + obj.offsety - obj.height / 2.0f))) / 100.0f, GM.ZObjects);
}
else
{
placement = new Vector3((obj.x + obj.offsetx + obj.width / 2) / 100.0f, ((mapfile.sizey * mapfile.tilesizey / 2) - ((obj.y + obj.offsety - obj.height / 2.0f))) / 100.0f + (mapfile.tilesizey / 2.0f / 100.0f), GM.ZObjects);
}
/*break;
* case "isometric":
* placement = new Vector3((obj.x + obj.offsetx + obj.width / 2) / 100.0f, ((mapfile.sizey * mapfile.tilesizey / 2) - ((obj.y + obj.offsety - obj.height / 2.0f))) / 100.0f, GM.ZObjects);
* break;
* default:
* placement = new Vector3((obj.x + obj.offsetx + obj.width / 2) / 100.0f, ((mapfile.sizey * mapfile.tilesizey) - ((obj.y + obj.offsety - obj.height / 2.0f))) / 100.0f, GM.ZObjects);
* break;
* }*/
placement.z += 2;
if (obj.modifiers.ContainsKey("collider") && (obj.modifiers["collider"] == "true"))
{
curObj.AddComponent <PolygonCollider2D>();
}
else if (obj.modifiers.ContainsValue("trigger"))
{
curObjGO.addTrigger(curObj, Radius, objectssave);
}
else
{
curObj.AddComponent <BoxCollider2D>();
curObj.GetComponent <BoxCollider2D>().isTrigger = true;
}
if (obj.modifiers.ContainsKey("loadChunk"))
{
curObj.tag = "Loader";
}
curObj.GetComponent <Transform>().position = placement;
curObj.transform.SetParent(emptyGO.GetComponent <Transform>());
}
}
}
// interpolate the measurements to layer queryLayer then interpolate over the layer
void InterpolateLayer(int[] dataIndices, int queryLayer)
{
int desiredSensCount = 3; // number of sensed positions (measured or interpolated) needed on each layer, 3 for tirangle
int layerSensCount = 0; // number of sensed positions (measured or interpolated) on a layer
int indx = 0;
//float[] valueAtPos = new float[Sensors.Length];
int[] sensorLayerDist = new int[Sensors.Length]; // distance (in terms of number of layers) of sensors to query layer
int[] sensorLayerDistPermut = new int[Sensors.Length]; // permutation of distance array, needed after sorting the array
Vector3 bary, queryPoint; // placeholder for bary centric coordinates, and the query point
Vector3[] verts = new Vector3[desiredSensCount]; // points on layer needed for interpolatation (vertices of polygon)
float[] sensedValues = new float[desiredSensCount]; // values (measured or interpolated) on the layer
bool tooClose; // flag to check if two sensed locations are too close (i.e. same sensro location )
for (int i = 0; i < Sensors.Length; i++)
{
sensorLayerDist[i] = Math.Abs(queryLayer - Sensors[i].Layer);
sensorLayerDistPermut[i] = i;
}
//Array.Sort(sensorLayerDist);
Array.Sort(sensorLayerDist, sensorLayerDistPermut);
// while not enough points on the layer, interpolate sensors to layer
while (layerSensCount < desiredSensCount && indx < Sensors.Length)
{
tooClose = false;
// if sensor is too close to prev. sensor positions, skip
for (int j = 0; j < indx; j++) // TODO finde a beeter threshold for distance , check distance between points projected to same layer
{
if (Vector3.Distance(Sensors[sensorLayerDistPermut[j]].Pos, Sensors[sensorLayerDistPermut[indx]].Pos) < Utilities.Scaled(0.1F) * ObjectGO.GetComponent <Renderer>().bounds.size.magnitude)
{
tooClose = true;
indx++;
break;
}
}
if (tooClose)
{
continue;
}
if (sensorLayerDist[indx] == 0)
{
verts[layerSensCount] = new Vector3(Sensors[sensorLayerDistPermut[indx]].Pos.x, Sensors[sensorLayerDistPermut[indx]].Pos.y, Sensors[sensorLayerDistPermut[indx]].Pos.z);
sensedValues[layerSensCount] = Sensors[sensorLayerDistPermut[indx]].Values[dataIndices[sensorLayerDistPermut[indx]]];
}
else
{
verts[layerSensCount] = new Vector3(Sensors[sensorLayerDistPermut[indx]].Pos.x, Sensors[sensorLayerDistPermut[indx]].Pos.y, Sensors[sensorLayerDistPermut[indx]].Pos.z);
sensedValues[layerSensCount] = Sensors[sensorLayerDistPermut[indx]].Values[dataIndices[sensorLayerDistPermut[indx]]];
}
indx++;
layerSensCount++;
}
//Debug.Log(string.Format("({0}, {1}, {2})", sensedValues[0], sensedValues[1], sensedValues[2]));
for (int i = 0; i < InterpolatedValues.GetLength(0); i++)
{
for (int j = 0; j < InterpolatedValues.GetLength(1); j++)
{
queryPoint = GetGridPosition(i, j, queryLayer);
bary = Utilities.BarycentricCoordinates(verts[0], verts[1], verts[2], queryPoint);
//interpVals[i, j, queryLayer] = bary[0] * sensedValues[0] + bary[1] * MCPosB + bary[2] * MCPosC;
InterpolatedValues[i, j, queryLayer] = bary[0] * sensedValues[0] + bary[1] * sensedValues[1] + bary[2] * sensedValues[2];
}
}
}
