void populate()
{
m_populateRetry = true;
var dx = new UniformIntDistribution(m_region.min.x, m_region.max.x);
var dy = new UniformIntDistribution(m_region.min.y, m_region.max.y);
var gen = new StaticRandomGenerator <DefaultRandomGenerator>();
var x = dx.Next(gen);
var y = dy.Next(gen);
if (m_snake != null && m_snake.haveNode(x, y))
{
return;
}
if (!m_populatableZone.Contains(TilemapInfos.instance.tileID(x, y)))
{
return;
}
var obj = Instantiate(m_powerupPrefab, new Vector3(x, y, -0.5f), Quaternion.identity);
m_currentPowerup = obj.GetComponent <SnakePowerupLogic>();
m_populateRetry = false;
}
protected void Fire(Vector2 direction)
{
if (m_projectilePrefab == null)
{
return;
}
var projectileObj = GameObject.Instantiate(m_projectilePrefab);
var projectile = projectileObj.GetComponent <BaseProjectile>();
if (projectile != null)
{
projectile.isPlayerProjectile = m_isPlayerWeapon;
projectile.SetDirection(direction);
float angle = Mathf.Atan2(direction.y, direction.x);
float cos = Mathf.Cos(angle);
float sin = Mathf.Sin(angle);
Vector2 pos = m_owner.transform.position;
var offset = m_ballsStatOffset;
if (angle < -Mathf.PI / 2 || angle > Mathf.PI / 2)
{
offset.y *= -1;
}
pos += new Vector2(offset.x * cos - offset.y * sin, offset.x * sin + offset.y * cos);
projectile.transform.position = pos;
if (m_isPlayerWeapon)
{
var stat = PlayerStats.Instance().GetStatValue("ProjectileSizeMultiplier");
projectile.transform.localScale = new Vector3(stat, stat, stat);
}
}
if (m_isPlayerWeapon)
{
PlayerStats.Instance().gold -= m_firePrice;
}
if (m_gunFire != null)
{
m_gunFire.SetActive(true);
DOVirtual.DelayedCall(0.1f, () =>
{
if (this == null)
{
return;
}
if (m_gunFire != null)
{
m_gunFire.SetActive(false);
}
});
}
var index = new UniformIntDistribution(0, m_bulletSounds.Count).Next(new StaticRandomGenerator <MT19937>());
SoundSystem.Instance().play(m_bulletSounds[index], 0.5f, true);
}
void InstantiateRoom(RoomGeneration r)
{
int nbRooms = 0;
for (int i = 0; i < m_roomPrefabs.Count; i++)
{
if (m_roomPrefabs[i].type == r.type)
{
nbRooms++;
}
}
int index = new UniformIntDistribution(0, nbRooms).Next(new StaticRandomGenerator <MT19937>()) + 1;
for (int i = 0; i < m_roomPrefabs.Count; i++)
{
if (m_roomPrefabs[i].type == r.type)
{
index--;
if (index == 0)
{
InstantiateRoom(r, m_roomPrefabs[i]);
break;
}
}
}
}
void CreateLoot()
{
if (m_loots.Count == 0 || m_lootCount <= 0)
{
return;
}
List <float> weights = new List <float>();
for (int i = 0; i < m_loots.Count; i++)
{
weights.Add(m_loots[i].weight);
}
for (int i = 0; i < m_lootCount; i++)
{
int index = new DiscreteDistribution(weights).Next(new StaticRandomGenerator <MT19937>());
int nb = new UniformIntDistribution(m_loots[index].countMin, m_loots[index].countMax + 1).Next(new StaticRandomGenerator <MT19937>());
for (int j = 0; j < nb; j++)
{
var obj = Instantiate(m_loots[index].dropPrefab);
obj.transform.position = transform.position + new Vector3(0, 0, 0.1f);
}
}
}
void populate()
{
Matrix <int> tiles = new Matrix <int>(-1);
var rand = new StaticRandomGenerator <DefaultRandomGenerator>();
var d = new UniformIntDistribution(m_tiles.Count() - 1);
for (int i = m_bounds.min.x; i <= m_bounds.max.x; i++)
{
for (int j = m_bounds.min.y; j < m_bounds.max.y; j++)
{
tiles.set(i, j, d.Next(rand));
}
}
for (int i = m_bounds.min.x; i <= m_bounds.max.x; i++)
{
for (int j = m_bounds.min.y; j < m_bounds.max.y; j++)
{
if (m_tilemap.GetTile(new Vector3Int(i, j, 0)) == null)
{
m_tilemap.SetTile(new Vector3Int(i, j, 0), m_tiles[tiles.get(i, j)]);
}
}
}
}
public void Spawn()
{
int index = new UniformIntDistribution(0, m_prefabs.Count).Next(new StaticRandomGenerator <MT19937>());
var obj = Instantiate(m_prefabs[index]);
obj.transform.position = transform.position;
}
void Start()
{
if (m_items.Count == 0)
{
return;
}
var index = new UniformIntDistribution(0, m_items.Count).Next(new StaticRandomGenerator <MT19937>());
var obj = Instantiate(m_items[index]);
obj.transform.position = transform.position;
}
void startButtons()
{
float multiplier = 1 + m_currentTime / m_timeReductionDelay;
var gen = new StaticRandomGenerator <DefaultRandomGenerator>();
float multiButtonProbability = Mathf.Min(m_maxMultipleButtonChance, m_multipleButtonChance * multiplier);
var dMultibutton = new BernoulliDistribution(multiButtonProbability);
var dButtons = new UniformIntDistribution(m_buttons.Count - 1);
do
{
m_buttons[dButtons.Next(gen)].startButton(m_buttonActionTime);
}while (dMultibutton.Next(gen));
selectNextDelay();
}
void Update()
{
m_input.x = Input.GetAxis(horizontalInputName);
m_input.y = Input.GetAxis(verticalInputName);
var magnitude = m_input.magnitude;
if (magnitude > 1.0f)
{
m_input /= magnitude;
}
m_invincibleTime -= Time.deltaTime;
var color = Color.black;
if (m_invincibleTime > 0)
{
float colorValue = Mathf.Sin(m_invincibleTime * m_blinkTime) * 0.5f + 0.5f;
color = new Color(colorValue, colorValue, colorValue);
}
var renders = m_visual.GetComponentsInChildren <SpriteRenderer>();
for (int i = 0; i < renders.Length; i++)
{
renders[i].material.SetColor("_AdditiveColor", color);
}
Vector2 pos = transform.position;
m_totalDistance += (pos - m_oldPosition).magnitude;
if (m_totalDistance > m_stepDistance)
{
m_totalDistance -= m_stepDistance;
int index = new UniformIntDistribution(0, m_footSteps.Count).Next(new StaticRandomGenerator <MT19937>());
SoundSystem.Instance().play(m_footSteps[index], 0.05f, true);
}
m_oldPosition = pos;
}
void placeImportantPoints(IRandomGenerator gen)
{
var tiles = LevelMap.instance.tiles;
LevelMap.instance.importantPoints.Clear();
var dx = new UniformIntDistribution(2, m_properties.width - 3);
var dy = new UniformIntDistribution(2, m_properties.height - 3);
var dPoint = new UniformIntDistribution(m_importantPoints.Count - 1);
var dRot = new UniformIntDistribution(3);
for (int i = 0; i < m_properties.importantPointCount; i++)
{
for (int j = 0; j < m_properties.maxImportantPointsTry; j++)
{
var x = dx.Next(gen);
var y = dy.Next(gen);
bool ok = true;
foreach (var p in LevelMap.instance.importantPoints)
{
if (new Vector2(x - p.x, y - p.y).magnitude > m_properties.minImportantPointDistance)
{
continue;
}
ok = false;
break;
}
if (!ok)
{
continue;
}
var localMap = tiles.getLocal(x, y);
if (localMap.get(0, 0) != localMap.get(0, 1) || localMap.get(0, 0) != localMap.get(0, 1) ||
localMap.get(0, 0) != localMap.get(0, 1) || localMap.get(0, 0) != localMap.get(0, 1) || localMap.get(0, 0) != localMap.get(0, 1) ||
localMap.get(0, 0) != localMap.get(0, 1) || localMap.get(0, 0) != localMap.get(0, 1) || localMap.get(0, 0) != localMap.get(0, 1))
{
continue;
}
var point = m_importantPoints[dPoint.Next(gen)];
if (point.biome != localMap.get(0, 0))
{
continue;
}
var obj = Instantiate(point.prefab, m_properties.zoneParent);
obj.transform.localPosition = new Vector3(2 * x, 0, 2 * y);
obj.transform.localRotation = Quaternion.Euler(0, dRot.Next(gen) * 90, 0);
ImportantPointInfos iP = new ImportantPointInfos();
iP.x = x;
iP.y = y;
iP.name = point.name;
LevelMap.instance.importantPoints.Add(iP);
break;
}
}
}
public void TestInvalidQuantile(double probability)
{
Assert.Throws <ArgumentException>(
() => _ = new UniformIntDistribution(1, 2).Quantile(probability));
}
public void TestConstructInvalid()
{
Assert.Throws <ArgumentException>(() => _ = new UniformIntDistribution(2, 1));
}
static void makeRivers(PlanetData planet, IRandomGenerator gen, int riverNb, int riverTestCount)
{
var dStart = new UniformIntDistribution(0, planet.points.Length - 1);
int oceanBiomeIndex = -1;
int lakeBiomeIndex = -1;
for (int i = 0; i < planet.biomes.Length; i++)
{
if (planet.biomes[i].isLakeBiome)
{
lakeBiomeIndex = i;
}
if (planet.biomes[i].isOceanBiome)
{
oceanBiomeIndex = i;
}
}
for (int i = 0; i < riverNb; i++)
{
int currentIndex = -1;
for (int j = 0; j < riverTestCount; j++)
{
int index = dStart.Next(gen);
bool isOk = true;
if (planet.points[index].biomeID >= 0 || planet.points[index].riverInfo.isRiver())
{
isOk = false;
}
foreach (int p in planet.points[index].connectedPoints)
{
if (planet.points[p].biomeID >= 0 || planet.points[p].riverInfo.isRiver())
{
isOk = false;
}
}
if (isOk && (currentIndex < 0 || planet.points[currentIndex].height < planet.points[index].height))
{
currentIndex = index;
}
}
if (currentIndex < 0)
{
continue;
}
planet.points[currentIndex].riverInfo.width = 1;
while (true)
{
int nextPoint = -1;
foreach (var p in planet.points[currentIndex].connectedPoints)
{
if (nextPoint < 0 || planet.points[nextPoint].height > planet.points[p].height)
{
nextPoint = p;
}
}
if (planet.points[nextPoint].height > planet.points[currentIndex].height)
{
break;
}
if (planet.points[nextPoint].biomeID == oceanBiomeIndex && oceanBiomeIndex >= 0)
{
break;
}
planet.points[currentIndex].riverInfo.nextIndex = nextPoint;
planet.points[nextPoint].riverInfo.previousIndexs.Add(currentIndex);
if (planet.points[nextPoint].riverInfo.isRiver())
{
int current = nextPoint;
float width = planet.points[current].riverInfo.width;
do
{
planet.points[current].riverInfo.width += width;
current = planet.points[current].riverInfo.nextIndex;
}while (current >= 0);
}
planet.points[nextPoint].riverInfo.width = planet.points[currentIndex].riverInfo.width + 1;
currentIndex = nextPoint;
if (planet.points[nextPoint].biomeID == lakeBiomeIndex && lakeBiomeIndex >= 0)
{
break;
}
}
}
float maxWidth = 0;
for (int i = 0; i < planet.points.Length; i++)
{
maxWidth = Mathf.Max(maxWidth, planet.points[i].riverInfo.width);
}
for (int i = 0; i < planet.points.Length; i++)
{
planet.points[i].riverInfo.width /= maxWidth;
}
}
void RealyStartSpawning()
{
m_time = m_spawningTime;
m_velocity = new Vector2(0, 0);
var rand = new StaticRandomGenerator <MT19937>();
float spawnMultiplier = m_isPowered ? m_poweredSpawnMultiplier : 1;
int spawnNb = Mathf.RoundToInt(new UniformIntDistribution(m_minSpawnNb, m_maxSpawnNb + 1).Next(rand) * spawnMultiplier);
if (spawnNb > 0)
{
var pos = transform.position;
float angle = new UniformFloatDistribution(0, Mathf.PI * 2).Next(rand);
float minAngle = Mathf.PI / spawnNb / 2;
float maxAngle = minAngle * 4;
int tryCount = 0;
for (int i = 0; i < spawnNb; i++)
{
var dir = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * new UniformFloatDistribution(m_minSpawnDistance, m_maxSpawnDistance).Next(rand);
var ray = Physics2D.Raycast(transform.position, dir, dir.magnitude, LayerMask.GetMask("Default"));
if (ray.collider != null)
{
tryCount++;
if (tryCount < 10)
{
i--;
}
else
{
tryCount = 0;
}
}
else
{
tryCount = 0;
DOVirtual.DelayedCall(new UniformFloatDistribution(m_minSpawnDelay, m_maxSpawnDelay).Next(rand), () =>
{
if (this == null)
{
return;
}
DOVirtual.DelayedCall(0.3f, () =>
{
if (this == null)
{
return;
}
var index = new UniformIntDistribution(0, m_entities.Count).Next(rand);
var obj = Instantiate(m_entities[index]);
obj.transform.position = pos + new Vector3(dir.x, dir.y);
});
if (m_spawnFx != null)
{
var fx = Instantiate(m_spawnFx);
fx.transform.position = pos + new Vector3(dir.x, dir.y, -0.1f);
Destroy(fx, 2);
}
SoundSystem.Instance().play(m_spawnSound, 0.5f, true);
});
}
angle += new UniformFloatDistribution(minAngle, maxAngle).Next(rand);
}
}
m_animator.SetTrigger("Invoke");
m_state = State.Spawning;
}
void placeBordeaux(IRandomGenerator gen)
{
var tiles = LevelMap.instance.tiles;
var dx = new UniformIntDistribution(2, m_properties.width - 3);
var dy = new UniformIntDistribution(2, m_properties.height - 3);
var dRot = new UniformIntDistribution(3);
bool bdxSet = false;
for (int j = 0; j < m_properties.maxImportantPointsTry; j++)
{
var x = dx.Next(gen);
var y = dy.Next(gen);
bool ok = true;
foreach (var p in LevelMap.instance.importantPoints)
{
if (new Vector2(x - p.x, y - p.y).magnitude > m_properties.minImportantPointDistance)
{
continue;
}
ok = false;
break;
}
if (!ok)
{
continue;
}
var localMap = tiles.getLocal(x, y);
if (localMap.get(0, 0) != localMap.get(0, 1) || localMap.get(0, 0) != localMap.get(0, 2) ||
localMap.get(0, 0) != localMap.get(1, 0) || localMap.get(0, 0) != localMap.get(1, 1) || localMap.get(1, 2) != localMap.get(0, 1) ||
localMap.get(0, 0) != localMap.get(2, 0) || localMap.get(0, 0) != localMap.get(2, 1) || localMap.get(2, 2) != localMap.get(0, 1))
{
continue;
}
if (localMap.get(0, 0) != Biome.Land)
{
continue;
}
var obj = Instantiate(m_bordeauxPrefab, m_properties.zoneParent);
obj.transform.localPosition = new Vector3(2 * x, 0, 2 * y);
obj.transform.localRotation = Quaternion.Euler(0, dRot.Next(gen) * 90, 0);
ImportantPointInfos iP = new ImportantPointInfos();
iP.x = x;
iP.y = y;
iP.name = "Bordeaux";
LevelMap.instance.bordeaux = iP;
bdxSet = true;
break;
}
if (!bdxSet)
{
var x = dx.Next(gen);
var y = dy.Next(gen);
var obj = Instantiate(m_bordeauxPrefab, m_properties.zoneParent);
obj.transform.localPosition = new Vector3(2 * x, 0, 2 * y);
obj.transform.localRotation = Quaternion.Euler(0, dRot.Next(gen) * 90, 0);
ImportantPointInfos iP = new ImportantPointInfos();
iP.x = x;
iP.y = y;
iP.name = "bordeaux";
LevelMap.instance.bordeaux = iP;
}
}
bool CreateNewRoomAround(int index, List <RoomGeneration> rooms)
{
int nbDoors = 0;
var r = rooms[index];
var pos = new Vector2Int(r.x, r.y);
if (CanGo(pos + new Vector2Int(0, -1), rooms))
{
nbDoors++;
}
if (CanGo(pos + new Vector2Int(0, 1), rooms))
{
nbDoors++;
}
if (CanGo(pos + new Vector2Int(-1, 0), rooms))
{
nbDoors++;
}
if (CanGo(pos + new Vector2Int(1, 0), rooms))
{
nbDoors++;
}
if (nbDoors == 0)
{
return(false);
}
RoomGeneration nextRoom = new RoomGeneration();
nbDoors = new UniformIntDistribution(0, nbDoors).Next(new StaticRandomGenerator <MT19937>()) + 1;
if (CanGo(pos + new Vector2Int(0, 1), rooms))
{
nbDoors--;
}
if (nbDoors == 0)
{
r.upDoor = true;
nextRoom.downDoor = true;
pos.y++;
}
else
{
if (CanGo(pos + new Vector2Int(0, -1), rooms))
{
nbDoors--;
}
if (nbDoors == 0)
{
r.downDoor = true;
nextRoom.upDoor = true;
pos.y--;
}
else
{
if (CanGo(pos + new Vector2Int(-1, 0), rooms))
{
nbDoors--;
}
if (nbDoors == 0)
{
r.leftDoor = true;
nextRoom.rightDoor = true;
pos.x--;
}
else
{
if (CanGo(pos + new Vector2Int(1, 0), rooms))
{
nbDoors--;
}
if (nbDoors == 0)
{
r.rightDoor = true;
nextRoom.leftDoor = true;
pos.x++;
}
}
}
}
nextRoom.x = pos.x;
nextRoom.y = pos.y;
rooms.Add(nextRoom);
return(true);
}
void Start()
{
List <RoomGeneration> rooms = new List <RoomGeneration>();
RoomGeneration baseRoom = new RoomGeneration();
baseRoom.type = RoomType.StartRoom;
rooms.Add(baseRoom);
int roomOffset = Mathf.FloorToInt(m_roomCount * m_spawnOffset);
while (rooms.Count < m_roomCount)
{
int minIndex = rooms.Count - 1 - roomOffset;
if (minIndex < 0)
{
minIndex = 0;
}
int maxIndex = rooms.Count;
int startIndex = new UniformIntDistribution(minIndex, maxIndex).Next(new StaticRandomGenerator <MT19937>());
if (startIndex >= rooms.Count)
{
startIndex = rooms.Count - 1;
}
bool found = false;
for (int i = startIndex; i < rooms.Count; i++)
{
if (CreateNewRoomAround(i, rooms))
{
found = true;
break;
}
}
if (!found)
{
for (int i = startIndex - 1; i > 0; i--)
{
if (CreateNewRoomAround(i, rooms))
{
found = true;
break;
}
}
}
if (!found)
{
break;
}
}
CreateBossRoom(rooms);
rooms[rooms.Count - 1].type = RoomType.BossRoom;
for (int i = 0; i < m_shopRoomCount; i++)
{
int validRoomCount = m_roomCount - 2 - i;
int index = new UniformIntDistribution(0, validRoomCount).Next(new StaticRandomGenerator <MT19937>()) + 1;
for (int j = 0; j < rooms.Count; j++)
{
if (rooms[j].type == RoomType.DefaultRoom)
{
index--;
}
if (index == 0)
{
rooms[j].type = RoomType.ShopRoom;
break;
}
}
}
for (int i = 0; i < rooms.Count; i++)
{
InstantiateRoom(rooms[i]);
}
m_rooms[0].discovered = true;
Event <UpdateMinimapEvent> .Broadcast(new UpdateMinimapEvent(m_rooms, m_currentRoom));
}
