private bool findCASpawns(LevelGenOutput output)
{
List <LevelGenMap.Coordinate> openTiles = new List <LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
EnemySelector enemySelector = new EnemySelector();
int difficulty = ProgressData.GetCurrentDifficulty();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
LevelGenCaveInfo caveInfo = output.MapInfo[LevelGenCaveInfo.KEY] as LevelGenCaveInfo;
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
{
findMinibossSpawn(openTiles, (caveInfo.Data as List <List <LevelGenMap.Coordinate> >)[0]);
}
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - CA");
return(false);
}
else
{
spawnSimple(0, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, true);
}
return(true);
}
public void Init()
{
this.UserTransform = GameObject.FindGameObjectWithTag(UserSelectorTag).transform;
this.EnemyTansform = GameObject.FindGameObjectWithTag(EnemySelectorTag).transform;
this.UserTransformAnimator = UserTransform.GetComponent <Animator>();
this.user = new Selector(
target: this.UserTransform,
step: GameElementConstants.minSpeedBar,
downClamp: this.minSelectorAngle,
upClamp: this.maxSelectorAngle);
this.uiManager = UI.Behaviours.GamePlay.GamePlayManager.Instance;
this.uiManager.gamePlay.TapScreen.TapEvent += CheckMatch;
this.zigZag = new ZigZag(
lowerClamp: this.minSelectorAngle,
upperClamp: this.maxSelectorAngle,
divisions: this.SelectorDivisions);
this.enemyS = new EnemySelector(GameObject.FindGameObjectWithTag(EnemySelectorTag));
this.enemyS.Init();
}
private bool findBSPCAComboSpawns(LevelGenOutput output)
{
List <LevelGenMap.Coordinate> openTiles = new List <LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
EnemySelector enemySelector = new EnemySelector();
int difficulty = ProgressData.GetCurrentDifficulty();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
LevelGenCaveInfo caveInfo = output.MapInfo[LevelGenCaveInfo.KEY] as LevelGenCaveInfo;
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
{
findMinibossSpawn(openTiles, (caveInfo.Data as List <List <LevelGenMap.Coordinate> >)[0]);
}
LevelGenRoomInfo roomInfo = output.MapInfo[LevelGenRoomInfo.KEY] as LevelGenRoomInfo;
List <SimpleRect> availableRooms = new List <SimpleRect>(roomInfo.Data as List <SimpleRect>);
availableRooms.Shuffle();
// Player room
SimpleRect playerRoom = availableRooms[availableRooms.Count - 1];
availableRooms.RemoveAt(availableRooms.Count - 1);
List <LevelGenMap.Coordinate> playerRoomCoords = coordinatesInRoom(playerRoom);
openTiles.RemoveList(playerRoomCoords);
playerRoomCoords.Shuffle();
for (int p = 0; p < DynamicData.MAX_PLAYERS; ++p)
{
if (DynamicData.GetSessionPlayer(p).HasJoined)
{
_playerSpawns.Add(playerRoomCoords[playerRoomCoords.Count - 1].integerVector);
playerRoomCoords.RemoveAt(playerRoomCoords.Count - 1);
}
}
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - CA");
return(false);
}
else
{
spawnSimple(0, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, false);
}
return(true);
}
private void Start()
{
deadEnemies = new List <GameObject>();
winText.enabled = false;
GameObject manager = GameObject.Find("MovementManager");
enemySelector = manager.GetComponent <EnemySelector>();
maxDeadEnemies = enemySelector.GetEnemies().Length;
turnManager = GameObject.Find("GameRoundManager").GetComponent <TurnManager>();
}
private void OnTriggerStay2D(Collider2D collision)
{
//Check if we collide with the player, if that's true, try to follow him
if (collision.tag == "Player" && Vector3.Distance(transform.position, collision.transform.position) > MinDistance)
{
//Get Enemy Selector cmp and check if it can be follow
EnemySelector EnmSlt = collision.gameObject.GetComponentInChildren <EnemySelector>();
if (EnmSlt && EnmSlt.CanBeFollowed(this.gameObject))
{
EnemyBehaviour.AskFollow(collision.gameObject);
}
}
}
// Use this for initialization
void Start()
{
gameOver = false;
GameObject manager = GameObject.Find("MovementManager");
playerSelector = manager.GetComponent <PlayerSelector>();
enemySelector = manager.GetComponent <EnemySelector>();
turnText.enabled = false;
gameRound = 0;
enemies = enemySelector.GetEnemies();
players = playerSelector.GetPlayers();
//StartCoroutine("PlayerTurn");
}
/// <summary>
/// Show UI tile for movement of the player
/// </summary>
private void ShowEnemyInRangeTile()
{
Vector2 start = transform.position;
float distance;
this._EnemiesTiles = GameObject.FindGameObjectsWithTag("Enemy");
foreach (var tile in this._EnemiesTiles)
{
distance = EnemySelector.ManhattanDistance2D(start, tile.transform.position);
if (distance <= Managers.Player.SpellRange && distance > 0 && this.HasLineOfSightOnTarget(tile.transform.position))
{
this.InstantiateSelectableTile(tile.transform.position);
}
}
}
void EnemyButtons()
{
foreach (GameObject enemy in EnemiesInBattle)
{
newButton = Instantiate(enemyButton) as GameObject;
EnemySelector button = newButton.GetComponent <EnemySelector>();
EnemyStateMachine currEnemy = enemy.GetComponent <EnemyStateMachine>();
Text buttonText = newButton.GetComponentInChildren <Text>();
buttonText.text = currEnemy.enemy.name;
button.Enemy = enemy;
enemyButtons.Add(newButton);
newButton.transform.SetParent(spacer, false);
}
}
public void SessionCharacterList()
{
if (characterList.alpha == 1f)
{
HideCharacterList();
return;
}
CharacterSelector[] characters = listCharacters.GetComponentsInChildren <CharacterSelector>();
for (int i = 0; i < characters.Length; i++)
{
Destroy(characters[i].gameObject);
}
characterList.alpha = 1f;
characterList.blocksRaycasts = true;
characterList.interactable = true;
for (int i = 0; i < sessionData.Content_Lobby.characters.Count; i++)
{
Content_Lobby character = sessionData.Content_Lobby.characters[i];
CharacterSelector characterSelect = Instantiate(characterSample, listCharacters);
characterSelect.name = "Character_" + character.ID_Character;
characterSelect.id_Character = character.ID_Character;
characterSelect.SetVisual(character.ID_Token);
}
//SAMPLES
for (int i = 0; i < 4; i++)// 4 samples enemy
{
EnemySelector enemySelect = Instantiate(enemySample, listCharacters);
enemySelect.name = "Ennemy_" + i;
enemySelect.SetVisual(i);
}
ItemSelector chestSelect = Instantiate(itemSample, listCharacters);
chestSelect.name = "Chest";
chestSelect.SetVisual(0);
}
void Start()
{
PrefabSelector objects = GetComponent <PrefabSelector>();
EnemySelector enemies = GetComponent <EnemySelector>();
for (int i = 0; i < prefabSpawn; i++)
{
float testX = Random.Range(-24 + transform.position.x, 24 + transform.position.x);
int useX = Mathf.RoundToInt(testX);
float testZ = Random.Range(-24 + transform.position.z, 24 + transform.position.z);
int useZ = Mathf.RoundToInt(testZ);
Vector3 testSpot = new Vector3(useX, 0, useZ);
if (CheckSpots(testSpot))
{
GameObject addMe = Instantiate(objects.givePrefab(), testSpot, Quaternion.identity) as GameObject;
addMe.transform.parent = transform;
TakeSpots.Add(testSpot);
}
}
for (int i = 0; i < enemySpawn; i++)
{
float testX = Random.Range(-24 + transform.position.x, 24 + transform.position.x);
int useX = Mathf.RoundToInt(testX);
float testZ = Random.Range(-24 + transform.position.z, 24 + transform.position.z);
int useZ = Mathf.RoundToInt(testZ);
Vector3 testSpot = new Vector3(useX, 0, useZ);
if (CheckEnemySpots(testSpot))
{
GameObject addMe = Instantiate(enemies.givePrefab(), testSpot, Quaternion.identity) as GameObject;
addMe.transform.parent = transform;
TakeSpots.Add(testSpot);
}
else
{
i--;
}
}
}
private bool findCASpawns(LevelGenOutput output)
{
List<LevelGenMap.Coordinate> openTiles = new List<LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
EnemySelector enemySelector = new EnemySelector();
int difficulty = ProgressData.GetCurrentDifficulty();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
LevelGenCaveInfo caveInfo = output.MapInfo[LevelGenCaveInfo.KEY] as LevelGenCaveInfo;
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
findMinibossSpawn(openTiles, (caveInfo.Data as List<List<LevelGenMap.Coordinate>>)[0]);
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - CA");
return false;
}
else
{
spawnSimple(0, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, true);
}
return true;
}
private int pickMaybeGuaranteedEnemy(int guaranteesSpawned, int totalGuarantees, int enemiesSpawned, int difficulty, int[] guaranteedEnemiesPlaced, LevelGenOutput output, EnemySelector enemySelector)
{
if (guaranteesSpawned < totalGuarantees && Random.Range(0, this.NumEnemies) < enemiesSpawned + (totalGuarantees - guaranteesSpawned))
{
// Use guarantee for united-spawn
int guaranteedDifficulty = 0;
for (int i = 0; i < guaranteedEnemiesPlaced.Length; ++i)
{
if (guaranteedEnemiesPlaced[i] < output.Input.GuaranteedEnemiesByDifficulty[i])
{
guaranteedDifficulty = i;
if (Random.value > 0.5f)
{
break;
}
}
}
return(enemySelector.ChooseEnemyOfDifficulty(guaranteedDifficulty));
}
return(enemySelector.ChooseEnemy(difficulty));
}
private void spawnSimple(int enemiesSpawned, LevelGenOutput output, int[] guaranteedEnemiesPlaced, EnemySelector enemySelector, int difficulty, List <LevelGenMap.Coordinate> openTiles, bool spawnPlayers)
{
// Guaranteed enemies
for (int i = 0; i < output.Input.GuaranteedEnemiesByDifficulty.Length; ++i)
{
while (guaranteedEnemiesPlaced[i] < output.Input.GuaranteedEnemiesByDifficulty[i])
{
int enemyId = enemySelector.ChooseEnemyOfDifficulty(i);
guaranteedEnemiesPlaced[i] = guaranteedEnemiesPlaced[i] + 1;
++enemiesSpawned;
_enemySpawns.Add(new EnemySpawnGroup(findGoodOpenPosition(openTiles, output.Input.MinDistanceBetweenSpawns).integerVector, enemyId));
}
}
// Remaining enemies
for (; enemiesSpawned < this.NumEnemies; ++enemiesSpawned)
{
int enemyId = enemySelector.ChooseEnemy(difficulty);
_enemySpawns.Add(new EnemySpawnGroup(findGoodOpenPosition(openTiles, output.Input.MinDistanceBetweenSpawns).integerVector, enemyId));
}
// Players
if (spawnPlayers)
{
bool first = true;
List <LevelGenMap.Coordinate> tiles = openTiles;
for (int i = 0; i < DynamicData.MAX_PLAYERS; ++i)
{
if (DynamicData.GetSessionPlayer(i).HasJoined)
{
LevelGenMap.Coordinate playerSpawn = findGoodOpenPosition(tiles, 0);
_playerSpawns.Add(playerSpawn.integerVector);
if (first)
{
first = false;
List <LevelGenMap.Coordinate> nearbySpawns = new List <LevelGenMap.Coordinate>();
foreach (LevelGenMap.Coordinate coord in openTiles)
{
if (Mathf.Abs(coord.x - playerSpawn.x) + Mathf.Abs(coord.y - playerSpawn.y) <= this.MaxPlayerSpawnDistance)
{
nearbySpawns.Add(coord);
}
}
if (nearbySpawns.Count >= DynamicData.MAX_PLAYERS)
{
tiles = nearbySpawns;
}
}
else
{
openTiles.Remove(playerSpawn);
}
}
}
}
}
private bool findBSPSpawns(LevelGenOutput output)
{
List<LevelGenMap.Coordinate> openTiles = new List<LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
LevelGenRoomInfo roomInfo = output.MapInfo[LevelGenRoomInfo.KEY] as LevelGenRoomInfo;
EnemySelector enemySelector = new EnemySelector();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
findMinibossSpawn(openTiles, openTiles);
int difficulty = ProgressData.GetCurrentDifficulty();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
int totalGuarantees = 0;
for (int i = 0; i < guaranteedEnemiesPlaced.Length; ++i)
{
totalGuarantees += output.Input.GuaranteedEnemiesByDifficulty[i];
}
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1 ||
roomInfo == null || roomInfo.Data.Count < 4 + difficulty)
{
Debug.Log("Regeneration necessary - BSP 1");
return false;
}
else
{
List<SimpleRect> availableRooms = new List<SimpleRect>(roomInfo.Data as List<SimpleRect>);
availableRooms.Shuffle();
// Player room
SimpleRect playerRoom = availableRooms[availableRooms.Count - 1];
availableRooms.RemoveAt(availableRooms.Count - 1);
List<LevelGenMap.Coordinate> playerRoomCoords = coordinatesInRoom(playerRoom);
openTiles.RemoveList(playerRoomCoords);
playerRoomCoords.Shuffle();
for (int p = 0; p < DynamicData.MAX_PLAYERS; ++p)
{
if (DynamicData.GetSessionPlayer(p).HasJoined)
{
_playerSpawns.Add(playerRoomCoords[playerRoomCoords.Count - 1].integerVector);
playerRoomCoords.RemoveAt(playerRoomCoords.Count - 1);
}
}
if (openTiles.Count <= this.NumEnemies * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - BSP 2");
return false;
}
else
{
int enemiesSpawned = 0;
int guaranteesSpawned = 0;
bool haveUnitedAllRoomsSoFar = true;
// Enemy rooms
for (int r = 0; r < availableRooms.Count; ++r)
{
SimpleRect room = availableRooms[r];
if (this.NumEnemies - enemiesSpawned < 4 || (r == availableRooms.Count - 1 && haveUnitedAllRoomsSoFar && guaranteesSpawned < totalGuarantees))
break;
if (Random.value > 0.65f)
{
haveUnitedAllRoomsSoFar = false;
continue;
}
List<EnemySpawn> roomSpawns = new List<EnemySpawn>();
EnemySelector.WeightSet roomWeightSet = new EnemySelector.WeightSet();
enemySelector.AddWeightSet(roomWeightSet);
// United-spawn room
int favoredEnemyId = pickMaybeGuaranteedEnemy(guaranteesSpawned, totalGuarantees, enemiesSpawned, difficulty, guaranteedEnemiesPlaced, output, enemySelector);
roomWeightSet.WeightsByEnemyId[favoredEnemyId] = 100;
List<IntegerVector> roomCorners = new List<IntegerVector>();
roomCorners.Add(new IntegerVector(room.X, room.Y));
roomCorners.Add(new IntegerVector(room.X + room.Width, room.Y));
roomCorners.Add(new IntegerVector(room.X, room.Y + room.Height));
roomCorners.Add(new IntegerVector(room.X + room.Width, room.Y + room.Height));
roomCorners.Shuffle();
IntegerVector firstPosition = roomCorners[roomCorners.Count - 1];
++enemiesSpawned;
roomSpawns.Add(new EnemySpawn(firstPosition, favoredEnemyId));
roomCorners.RemoveAt(roomCorners.Count - 1);
int enemyDifficulty = StaticData.EnemyData.EnemyTypes[favoredEnemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
foreach (IntegerVector position in roomCorners)
{
++enemiesSpawned;
int enemyId = enemySelector.ChooseEnemy(difficulty);
roomSpawns.Add(new EnemySpawn(position, enemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[enemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
}
bool extraTwo = false;
if (this.NumEnemies - enemiesSpawned > 2 && Random.value < CHANCE_FOR_EXTRA_TWO_IN_BSP_ROOM)
{
// Let's add 2 along the walls of the longest room dimension
extraTwo = true;
favoredEnemyId = pickMaybeGuaranteedEnemy(guaranteesSpawned, totalGuarantees, enemiesSpawned, difficulty, guaranteedEnemiesPlaced, output, enemySelector);
roomWeightSet.WeightsByEnemyId[favoredEnemyId] = 100;
IntegerVector position1;
IntegerVector position2;
if (room.Width > room.Height)
{
position1 = new IntegerVector(room.X + room.Width / 2, room.Y);
position2 = new IntegerVector(room.X + room.Width / 2, room.Y + room.Height);
}
else
{
position1 = new IntegerVector(room.X, room.Y + room.Height / 2);
position2 = new IntegerVector(room.X + room.Width, room.Y + room.Height / 2);
}
enemiesSpawned += 2;
roomSpawns.Add(new EnemySpawn(position1, favoredEnemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[favoredEnemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
int enemyId = enemySelector.ChooseEnemy(difficulty);
roomSpawns.Add(new EnemySpawn(position2, enemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[enemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
}
_enemySpawns.Add(new EnemySpawnGroup(new IntegerVector(room.X + room.Width / 2, room.Y + room.Height / 2), roomSpawns, ((Mathf.Max(room.Width, room.Height) + 2.6f) / 2.0f) * _tileRenderer.TileRenderSize));
if (!enemySelector.RemoveWeightSet(roomWeightSet))
{
Debug.Log("hrrmmmm");
}
if (extraTwo || Random.value < CHANCE_FOR_REMOVE_SPAWN_ROOM_FOR_FUTURE_BSP)
openTiles.RemoveList(coordinatesInRoom(room));
}
// Non united-room spawns
spawnSimple(enemiesSpawned, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, false);
}
}
return true;
}
private bool findBSPSpawns(LevelGenOutput output)
{
List <LevelGenMap.Coordinate> openTiles = new List <LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
LevelGenRoomInfo roomInfo = output.MapInfo[LevelGenRoomInfo.KEY] as LevelGenRoomInfo;
EnemySelector enemySelector = new EnemySelector();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
{
findMinibossSpawn(openTiles, openTiles);
}
int difficulty = ProgressData.GetCurrentDifficulty();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
int totalGuarantees = 0;
for (int i = 0; i < guaranteedEnemiesPlaced.Length; ++i)
{
totalGuarantees += output.Input.GuaranteedEnemiesByDifficulty[i];
}
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1 ||
roomInfo == null || roomInfo.Data.Count < 4 + difficulty)
{
Debug.Log("Regeneration necessary - BSP 1");
return(false);
}
else
{
List <SimpleRect> availableRooms = new List <SimpleRect>(roomInfo.Data as List <SimpleRect>);
availableRooms.Shuffle();
// Player room
SimpleRect playerRoom = availableRooms[availableRooms.Count - 1];
availableRooms.RemoveAt(availableRooms.Count - 1);
List <LevelGenMap.Coordinate> playerRoomCoords = coordinatesInRoom(playerRoom);
openTiles.RemoveList(playerRoomCoords);
playerRoomCoords.Shuffle();
for (int p = 0; p < DynamicData.MAX_PLAYERS; ++p)
{
if (DynamicData.GetSessionPlayer(p).HasJoined)
{
_playerSpawns.Add(playerRoomCoords[playerRoomCoords.Count - 1].integerVector);
playerRoomCoords.RemoveAt(playerRoomCoords.Count - 1);
}
}
if (openTiles.Count <= this.NumEnemies * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - BSP 2");
return(false);
}
else
{
int enemiesSpawned = 0;
int guaranteesSpawned = 0;
bool haveUnitedAllRoomsSoFar = true;
// Enemy rooms
for (int r = 0; r < availableRooms.Count; ++r)
{
SimpleRect room = availableRooms[r];
if (this.NumEnemies - enemiesSpawned < 4 || (r == availableRooms.Count - 1 && haveUnitedAllRoomsSoFar && guaranteesSpawned < totalGuarantees))
{
break;
}
if (Random.value > 0.65f)
{
haveUnitedAllRoomsSoFar = false;
continue;
}
List <EnemySpawn> roomSpawns = new List <EnemySpawn>();
EnemySelector.WeightSet roomWeightSet = new EnemySelector.WeightSet();
enemySelector.AddWeightSet(roomWeightSet);
// United-spawn room
int favoredEnemyId = pickMaybeGuaranteedEnemy(guaranteesSpawned, totalGuarantees, enemiesSpawned, difficulty, guaranteedEnemiesPlaced, output, enemySelector);
roomWeightSet.WeightsByEnemyId[favoredEnemyId] = 100;
List <IntegerVector> roomCorners = new List <IntegerVector>();
roomCorners.Add(new IntegerVector(room.X, room.Y));
roomCorners.Add(new IntegerVector(room.X + room.Width, room.Y));
roomCorners.Add(new IntegerVector(room.X, room.Y + room.Height));
roomCorners.Add(new IntegerVector(room.X + room.Width, room.Y + room.Height));
roomCorners.Shuffle();
IntegerVector firstPosition = roomCorners[roomCorners.Count - 1];
++enemiesSpawned;
roomSpawns.Add(new EnemySpawn(firstPosition, favoredEnemyId));
roomCorners.RemoveAt(roomCorners.Count - 1);
int enemyDifficulty = StaticData.EnemyData.EnemyTypes[favoredEnemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
foreach (IntegerVector position in roomCorners)
{
++enemiesSpawned;
int enemyId = enemySelector.ChooseEnemy(difficulty);
roomSpawns.Add(new EnemySpawn(position, enemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[enemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
}
bool extraTwo = false;
if (this.NumEnemies - enemiesSpawned > 2 && Random.value < CHANCE_FOR_EXTRA_TWO_IN_BSP_ROOM)
{
// Let's add 2 along the walls of the longest room dimension
extraTwo = true;
favoredEnemyId = pickMaybeGuaranteedEnemy(guaranteesSpawned, totalGuarantees, enemiesSpawned, difficulty, guaranteedEnemiesPlaced, output, enemySelector);
roomWeightSet.WeightsByEnemyId[favoredEnemyId] = 100;
IntegerVector position1;
IntegerVector position2;
if (room.Width > room.Height)
{
position1 = new IntegerVector(room.X + room.Width / 2, room.Y);
position2 = new IntegerVector(room.X + room.Width / 2, room.Y + room.Height);
}
else
{
position1 = new IntegerVector(room.X, room.Y + room.Height / 2);
position2 = new IntegerVector(room.X + room.Width, room.Y + room.Height / 2);
}
enemiesSpawned += 2;
roomSpawns.Add(new EnemySpawn(position1, favoredEnemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[favoredEnemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
int enemyId = enemySelector.ChooseEnemy(difficulty);
roomSpawns.Add(new EnemySpawn(position2, enemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[enemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
}
_enemySpawns.Add(new EnemySpawnGroup(new IntegerVector(room.X + room.Width / 2, room.Y + room.Height / 2), roomSpawns, ((Mathf.Max(room.Width, room.Height) + 2.6f) / 2.0f) * _tileRenderer.TileRenderSize));
if (!enemySelector.RemoveWeightSet(roomWeightSet))
{
Debug.Log("hrrmmmm");
}
if (extraTwo || Random.value < CHANCE_FOR_REMOVE_SPAWN_ROOM_FOR_FUTURE_BSP)
{
openTiles.RemoveList(coordinatesInRoom(room));
}
}
// Non united-room spawns
spawnSimple(enemiesSpawned, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, false);
}
}
return(true);
}
private bool findBSPCAComboSpawns(LevelGenOutput output)
{
List<LevelGenMap.Coordinate> openTiles = new List<LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
EnemySelector enemySelector = new EnemySelector();
int difficulty = ProgressData.GetCurrentDifficulty();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
LevelGenCaveInfo caveInfo = output.MapInfo[LevelGenCaveInfo.KEY] as LevelGenCaveInfo;
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
findMinibossSpawn(openTiles, (caveInfo.Data as List<List<LevelGenMap.Coordinate>>)[0]);
LevelGenRoomInfo roomInfo = output.MapInfo[LevelGenRoomInfo.KEY] as LevelGenRoomInfo;
List<SimpleRect> availableRooms = new List<SimpleRect>(roomInfo.Data as List<SimpleRect>);
availableRooms.Shuffle();
// Player room
SimpleRect playerRoom = availableRooms[availableRooms.Count - 1];
availableRooms.RemoveAt(availableRooms.Count - 1);
List<LevelGenMap.Coordinate> playerRoomCoords = coordinatesInRoom(playerRoom);
openTiles.RemoveList(playerRoomCoords);
playerRoomCoords.Shuffle();
for (int p = 0; p < DynamicData.MAX_PLAYERS; ++p)
{
if (DynamicData.GetSessionPlayer(p).HasJoined)
{
_playerSpawns.Add(playerRoomCoords[playerRoomCoords.Count - 1].integerVector);
playerRoomCoords.RemoveAt(playerRoomCoords.Count - 1);
}
}
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - CA");
return false;
}
else
{
spawnSimple(0, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, false);
}
return true;
}
private void spawnSimple(int enemiesSpawned, LevelGenOutput output, int[] guaranteedEnemiesPlaced, EnemySelector enemySelector, int difficulty, List<LevelGenMap.Coordinate> openTiles, bool spawnPlayers)
{
// Guaranteed enemies
for (int i = 0; i < output.Input.GuaranteedEnemiesByDifficulty.Length; ++i)
{
while (guaranteedEnemiesPlaced[i] < output.Input.GuaranteedEnemiesByDifficulty[i])
{
int enemyId = enemySelector.ChooseEnemyOfDifficulty(i);
guaranteedEnemiesPlaced[i] = guaranteedEnemiesPlaced[i] + 1;
++enemiesSpawned;
_enemySpawns.Add(new EnemySpawnGroup(findGoodOpenPosition(openTiles, output.Input.MinDistanceBetweenSpawns).integerVector, enemyId));
}
}
// Remaining enemies
for (; enemiesSpawned < this.NumEnemies; ++enemiesSpawned)
{
int enemyId = enemySelector.ChooseEnemy(difficulty);
_enemySpawns.Add(new EnemySpawnGroup(findGoodOpenPosition(openTiles, output.Input.MinDistanceBetweenSpawns).integerVector, enemyId));
}
// Players
if (spawnPlayers)
{
bool first = true;
List<LevelGenMap.Coordinate> tiles = openTiles;
for (int i = 0; i < DynamicData.MAX_PLAYERS; ++i)
{
if (DynamicData.GetSessionPlayer(i).HasJoined)
{
LevelGenMap.Coordinate playerSpawn = findGoodOpenPosition(tiles, 0);
_playerSpawns.Add(playerSpawn.integerVector);
if (first)
{
first = false;
List<LevelGenMap.Coordinate> nearbySpawns = new List<LevelGenMap.Coordinate>();
foreach (LevelGenMap.Coordinate coord in openTiles)
{
if (Mathf.Abs(coord.x - playerSpawn.x) + Mathf.Abs(coord.y - playerSpawn.y) <= this.MaxPlayerSpawnDistance)
nearbySpawns.Add(coord);
}
if (nearbySpawns.Count >= DynamicData.MAX_PLAYERS)
tiles = nearbySpawns;
}
else
{
openTiles.Remove(playerSpawn);
}
}
}
}
}
private int pickMaybeGuaranteedEnemy(int guaranteesSpawned, int totalGuarantees, int enemiesSpawned, int difficulty, int[] guaranteedEnemiesPlaced, LevelGenOutput output, EnemySelector enemySelector)
{
if (guaranteesSpawned < totalGuarantees && Random.Range(0, this.NumEnemies) < enemiesSpawned + (totalGuarantees - guaranteesSpawned))
{
// Use guarantee for united-spawn
int guaranteedDifficulty = 0;
for (int i = 0; i < guaranteedEnemiesPlaced.Length; ++i)
{
if (guaranteedEnemiesPlaced[i] < output.Input.GuaranteedEnemiesByDifficulty[i])
{
guaranteedDifficulty = i;
if (Random.value > 0.5f)
break;
}
}
return enemySelector.ChooseEnemyOfDifficulty(guaranteedDifficulty);
}
return enemySelector.ChooseEnemy(difficulty);
}
