/// <summary>
/// Creates level part of certain difficulty, places is to certain spot and adds it to the list of current active level parts
/// </summary>
/// <param name="levelPartArray"></param>
/// <param name="levelPartNumber"></param>
/// <param name="pos"></param>
private void createLevelPart(LevelPart[] levelPartArray, int levelPartNumber, Vector2 pos)
{
LevelPart levelPart = Instantiate(levelPartArray[levelPartNumber].gameObject, position: pos, Quaternion.identity).GetComponent <LevelPart>();
levelPart.AddToActiveLevelParts(_currentActiveLevelParts);
levelPart.SetSpeedOfMoving(_currentLevelSpeed);
}
void Awake()
{
if (levelPart == null)
{
levelPart = GetComponent <LevelPart>();
}
}
// Places tile on new space in LevelPart and updated references of shared walls and neighbors
public void Reposition(Vector2 newPos, LevelPart newBelonging, bool setNeigh)
{
UpdateAttachedObjectsList();
Vector2 movedDistance = new Vector2(newPos.x - Pos.x, newPos.y - Pos.y);
// set LevelPart belonging to
mLevelPartBelongingTo = newBelonging;
// Delete Neighbors refrence to this tile, and delete own references
DeleteNeighborRelation(LookingDirection.North);
DeleteNeighborRelation(LookingDirection.East);
DeleteNeighborRelation(LookingDirection.South);
DeleteNeighborRelation(LookingDirection.West);
// reposition on LevelPart
gameObject.transform.localPosition = new Vector3(newPos.x * World.TILE_SIZE, 0, newPos.y * World.TILE_SIZE);
mPos = newPos;
// get new neighbors from LevelPart
if (setNeigh)
{
SetNeighbor(LookingDirection.North, mLevelPartBelongingTo.GetTileByPos(new Vector2(newPos.x, newPos.y + 1)));
SetNeighbor(LookingDirection.West, mLevelPartBelongingTo.GetTileByPos(new Vector2(newPos.x - 1, newPos.y)));
SetNeighbor(LookingDirection.South, mLevelPartBelongingTo.GetTileByPos(new Vector2(newPos.x, newPos.y - 1)));
SetNeighbor(LookingDirection.East, mLevelPartBelongingTo.GetTileByPos(new Vector2(newPos.x + 1, newPos.y)));
}
// Take objects belonging to tile with it
foreach (GameObject obj in AttachedObjects)
{
obj.transform.position = new Vector3(obj.transform.position.x + movedDistance.x * World.TILE_SIZE, obj.transform.position.y, obj.transform.position.z + movedDistance.y * World.TILE_SIZE);
}
}
public static void LoadLevel(Camera camera, string fileName)
{
//load the background and then the level
Stage.level = new Level();
StreamReader reader = new StreamReader(fileName);
LevelPart currentLevelPart = null;
int order = 0;
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (line.StartsWith("B"))
{
//background
int layerOrder = int.Parse(reader.ReadLine());
float para = float.Parse(reader.ReadLine());
currentLevelPart?.Layers.Add(LoadBackground(reader.ReadLine(), camera, para, layerOrder));
}
else if (line.StartsWith("A"))
{
//entities in the game player level
int areaOrder = int.Parse(reader.ReadLine());
LevelPart lp = LoadArea(reader.ReadLine(), camera);
lp.Song = line[1] - '0';
if (currentLevelPart != null)
{
Stage.level.AddArea(currentLevelPart, order);
}
currentLevelPart = lp;
order = areaOrder;
}
}
Stage.level.AddArea(currentLevelPart, order);
}
private void DeletePart()
{
LevelPart vPartToDelete = m_levelPartSpawned.Dequeue();
vPartToDelete.isSpawn = false;
vPartToDelete.gameObject.SetActive(false);
}
public void SpawnObject()
{
LevelPart spawnedLevelPart = Instantiate(GiveMember(), _spawnPoint.position, Quaternion.identity);
spawnedLevelPart.Init(_player);
spawnedLevelPart.Arrived += SpawnObject;
}
private void SpawnNewPart()
{
var distanceBetweenParts = Random.Range(1, maximumDistanceBetweenParts);
var newPosition = (Vector2)lastSpawnedPart.transform.position + new Vector2(lastSpawnedPart.SizeOfLevelPart + distanceBetweenParts, 0);;
var randomPart = availableLevelParts[Random.Range(0, availableLevelParts.Length)];
lastSpawnedPart = Instantiate(randomPart, newPosition, Quaternion.identity);
}
public void DespawnLastPart()
{
if (LastPart == null)
{
return;
}
LastPart.DespawnPart();
LastPart = null;
}
private void SpawnFirstParts()
{
m_LastLevelPartSpawn = Instantiate(m_LevelPart[0].LevelTransform, m_LevelPart[0].LevelTransform.transform.position, Quaternion.identity).GetComponent <LevelPart>();
m_levelPartSpawned.Enqueue(m_LastLevelPartSpawn);
for (int i = 0; i < m_nbPart; i++)
{
SpawnLevelPart();
}
}
private LevelPart GetRandomPart()
{
int vRandomIndex = UnityEngine.Random.Range(0, m_levelPartsInstantiate.Length - 1);
LevelPart vPartToReturn = m_levelPartsInstantiate[vRandomIndex];
if (vPartToReturn.isSpawn)
{
vPartToReturn = GetRandomPart();
}
return(vPartToReturn);
}
public bool CheckPartPosition(LevelPart part, float posZ)
{
if (Player.position.z >= posZ && Player.position.z <= posZ + part.Length)
{
if (!part.IsActive)
{
//Debug.Log(string.Format("Part: {0} Pos: {1} Player: {2}", part.name, posZ, Player.position.z));
part.StartPart();
return(true);
}
}
return(false);
}
public static LevelPart LoadArea(string filename, Camera camera)
{
QuadTree quad = new QuadTree((Rectangle)camera.Limits, 0);
Dictionary <int, Vector2> dict = new Dictionary <int, Vector2>();
ReadCSV(filename, null, quad, dict);
LevelPart lp = new LevelPart
{
Entities = quad,
ExitPositions = dict
};
return(lp);
}
public void AddRandomPart()
{
if (partInfos.Length < 3)
{
AddPart(null);
return;
}
LevelPart part = null;
do
{
part = partInfos.RandomEntry(Weight).LevelPart;
} while (part == CurrentPart || part == NextPart || part == null);
AddPart(part);
}
private void SpawnLevelPart()
{
LevelPart vLevelPartToSpawn = GetRandomPart();
vLevelPartToSpawn.transform.position = m_LastLevelPartSpawn.EndPoint.position;
vLevelPartToSpawn.transform.rotation = Quaternion.identity;
vLevelPartToSpawn.gameObject.SetActive(true);
vLevelPartToSpawn.isSpawn = true;
m_ParticlePooling.CreateParticle(m_Particles, vLevelPartToSpawn.particlePosition);
m_levelPartSpawned.Enqueue(vLevelPartToSpawn);
m_LastLevelPartSpawn = vLevelPartToSpawn;
m_NextPartSpawn = true;
m_PartCount += 1;
m_GM.SetScore(m_PartCount);
}
public void AddPart(LevelPart part)
{
DespawnLastPart();
LastPart = CurrentPart;
CurrentPart = NextPart;
NextPart = part;
if (NextPart != null)
{
NextPart.SpawnPart(CurrentZPos);
CheckPartPosition(NextPart, CurrentZPos);
CurrentZPos += NextPart.Length;
}
if (CurrentPart != null)
{
MaxZPosToLoadNewPart += CurrentPart.Length;
}
}
public void RemovePart(Vector2 location)
{
var count = 0;
LevelPart partToRemove = null;
foreach (var part in CurrentLevel.LevelParts)
{
if (part.PartLocation == location)
{
Debug.Log("Part Location: " + part.PartLocation + ", location:" + location);
RemoveObject(part.PartTag);
partToRemove = part;
continue;
}
count++;
}
if (partToRemove != null)
{
CurrentLevel.RemovePart(partToRemove);
}
}
private void SpawnFirstPart()
{
lastSpawnedPart = Instantiate(availableLevelParts[0], transform.position, Quaternion.identity);
}
public void RemovePart(LevelPart part)
{
Undo.RecordObject(manager, "Before Remove Part");
}
void OnEnable()
{
myTarget = (LevelPart)target;
Tools.hidden = true;
}
/// <summary>
/// Generates specified number of level parts.
/// </summary>
/// <param name="partsNumber">Parts number.</param>
public void GenerateLevelParts(int partsNumber)
{
for (var i = 0; i < partsNumber; ++i)
{
int rnd;
LevelPart newPart;
// If we have something generated, place new part after it.
if (lastGeneratedPart != null)
{
// We can generate only parts to which we can connect.
// So we neet to chose one type first.
rnd = Random.Range(0, lastGeneratedPart.canConnectTo.Count);
var selectedType = lastGeneratedPart.canConnectTo[rnd];
// Then we chose one part of selected type and create it.
var listPartOfType = partsByTypes[selectedType];
var count = listPartOfType.Count;
rnd = Random.Range(0, count);
var neededPart = listPartOfType[rnd];
newPart = Instantiate<LevelPart>(neededPart);
// And place it after the previous part.
newPart.transform.position = lastGeneratedPart.transform.position + new Vector3(0f, 0f, newPart.length);
}
// If it is first part we can generate whatever we want.
// Then we place it to zero coordinates.
else
{
rnd = Random.Range(0, levelPartPrefabs.Count);
newPart = Instantiate<LevelPart>(levelPartPrefabs[rnd]);
newPart.transform.position = Vector3.zero;
}
// And store generated part.
generatedParts.Enqueue(newPart);
lastGeneratedPart = newPart;
}
// After generating new parts we have to cut the level.
CutLevel(1.5f);
}
public void AddPart(LevelPart part)
{
Undo.RecordObject(manager, "Before Add Part");
}
