private void SpawnEnemyAt(int x, int z, string name = "")
{
var spawnLoc = new Vector2Int(x, z);
var rand = SeededRandom.Range(1, 4);
GameObject newEnemy;
switch (rand)
{
case 1:
newEnemy = EnemySpawner.SpawnArcher(spawnLoc);
break;
case 2:
newEnemy = EnemySpawner.SpawnBrute(spawnLoc);
break;
default:
newEnemy = EnemySpawner.SpawnBasicMeleeEnemy(spawnLoc);
break;
}
var enemyBody = newEnemy.GetComponent <EnemyBody>();
enemies.Add(enemyBody);
enemyBody.name = "EnemyID: " + enemies.Count;
PlaceObjectOn(spawnLoc.x, spawnLoc.y, enemyBody);
}
public void SetSize()
{
var width = SeededRandom.Range(Info.MinWidth, Info.MaxWidth);
var height = SeededRandom.Range(Info.MinHeight, Info.MaxHeight);
Bounds.Resize(width, height);
}
private void SpawnMoneyAt(int x, int z)
{
GameObject moneyObj = ItemSpawner.SpawnMoney(new Vector2Int(x, z));
DroppedMoney newMoneyBloodMoney = moneyObj.GetComponent <DroppedMoney>();
int amount = SeededRandom.Range(10, 20); // Technically, the amount of money can change if you swap floors. Hopefully nobody notices.
newMoneyBloodMoney.Initialize(amount); // Set how much this is worth
newMoneyBloodMoney.xPos = x;
newMoneyBloodMoney.zPos = z;
map[x, z].SetItemOnTile(newMoneyBloodMoney);
}
protected virtual bool PlaceExit(Room prev, float direction, float pathVariance)
{
var res = AttemptToPlaceRoom(prev, exit, direction + SeededRandom.Range(-pathVariance, pathVariance));
if (res != -1)
{
PlacedRooms.Add(exit);
return(true);
}
else
{
return(false);
}
}
protected override bool PlaceExit(Room prev, float direction, float pathVariance)
{
var res = AttemptToPlaceRoom(prev, BossRoom, direction + SeededRandom.Range(-pathVariance, pathVariance));
if (res != -1)
{
PlacedRooms.Add(BossRoom);
return(base.PlaceExit(BossRoom, direction, pathVariance));
}
else
{
return(false);
}
}
public static Tile GetRandomTopWallDecoration()
{
int rand = SeededRandom.Range(0, 3);
switch (rand)
{
case 0:
return(Ring[0]);
case 1:
return(Ring[1]);
case 2:
default:
return(Flag);
}
}
public static Tile GetRandomFloorDecoration()
{
int rand = SeededRandom.Range(0, 4);
switch (rand)
{
case 0:
return(Bones);
case 1:
return(Boxes[0]);
case 2:
return(Boxes[1]);
case 3:
default:
return(Skull);
}
}
private List <int> GetBossFloors()
{
//Last floor should always be a boss
var floors = NumberOfFloors - 1;
var bosses = NumberOfBosses - 1;
var res = new List <int>();
while (bosses > 0 && res.Count != floors)
{
var randomInt = SeededRandom.Range(0, floors);
if (!res.Contains(randomInt))
{
res.Add(randomInt);
bosses--;
}
}
res.Add(NumberOfFloors - 1);
return(res);
}
protected void CreateBranches(List <Room> roomsToBranch)
{
Debug.Log($"Number of rooms to branch: {roomsToBranch.Count}");
var currentBranch = new List <Room>();
var i = 0;
while (i < roomsToBranch.Count)
{
currentBranch.Clear();
var room = roomsToBranch[i];
var curr = SeededRandom.PickRandom(branchable);
var numConnections = SeededRandom.PickRandom(branchConnectionLength);
currentBranch = TryCreateBranch(room, curr, numConnections);
if (currentBranch.Count != numConnections + 1)
{
continue;
}
foreach (var branched in currentBranch)
{
if (branched.Info.MaxConnections > 1 && SeededRandom.RandBool(.3f))
{
if (branched is StandardRoom)
{
for (int j = 0; j < SeededRandom.Range(1, 4); j++)
{
branchable.Add(branched);
}
}
else
{
branchable.Add(branched);
}
}
}
i++;
}
}
protected virtual List <Room> InitRooms()
{
var rooms = new List <Room>();
Entrance = new Entrance();
Exit = new Exit();
rooms.Add(Entrance);
rooms.Add(Exit);
for (int i = 0; i < CustomRun.instance.RoomsPerFloor - 2; i++)
{
rooms.Add(new StandardRoom());
}
var randomInt = SeededRandom.Range(0, rooms.Count);
rooms.Insert(randomInt, new LargeSqaureRoom());
rooms.Add(new CoinRoom());
//for (int i = 0; i < 2; i++)
//{
// rooms.Add(new SpecialRoom());
//}
return(rooms);
}
public override bool Build(List <Room> rooms)
{
this.Rooms = rooms;
InitBuilder();
if (entrance == null || exit == null)
{
return(false);
}
float direction = SeededRandom.RandomDirection();
entrance.SetSize();
entrance.Bounds.SetPosition(0, 0);
PlacedRooms.Add(entrance);
branchable.Add(entrance);
int roomsOnPath = (int)(multiConnections.Count * pathLengthPercentage) + SeededRandom.PickRandom(pathLengthJitters);
roomsOnPath = Math.Min(roomsOnPath, multiConnections.Count);
float pathVariance = 15;
var curr = entrance;
float res;
int rejected = 0;
for (int i = 0; i < roomsOnPath; i++)
{
for (int j = 0; j < SeededRandom.PickRandom(pathConnectionLength); j++)
{
var connectionRoom = new ConnectionRoom();
res = AttemptToPlaceRoom(curr, connectionRoom, direction + SeededRandom.Range(-pathVariance, pathVariance));
if (res != -1)
{
PlacedRooms.Add(connectionRoom);
branchable.Add(connectionRoom);
curr = connectionRoom;
}
else
{
rejected++;
}
}
var next = multiConnections[i];
res = AttemptToPlaceRoom(curr, next, direction + SeededRandom.Range(-pathVariance, pathVariance));
if (res != -1)
{
PlacedRooms.Add(next);
branchable.Add(next);
curr = next;
}
else
{
rejected++;
}
}
for (int j = 0; j < SeededRandom.PickRandom(pathConnectionLength); j++)
{
var connectionRoom = new ConnectionRoom();
res = AttemptToPlaceRoom(curr, connectionRoom, direction + SeededRandom.Range(-pathVariance, pathVariance));
if (res != -1)
{
PlacedRooms.Add(connectionRoom);
branchable.Add(connectionRoom);
curr = connectionRoom;
}
else
{
rejected++;
}
}
if (!PlaceExit(curr, direction, pathVariance))
{
return(false);
}
var roomsToBranch = GetRoomsToBranch(roomsOnPath);
CreateBranches(roomsToBranch);
FindNeighbours();
return(true);
}
void Start()
{
rotateSpeed = new Vector3(SeededRandom.Range(rotationSpeed.minOffset.x, rotationSpeed.maxOffset.x),
SeededRandom.Range(rotationSpeed.minOffset.y, rotationSpeed.maxOffset.y),
SeededRandom.Range(rotationSpeed.minOffset.z, rotationSpeed.maxOffset.z));
}
public static Vector3 RandomPositionInView(float margin)
{
return(new Vector3(SeededRandom.Range(trueBottomLeft.x + margin, trueTopRight.x - margin), SeededRandom.Range(trueBottomLeft.y + margin, trueTopRight.y - margin), 0f));
}
/// <summary>
/// Spawns object(s).
/// </summary>
void MultiSpawn()
{
// Get base range
float min = Mathf.Abs(maxAngleOfEntryOffset - minAngleOfEntryOffset) / 2f;
float max = -min;
// Get angular distance between object spawns
float separation = Mathf.Abs(maxAngleOfEntryOffset - minAngleOfEntryOffset) + angularSeparation;
// Get starting angle
float baseAngle = angleOfEntry;
switch (angleOfEntryType)
{
// AngleOfEntryType.FixedAngle not needed
case AngleOfEntryType.WaveDirection:
baseAngle = SpaceObjectDirection.GetAngle();
break;
case AngleOfEntryType.RandomAngle:
baseAngle = SeededRandom.Range(0f, Mathf.PI * 2f);
break;
}
baseAngle += (Mathf.Abs(minAngleOfEntryOffset) + max) * SeededRandom.Sign();
float angle = baseAngle + SeededRandom.Range(min, max);
// We have our start position
Vector3 start = Screen.GetRadiusEdge(angle);
if (angleOfEntryType == AngleOfEntryType.FixedPosition)
{
start = fixedPosition;
}
else if (angleOfEntryType == AngleOfEntryType.RandomPosition)
{
start = Screen.RandomPositionInView(4f);
}
// Decide on target
Vector3 target = DecideTarget(start);
float baseTargetAngle = GetTargetAngle(start, target);
float targetAngle = SeededRandom.Range(minTargetOffset, maxTargetOffset) * SeededRandom.Sign() + baseTargetAngle;
// Always spawn 1
Spawn(start, targetAngle);
// Loop through all spawns
for (int i = 1; i < SeededRandom.Range(minMultiSpawns, maxMultiSpawns + 1); i++)
{
// Get positional modifier
int modifier = (i + 1) / 2;
if (i % 2 == 0)
{
modifier *= -1;
}
// Base angle for current spawn
angle = (separation * modifier) + baseAngle + SeededRandom.Range(min, max);
start = Screen.GetRadiusEdge(angle);
// Do we need to pick another base angle?
if (!parallel)
{
target = DecideTarget(start);
baseTargetAngle = GetTargetAngle(start, target);
}
targetAngle = SeededRandom.Range(minTargetOffset, maxTargetOffset) * SeededRandom.Sign() + baseTargetAngle;
Spawn(start, targetAngle);
}
}
/// <summary>
/// Spawn the specified offset and baseAngle.
/// </summary>
/// <param name="offset">Offset. The index of the multispawn at which this spawn is.</param>
/// <param name="baseAngle">Base angle. The angle all multispawn objects will be based on.</param>
void Spawn(int offset, float baseAngle)
{
Vector3 oldPosition = transform.position;
float corrector;
Vector3 corrected = transform.position;
if (spawnAlignment.x != 0f)
{
corrector = Mathf.Ceil(transform.position.x / spawnAlignment.x);
corrected.x = corrector * spawnAlignment.x;
}
if (spawnAlignment.y != 0f)
{
corrector = Mathf.Ceil(transform.position.y / spawnAlignment.y);
corrected.y = corrector * spawnAlignment.y;
}
if (spawnAlignment.z != 0f)
{
corrector = Mathf.Ceil(transform.position.z / spawnAlignment.z);
corrected.z = corrector * spawnAlignment.z;
}
transform.position = corrected;
// Get the angle at which to spawn
int adapter = Mathf.FloorToInt((offset + 1) / 2f) * Global.signs [offset % 2];
float angle = (angularSeparation) * adapter + baseAngle;
// Pre rotate so transform.up becomes usable
transform.eulerAngles = new Vector3(0f, 0f, (baseAngle + (Mathf.PI * 0.5f)) * Mathf.Rad2Deg);
// Decide starting position
// SpaceObjectSpawnType.Predefined not needed in switch
switch (spawnType)
{
case SpaceObjectSpawnType.Parallel:
transform.position = Screen.GetRadiusEdge(angle);
break;
}
corrected = adapter * gridSeparation;
transform.position += corrected;
// Add random offset to start position
transform.position = new Vector3(transform.position.x - SeededRandom.Range(spawnOffsets.minOffset.x, spawnOffsets.maxOffset.x),
transform.position.y - SeededRandom.Range(spawnOffsets.minOffset.y, spawnOffsets.maxOffset.y),
transform.position.z - SeededRandom.Range(spawnOffsets.minOffset.z, spawnOffsets.maxOffset.z));
Vector3 targetPoint = predefinedTrajectory;
// SpaceObjectTrajectoryType.Predefined no needed in switch
switch (trajectoryType)
{
case SpaceObjectTrajectoryType.Targeted:
// Pick a random target, if none exists, use predefined targetPoint
GameObject target = ShipContainer.GetSpaceShip(SeededRandom.Range(0, 25));
if (target != null)
{
targetPoint = target.transform.position;
}
break;
case SpaceObjectTrajectoryType.TargetOpposite:
// Set target to the opposite of the screen, multispawns will move parallel
targetPoint = Screen.GetScreenEdge(transform.position, transform.up);
break;
case SpaceObjectTrajectoryType.TargetOppositeX:
targetPoint = transform.position;
targetPoint.x *= -1f;
break;
case SpaceObjectTrajectoryType.TargetOppositeY:
targetPoint = transform.position;
targetPoint.y *= -1f;
break;
case SpaceObjectTrajectoryType.TargetZero:
targetPoint = Vector3.zero;
break;
}
GameObject newObject = Instantiate(prefab) as GameObject;
Movement movement = newObject.GetComponent <Movement> ();
if (movement)
{
movement.SetTarget(targetPoint);
}
targetPoint -= transform.position;
transform.eulerAngles = new Vector3(0f, 0f, Mathf.Atan2(targetPoint.y, targetPoint.x) * Mathf.Rad2Deg + 270f);
newObject.transform.parent = transform.parent;
newObject.transform.position = transform.position;
newObject.transform.rotation = transform.rotation;
transform.position = oldPosition;
}
