IEnumerator CreateJumpLinks(SphereMap map, List <int>[] neighbours, List <Vector3>[] neighboursJoints)
{
yield return(new WaitForSecondsRealtime(0.25f));
for (int pol1 = 0; pol1 < neighbours.Length; ++pol1)
{
if (map.cells[pol1].walkable)
{
for (int pol2 = 0; pol2 < neighbours[pol1].Count; ++pol2)
{
if (map.cells[neighbours[pol1][pol2]].walkable)
{
Vector3 p1 = Vector3.zero; // cells[pol1].transform.position;
//Vector3 c = this.transform.TransformPoint(neighboursJoints[pol1][pol2]);
Vector3 p2 = map.cells[neighbours[pol1][pol2]].transform.position;
p2 = map.cells[pol1].transform.InverseTransformPoint(p2);
Vector3 p12 = (p2 - p1) * 0.3f + p1; p12.y = 0;
NavMeshLink link = map.cells[pol1].gameObject.AddComponent <UnityEngine.AI.NavMeshLink>();
link.startPoint = p12;
link.endPoint = p2;
link.autoUpdate = false;
}
}
}
}
}
public override void Initialize()
{
player = Instantiate(playerShipPrefab, Vector3.zero, Quaternion.identity, transform) as PlayerShip;
Camera.main.GetComponent <CameraFollow>().setTarget(player.transform);
player.SetProjectileList(projectileList);
player.Initialize();
player.OnDestroyed += () =>
{
finishGame = true;
endTimer = Time.fixedTime + 1;
timeScaleEffect.Deactivate();
SFX.SoundEffectController.Instance.UnlockEffects();
SFX.SoundEffectController.Instance.SetTargetLowPass(500f);
};
map = Instantiate(sphearMapPrefab, Vector3.right * 10, Quaternion.identity, transform);
map.SetPlayerTransform(player.transform);
map.Initialize();
InitializeEnemies();
timeScaleEffect?.Initialize();
bossBattleEffect?.Initialize();
}
public SphereMap GetSphereMap(Frame frame, bool mirrored)
{
SphereMap sensor = new SphereMap(Radius, Mask);
RootModule module = (RootModule)Data.GetModule(ID.Root);
sensor.Sense(module == null ? Matrix4x4.identity : module.GetRootTransformation(frame, mirrored));
return(sensor);
}
public SphereMapEditorForm(SphereMap sphereMap)
{
this.InitializeComponent();
if (!String.IsNullOrEmpty(sphereMap.ImagePath)) {
this.txtPathBase.Text = Path.GetDirectoryName(sphereMap.ImagePath);
this.ddlNamePrefix.SelectedItem = sphereMap.ImagePath;
}
this.numericUpDownRadius.Value = Convert.ToDecimal(sphereMap.Radius);
this.SphereMap = sphereMap;
var files = Directory.GetFiles(this.txtPathBase.Text);
this.ddlNamePrefix.Items.AddRange(files.ToArray());
}
public SphereMapEditorForm(SphereMap sphereMap)
{
this.InitializeComponent();
if (!String.IsNullOrEmpty(sphereMap.ImagePath))
{
this.txtPathBase.Text = Path.GetDirectoryName(sphereMap.ImagePath);
this.ddlNamePrefix.SelectedItem = sphereMap.ImagePath;
}
this.numericUpDownRadius.Value = Convert.ToDecimal(sphereMap.Radius);
this.SphereMap = sphereMap;
var files = Directory.GetFiles(this.txtPathBase.Text);
this.ddlNamePrefix.Items.AddRange(files.ToArray());
}
private void btnOk_Click(object sender, EventArgs e)
{
string path = this.ddlNamePrefix.SelectedItem as String;
if (!String.IsNullOrEmpty(path)) {
this.SphereMap = new SphereMap(Convert.ToSingle(this.numericUpDownRadius.Value), path);
this.DialogResult = DialogResult.OK;
this.Close();
} else {
if (
MessageBox.Show("The file name is empty! Close dialog anyway?", "Choose a file...",
MessageBoxButtons.YesNo) == DialogResult.Yes) {
this.DialogResult = DialogResult.Cancel;
this.Close();
}
}
}
private void btnOk_Click(object sender, EventArgs e)
{
string path = this.ddlNamePrefix.SelectedItem as String;
if (!String.IsNullOrEmpty(path))
{
this.SphereMap = new SphereMap(Convert.ToSingle(this.numericUpDownRadius.Value), path);
this.DialogResult = DialogResult.OK;
this.Close();
}
else
{
if (
MessageBox.Show("The file name is empty! Close dialog anyway?", "Choose a file...",
MessageBoxButtons.YesNo) == DialogResult.Yes)
{
this.DialogResult = DialogResult.Cancel;
this.Close();
}
}
}
protected override void DerivedDraw(MotionEditor editor)
{
SphereMap sensor = GetSphereMap(editor.GetCurrentFrame(), editor.Mirror);
sensor.Draw();
}
IEnumerator CreateTile(int polygonId, Mesh mesh, Vector3 center, Vector3 orientation, Color color, float height, SphereMap map)
{
yield return(new WaitForSecondsRealtime(0.0f));
GameObject meshGo = new GameObject();
MeshFilter mf2 = meshGo.AddComponent <MeshFilter>();
MeshRenderer mr2 = meshGo.AddComponent <MeshRenderer>();
mr2.sharedMaterial = new Material(this.GetComponent <MeshRenderer>().sharedMaterial);// new Material(Shader.Find("Diffuse"));
mr2.sharedMaterial.color = color;
// mr2.material = material;
GameObject cellGo = new GameObject();
cellGo.transform.parent = this.transform;
cellGo.transform.localScale = Vector3.one;
//cellGo.transform.localRotation = Quaternion.identity;
cellGo.transform.LookAt(center + orientation);
cellGo.transform.Rotate(90, 0, 0);
meshGo.transform.parent = cellGo.transform;
//go2.transform.localPosition = Vector3.zero;
//meshGo.transform.localRotation = Quaternion.identity;
meshGo.transform.localScale = Vector3.one;
meshGo.transform.localPosition = Vector3.zero;
meshGo.hideFlags = HideFlags.HideInHierarchy;
/*
* MeshCollider collider = meshGo.AddComponent<MeshCollider>();
* collider.sharedMesh = mesh;
* collider.convex = true;
* collider.inflateMesh = true;
*/
cellGo.transform.localPosition = center;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
mf2.sharedMesh = mesh;
bool walkable = height > 0.1f;
SphereMapCell cell = cellGo.AddComponent <SphereMapCell>();
cell.PositionSpherical = FromCartesian(center);
cellGo.name = "[" + (int)(cell.PositionSpherical.x * Mathf.Rad2Deg + 360) % 360 + "," + (int)(cell.PositionSpherical.y * Mathf.Rad2Deg + 360) % 360 + "]";
cell.index = polygonId;
cell.sphere = map;
map.cells[polygonId] = cell;
cell.walkable = walkable;
NavMeshSurface navSurface = cellGo.AddComponent <NavMeshSurface>();
navSurface.collectObjects = CollectObjects.Children;
navSurface.defaultArea = walkable ? 0 : 1;
navSurface.AddData();
navSurface.BuildNavMesh();
}
void Flip(Mesh mesh)
{
Vector3[] vertices = mesh.vertices;
Vector3[] normals = mesh.normals;
int[] triangles = mesh.triangles;
List <Vector3> centers = new List <Vector3>();
List <Vector3> newNormals = new List <Vector3>();
List <int>[] polygons = new List <int> [vertices.Length];
int inv = 0;
for (int t = 0; t < triangles.Length; t += 3)
{
Vector3 center = (vertices[triangles[t]] + vertices[triangles[t + 1]] + vertices[triangles[t + 2]]) / 3;
centers.Add(center);
Vector3 normal = (normals[triangles[t]] + normals[triangles[t + 1]] + normals[triangles[t + 2]]).normalized;
newNormals.Add(normal);
for (int d = 0; d < 3; ++d)
{
if (polygons[triangles[t + d]] == null)
{
polygons[triangles[t + d]] = new List <int>();
}
polygons[triangles[t + d]].Add(inv);
}
++inv;
}
for (int pol = 0; pol < polygons.Length; ++pol)
{
// SORT THE POLYGON CONTOUR
List <int> shape = new List <int>();
List <int> unusedPoints = new List <int>(polygons[pol]);
shape.Add(unusedPoints[0]);
unusedPoints.RemoveAt(0);
{
int p = 0;
while (unusedPoints.Count > 0)
{
int min = 0;
float d = (centers[shape[p]] - centers[unusedPoints[0]]).sqrMagnitude;
for (int p2 = 1; p2 < unusedPoints.Count; ++p2)
{
float d2 = (centers[shape[p]] - centers[unusedPoints[p2]]).sqrMagnitude;
if (d2 < d)
{
d = d2;
min = p2;
}
}
shape.Add(unusedPoints[min]);
unusedPoints.RemoveAt(min);
++p;
}
polygons[pol] = shape;
}
//Make it clockwise
{
Vector3 center = Vector3.zero;
foreach (int p in polygons[pol])
{
center += centers[p];
}
center /= polygons[pol].Count;
Vector3 a = center;
Vector3 b = centers[polygons[pol][0]];
Vector3 c = centers[polygons[pol][1]];
Vector3 side1 = b - a;
Vector3 side2 = c - a;
Vector3 perp = Vector3.Cross(side1, side2);
if ((a + perp).sqrMagnitude <= (a).sqrMagnitude)
{
polygons[pol].Reverse();
}
}
}
// Compute neighbours
List <int>[] sharedVertices = new List <int> [centers.Count];
for (int pol = 0; pol < polygons.Length; ++pol)
{
foreach (int v in polygons[pol])
{
if (v >= sharedVertices.Length)
{
Debug.LogWarning("problem in size: " + v + " >= " + sharedVertices.Length);
}
if (sharedVertices[v] == null)
{
sharedVertices[v] = new List <int>();
}
sharedVertices[v].Add(pol);
}
}
List <int>[] neighbours = new List <int> [polygons.Length];
List <Vector3>[] neighboursJoints = new List <Vector3> [polygons.Length];
for (int v = 0; v < sharedVertices.Length; ++v)
{
for (int pol = 0; pol < sharedVertices[v].Count; ++pol)
{
if (neighbours[sharedVertices[v][pol]] == null)
{
neighbours[sharedVertices[v][pol]] = new List <int>();
neighboursJoints[sharedVertices[v][pol]] = new List <Vector3>();
}
for (int pol2 = 0; pol2 < sharedVertices[v].Count; ++pol2)
{
if (pol == pol2)
{
continue;
}
neighbours[sharedVertices[v][pol]].Add(sharedVertices[v][pol2]);
neighboursJoints[sharedVertices[v][pol]].Add(centers[v]);
}
}
}
#region basemesh
/*
* //THIS IS THE SPHERE WITHOUT DISPLACEMENT
* {
* List<int> newTriangles = new List<int>();
* foreach (List<int> pol in polygons)
* {
* Vector3 center = Vector3.zero;
* Vector3 normal = Vector3.zero;
* foreach (int p in pol)
* {
* center += centers[p];
* normal += newNormals[p];
* }
* center /= pol.Count;
* centers.Add(center);
*
* normal.Normalize();
* newNormals.Add(normal);
*
* int centerIdx = centers.Count - 1;
* {
*
* for (int idxp = 0; idxp < pol.Count - 1; ++idxp)
* {
* newTriangles.Add(centerIdx);
* newTriangles.Add(pol[idxp]);
* newTriangles.Add(pol[idxp + 1]);
* }
* newTriangles.Add(centerIdx);
* newTriangles.Add(pol[pol.Count - 1]);
* newTriangles.Add(pol[0]);
*
*
* }
* }
* mesh.vertices = centers.ToArray();
* mesh.normals = newNormals.ToArray();
* mesh.triangles = newTriangles.ToArray();
* mesh.RecalculateNormals();
* }
*/
#endregion
#region Tiles
float[] offset = new float[polygons.Length];
SphereMapCell[] cells = new SphereMapCell[polygons.Length];
SphereMap map = GetComponent <SphereMap>();
map.cells = cells;
{
Clear();
for (int pol = 0; pol < polygons.Length; ++pol)
{
List <int> polygon = polygons[pol];
Mesh mesh2 = new Mesh();
Vector3[] vertices2 = new Vector3[polygon.Count + 1];
Vector3[] normals2 = new Vector3[polygon.Count + 1];
Vector3 center = Vector3.zero;
Vector3 normal = Vector3.zero;
int idx = 0;
foreach (int p in polygon)
{
center += centers[p];
normal += newNormals[p];
vertices2[idx] = centers[p];
normals2[idx] = newNormals[p];
++idx;
}
center /= polygon.Count;
int centerIdx = vertices2.Length - 1;
vertices2[centerIdx] = center;
normal.Normalize();
normals2[centerIdx] = normal;
List <int> triangles2 = new List <int>();
{
for (int idxp = 0; idxp < polygon.Count - 1; ++idxp)
{
triangles2.Add(centerIdx);
triangles2.Add(idxp);
triangles2.Add(idxp + 1);
}
triangles2.Add(centerIdx);
triangles2.Add(polygon.Count - 1);
triangles2.Add(0);
}
for (int v = 0; v < vertices2.Length; ++v)
{
vertices2[v] -= center;
}
offset[pol] = Mathf.Max(0, (Perlin.Fbm(center * noiseScale + offsetPerlin, bumpiness))) * steepness;
/*for (int v = 0; v < vertices2.Length; ++v)
* {
*
* vertices2[v] += normal* 0.0001f;
*
* }*/
center += normal * (offset[pol] + 0.01f);
Color color = colors.Evaluate(offset[pol] / steepness);
mesh2.vertices = vertices2;
mesh2.normals = normals2;
mesh2.triangles = triangles2.ToArray();
StartCoroutine(CreateTile(pol, mesh2, center, normal, color, offset[pol], map));
//CreateTile(pol, mesh2, center, normal, color);
}
StartCoroutine(CreateJumpLinks(map, neighbours, neighboursJoints));
}
#endregion
#region TilesWithBase
if (CreateTiles)
{
Material material = this.GetComponent <MeshRenderer>().material;// new Material(Shader.Find("Diffuse"));
for (int c = transform.childCount - 1; c >= 0; --c)
{
Destroy(transform.GetChild(c).gameObject);
}
for (int pol = 0; pol < polygons.Length; ++pol)
{
List <int> polygon = polygons[pol];
GameObject go2 = new GameObject();
MeshFilter mf2 = go2.AddComponent <MeshFilter>();
MeshRenderer mr2 = go2.AddComponent <MeshRenderer>();
mr2.material = material;
Mesh mesh2 = new Mesh();
Vector3[] vertices2 = new Vector3[2 * polygon.Count + 1];
Vector3[] normals2 = new Vector3[2 * polygon.Count + 1];
Vector3 center = Vector3.zero;
Vector3 normal = Vector3.zero;
go2.transform.parent = this.transform;
go2.transform.localPosition = Vector3.zero;
go2.transform.localScale = Vector3.one;
int idx = 0;
foreach (int p in polygon)
{
center += centers[p];
normal += newNormals[p];
vertices2[idx] = centers[p];
normals2[idx] = newNormals[p];
vertices2[idx + polygon.Count] = centers[p];
normals2[idx + polygon.Count] = newNormals[p];
++idx;
}
center /= polygon.Count;
int centerIdx = vertices2.Length - 1;
vertices2[centerIdx] = center;
normal.Normalize();
normals2[centerIdx] = normal;
List <int> triangles2 = new List <int>();
{
for (int idxp = 0; idxp < polygon.Count - 1; ++idxp)
{
triangles2.Add(centerIdx);
triangles2.Add(idxp);
triangles2.Add(idxp + 1);
}
triangles2.Add(centerIdx);
triangles2.Add(polygon.Count - 1);
triangles2.Add(0);
{
for (int idxp = 0; idxp < polygon.Count - 1; idxp++)
{
triangles2.Add(idxp);
triangles2.Add(idxp + polygon.Count);
triangles2.Add(idxp + 1);
triangles2.Add(idxp + polygon.Count);
triangles2.Add(idxp + polygon.Count + 1);
triangles2.Add(idxp + 1);
}
triangles2.Add(polygon.Count - 1);
triangles2.Add(polygon.Count + polygon.Count - 1);
triangles2.Add(0);
triangles2.Add(polygon.Count + polygon.Count - 1);
triangles2.Add(polygon.Count);
triangles2.Add(0);
}
}
go2.transform.localPosition = center;
// go2.transform.LookAt(normal);
for (int v = 0; v < vertices2.Length; ++v)
{
vertices2[v] -= center;
}
float height = offset[pol];
for (int v = 0; v < polygon.Count; ++v)
{
vertices2[v] += normal * height;
}
vertices2[centerIdx] += normal * height;
mr2.material.color = Color.Lerp(Random.ColorHSV(0.3f, 0.35f, 0.5f, 1, 0.8f, 0.9f), Random.ColorHSV(0.1f, 0.15f, 0.5f, 1, 0.8f, 0.9f), height * 5);
mesh2.vertices = vertices2;
mesh2.normals = normals2;
mesh2.triangles = triangles2.ToArray();
mf2.sharedMesh = mesh2;
mf2.mesh.RecalculateNormals();
mf2.mesh.RecalculateBounds();
}
}
#endregion
#region DisplacedMesh
else
{
List <Vector3> vertices3 = new List <Vector3>();
List <Vector3> normals3 = new List <Vector3>();
List <int> triangles3 = new List <int>();
for (int pol = 0; pol < polygons.Length; ++pol)
{
List <int> polygon = polygons[pol];
Vector3[] vertices2 = new Vector3[2 * polygon.Count + 1];
Vector3[] normals2 = new Vector3[2 * polygon.Count + 1];
Vector3 center = Vector3.zero;
Vector3 normal = Vector3.zero;
int idx = 0;
foreach (int p in polygon)
{
center += centers[p];
normal += newNormals[p];
vertices2[idx] = centers[p];
normals2[idx] = newNormals[p];
vertices2[idx + polygon.Count] = centers[p];
normals2[idx + polygon.Count] = newNormals[p];
++idx;
}
center /= polygon.Count;
int centerIdx = vertices2.Length - 1;
vertices2[centerIdx] = center;
normal.Normalize();
normals2[centerIdx] = normal;
List <int> triangles2 = new List <int>();
{
for (int idxp = 0; idxp < polygon.Count - 1; ++idxp)
{
triangles2.Add(centerIdx);
triangles2.Add(idxp);
triangles2.Add(idxp + 1);
}
triangles2.Add(centerIdx);
triangles2.Add(polygon.Count - 1);
triangles2.Add(0);
{
for (int idxp = 0; idxp < polygon.Count - 1; idxp++)
{
triangles2.Add(idxp);
triangles2.Add(idxp + polygon.Count);
triangles2.Add(idxp + 1);
triangles2.Add(idxp + polygon.Count);
triangles2.Add(idxp + polygon.Count + 1);
triangles2.Add(idxp + 1);
}
triangles2.Add(polygon.Count - 1);
triangles2.Add(polygon.Count + polygon.Count - 1);
triangles2.Add(0);
triangles2.Add(polygon.Count + polygon.Count - 1);
triangles2.Add(polygon.Count);
triangles2.Add(0);
}
}
float height = offset[pol];
for (int v = 0; v < polygon.Count; ++v)
{
vertices2[v] += normal * height;
}
vertices2[centerIdx] += normal * height;
int prevCount = vertices3.Count;
foreach (Vector3 v in vertices2)
{
vertices3.Add(v);
}
foreach (Vector3 n in normals2)
{
normals3.Add(n);
}
foreach (int t in triangles2)
{
triangles3.Add(t + prevCount);
}
}
mesh.vertices = vertices3.ToArray();
mesh.normals = normals3.ToArray();
mesh.triangles = triangles3.ToArray();
mesh.RecalculateNormals();
}
#endregion
}
