public bool Split(float c)
{
if (ULife == 0)
{
//Step 1, initialize
ULife = RandomFloat.Range(0.5f, 1f);
BLife = 0;
}
float BNext = BLife + h(c, 0.0025f, 0.002f) * (1 - BLife); //Step 2
if (BNext > ULife)
{
//Tumble and return to step 1
ULife = 0;
BLife = 0;
return(true);
}
else
{
//Keep running, and return to step 2
BLife = BNext;
return(false);
}
}
void Start()
{
var time = GetTime();
var randomService = new RandomFloat(new System.Random());
var collisions = GetCollisions();
//Create the Hazard Spawner
var hazardSpawner = new HazardSpawner(
time,
spawnInterval,
randomService,
minHazardHeight,
maxHazardHeight,
initialPosition,
hazardSpeed
);
//Initialize Bird
bird.Setup(time, collisions);
//When a collision event occurs, the hazard spawner stop spawning hazards
collisions.Subscribe(collisionEvent => hazardSpawner.Stop());
//Every time the HazardSpawner spawns a hazar, create a hazard view
hazardSpawner.Hazards.Subscribe(hazard => CreateHazard(hazard, collisions));
}
public bool Die(float c)
{
if (UDeath == 0)
{
//Step 1, initialize
UDeath = RandomFloat.NextFloat();
BDeath = 0;
}
float BNext = BDeath + h(c, -0.001f, 0.035f) * (1 - BDeath); //Step 2
if (BNext > UDeath)
{
//Tumble and return to step 1
UDeath = 0;
BDeath = 0;
return(true);
}
else
{
//Keep running, and return to step 2
BDeath = BNext;
return(false);
}
}
public void Init(ISFSObject gameInfo)
{
//interval,0.2:0.3#2:4#2:4#3:5#8:20
if (!gameInfo.ContainsKey("interval"))
{
return;
}
var info = gameInfo.GetUtfString("interval");
var intervals = info.Split('#');
var len = intervals.Length;
_randomFloat = new RandomFloat[len];
for (var i = 0; i < len; i++)
{
var interval = intervals[i];
var minMax = interval.Split(':');
if (minMax.Length < 2)
{
continue;
}
var rf = new RandomFloat();
float.TryParse(minMax[0], out rf.Min);
float.TryParse(minMax[1], out rf.Max);
_randomFloat[i] = rf;
}
SetInterVal();
}
public HazardSpawner(
UniRx.IObservable <float> time,
float spawnInterval,
RandomFloat randomService,
float minHazardHeight,
float maxHazardHeight,
float initialPosition,
float hazardSpeed
)
{
this.randomService = randomService;
this.minHazardHeight = minHazardHeight;
this.maxHazardHeight = maxHazardHeight;
this.initialPosition = initialPosition;
this.hazardSpeed = hazardSpeed;
this.time = time;
spawning = true;
// Transform the time to emit events every 'spawnInterval' seconds
Hazards = time
.Buffer(Span(spawnInterval))
// Put an event at the beginning of the time-line
.StartWith(FirstSpawnEvent())
// Only spawn if 'spawning' is on
.Where(_ => spawning)
// transform the spawn events into hazards
.Select(l => HazardFactory());
}
/// <summary>
/// Create a PowerCutAreaGimmickLocator with random values.
/// </summary>
/// <param name="randomFloat">Function to generate a random float.</param>
/// <returns>The generated locator.</returns>
private static PowerCutAreaGimmickLocator CreateLocator(RandomFloat randomFloat)
{
var position = new Vector4(randomFloat(), randomFloat(), randomFloat(), randomFloat());
var rotation = new Quaternion(randomFloat(), randomFloat(), randomFloat(), randomFloat());
var locator = new PowerCutAreaGimmickLocator(position, rotation);
return(locator);
}
public static Vector3 GetRandomVector(float xRange, float yRange, float zRange)
{
return(new Vector3
(
RandomFloat.Range(-xRange, xRange),
RandomFloat.Range(-yRange, yRange),
RandomFloat.Range(-zRange, zRange)
));
}
public static Vector3 GetRandomVector(float xRangeMin, float yRangeMin, float zRangeMin, float xRangeMax, float yRangeMax, float zRangeMax)
{
return(new Vector3
(
RandomFloat.Range(xRangeMin, xRangeMin),
RandomFloat.Range(yRangeMin, yRangeMax),
RandomFloat.Range(zRangeMin, zRangeMax)
));
}
void ThenHazardsHaveExpectedHeights(List <Hazard> spawnedHazards)
{
var randomService = new RandomFloat(new Random(RandomSeed));
foreach (var hazard in spawnedHazards)
{
var randomHeight = randomService.Next(MinHazardHeight, MaxHazardHeight);
AssertAreApproximatelyEqual(hazard.Height, randomHeight, 0.01f);
}
}
internal static Vector3 GetRandomPosition(this BoxCollider2D self, PositionSpace space = PositionSpace.World)
{
Vector3 pos = (space == PositionSpace.Local) ?
self.transform.localPosition
: self.transform.position;
pos += (Vector3)self.offset + new Vector3(RandomFloat.Range(-self.size.x, self.size.x) / 2, RandomFloat.Range(-self.size.y, self.size.y) / 2, 0);
return(pos);
}
/// <summary>
/// Create a NamedGimmickLocator with random values.
/// </summary>
/// <param name="randomFloat">Function to generate a random float.</param>
/// <returns>The generated locator.</returns>
private static NamedGimmickLocator CreateLocator(RandomFloat randomFloat)
{
var position = new Vector4(randomFloat(), randomFloat(), randomFloat(), randomFloat());
var rotation = new Quaternion(randomFloat(), randomFloat(), randomFloat(), randomFloat());
var locatorName = 424242u;
var dataSetName = 191919u;
var locator = new NamedGimmickLocator(position, rotation, locatorName, dataSetName);
return(locator);
}
/// <summary>
/// Create a ScaledGimmickLocator with random values.
/// </summary>
/// <param name="randomFloat">Function to generate a random float.</param>
/// <returns>The generated locator.</returns>
private static ScaledGimmickLocator CreateLocator(RandomFloat randomFloat)
{
var position = new Vector4(randomFloat(), randomFloat(), randomFloat(), randomFloat());
var rotation = new Quaternion(randomFloat(), randomFloat(), randomFloat(), randomFloat());
var scale = new WideVector3(randomFloat(), randomFloat(), randomFloat(), 42, 19);
var locatorName = 424242u;
var dataSetName = 191919u;
var locator = new ScaledGimmickLocator(position, rotation, scale, locatorName, dataSetName);
return(locator);
}
public static CenterObjectV1 NextPosition()
{
return(new CenterObjectV1
{
Type = "Point",
Coordinates = new double[]
{
RandomFloat.NextFloat(-180, 168), // Longitude
RandomFloat.NextFloat(-90, 90), // Latitude
}
});
}
public static Color GetRandomHueColor(float saturation, float lightness)
{
ColorHSL hsl = new ColorHSL()
{
h = RandomFloat.Range(0, 360),
s = saturation,
l = lightness
};
Color rgb;
hslToRgb(hsl, out rgb);
return(rgb);
}
//Simulates numCells many cells with iterations many steps each
public void CreateCells(int numCells)
{
cells[0] = new List <Cell>();
for (int i = 0; i < numCells; i++)
{
float x = RandomFloat.Range(-12f, 12f);
float z = RandomFloat.Range(-12f, 12f);
Cell cell = BacteriaFactory.CreateNewCell(x, z, RandomFloat.Range(0, 2 * MathFloat.PI), false);
cells[0].Add(cell);
allCells.Add(cell);
}
}
public static Vector3 GetRandomPointInVolume(this Bounds self)
{
Vector3 point = self.center;
Vector3 extents = self.extents;
point += new Vector3
(
RandomFloat.Range(-extents.x, extents.x),
RandomFloat.Range(-extents.y, extents.y),
RandomFloat.Range(-extents.z, extents.z)
);
return(point);
}
public static BeaconV1 NextBeacon(int siteCount = 100)
{
return(new BeaconV1()
{
Id = IdGenerator.NextLong(),
SiteId = NextSiteId(siteCount),
Udi = IdGenerator.NextShort(),
Label = RandomString.NextString(10, 25),
Type = NextBeaconType(),
Radius = RandomFloat.NextFloat(3, 150),
Center = NextPosition()
});
}
protected float CalculateTumbleAngle()
{
//Tumble angle based on article (Edgington)
float newAngle = RandomFloat.Range(18f, 98f);
float rand = RandomFloat.Range(0.0f, 1.0f);
if (rand > 0.5)
{
newAngle *= -1;
}
newAngle *= MathFloat.PI / 180;
newAngle += this.angle;
return(newAngle);
}
internal static Vector3 GetRandomPosition(this CircleCollider2D self, PositionSpace space = PositionSpace.World)
{
Vector3 pos = (space == PositionSpace.Local) ?
self.transform.localPosition
: self.transform.position;
Vector3 point = new Vector3(RandomFloat.Range(-self.radius, self.radius), 0, 0);
point = point.RotateZ(RandomFloat.Range(0, 360));
pos += (Vector3)self.offset + point;
return(pos);
}
void GivenAHazardSpawner()
{
var randomService = new RandomFloat(new Random(RandomSeed));
hazardSpawner = new HazardSpawner(
time,
SpawnHazardsEvery,
randomService,
MinHazardHeight,
MaxHazardHeight,
HazardInitialPosition,
HazardsSpeed
);
}
public bool DecideState(float c)
{
SolveStiff(c);
double r = RandomFloat.NextFloat();
if (S > U)
{
S = 0.0f;
U = RandomFloat.Range(0f, 0.8f);
return(false); //Tumbling
}
else
{
return(true); //Running
}
}
public void SetValue(Type type, object value)
{
if (type == Type.Bool)
{
m_Bool = (bool)value;
}
else if (type == Type.Int)
{
m_Int = (Int)value;
}
else if (type == Type.Float)
{
m_Float = (Float)value;
}
else if (type == Type.FloatRange)
{
m_FloatRange = (FloatRange)value;
}
else if (type == Type.IntRange)
{
m_IntRange = (IntRange)value;
}
else if (type == Type.RandomFloat)
{
m_RandomFloat = (RandomFloat)value;
}
else if (type == Type.RandomInt)
{
m_RandomInt = (RandomInt)value;
}
else if (type == Type.String)
{
m_String = (string)value;
}
else if (type == Type.None)
{
return;
}
Changed.Send(this);
}
internal virtual void TakeDamage()
{
if (state == MonsterState.Living)
{
Vector3 splashVector = (transform.position - Player.Instance.transform.position).normalized;
life -= 1;
if (life == 0)
{
ApplySound();
state = MonsterState.Dying;
GoTweenChain chain = new GoTweenChain();
chain.insert(0,
transform
.scaleTo(0.5f, 0.75f, true)
.eases(GoEaseType.QuartOut)
);
chain.insert(0,
transform
.localEularAnglesTo(0.5f, new Vector3(0, 0, RandomFloat.Range(-180, 180)))
.eases(GoEaseType.QuadOut)
);
chain.insert(0.25f,
gameObject
.alphaTo(0.25f, 0, GoEaseType.QuartOut)
);
chain.setOnCompleteHandler(c => gameObject.DestroySelf());
chain.Start();
}
transform.position += splashVector * 25;
// bool isDying = ( life == 0 );
// transform.position += splashVector * ( isDying ? 100 : 25 );
}
}
public bool DecideState(float c)
{
float dC = c - l;
l = c;
if (U == 0)
{ //Step 1, initialize
U = RandomFloat.NextFloat();
B = 0;
}
float BNext = B + h(dC) * (1 - B); //Step 2
if (BNext > U)
{ //Tumble and return to step 1
U = 0;
B = 0;
return(false); //Tumble
}
else
{ //Keep running, and return to step 2
B = BNext;
return(true); //Run
}
}
