public RequestImplementation(IPlayerController controller, GameState game,
IBody body, Direction2 direction)
: base(RequestType.ShootDebugParticleFromPlanet, game, controller)
{
this.body = body;
this.direction = direction;
}
public void Move()
{
if (k2 == 4 && d1 == Direction1.up)
{
d1 = Direction1.down;
}
else
if (k2 == 4 && d1 == Direction1.down)
{
d1 = Direction1.up;
}
if (k2 == 8)
{
if (d2 == Direction2.right)
{
d2 = Direction2.left;
}
else
{
d2 = Direction2.right;
}
k2 = 0;
}
k2++;
}
public HitResult(Position2 point, Direction2 normal, float rayFactor, bool fromInside)
{
this.Point = point;
this.Normal = normal;
this.RayFactor = rayFactor;
this.FromInside = fromInside;
}
/// <summary>
/// Splash a bunch of trees down near (xloc, yloc).
///
/// Amount of trees is controlled by terrainTreeLevel.
/// </summary>
/// <remarks>Trees are not smoothed.</remarks>
/// <param name="xloc">Horizontal position of starting point for splashing trees.</param>
/// <param name="yloc">Vertical position of starting point for splashing trees.</param>
private void treeSplash(short xloc, short yloc)
{
short numTrees;
if (terrainTreeLevel < 0)
{
numTrees = (short)(getRandom(150) + 50);
}
else
{
numTrees = (short)(getRandom((short)(100 + (terrainTreeLevel * 2))) + 50);
}
Position treePos = new Position(xloc, yloc);
while (numTrees > 0)
{
Direction2 dir = (Direction2)(Direction2.DIR2_NORTH + getRandom(7));
treePos.move(dir);
if (!treePos.testBounds())
{
return;
}
if ((map[treePos.posX, treePos.posY] & (ushort)MapTileBits.LOMASK) == (ushort)MapTileCharacters.DIRT)
{
map[treePos.posX, treePos.posY] = (ushort)MapTileCharacters.WOODS | (ushort)MapTileBits.BLBNBIT;
}
numTrees--;
}
}
public HitResult(Position2 point, Direction2 normal, float rayFactor, bool fromInside)
{
this.Point = point;
this.Normal = normal;
this.RayFactor = rayFactor;
this.FromInside = fromInside;
}
public static List <Vector2> GetWirePointPositions(Vector2 start, Vector2 end, bool clamp = true, bool straight = false)
{
List <Vector2> points = new List <Vector2>();
if (straight)
{
points.Add(start);
Direction2 cardinal = start.CardinalTo(end);
points.Add(cardinal.GetAxis() == Axis.X ? new Vector2(end.X, start.Y) : new Vector2(start.X, end.Y));
}
else if (clamp)
{
return(GetWirePointPositions(ClampWire(start), ClampWire(end), false));
}
else
{
// Direction2 cardinal = start.CardinalTo(end);
// int dx = Math.Abs(cardinal.Offset().X);
// int dy = Math.Abs(cardinal.Offset().Y);
// float mx = (1 - dx) * start.X + dx * end.X;
// float my = (1 - dy) * start.Y + dy * end.Y;
points.Add(start);
points.Add(new Vector2(start.X, end.Y));
points.Add(end);
}
return(points);
}
public Snake(int x, int y)
{
this.x = x;
this.y = y;
d1 = Direction1.up;
d2 = Direction2.right;
}
public RequestImplementation(IPlayerController controller, GameState game,
IBody body, Direction2 direction)
: base(RequestType.ShootProjectileFromPlanet, game, controller)
{
this.body = body;
this.direction = direction;
this.validPlayer = true;
}
public static Direction2 MoveCoin()
{
Array values = Enum.GetValues(typeof(Direction2));
Random random = new Random();
Direction2 randomBar = (Direction2)values.GetValue(random.Next(values.Length));
return(randomBar);
}
public Projectile(GameState game, Ship owner, Vector2 position,
Vector2 baseVelocity, Direction2 direction, float speed, float lifeTime)
: base(game)
{
this.owner = owner;
this.position = position;
this.velocity = baseVelocity + direction.Vector * speed;
this.deathTime = game.TimeF + lifeTime;
}
public RequestImplementation(PlayerConnectionLookup connectionLookup, NetConnection connection,
NetBuffer buffer, GameState game)
: base(RequestType.ShootDebugParticleFromPlanet, game, connectionLookup, connection)
{
var p = buffer.Read <RequestParameters>();
this.body = game.Bodies[p.BodyId];
this.direction = p.Direction;
}
/// <summary>
/// Creates a new polar position.
/// </summary>
/// <param name="r">The distance of the point to the origin.</param>
/// <param name="angle">The direction of the vector originating in the origin pointing towards the point.</param>
public PolarPosition(float r, Direction2 angle)
{
if (r < 0)
{
throw new ArgumentException("The radius has to be non-negative.");
}
R = r;
Angle = angle;
}
public Settings()
{
Width = 16;
Height = 16;
Speed = 16;
Score = 0;
Point = 100;
GameOver = false;
direction = Direction.Down;
di = Direction2.Left;
}
public Parameters(Id <IBody> id, Id <IBody> parentId, Radius orbitRadius, Direction2 orbitDirection,
Radius radius, float mass, float health)
{
this.Id = id;
this.ParentId = parentId;
this.OrbitRadius = orbitRadius;
this.OrbitDirection = orbitDirection;
this.Radius = radius;
this.Mass = mass;
this.Health = health;
}
public static void Create(GameState game, int count, Color color, Vector2 position,
Direction2 direction, float directionVariance, float speed, float lifeTime)
{
for (int i = 0; i < count; i++)
{
new Particle(game, color, position,
direction + (StaticRandom.Float(-1, 1) * directionVariance).Radians(),
StaticRandom.Float(speed), StaticRandom.Float(0.5f, 1) * lifeTime
);
}
}
public static Axis GetAxis(this Direction2 direction)
{
if (direction == Direction2.Left || direction == Direction2.Right)
{
return(Axis.X);
}
if (direction == Direction2.Up || direction == Direction2.Down)
{
return(Axis.Y);
}
return(Axis.Undefined);
}
/// <summary>
/// Try to drive one tile in a random direction.
/// </summary>
/// <param name="pos">Current position.</param>
/// <param name="dirLast">Forbidden direction for movement (to prevent reversing).</param>
/// <returns>Direction of movement, DIR2_INVALID is returned if not moved.</returns>
private Direction2 tryGo(Position pos, Direction2 dirLast)
{
Direction2[] directions = new Direction2[4];
// Find connections from current position.
Direction2 dir = Direction2.DIR2_NORTH;
int count = 0;
int i;
for (i = 0; i < 4; i++)
{
if (dir != dirLast && roadTest(getTileFromMap(pos, dir, (ushort)MapTileCharacters.DIRT)))
{
// found a road in an allowed direction
directions[i] = dir;
count++;
}
else
{
directions[i] = Direction2.DIR2_INVALID;
}
dir = DirectionUtils.rotate90(dir);
}
if (count == 0)
{
// dead end
return(Direction2.DIR2_INVALID);
}
// We have at least one way to go.
if (count == 1)
{
// only one solution
for (i = 0; i < 4; i++)
{
if (directions[i] != Direction2.DIR2_INVALID)
{
return(directions[i]);
}
}
}
// more than one choice, draw a random number.
i = getRandom16() & 3;
while (directions[i] == Direction2.DIR2_INVALID)
{
i = (i + 1) & 3;
}
return(directions[i]);
}
public Settings()
{
Width = 16;
Height = 16;
x = 8;
Wynik = 0;
Wynik2 = 0;
Punkty = 100;
GameOver = false;
direction = Direction.Down;
direction2 = Direction2.Down;
}
public CommandImplementation(GameState game, IBody body, Direction2 direction)
: base(CommandType.ShootDebugParticleFromPlanet, game)
{
var bodyShape = body.Shape;
var d = Difference2.In(direction, 1.U());
this.ps = new CommandParameters(
this.game.GetUniqueId <FreeObject>(),
bodyShape.Center + d * bodyShape.Radius.NumericValue * 1.5f,
d * 1 / TimeSpan.One
);
}
public CommandImplementation(GameState game, IBody body, Player player, Direction2 direction)
: base(CommandType.ShootProjectileFromPlanet, game)
{
var bodyShape = body.Shape;
var d = Difference2.In(direction, 0.9f.U());
this.ps = new CommandParameters(
this.game.GetUniqueId <FreeObject>(),
player,
bodyShape.Center + d * bodyShape.Radius.NumericValue * 1.5f,
body.Velocity + d / TimeSpan.One
);
}
public static Direction2 Right(this Direction2 dir)
{
if (dir == Direction2.None)
{
return(dir);
}
Direction2 right = (Direction2)(((int)dir + 1) % 4);
if (dir > Direction2.Left)
{
right += 4;
}
return(right);
}
public static Direction2 Left(this Direction2 dir)
{
if (dir == Direction2.None)
{
return(dir);
}
Direction2 left = (Direction2)Helper.Wrap((int)dir % 4 - 1, 0, 3);
if (dir > Direction2.Left)
{
left += 4;
}
return(left);
}
public Ship(GameState game, Vector2 position,
IShipController controller, int faction = 0, float acceleration = 5,
Direction2 direction = default(Direction2), float inverseFriction = 0.8f)
: base(game)
{
this.position = position;
this.controller = controller;
this.faction = faction;
this.acceleration = acceleration;
this.forwards = direction;
this.inverseFriction = inverseFriction;
controller.SetShip(this);
game.Ships.Add(this);
}
private void updateMovement(TimeSpan elapsedTime, float acceleration, float leftRight)
{
var t = (float)elapsedTime.NumericValue;
this.speed += new Acceleration(acceleration * 50) * elapsedTime;
this.speed *= Mathf.Pow(1e-3f, t);
this.turnSpeed += AngularAcceleration.FromRadians(leftRight * 5) * elapsedTime;
this.turnSpeed *= Mathf.Pow(1e-7f, t);
this.Direction += this.turnSpeed * (elapsedTime * this.speed.NumericValue);
this.Position += this.Direction * this.speed * elapsedTime;
this.distanceTraveled += this.speed * elapsedTime;
}
/// <summary>
/// Try to drive to a destination.
/// </summary>
/// <param name="startPos">Starting position.</param>
/// <param name="destZone">Zonetype to drive to.</param>
/// <returns>Was drive succesful?</returns>
bool tryDrive(Position startPos, ZoneType destZone)
{
Direction2 dirLast = Direction2.DIR2_INVALID;
Position drivePos = new Position(startPos);
/* Maximum distance to try */
for (short dist = 0; dist < MAX_TRAFFIC_DISTANCE; dist++)
{
Direction2 dir = tryGo(drivePos, dirLast);
if (dir != Direction2.DIR2_INVALID)
{
// we found a road
drivePos.move(dir);
dirLast = DirectionUtils.rotate180(dir);
/* Save pos every other move.
* This also relates to
* Micropolis::trafficDensityMap::MAP_BLOCKSIZE
*/
if ((dist & 1) != 0)
{
pushPos(drivePos);
}
if (driveDone(drivePos, destZone))
{
// if destination is reached
return(true); /* pass */
}
}
else
{
if (curMapStackPointer > 0)
{
/* dead end, backup */
curMapStackPointer--;
dist += 3;
}
else
{
return(false); /* give up at start */
}
}
}
return(false); /* gone MAX_TRAFFIC_DISTANCE */
}
public static HitResult?TryHit(this IProjectileCollider collider, Ray ray)
{
var start = ray.Start.NumericValue;
var dir = ray.Direction.NumericValue;
var center = collider.Position.NumericValue;
var radius = collider.Radius.NumericValue;
var a = start.X - center.X;
var b = start.Y - center.Y;
var r2 = radius * radius;
var c2 = dir.X * dir.X;
var d2 = dir.Y * dir.Y;
var cd = dir.X * dir.Y;
var s = (r2 - a * a) * d2
+ (r2 - b * b) * c2
+ 2 * a * b * cd;
// if s is less than 0, the solutions for f are imaginary
// and the ray's line does not intersect the circle
if (s >= 0)
{
var f = (Mathf.Sqrt(s) + a * dir.X + b * dir.Y) / -(c2 + d2);
if (f <= 1)
{
var isInside = a * a + b * b < r2;
if (f >= 0 || (isInside && !float.IsNegativeInfinity(f)))
{
// TODO: currently returns negative f if ray starts inside
// consider treating this case differently?
// do we ever care about 'exit hits'?
// probably want to split entry/exit hits
// how to handle moving targets?
return(new HitResult(
new Position2(start + dir * f),
Direction2.Of(new Vector2(a, b)),
f,
isInside
));
}
}
}
return(null);
}
/// <summary>
/// Check at position pos for a power-less conducting tile in the
/// direction testDir.
/// TODO Re-use something like Micropolis::getFromMap(), and fold this function into its caller.
/// </summary>
/// <param name="pos">Position to start from.</param>
/// <param name="testDir">Direction to investigate.</param>
/// <returns>Unpowered tile has been found in the indicated direction.</returns>
private bool testForConductive(Position pos, Direction2 testDir)
{
var movedPos = new Position(pos);
if (movedPos.move(testDir))
{
if ((ushort)(map[movedPos.posX, movedPos.posY] & (ushort)MapTileBits.CONDBIT) == (ushort)MapTileBits.CONDBIT)
{
if (powerGridMap.worldGet(movedPos.posX, movedPos.posY) == 0)
{
return(true);
}
}
}
return(false);
}
public int SelectWall(Direction dir)
{
int row = 0;
int column = 0;
Direction2 dir2 = Direction2.LeftRight;
switch (dir)
{
case Direction.Up:
dir2 = Direction2.LeftRight;
row = turtle.Row;
column = turtle.Column;
break;
case Direction.Down:
dir2 = Direction2.LeftRight;
row = turtle.Row + 1;
column = turtle.Column;
break;
case Direction.Left:
dir2 = Direction2.UpDown;
row = turtle.Row;
column = turtle.Column;
break;
case Direction.Right:
dir2 = Direction2.UpDown;
row = turtle.Row;
column = turtle.Column + 1;
break;
}
int index = -1;
for (int i = 0; i < Walls.Count; i++)
{
if (Walls[i].Column == column && Walls[i].Row == row && Walls[i].Direction == dir2)
{
index = i;
break;
}
}
return(index);
}
public static Direction2 GetOppositeDirection(Direction2 direction)
{
switch (direction)
{
case Direction2.East:
return(Direction2.West);
case Direction2.West:
return(Direction2.East);
case Direction2.North:
return(Direction2.South);
default:
return(Direction2.North);
}
}
private void generateIntersectionsOnCircle(int count, float radius)
{
var angleBetweenIntersections = 360.Degrees() / count;
var levelRadius = radius * Constants.Game.World.HexagonWidth.U();
var startAngle = Direction2.FromDegrees(StaticRandom.Float(360));
var angleVariance = angleBetweenIntersections.Radians * 0.3f;
for (var i = 0; i < count; i++)
{
var angle = startAngle + angleBetweenIntersections * i
+ StaticRandom.Float(-angleVariance, angleVariance).Radians();
var point = new Position2() + angle.Vector
* (levelRadius * StaticRandom.Float(0.8f, 1));
intersections.Add(point);
}
}
public void MakeShip(Vector2 position, int faction,
int minCannons = 2, int maxCannons = 5, Direction2 direction = default(Direction2))
{
var cannons = StaticRandom.Int(minCannons, maxCannons + 1);
var s = new Ship(this.game, position,
new SimpleEnemyShipController(this.game), faction,
11 - 3f / 2f * cannons, direction, Math.Min(0.4f + 0.1f * cannons, 0.9f)
);
for (int j = 0; j < cannons; j++)
{
var x2 = (j - cannons / 2f + 0.5f) / cannons * 5;
var a = Angle.FromDegrees(90);
s.AddEquipment(new Cannon(this.game, new Vector2(x2, 2), a, GunControlGroup.Left));
s.AddEquipment(new Cannon(this.game, new Vector2(x2, -2), -a, GunControlGroup.Right));
}
}
public OrbitingBody(GameState game, Id <IBody> id, IBody parent,
Radius orbitRadius, Direction2 orbitDirection, Radius radius,
float mass, Color color, float health)
: base(game, id)
{
this.parent = parent;
this.orbitRadius = orbitRadius;
this.orbitDirection = orbitDirection;
this.radius = radius;
this.mass = mass;
this.color = color;
this.health = health;
this.maxHealth = health;
this.center = this.calculatePosition();
this.angularVelocity =
((Constants.G * parent.Mass / orbitRadius.NumericValue).Sqrted() / orbitRadius.NumericValue).Radians();
}
/// <summary>
/// Make a small river.
/// </summary>
/// <param name="riverPos">Start position of making a river.</param>
/// <param name="riverDir">Global direction of the river.</param>
/// <param name="terrainDir">Local direction of the terrain.</param>
/// <returns>Last used local terrain direction.</returns>
private Direction2 doSRiver(Position riverPos, Direction2 riverDir, Direction2 terrainDir)
{
int rate1, rate2;
if (terrainCurveLevel < 0)
{
rate1 = 100;
rate2 = 200;
}
else
{
rate1 = terrainCurveLevel + 10;
rate2 = terrainCurveLevel + 100;
}
Position pos = new Position(riverPos);
while (Position.testBounds((short)(pos.posX + 3), (short)(pos.posY + 3)))
{
//printf("doSRiver %d %d td %d rd %d\n", pos.posX, pos.posY, terrainDir, riverDir);
plopSRiver(pos);
if (getRandom((short)rate1) < 10)
{
terrainDir = riverDir;
}
else
{
if (getRandom((short)rate2) > 90)
{
terrainDir = DirectionUtils.rotate45(terrainDir);
}
if (getRandom((short)rate2) > 90)
{
terrainDir = DirectionUtils.rotate45(terrainDir, 7);
}
}
pos.move(terrainDir);
}
return(terrainDir);
}
/// <summary>
/// Get neighbouring tile from the map.
/// TODO should probably be in a Tile or Map class or something.
/// </summary>
/// <param name="pos">Current position.</param>
/// <param name="dir">Direction of neighbouring tile, only horizontal and vertical directions are supported.</param>
/// <param name="defaultTile">Tile to return if off-map.</param>
/// <returns>
/// The tile in the indicated direction. If tile is off-world or an
/// incorrect direction is given, DIRT is returned
/// </returns>
private ushort getTileFromMap(Position pos, Direction2 dir, ushort defaultTile)
{
switch (dir)
{
case Direction2.DIR2_NORTH:
if (pos.posY > 0)
{
return((ushort)(map[pos.posX, pos.posY - 1] & (ushort)MapTileBits.LOMASK));
}
return(defaultTile);
case Direction2.DIR2_EAST:
if (pos.posX < WORLD_W - 1)
{
return((ushort)(map[pos.posX + 1, pos.posY] & (ushort)MapTileBits.LOMASK));
}
return(defaultTile);
case Direction2.DIR2_SOUTH:
if (pos.posY < WORLD_H - 1)
{
return((ushort)(map[pos.posX, pos.posY + 1] & (ushort)MapTileBits.LOMASK));
}
return(defaultTile);
case Direction2.DIR2_WEST:
if (pos.posX > 0)
{
return((ushort)(map[pos.posX - 1, pos.posY] & (ushort)MapTileBits.LOMASK));
}
return(defaultTile);
default:
return(defaultTile);
}
}
public override void Update(TimeSpan t)
{
var rotation = this.controls.RotateCounterClockwise.AnalogAmount
- this.controls.RotateClockwise.AnalogAmount;
this.aimDirection += 2f.Radians() * rotation * (float)t.NumericValue;
#if DEBUG
if (this.controls.ShootDebug.Hit)
{
var request = ShootDebugParticleFromPlanet.Request(this.game, this, this.body, this.aimDirection);
this.game.RequestHandler.TryDo(request);
}
#endif
if (this.controls.Shoot.Active)
{
var fireInterval = new TimeSpan(1 / this.economy[EcoValue.FireRate].Value);
var timeSinceLastShot = this.game.Time - this.lastShot;
if (timeSinceLastShot > fireInterval)
{
if (this.economy[EcoValue.Projectiles].Value >= 1)
{
var request = ShootProjectileFromPlanet.Request(this.game, this, this.body, this.aimDirection);
this.game.RequestHandler.TryDo(request);
this.lastShot = this.game.Time;
}
}
}
this.updateZoom(t);
foreach (var stat in this.stats)
{
stat.Update(t);
}
}
public Particle(GameState game, Color color, Vector2 position, Direction2 direction, float speed, float lifeTime)
: this(game, color, position, direction.Vector * speed, lifeTime)
{
}
public virtual void Update(ShipControlState controlState, float elapsedTime)
{
this.realPosition = this.owner.LocalToGlobalPosition(this.positionOffset);
this.realDirection = this.owner.LocalToGlobalDirection(this.directionOffset);
}
private void updateMovement(ShipControlState controlState, float elapsedTime)
{
this.forwards += Angle.FromRadians(controlState.Steer) * elapsedTime;
if (controlState.Accelerate)
{
this.velocity += this.forwards.Vector * this.acceleration * elapsedTime;
}
var dragFactor = Mathf.Pow(this.inverseFriction, elapsedTime);
this.velocity *= dragFactor;
this.position += this.velocity * elapsedTime;
this.localRotation = Matrix2.CreateRotation(-this.forwards.Radians);
}
public override void Update(TimeSpan t)
{
var rotation = this.controls.RotateCounterClockwise.AnalogAmount
- this.controls.RotateClockwise.AnalogAmount;
this.aimDirection += 2f.Radians() * rotation * (float)t.NumericValue;
#if DEBUG
if (this.controls.ShootDebug.Hit)
{
var request = ShootDebugParticleFromPlanet.Request(this.game, this, this.body, this.aimDirection);
this.game.RequestHandler.TryDo(request);
}
#endif
if (this.controls.Shoot.Active)
{
var fireInterval = new TimeSpan(1 / this.economy[EcoValue.FireRate].Value);
var timeSinceLastShot = this.game.Time - this.lastShot;
if (timeSinceLastShot > fireInterval)
{
if (this.economy[EcoValue.Projectiles].Value >= 1)
{
var request = ShootProjectileFromPlanet.Request(this.game, this, this.body, this.aimDirection);
this.game.RequestHandler.TryDo(request);
this.lastShot = this.game.Time;
}
}
}
this.updateZoom(t);
foreach (var stat in this.stats)
{
stat.Update(t);
}
}
private void updateMovement(TimeSpan elapsedTime, float acceleration, float leftRight)
{
var t = (float)elapsedTime.NumericValue;
this.speed += new Acceleration(acceleration * 50) * elapsedTime;
this.speed *= Mathf.Pow(1e-3f, t);
this.turnSpeed += AngularAcceleration.FromRadians(leftRight * 5) * elapsedTime;
this.turnSpeed *= Mathf.Pow(1e-7f, t);
this.Direction += this.turnSpeed * (elapsedTime * this.speed.NumericValue);
this.Position += this.Direction * this.speed * elapsedTime;
this.distanceTraveled += this.speed * elapsedTime;
}
