public override void createParticle()
{
int nextIndex = -1;
do
{
nextIndex = RANDOM.Next(this.SPAWN_LOCATIONS.Length);
} while (this.lastUsedIndex == nextIndex);
this.lastUsedIndex = nextIndex;
base.particleParams.Position = this.SPAWN_LOCATIONS[this.lastUsedIndex];
ConstantSpeedParticle particle = new ConstantSpeedParticle(base.particleParams);
ScaleOverTimeEffectParams effectParms = new ScaleOverTimeEffectParams {
Reference = particle,
ScaleBy = new Vector2(1f)
};
particle.addEffect(new ScaleOverTimeEffect(effectParms));
RotateOverTimeEffectParams rotateEffectParms = new RotateOverTimeEffectParams {
Reference = particle,
RotateBy = 2f
};
particle.addEffect(new RotateOverTimeEffect(rotateEffectParms));
FadeEffectParams fadeEffectParms = new FadeEffectParams {
Reference = particle,
State = FadeEffect.FadeState.Out,
TotalTransitionTime = TIME_TO_LIVE,
OriginalColour = COLOUR
};
particle.addEffect(new FadeEffect(fadeEffectParms));
base.particles.Add(particle);
base.createParticle();
}
public void DoFire()
{
int counter = 0;
int rand = RANDOM.Next(0, 255);
int curSrc = FIRE_WIDTH;
do
{
int srcOffset = (curSrc + counter);
int pixel = FIRE_PIXELS[srcOffset];
int step = 2;
rand = SpreadFire(pixel, curSrc, counter, srcOffset, rand, FIRE_WIDTH);
curSrc += FIRE_WIDTH;
srcOffset += FIRE_WIDTH;
do
{
pixel = FIRE_PIXELS[srcOffset];
step += 2;
rand = SpreadFire(pixel, curSrc, counter, srcOffset, rand, FIRE_WIDTH);
pixel = FIRE_PIXELS[srcOffset + FIRE_WIDTH];
curSrc += FIRE_WIDTH;
srcOffset += FIRE_WIDTH;
rand = SpreadFire(pixel, curSrc, counter, srcOffset, rand, FIRE_WIDTH);
curSrc += FIRE_WIDTH;
srcOffset += FIRE_WIDTH;
} while (step < FIRE_HEIGHT);
counter++;
curSrc -= ((FIRE_WIDTH * FIRE_HEIGHT) - FIRE_WIDTH);
} while (counter < FIRE_WIDTH);
}
protected override IEnumerable <object> GenerateData(BooleanColumnPOCO column, int recordsCount)
{
while (recordsCount-- > 0)
{
yield return(RANDOM.Next(0, 2));
}
}
private BtrieveFile CreateBtrieveFile()
{
var btrieveFile = new BtrieveFile()
{
RecordLength = RECORD_LENGTH,
FileName = $"{RANDOM.Next() % 100_000_000}.DAT",
RecordCount = 3,
};
var key = new BtrieveKey();
key.Segments.Add(new BtrieveKeyDefinition()
{
Number = 0,
Attributes = EnumKeyAttributeMask.UseExtendedDataType | EnumKeyAttributeMask.Duplicates,
DataType = EnumKeyDataType.Zstring,
Offset = 0,
Length = 32,
Segment = false,
});
btrieveFile.Keys.Add(0, key);
btrieveFile.Records.Add(new BtrieveRecord(1, CreateRecord("ABC", 1)));
btrieveFile.Records.Add(new BtrieveRecord(2, CreateRecord("ABC", 2)));
btrieveFile.Records.Add(new BtrieveRecord(3, CreateRecord("abc", 3)));
btrieveFile.Records.Add(new BtrieveRecord(4, CreateRecord("abc", 4)));
btrieveFile.Records.Add(new BtrieveRecord(5, CreateRecord("test", 5)));
btrieveFile.Records.Add(new BtrieveRecord(6, CreateRecord("yyz", 6)));
return(btrieveFile);
}
//Allow the player to guess one player's goals
protected override int GuessGoal(Player player)
{
int coinTotal = 20;
foreach (Tuple <string, int> record in Tracking)
{
if (record.Item1 == player.Name)
{
//AI track purchases perfectly, so this artificially adds some uncertainty to their guessing
int badness = RANDOM.Next(-1, 2);
coinTotal += record.Item2 + badness;
}
}
if (coinTotal < 7)
{
return(3);
}
if (coinTotal < 15)
{
return(10);
}
if (coinTotal < 25)
{
return(20);
}
if (coinTotal < 35)
{
return(30);
}
return(40);
}
public override void createParticle() {
if (Emitt) {
float x = RANDOM.Next(0, 180);
if (RANDOM.Next(0, 2) == 1) {
x = -x;
}
float y = RANDOM.Next(0, 180);
if (RANDOM.Next(0, 2) == 1) {
y = -y;
}
float rotation = (float)Math.Atan2(x, -y);
BaseParticle2DParams particleParms = new BaseParticle2DParams();
particleParms.TimeToLive = 1000;
particleParms.Texture = base.particleTexture;
particleParms.Scale = new Vector2(.75f);
particleParms.Position = this.position;
particleParms.Origin = new Vector2(Constants.TILE_SIZE / 2);
particleParms.Direction = new Vector2(x, y);
particleParms.Acceleration = new Vector2(.15f);
particleParms.Rotation = rotation;
particleParms.LightColour = Color.White;
ConstantSpeedParticle particle = new ConstantSpeedParticle(particleParms);
base.particles.Add(particle);
base.createParticle();
}
}
public void injectFireballs()
{
for (int i = 0; i < _power * 10; i++)
{
float speed = RANDOM.getFloat(5, 15);
Fireball fireball = new Fireball(position, RANDOM.getRotation, 1, 0, speed, -1);
_fireballs.Add(fireball);
}
}
//Assign one of the goals to each player
protected virtual void AssignGoals()
{
List <int> goalAssignments = new List <int>(GOALS);
for (int i = Players.Count; i > 0; i--)
{
Players[i - 1].Goal = goalAssignments.Pull(RANDOM.Next(0, i));
}
}
protected override IEnumerable <object> GenerateData(NumberColumnPOCO column, int recordsCount)
{
int columnMax = GetColumnMax(column);
int columnMin = GetColumnMin(column);
while (recordsCount-- > 0)
{
yield return(RANDOM.Next(columnMin, columnMax));
}
}
public MBBSEmuIntegrationTestBase()
{
_modulePath = GetModulePath();
_serviceResolver = new ServiceResolver(SessionBuilder.ForTest($"MBBSDb_{RANDOM.Next()}"));
_serviceResolver.GetService <IAccountRepository>().Reset("sysop");
_serviceResolver.GetService <IAccountKeyRepository>().Reset();
Directory.CreateDirectory(_modulePath);
}
public static void AddNoise(SpriteBatch spriteBatch, int noiseAmount)
{
for (int a = 0; a <= noiseAmount; a++)
{
for (int i = 0; i <= SCREEN_SIZE.X; i++)
{
spriteBatch.Draw(Sprites.SPR_WHITEPIXEL, new Vector2(i + RANDOM.Next(-5, 5), RANDOM.Next(SCREEN_SIZE.Y)), null, null, null, (float)RANDOM.NextDouble() * 2f, null, Color.Gray);
}
}
}
protected override IEnumerable <object> GenerateData(ChoiceColumnPOCO column, int recordsCount)
{
var choiceCount = column.Choices.Count();
while (recordsCount-- > 0)
{
var idx = RANDOM.Next(choiceCount);
yield return(column.Choices[idx]);
}
}
protected override IEnumerable <object> GenerateData(NumberColumnPOCO column, int recordsCount)
{
var columnMin = GetColumnMin(column);
var columnMax = GetColumnMax(column);
while (recordsCount-- > 0)
{
yield return(RANDOM.NextDouble() * (columnMax - columnMin) + columnMin);
}
}
protected override IEnumerable <object> GenerateData(DateTimeColumnPOCO column, int recordsCount)
{
var milisecondsRange = (column.MaxValue - column.MinValue).TotalMilliseconds;
while (recordsCount-- > 0)
{
var miliseconds = RANDOM.NextDouble() * milisecondsRange;
yield return(column.MinValue.AddMilliseconds(miliseconds));
}
}
//-----------------------------------------------------------------------------------------------------
// ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
//====================================================================================================
// ■ START
//====================================================================================================
void Start()
{
var position = Transform.Position;
Height = math.distance(position, new float3(0, 0, 0));
HitCount = RANDOM.Int(1, 20);
OriginalHitCount = HitCount;
Color = OriginalColor;
}
public override void Update(object gameTime)
{
if (GlobalPosition.Y + Origin.Y * 10 < 0 && GlobalPosition.X + Origin.X * 10 > SCREEN_SIZE.X)
{
opacity = (float)RANDOM.NextDouble() * 0.3f;
position = new Vector2(-Origin.X * 10, SCREEN_SIZE.Y + Origin.Y * 10);
}
else
{
position += velocity;
}
}
//Extend Lists to allow obtaining a random item
public static T GetRandom <T>(this IList <T> list)
{
if (list.Count == 0)
{
throw new Exception("Empty List!");
}
if (list.Count == 1)
{
return(list[0]);
}
return(list[RANDOM.Next(0, list.Count)]);
}
public static object ListRandom(
[DekiScriptParam("list value")] ArrayList list
)
{
if (list.Count == 0)
{
return(null);
}
int index = RANDOM.Next(list.Count);
return(list[index]);
}
protected override IEnumerable <object> GenerateData(TextColumnPOCO column, int recordsCount)
{
var textSamples = textDAO.GetRandomTexts(recordsCount);
while (recordsCount-- > 0)
{
var text = textSamples[recordsCount % textSamples.Count()];
var maxLength = Math.Min(text.Length, column.MaxLength);
var length = RANDOM.Next(column.MinLength, maxLength);
yield return(text.Substring(0, length));
}
}
//====================================================================================================
// ■ ADD ASTEROID
//====================================================================================================
void AddAsteroid()
{
var obj = (GAMEOBJECT)Instantiate(AsteroidObject);
obj.SetActive(true);
obj.Tag = "Asteroid";
obj.Transform.Parent = AsteroidInstances.Transform;
var planetAxis = new float3(RANDOM.Float(-1, 1), RANDOM.Float(-1, 1), RANDOM.Float(-1, 1));
var planetRotationSpeed = RANDOM.Float(20, 200);
obj.Transform.RotateAround(new float3(0, 0, 0), planetAxis, planetRotationSpeed);
}
public override void Update(object gameTime)
{
base.Update(gameTime);
if (GameStats.InWave)
{
if (RANDOM.Next(50) == 0 && resources > 0)
{
double type_a = Math.Sqrt(Math.Min(LIST_ENEMIES.Count, (int)(GameStats.Wave / 3)));
double type_b = Math.Sqrt(Math.Min(LIST_ENEMIES.Count, (int)(GameStats.Wave / 3)));
string eType = LIST_ENEMIES[RANDOM.Next((int)(type_a * type_b))];
Type t = Type.GetType(eType); //Get the type of the object
object temp = Activator.CreateInstance(t); //Create an instance of that object
Enemy obj = temp as Enemy; //Cast it as an Enemy
GridNode node = available[RANDOM.Next(available.Count)];
obj.startNode = node;
obj.Position = node.Position;
plane.Add(obj);
resources -= obj.cost;
}
bool AllDeath = true;
List <Enemy> list = plane.FindByType <Enemy>();
foreach (Enemy e in list)
{
if (!e.kill)
{
AllDeath = false;
break;
}
}
if (AllDeath && GameStats.InWave && resources <= 0)
{
GameStats.InWave = false;
GameStats.WaveTimer = 10 * 60;
}
}
if (!GameStats.InWave && GameStats.WaveTimer > 0)
{
GameStats.WaveTimer--;
if (GameStats.WaveTimer <= 0)
{
GameStats.InWave = true;
int x = GameStats.Wave++;
resources = (int)(500 + 2 * Math.Pow(x, (Math.Sqrt(x / 100) + 1)) + 400 * (float)Math.Sqrt(x));
}
}
}
//====================================================================================================
// ■ UPDATE
//====================================================================================================
void Update()
{
if (AlienCount < AlienMaxCount)
{
var position = new float3(RANDOM.Float(-1, 1), RANDOM.Float(-1, 1), RANDOM.Float(-1, 1));
var normal = math.normalize(position);
var height = GAMEOBJECT.Find("Center").GetComponent <CENTER>().GetHeight();
position = math.normalize(position) * height;
PutAlien(position, normal);
}
}
public override void SetupRules()
{
int maxQueryFailures = RANDOM.Next(1, MAX_ATTEMPTS);
int maxUpdateFailures = MAX_ATTEMPTS - maxQueryFailures;
Console.WriteLine("Max UPDATE fault failures: " + maxUpdateFailures);
Console.WriteLine("Max QUERY fault failures: " + maxQueryFailures);
Rules.Add(new FaultRule(MongoRepositoryHelper.Method.UPDATE_CAS,
CustomConditions.TriggerRandomlyWithMax(maxUpdateFailures),
BuiltInFaults.ThrowExceptionFault(expectedFault)));
Rules.Add(new FaultRule(MongoRepositoryHelper.Method.SINGLE,
CustomConditions.TriggerRandomly(1, maxQueryFailures),
BuiltInFaults.ThrowExceptionFault(expectedFault)));
}
public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
{
if (RANDOM.Next(8) == 0)
{
SortingThread.AddRequest(this);
}
base.Draw(gameTime, spriteBatch);
//Draw the grid outlines
for (int i = 0; i < (LEVEL_SIZE.X + LEVEL_SIZE.Y); ++i)
{
//Right to left
DrawingHelper.DrawLine(spriteBatch, GlobalPosition + new Vector2(LEVEL_SIZE.X * NODE_SIZE.X - NODE_SIZE.X * i, 0), GlobalPosition + new Vector2(LEVEL_SIZE.X * NODE_SIZE.X, NODE_SIZE.Y * i), Color.Black, 2, 0.0f);
//Left to right
DrawingHelper.DrawLine(spriteBatch, GlobalPosition + new Vector2(NODE_SIZE.X * i, 0), GlobalPosition + new Vector2(0, NODE_SIZE.Y * i), Color.Black, 2, 0.0f);
}
}
//(Generic) Decide on what action to take for the turn
public virtual string DecideAction(int currentShareValue)
{
string action = "";
//50% chance to buy or pass
if (RANDOM.Next(2) == 1)
{
action = ACTION_BUY;
}
else
{
action = ACTION_PASS_ROUND;
}
return(action);
}
//----------------------------------------------------------------------------------------------------
// ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
//====================================================================================================
// ■ START
//====================================================================================================
void Start()
{
Axis = new float3(RANDOM.Float(-1, 1), RANDOM.Float(-1, 1), RANDOM.Float(-1, 1));
RotationSpeed = RANDOM.Float(5, 20);
//Planet
PlanetAxis = new float3(RANDOM.Float(-1, 1), RANDOM.Float(-1, 1), RANDOM.Float(-1, 1));
PlanetRotationSpeed = RANDOM.Float(5, 20);
HitCount = RANDOM.Int(10, 100);
OriginalHitCount = HitCount;
var position = Transform.Position;
Height = math.distance(position, new float3(0, 0, 0));
}
//Fill any open spots in the game with computer players
void GetComputerPlayers()
{
List <string> ComputerNames = new List <string> {
"Groot", "Thor", "Hulk", "Mantis", "Thanos", "Spider-Man",
"Captain America", "Iron Man", "Black Panther", "Doctor Strange", "Scarlet Witch",
"Star-Lord", "Loki", "Gamora", "Black Widow", "Vision", "Bucky", "Nebula", "Drax", "Ant-Man (Not Pictured)"
};
while (Players.Count < 5)
{
NonBlockingSleep(1);
Player tempPlayer = new DumbAIPlayer(ComputerNames.Pull(RANDOM.Next(ComputerNames.Count())), RANDOM.Next());
Players.Add(tempPlayer);
WriteLine(tempPlayer.Name + " joined the game!");
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testUpper()
public virtual void testUpper()
{
for (int i = 0; i < 10; i++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double x = A + 5 * Math.log(RANDOM.nextDouble());
double x = A + 5 * Math.Log(RANDOM.NextDouble());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double y = 5 * NORMAL.nextRandom();
double y = 5 * NORMAL.nextRandom();
assertRoundTrip(UPPER_LIMIT, x);
assertReverseRoundTrip(UPPER_LIMIT, y);
assertGradient(UPPER_LIMIT, x);
assertInverseGradient(UPPER_LIMIT, y);
assertGradientRoundTrip(UPPER_LIMIT, x);
}
}
public virtual Enemy findTarget()
{
for (int i = enemies.Count - 1; i >= 0; --i)
{
if (CalculateDistance(GlobalPosition, enemies[i].GlobalPositionCenter) > TowerRange(type, stats))
{
enemies.RemoveAt(i);
}
}
if (enemies.Count > 0)
{
return(enemies[RANDOM.Next(enemies.Count)]);
}
return(null);
}
public int SpreadFire(int pixel, int curSrc, int counter, int srcOffset, int rand, int width)
{
if (pixel != 0)
{
int randIdx = RANDOM.Next(0, 255);
int tmpSrc;
rand = ((rand + 2) & 255);
tmpSrc = (curSrc + (((counter - (randIdx & 3)) + 1) & (width - 1)));
FIRE_PIXELS[tmpSrc - FIRE_WIDTH] = pixel - (randIdx & 1);
}
else
{
FIRE_PIXELS[srcOffset - FIRE_WIDTH] = 0;
}
return(rand);
}