public IsleAbstract travelDownLeft(int startX, int startY)
{
IsleAbstract endIsle = null;
int x = startX;
int y = startY;
while (true)
{
if (x % 2 == 0)
{
y--;
}
x--;
if (x < 0 || y < 0)
{
return(null);
}
if (world[x, y] != null)
{
endIsle = world[x, y];
break;
}
}
return(endIsle);
}
public void inserObjectsOnMap()
{
List <IsleAbstract> tmpList = new List <IsleAbstract>(this.isles);
// start Isle
int tmp = rnd.Next(0, tmpList.Count);
startIsle = tmpList[tmp];
startIsle.isleObjectType = IsleAbstract.IsleObjectType.start;
tmpList.RemoveAt(tmp);
// keys
for (int i = 0; i < 3; i++)
{
tmp = rnd.Next(0, tmpList.Count);
tmpList[tmp].isleObjectType = IsleAbstract.IsleObjectType.key;
tmpList[tmp].keyNumber = i + 1;
tmpList.RemoveAt(tmp);
}
// boss
tmp = rnd.Next(0, tmpList.Count);
tmpList[tmp].isleObjectType = IsleAbstract.IsleObjectType.boss;
bossIsle = tmpList[tmp];
tmpList.RemoveAt(tmp);
}
public IsleAbstract travelDownRight(int startX, int startY)
{
IsleAbstract endIsle = null;
int x = startX;
int y = startY;
while (true)
{
if (x % 2 == 0)
{
y--;
}
x++;
if (x >= world.GetLength(0) || y < 0)
{
return(null);
}
if (world[x, y] != null)
{
endIsle = world[x, y];
break;
}
}
return(endIsle);
}
public IsleAbstract travelUpLeft(int startX, int startY)
{
IsleAbstract endIsle = null;
int x = startX;
int y = startY;
while (true)
{
if (x % 2 == 1)
{
y++;
}
x--;
if (x < 0 || y >= world.GetLength(1))
{
return(null);
}
if (world[x, y] != null)
{
endIsle = world[x, y];
break;
}
}
return(endIsle);
}
public IsleAbstract travelInDirection(int startX, int startY, int direction)
{
IsleAbstract endIsle = null;
switch (direction)
{
case 0: endIsle = travelUp(startX, startY);
break;
case 1:
endIsle = travelUpRight(startX, startY);
break;
case 2:
endIsle = travelDownRight(startX, startY);
break;
case 3:
endIsle = travelDown(startX, startY);
break;
case 4:
endIsle = travelDownLeft(startX, startY);
break;
case 5:
endIsle = travelUpLeft(startX, startY);
break;
}
return(endIsle);
}
public void Teleport()
{
// teleport player to isle;
CharacterController cr = player.GetComponent <CharacterController>();
cr.velocity.Set(0, 0, 0);
IsleAbstract currentIsle = lvlManager.currentIsle;
int direction = Direction;
targetIsle = currentIsle.getIsleFromForection(direction);
targetPortal = targetIsle.IsleObj.Portals[(direction + 3) % 6];
Vector3 startPos = transform.position + new Vector3(0, 1, 0);
Vector3 targetPos = targetPortal.spawnPoint.transform.position + new Vector3(0, 1, 0);
cr.enabled = false;
player.GetComponent <Player>().IsControllable = false;
// start lerping of player
player.GetComponent <LerperTeleportation>().StartLerp(startPos, targetPos, 50);
checkTeleportFinished = StartCoroutine(checkTeleportFiniedHandler());
lvlManager.currentIsle.IsleObj.RemoveBorders();
}
public IsleAbstract getRandomIsle()
{
IsleAbstract isle = null;
int tmp = rnd.Next(0, isles.Count);
isle = isles[tmp];
return(isle);
}
private void buildMinimalTree()
{
if (isles == null)
{
return;
}
connections = new List <ConnectionAbstract>();
int tmp = rnd.Next(0, isles.Count);
IsleAbstract startIsle = isles[tmp];
searchNeighbour(startIsle, null, -1);
}
public IsleAbstract travelUp(int startX, int startY)
{
IsleAbstract endIsle = null;
for (int y = startY + 1; y < world.GetLength(1); y++)
{
if (world[startX, y] != null)
{
endIsle = world[startX, y];
break;
}
}
return(endIsle);
}
public IsleAbstract travelDown(int startX, int startY)
{
IsleAbstract endIsle = null;
for (int y = startY - 1; y >= 0; y--)
{
if (world[startX, y] != null)
{
endIsle = world[startX, y];
break;
}
}
return(endIsle);
}
private void insertAdditionalConnections()
{
//AddConnPerIsle = System.Math.Min(AddConnPerIsle, 4);
IsleAbstract isle;
int connectionsToAdd = (int)System.Math.Floor(connections.Count * AddConnPerIsle);
for (int i = 0; i < connectionsToAdd; i++)
{
int tmp = rnd.Next(0, isles.Count);
isle = isles[tmp];
List <int> directions = new List <int>();
for (int j = 0; j < 6; j++)
{
directions.Add(j);
}
for (int j = 0; j < 6; j++)
{
tmp = rnd.Next(0, directions.Count);
int direction = directions[tmp];
directions.RemoveAt(tmp);
IsleAbstract islePartner = null;
if (isle.Portals[direction] != null)
{
continue;
}
islePartner = travelInDirection((int)isle.Index.x, (int)isle.Index.y, direction);
int directionFrom = (direction + 3) % 6;
if (islePartner != null)
{
connectIsles(isle, islePartner, directionFrom);
break;
}
}
}
}
private void connectIsles(IsleAbstract isle1, IsleAbstract isle2, int directionFrom)
{
PortalAbstract portal1 = new PortalAbstract();
PortalAbstract portal2 = new PortalAbstract();
ConnectionAbstract connection = new ConnectionAbstract();
portal1.isleAbstract = isle1;
portal1.ConnectedPortal = portal2;
portal1.Connection = connection;
portal2.isleAbstract = isle2;
portal2.ConnectedPortal = portal1;
portal2.Connection = connection;
connection.Portal1 = portal1;
connection.Portal2 = portal2;
connections.Add(connection);
isle1.Portals[(directionFrom + 3) % 6] = portal1;
isle2.Portals[directionFrom] = portal2;
}
public void GenerateMap()
{
rnd = new System.Random();
if (islesObjects != null)
{
for (int i = 0; i < islesObjects.Count; i++)
{
mr.returnObject(islesObjects[i].gameObject);
}
islesObjects.Clear();
}
if (connectionObjects != null)
{
for (int i = 0; i < connectionObjects.Count; i++)
{
mr.returnObject(connectionObjects[i].gameObject);
}
connectionObjects.Clear();
}
// Create World-Array
world = new IsleAbstract[WorldWidth, WorldHeight];
int numberFields = WorldWidth * WorldHeight;
// create list of all fields
List <Vector2> fields = new List <Vector2>();
for (int x = 0; x < WorldWidth; x++)
{
for (int y = 0; y < WorldHeight; y++)
{
fields.Add(new Vector2(x, y));
}
}
// Create abstract isles and give isles individual fields
IsleDensity = System.Math.Min(IsleDensity, 1);
int numberOfIslands = (int)Mathf.Floor(numberFields * IsleDensity); // Warum schickt Floor einen float zurück? Das war früher nicht so!
isles = new List <IsleAbstract>();
for (int i = 0; i < numberOfIslands; i++)
{
IsleAbstract isle = new IsleAbstract();
int tmp = rnd.Next(0, fields.Count);
isle.Index = fields[tmp];
isles.Add(isle);
fields.RemoveAt(tmp);
}
// set isles in world-array
for (int i = 0; i < isles.Count; i++)
{
int x = (int)isles[i].Index.x;
int y = (int)isles[i].Index.y;
world[x, y] = isles[i];
}
buildMinimalTree();
insertAdditionalConnections();
inserObjectsOnMap();
// render world
renderWorld();
}
private void searchNeighbour(IsleAbstract current, IsleAbstract last, int directionFrom)
{
if (current.Connected == true)
{
return;
}
// Connect isles
current.Connected = true;
if (last != null)
{
connectIsles(last, current, directionFrom);
}
List <int> directions = new List <int>();
for (int i = 0; i < 6; i++)
{
directions.Add(i);
}
// remove direction which is comes from
int directionsToCheck = 6;
if (directionFrom != -1)
{
directions.Remove(directionFrom);
directionsToCheck--;
}
for (int i = 0; i < directionsToCheck; i++)
{
int tmp = rnd.Next(0, directions.Count);
int direction = directions[tmp];
directions.RemoveAt(tmp);
IsleAbstract isle = null;
switch (direction)
{
case 0:
isle = travelUp((int)current.Index.x, (int)current.Index.y);
break;
case 1:
isle = travelUpRight((int)current.Index.x, (int)current.Index.y);
break;
case 2:
isle = travelDownRight((int)current.Index.x, (int)current.Index.y);
break;
case 3:
isle = travelDown((int)current.Index.x, (int)current.Index.y);
break;
case 4:
isle = travelDownLeft((int)current.Index.x, (int)current.Index.y);
break;
case 5:
isle = travelUpLeft((int)current.Index.x, (int)current.Index.y);
break;
}
if (isle != null)
{
direction = (direction + 3) % 6;
searchNeighbour(isle, current, direction);
}
}
}
private void renderWorld()
{
islesObjects = new List <Isle>();
connectionObjects = new List <Connection>();
Fieldwidth = System.Math.Max(Fieldwidth, 10);
IsleAbstract isle = null;
for (int x = 0; x < world.GetLength(0); x++)
{
for (int y = 0; y < world.GetLength(1); y++)
{
if (world[x, y] == null)
{
continue;
}
isle = world[x, y];
int offset = 0;
if (x % 2 == 1)
{
offset = Fieldwidth / 2;
}
int isleHeight = rnd.Next(-50, 51);
//int isleHeight = 0;
Vector3 pos = new Vector3(isle.Index.x * Fieldwidth, isleHeight, (isle.Index.y * Fieldwidth) + offset);
Isle isleObj;
if (isle.isleObjectType != IsleAbstract.IsleObjectType.boss)
{
int type = mr.random.Next(1, 5);
switch (type)
{
case 1: isleObj = mr.getObject(ObjectPool.categorie.islands, (int)ObjectPool.islands.type1).GetComponent <Isle>();
break;
case 2: isleObj = mr.getObject(ObjectPool.categorie.islands, (int)ObjectPool.islands.type2).GetComponent <Isle>();
break;
case 3: isleObj = mr.getObject(ObjectPool.categorie.islands, (int)ObjectPool.islands.type3).GetComponent <Isle>();
break;
case 4: isleObj = mr.getObject(ObjectPool.categorie.islands, (int)ObjectPool.islands.type4).GetComponent <Isle>();
break;
default: isleObj = mr.getObject(ObjectPool.categorie.islands, (int)ObjectPool.islands.type1).GetComponent <Isle>();
break;
}
}
else
{
isleObj = mr.getObject(ObjectPool.categorie.islands, (int)ObjectPool.islands.boss_portal).GetComponent <Isle>();
}
isleObj.transform.position = pos;
isleObj.Initialize(isle);
isle.IsleObj = isleObj;
if (isle.Connected == true)
{
//isleObj.gameObject.GetComponent<Renderer>().material.color = new Color(255, 0, 0); // TODO
}
islesObjects.Add(isleObj);
}
}
// render connections
for (int i = 0; i < connections.Count; i++)
{
Connection connectionObj = mr.getObject(ObjectPool.categorie.structures, (int)ObjectPool.structures.connection).GetComponent <Connection>();
connectionObj.connectionAbstract = connections[i];
connections[i].connectionObj = connectionObj;
LineRenderer lineRenderer = connectionObj.GetComponent <LineRenderer>();
lineRenderer.SetVertexCount(2);
lineRenderer.SetPosition(0, connections[i].Portal1.portalObj.transform.position + new Vector3(0, 1, 0));
lineRenderer.SetPosition(1, connections[i].Portal2.portalObj.transform.position + new Vector3(0, 1, 0));
connectionObjects.Add(connectionObj);
}
// add death Place
GameObject deathPlane = mr.getObject(ObjectPool.categorie.planes, (int)ObjectPool.planes.deathPlane);
deathPlane.transform.position = new Vector3(0, -100, 0);
}
public void ShowMiniMap()
{
if (listIsles != null)
{
for (int i = 0; i < listIsles.Count; i++)
{
Destroy(listIsles[i].gameObject);
}
listIsles.Clear();
}
if (listConnections != null)
{
for (int i = 0; i < listConnections.Count; i++)
{
Destroy(listConnections[i].gameObject);
}
listConnections.Clear();
}
// draw isles
listIsles = new List <UI_Isle>();
listConnections = new List <UI_Connection>();
levelManager = LevelManager.getLevelManager();
IsleAbstract[,] world = levelManager.world;
int mapWidth = world.GetLength(0) * Fieldwidth;
int mapHeight = world.GetLength(1) * Fieldwidth;
for (int x = 0; x < world.GetLength(0); x++)
{
for (int y = 0; y < world.GetLength(1); y++)
{
if (world[x, y] == null)
{
continue;
}
IsleAbstract isle = world[x, y];
int offset = 0;
if (x % 2 == 1)
{
offset = Fieldwidth / 2;
}
Vector3 pos = new Vector3(isle.Index.x * Fieldwidth, (isle.Index.y * Fieldwidth) + offset, -1);
pos = pos - new Vector3(mapWidth, mapHeight, 0);
UI_Isle ui_Isle = Instantiate(IsleImage);
ui_Isle.GetComponent <RawImage>().texture = ui_Isle.Normal;
isle.ui_Isle = ui_Isle;
ui_Isle.isleAbstract = isle;
ui_Isle.transform.SetParent(MiniMap.transform, false);
ui_Isle.transform.position = ui_Isle.transform.position + pos;
listIsles.Add(ui_Isle);
}
}
// draw connections
List <ConnectionAbstract> connections = levelManager.connections;
for (int i = 0; i < connections.Count; i++)
{
float x1 = connections[i].Portal1.isleAbstract.Index.x;
float y1 = connections[i].Portal1.isleAbstract.Index.y;
int offset = 0;
if (x1 % 2 == 1)
{
offset = Fieldwidth / 2;
}
Vector3 posIsle1 = new Vector3(x1 * Fieldwidth, (y1 * Fieldwidth) + offset, 0);
posIsle1 = posIsle1 - new Vector3(mapWidth, mapHeight, 0);
float x2 = connections[i].Portal2.isleAbstract.Index.x;
float y2 = connections[i].Portal2.isleAbstract.Index.y;
offset = 0;
if (x2 % 2 == 1)
{
offset = Fieldwidth / 2;
}
Vector3 posIsle2 = new Vector3(x2 * Fieldwidth, (y2 * Fieldwidth) + offset, 0);
posIsle2 = posIsle2 - new Vector3(mapWidth, mapHeight, 0);
Vector3 distanceVec = posIsle2 - posIsle1;
float distanceLength = distanceVec.magnitude;
float angle = Mathf.Atan2(distanceVec.x, distanceVec.y) * Mathf.Rad2Deg;
angle = 360 - angle;
UI_Connection ui_Conn = Instantiate(ConnectionImage);
ui_Conn.transform.SetParent(MiniMap.transform, false);
ui_Conn.transform.position = ui_Conn.transform.position + posIsle1;
ui_Conn.GetComponent <RectTransform>().sizeDelta = new Vector2(4, distanceLength);
ui_Conn.transform.Rotate(0f, 0f, angle);
ui_Conn.transform.SetAsFirstSibling();
listConnections.Add(ui_Conn);
}
// Add Compas
mapCompass = Instantiate(MapCompassImage).GetComponent <RawImage>();
mapCompass.transform.SetParent(MiniMap.transform, false);
mapCompass.enabled = false;
// set Background
MiniMapBackground.GetComponent <RectTransform>().sizeDelta = new Vector2(mapWidth + Fieldwidth, mapHeight + Fieldwidth);
UpdateMiniMap();
}
public void Initialize(IsleAbstract isle)
{
isleAbstract = isle;
mr = ObjectPool.getObjectPool();
lvlManager = LevelManager.getLevelManager();
playerObject = mr.getObject(ObjectPool.categorie.essential, (int)ObjectPool.essential.player);
rnd = mr.random;
ListEnemies = new List <GameObject>();
listBoxes = new List <Item>();
Portals = new Portal[6];
Portals[0] = PortalUp;
Portals[1] = PortalUpRight;
Portals[2] = PortalDownRight;
Portals[3] = PortalDown;
Portals[4] = PortalDownLeft;
Portals[5] = PortalUpLeft;
borders = new GameObject[4];
// prepare Enemy Spawns
for (int i = 0; i < EnemyPoints.Count; i++)
{
EnemyPoints[i].IslePosition = transform.position;
EnemyPoints[i].GetComponent <Renderer>().enabled = false;
}
// hide Player Start Point
if (PlayerStartPoint != null)
{
PlayerStartPoint.SetActive(false);
}
// hide Item Spawns
for (int i = 0; i < ItemPoints.Count; i++)
{
ItemPoints[i].GetComponent <Renderer>().enabled = false;
}
// Portal stuff
for (int i = 0; i < 6; i++)
{
// hide Portal-Tempaltes
Portals[i].gameObject.SetActive(false);
// show real Portals (and remove old ones
if (isleAbstract.Portals[i] != null)
{
Portal realPortal = mr.getObject(ObjectPool.categorie.structures, (int)ObjectPool.structures.portal).GetComponent <Portal>();
realPortal.transform.position = Portals[i].transform.position;
realPortal.transform.rotation = Portals[i].transform.rotation;
realPortal.spawnPoint.transform.position = Portals[i].spawnPoint.transform.position;
realPortal.spawnPoint.SetActive(false);
realPortal.portalSpiral.gameObject.SetActive(false);
realPortal.Direction = i;
isleAbstract.Portals[i].portalObj = realPortal;
realPortal.portalAbstract = isleAbstract.Portals[i];
Portals[i] = realPortal;
realPortal.transform.SetParent(gameObject.transform);
}
}
// set items ---------------------
int keyPoint = -1;
if (isleAbstract.isleObjectType == IsleAbstract.IsleObjectType.key)
{
keyPoint = rnd.Next(0, ItemPoints.Count);
}
for (int i = 0; i < ItemPoints.Count; i++)
{
// check for key
if (i == keyPoint)
{
// place key
GameObject key = null;
switch (isleAbstract.keyNumber)
{
case 1: key = mr.getObject(ObjectPool.categorie.items, (int)ObjectPool.items.key1);
break;
case 2: key = mr.getObject(ObjectPool.categorie.items, (int)ObjectPool.items.key2);
break;
case 3: key = mr.getObject(ObjectPool.categorie.items, (int)ObjectPool.items.key3);
break;
default: print("Error Key-Isle, but no valid key-Number. " + isleAbstract.keyNumber);
break;
}
key.GetComponent <Item>().initialize();
key.transform.position = ItemPoints[i].transform.position;
}
else
{
// place boxes
GameObject box = null;
if (rnd.Next(0, 101) > lvlManager.ChancesBigBoxes)
{
// small box
box = mr.getObject(ObjectPool.categorie.items, (int)ObjectPool.items.smallBox);
}
else
{
// big box
box = mr.getObject(ObjectPool.categorie.items, (int)ObjectPool.items.bigBox);
}
box.transform.position = ItemPoints[i].transform.position;
box.GetComponent <Item>().initialize();
listBoxes.Add(box.GetComponent <Item>());
}
}
}
