// Update is called once per frame
void Update()
{
for (short z = 0; z < 30; z++)
{
Vector3 topRight = myCamera.ViewportToWorldPoint(new Vector3(1, 1, z));
Vector3 topLeft = myCamera.ViewportToWorldPoint(new Vector3(0, 1, z));
Vector3 bottomRight = myCamera.ViewportToWorldPoint(new Vector3(1, 0, z));
Vector3 bottomLeft = myCamera.ViewportToWorldPoint(new Vector3(0, 0, z));
// short startX = (short)topLeft.x;
// short startY = (short)bottomLeft.y;
// short endX = (short)topRight.x;
// short endY = (short)topLeft.y;
// short cameraWidth = MathF.abs(endX - startX);
// short cameraHeight = MathF.abs(endY - startY);
/*print(topRight);
* print(topLeft);
* print(bottomRight);
* print(bottomLeft);*/
for (short x = (short)topLeft.x; x < topRight.x; x++)
{
for (short y = (short)bottomLeft.y; y < topLeft.y; y++)
{
// for (short z = i; z < 21; z++)
// {
if (x % sectorWidth == 0 && y % sectorWidth == 0)
{
ushort posY = (ushort)y;
ushort posZ = (ushort)topRight.z;
long seed = (long)x << 32 | (long)posY << 16 | (long)posZ;
randGen = new Lehmer(seed);
long rand = randGen.randomInt(1, 1000);
bool starExists = rand == 1;
if (starExists && !Physics.CheckSphere(new Vector3(x, y, (short)topRight.z), sectorWidth / 2f))
{
GameObject planet = Instantiate(myPrefab, new Vector3(x, y, (short)topRight.z), Quaternion.identity);
float scale = randGen.randomInt(1, 100) / 100f;
planet.transform.localScale = new Vector3(scale * sectorWidth, scale * sectorWidth, scale * sectorWidth);
// print(planet.transform.localScale);
}
}
// }
}
}
}
}
void InitProps(bool isAI)
{
// init BoldiCount
SetBoldiCount(isAI ? c_StartBoldiCountForAIs : Lehmer.Range(0, 50));
// scale according to start BoldiCount
SetScale(Vector3.one * (1.0f + m_BoldiCount * c_ScalePerBoldi));
// manage grow rate
m_GrowRate = 1.0f + m_BoldiCount * c_GrowPerBoldi;
m_GrowTimer.StartTimer(1.0f / m_GrowRate);
}
void LaunchRandom()
{
// find a home which is mine
IHome[] myHomes = m_Gameboard.GetHomes(TeamId, true);
IHome[] theirHomes = m_Gameboard.GetHomes(TeamId, false);
// launch boldies
if (myHomes.Length > 0 && theirHomes.Length > 0)
{
IHome from = myHomes[Lehmer.Range(0, myHomes.Length)];
IHome to = theirHomes[Lehmer.Range(0, theirHomes.Length)];
EAmount amount = (EAmount)Lehmer.Range(0, (int)EAmount.Count);
LaunchBoldies(from, to, amount);
}
}
void CreateHomes(Vector3 bounds)
{
// create random buffer
IntBufferedRandom rnd = new IntBufferedRandom();
rnd.AddValueRange(0, c_GridSize * c_GridSize);
rnd.Range = Lehmer.Range;
// create homes
int homeCount = Lehmer.Range(c_MinHomeCount, c_GridSize * c_GridSize);
for (int i = 0; i < homeCount; ++i)
{
CreateHome(GetPosition(rnd.DrawValue(), bounds));
}
}
private void AutoGenerate(object stack)
{
uint multiplier, initialValue, divider;
bool correctData, validPeriod;// flags
int period, aperiodicity;
double estimation;
IEnumerable <double> normalizedSequence;
Mediator md;
do
{
(multiplier, initialValue, divider) = Lehmer.GenerateRandomParameters();
RunCore(out md, multiplier, initialValue, divider, out normalizedSequence,
out estimation, out period, out aperiodicity);
validPeriod = md.CheckIndirectEstimation(estimation, 0.001);
correctData = period > 50_000;
} while (!correctData || !validPeriod);
UpdateTextboxes(multiplier, initialValue, divider);
UpdateView(md, normalizedSequence, stack, estimation, period, aperiodicity);
}
void Update()
{
if (!GameManager.Instance.dead)
{
while (levelCount < MaxSpawn)
{
Level s_Level = Instantiate(g_Level.gameObject, transform).GetComponent <Level>();
s_Level.name = "Level " + level;
level++;
if (curLevel != null)
{
s_Level.Obstacle = true;
if (!firstWall)
{
int j = 0;
for (int i = 1; i < 4; i++)
{
if (i != ((side + 2) % 4) && i != ((side + 2) % 4))
{
availableSides[j] = i;
j++;
}
}
side = availableSides[(int)(Lehmer.Next() * j)];
}
else
{
side = 2;
firstWall = false;
}
Wall_Door prev = GetWall(curLevel, side);
Wall_Door next = GetWall(s_Level, (side + 2) % 4);
prev.Opened = true;
next.Opened = true;
next.Entrance = true;
switch (side)
{
case 1:
pos.x += LevelUnits;
break;
case 2:
pos.z += LevelUnits;
break;
case 3:
pos.x -= LevelUnits;
break;
}
}
s_Level.transform.position = pos;
curLevel = s_Level;
levels.Add(s_Level);
levelCount++;
}
}
}
void StartTimer()
{
m_Timer.StartTimer(Lehmer.Range(2.0f, 5.0f));
}
void CommmitDirtyData(DirtyData dirtyData, CommitItems commitItems)
{
lock (_revenueLock)
{
foreach (var tick in dirtyData.DirtyRevenueTicks)
{
var revenues = GetRevenueReceivers(tick);
_revenueReceiversStroage.UpdateEntry(tick, revenues.ToByteArray());
_revenueReceiversStroage.LastAvailableTick = Math.Max(tick, _revenueReceiversStroage.LastAvailableTick);
}
var last = GetRevenueReceivers(_revenueReceiversStroage.LastAvailableTick);
if (last != null)
{
var previous = GetRevenueReceivers(last.PreviousTick);
var lastProcessed = _revenueReceiversStroage.LastProcessedTick;
while (previous != null)
{
if (previous.Tick <= lastProcessed)
{
break;
}
var tick = previous.Tick;
var accounts = previous.Accounts;
var count = accounts.Count;
var revenueInfo = previous.RevenueInfo;
var tickRevenue = revenueInfo.Revenue * revenueInfo.AccountRevenueFactor;
var accountRevenue = tickRevenue / count;
var maxCount = tickRevenue / Currency.OneCen;
if (count > maxCount)
{
var list = new List <long>(accounts);
list.Sort((a, b) => a.CompareTo(b));
var rand = new Lehmer(count);
for (var i = 0; i < count; i++)
{
var a = rand.Next(count);
var tmp = list[i];
list[i] = list[a];
list[a] = tmp;
}
for (var i = 0; i < maxCount; i++)
{
var accountId = list[i];
var account = GetMaintainAccount(accountId);
account.AddRevenue(tick, (int)Currency.OneCen);
commitItems.DirtyAccounts.Add(accountId);
}
}
else
{
foreach (var accountId in accounts)
{
var account = GetMaintainAccount(accountId);
account.AddRevenue(tick, accountRevenue);
commitItems.DirtyAccounts.Add(accountId);
}
}
previous = GetRevenueReceivers(previous.PreviousTick);
}
_revenueReceiversStroage.LastProcessedTick = last.PreviousTick;
}
}
foreach (var accountId in commitItems.DirtyAccounts)
{
var account = GetMaintainAccount(accountId);
_maintainAccountStorage.UpdateEntry(accountId, account.ToByteArray());
}
}
GameObject OffsetPrefab(PrefabSet sectionItem, GameObject obs)
{
Vector3 ori = obs.transform.position;
Vector3 pos = ori;
if (sectionItem.Origin != OriginPara.Center)
{
float xo = 0;
float yo = 0;
switch (sectionItem.Origin)
{
case OriginPara.NorthEast:
xo = levelUnits / 2;
yo = levelUnits / 2;
break;
case OriginPara.NorthWest:
xo = -levelUnits / 2;
yo = levelUnits / 2;
break;
case OriginPara.SouthEast:
xo = levelUnits / 2;
yo = -levelUnits / 2;
break;
case OriginPara.SouthWest:
xo = -levelUnits / 2;
yo = -levelUnits / 2;
break;
case OriginPara.RandomCorner:
xo = levelUnits / 2 * ((Lehmer.Next() > 0.5) ? -1 : 1);
yo = levelUnits / 2 * ((Lehmer.Next() > 0.5) ? -1 : 1);
break;
case OriginPara.Random:
if (Lehmer.Next() > 0.5)
{
xo = levelUnits / 2 * ((Lehmer.Next() > 0.5) ? -1 : 1);
yo = levelUnits / 2 * ((Lehmer.Next() > 0.5) ? -1 : 1);
}
break;
}
float ao = (start == 1 || start == 3) ? yo : xo;
float bo = (start == 1 || start == 3) ? xo : yo;
switch (start)
{
case 1:
ao *= -1;
break;
case 2:
ao *= -1;
bo *= -1;
break;
case 3:
bo *= -1;
break;
}
pos.x += ao;
pos.z += bo;
}
Vector2 d = Vector2.zero;
if (sectionItem.UseCustomPos)
{
d = (sectionItem.EndPos - sectionItem.StartPos);
}
else
{
d = (levelUnits * Vector2.one) - sectionItem.Size;
}
float x = (int)(Lehmer.Next() * d.x);
float y = (int)(Lehmer.Next() * d.y);
float a = (start == 1 || start == 3) ? y : x;
float b = (start == 1 || start == 3) ? x : y;
switch (start)
{
case 1:
a *= -1;
break;
case 2:
a *= -1;
b *= -1;
break;
case 3:
b *= -1;
break;
}
a -= ((pos - ori).x == 0.0f) ? a : (((pos - ori).x > 0) ? (sectionItem.Size.x / 2) : -(sectionItem.Size.y / 2));
b -= ((pos - ori).z == 0.0f) ? b : (((pos - ori).z > 0) ? (sectionItem.Size.y / 2) : -(sectionItem.Size.y / 2));
pos.x += a;
pos.z += b;
if (sectionItem.Offset != OffsetPara.None)
{
float offset = 4.0f;
int dir = 0;
switch (sectionItem.Offset)
{
case OffsetPara.Closer:
dir = 1;
break;
case OffsetPara.Further:
dir = -1;
break;
case OffsetPara.Random:
dir = (Lehmer.Next() > 0.5) ? -1 : 1;
break;
}
switch (start)
{
case 0:
pos.z -= offset * dir;
break;
case 1:
pos.x += offset * dir;
break;
case 2:
pos.z += offset * dir;
break;
case 3:
pos.x -= offset * dir;
break;
}
}
pos.y = 0.0f;
obs.transform.position = pos;
if (start == 1 || start == 3)
{
obs.transform.rotation = Quaternion.AngleAxis(90.0f, Vector3.up);
}
return(obs);
}
public void GenerateObstacles()
{
if (obstacles.Count > 0)
{
foreach (GameObject obj in obstacles)
{
Destroy(obj);
}
obstacles.Clear();
}
if (enemies.Count > 0)
{
foreach (GameObject obj in enemies)
{
Destroy(obj);
}
enemies.Clear();
}
for (int i = 0; i < 4; i++)
{
Wall_Door wall = GetWall(i);
if (wall.Opened)
{
if (wall.Entrance)
{
start = i;
}
else
{
end = i;
}
}
}
int selection;
PrefabSet sectionItem;
GameObject item;
GameObject obs;
if (Lehmer.Next() > 0.5)
{
selection = Mathf.FloorToInt((float)Lehmer.Next() * Sections.Length);
sectionItem = Sections[selection];
item = sectionItem.Prefab;
obs = Instantiate(item, transform);
obs = OffsetPrefab(sectionItem, obs);
obstacles.Add(obs);
}
if (Lehmer.Next() > 0.5)
{
selection = Mathf.FloorToInt((float)Lehmer.Next() * Enemies.Length);
sectionItem = Enemies[selection];
item = sectionItem.Prefab;
obs = Instantiate(item, transform);
obs = OffsetPrefab(sectionItem, obs);
enemies.Add(obs);
}
}
void Start()
{
minMoonMass = (int)(minPlanetMass * moonMassSacle);
maxMoonMass = (int)(maxPlanetMass * moonMassSacle);
x = gameInfoObject.GetComponent <GameInfo>().x;
y = gameInfoObject.GetComponent <GameInfo>().y;
z = gameInfoObject.GetComponent <GameInfo>().z;
GameObject star = Instantiate(starPrefab, starPoisiton, Quaternion.identity);
ushort posY = (ushort)y;
ushort posZ = (ushort)z;
nLehmer = (long)x << 32 | (long)posY << 16 | (long)posZ;
randGenerator = new Lehmer(nLehmer);
bool starExists = randGenerator.randomInt(0, 15) == 1;
scale = randGenerator.randomInt(1, 100) / 100f;
numPlanets = (int)randGenerator.randomInt(0, maxNumPlanets);
// numPlanets = 1;
planetsGameObjects = new GameObject[numPlanets];
rigidBodies = new Rigidbody[numPlanets];
planets = new Planet[numPlanets];
moons = new Moon[numPlanets, maxNumMoons];
moonsGameObjects = new GameObject[numPlanets, maxNumMoons];
orbits = new EllipseOrbit[numPlanets, maxNumMoons];
for (int i = 0; i < numPlanets; i++)
{
int maxPlanetScaleToInt = (int)(maxPlanetScale * 100);
float planetScale = (maxPlanetScaleToInt - 1 - (uint)randGenerator.randomInt(1, maxPlanetScaleToInt - 1)) / 100f;
Vector3 planetPosition = new Vector3(randGenerator.randomInt(-maxPlanetRadiusDistance, maxPlanetRadiusDistance),
randGenerator.randomInt(-maxPlanetRadiusDistance, maxPlanetRadiusDistance),
randGenerator.randomInt(-maxPlanetRadiusDistance, maxPlanetRadiusDistance));
GameObject planet = Instantiate(planetPrefab, planetPosition, Quaternion.identity);
planetsGameObjects[i] = planet;
planets[i] = new Planet();
// startVelocity = (starPoisiton - planetPosition).normalized;
// planets[i].setVelocity(startVelocity);
planets[i].setMass((float)randGenerator.randomInt(minPlanetMass, maxPlanetMass));
//MOOOOOOOOOOOOOOOOOOOOON
numMoons = (int)randGenerator.randomInt(0, maxNumMoons);
planets[i].setNumMoons(numMoons);
for (int j = 0; j < numMoons; j++)
{
Vector3 moondistance = new Vector3(randGenerator.randomInt(-maxMoonRadiusDistance, maxMoonRadiusDistance),
randGenerator.randomInt(-maxMoonRadiusDistance, maxMoonRadiusDistance),
randGenerator.randomInt(-maxMoonRadiusDistance, maxMoonRadiusDistance));
Vector3 moonPosition = moondistance + planetPosition;
float minMagnitude = moonPosition.magnitude + planetRadius + 1;
float maxMagnitude = minMagnitude + maxVectorMagFromPlanet;
float mag = (float)randGenerator.randomInt((int)minMagnitude, (int)maxMagnitude);
float b = mag / 2;
Vector3 ellipseEndpoint = (mag * -1 * moondistance) + moonPosition;
Vector3 midPoint = (b * -1 * moonPosition) + moonPosition;
Vector3 normal = moondistance;
Vector3 tangent;
Vector3 t1 = Vector3.Cross(normal, Vector3.forward);
Vector3 t2 = Vector3.Cross(normal, Vector3.up);
if (t1.magnitude > t2.magnitude)
{
tangent = t1;
}
else
{
tangent = t2;
}
float a = (float)randGenerator.randomInt((int)minMagnitude, (int)maxMagnitude);
orbits[i, j] = new EllipseOrbit(a * .2f, b * .2f, midPoint);
orbits[i, j].setTheta((float)randGenerator.randomInt(0, 90));
GameObject moon = Instantiate(moonPrefab, moonPosition, Quaternion.identity);
moonsGameObjects[i, j] = moon;
moons[i, j] = new Moon();
//moons[i, j].setVelocity(startVelocity);
moons[i, j].setMass((float)randGenerator.randomInt(minMoonMass, maxMoonMass));
}
}
}
