public static vector2 getCenteredVector2(vector2 center, int dist)
{
var x = getCenteredInt(dist, center.x);
var y = getCenteredInt(dist, center.y);
return(new vector2(x, y));
}
public vector2 updateScreenPos()
{
vector2 newScreenPos = new vector2(pcPos.x - (frameBuffer[0].Length / 2) + 1, pcPos.y - (frameBuffer.Count / 2));
if (newScreenPos.x < 0)
{
newScreenPos.x = 0;
}
if (newScreenPos.y < 0)
{
newScreenPos.y = 0;
}
if (newScreenPos.x + frameBuffer[0].Length + 1 > Program.getWorld().tiles.GetLength(0))
{
newScreenPos.x = (short)(Program.getWorld().tiles.GetLength(0) - frameBuffer[0].Length);
}
if (newScreenPos.y + frameBuffer.Count + 1 > Program.getWorld().tiles.GetLength(1))
{
newScreenPos.y = (short)(Program.getWorld().tiles.GetLength(1) - frameBuffer.Count);
}
return(newScreenPos);
}
public ChexelEntity(vector2 pos, ConsoleColor f, char t)
{
this.pos = pos;
this.f = f;
this.t = t;
components = new Dictionary <string, ChexelComponent>();
}
public Chexel getChexel(int x, int y)
{
vector2 worldPos = ScreenToWorldPos(new vector2(x, y));
Chexel chexel = tileMap.getChexel(worldPos.x, worldPos.y);
if (entities.ContainsKey(worldPos))
{
chexel.f = entities[worldPos].f;
chexel.b = ConsoleColor.Black;
chexel.t = entities[worldPos].t;
}
List <FrameEntity> frameEntityCollection = new List <FrameEntity>(frameEntities);
foreach (FrameEntity v in frameEntityCollection)
{
Chexel temp = v.frame.getChexel(worldPos.x, worldPos.y);
if (temp.t != ' ')
{
chexel.t = temp.t;
chexel.f = temp.f;
chexel.b = temp.b;
}
}
return(chexel);
}
private Color getColorFromTile(Tile t, vector2 pos, vector2 tilePos)
{
Random.InitState((tilePos.x + tilePos.y + 1) * (tilePos.x + tilePos.y / 2) + tilePos.y);
switch (t)
{
case Tile.Energy:
var e = Level.currentLevel.EnergyTiles[Rand(Level.currentLevel.EnergyTiles)];
return(e.texture.GetPixel(pos.x + (int)(e.rect.x), pos.y + (int)(e.rect.y)));
case Tile.Floor:
var f = Level.currentLevel.FloorTiles[Rand(Level.currentLevel.FloorTiles)];
return(f.texture.GetPixel(pos.x + (int)(f.rect.x), pos.y + (int)(f.rect.y)));
case Tile.Hole:
var h = Aligntiles(tilePos.x, tilePos.y, Level.currentLevel.HoleTiles);
return(h.texture.GetPixel(pos.x + (int)(h.rect.x), pos.y + (int)(h.rect.y)));
case Tile.Wall:
var w = Level.currentLevel.WallTiles[Rand(Level.currentLevel.WallTiles)];
return(w.texture.GetPixel(pos.x + (int)(w.rect.x), pos.y + (int)(w.rect.y)));
case Tile.DoorUp:
var du = Level.currentLevel.DoorUpTiles[Rand(Level.currentLevel.DoorUpTiles)];
return(du.texture.GetPixel(pos.x + (int)(du.rect.x), pos.y + (int)(du.rect.y)));
case Tile.DoorDown:
var dd = Level.currentLevel.DoorDownTiles[Rand(Level.currentLevel.DoorDownTiles)];
return(dd.texture.GetPixel(pos.x + (int)(dd.rect.x), pos.y + (int)(dd.rect.y)));
}
return(Color.clear);
}
public void centerOnCell(vector2 pos)
{
offset.x = pos.x - (Program.frameManager.width / 2);
offset.y = pos.y - (Program.frameManager.height / 2);
if (offset.x > tileMap.width - 1 - (Program.frameManager.width))
{
offset.x = tileMap.width - 1 - (Program.frameManager.width);
}
if (offset.x < 0)
{
offset.x = 0;
}
if (offset.y > tileMap.height - 1 - (Program.frameManager.height))
{
offset.y = tileMap.height - 1 - (Program.frameManager.height);
}
if (offset.y < 0)
{
offset.y = 0;
}
}
public void PositionCorrection()
{
vector2 Correction = (Math.Max(Penetration - AllowedPenetration, 0) / (bodyA.InverseMass + bodyB.InverseMass)) * Normal * CorrectionPercentage;
bodyA.Postition -= Correction * bodyA.InverseMass;
bodyB.Postition += Correction * bodyB.InverseMass;
}
public static float[,] addCircleMap(float[,] map, float percentage, float lowerAmount)
{
var reMapped = new float[map.GetLength(0), map.GetLength(1)];
var zero = new vector2(map.GetLength(0) / 2, map.GetLength(1) / 2);
var currentPos = new vector2();
var max = new vector2(map.GetLength(0), map.GetLength(1));
var range = Remap(percentage, 0, 1, 0, max.dist(zero));
for (var y = 0; y < map.GetLength(1); y++)
{
for (var x = 0; x < map.GetLength(0); x++)
{
currentPos.x = x;
currentPos.y = y;
if (currentPos.dist(zero) > range)
{
reMapped[x, y] = 1;
}
else
{
reMapped[x, y] = map[x, y] - lowerAmount;
if (reMapped[x, y] < 0)
{
reMapped[x, y] = 0;
}
}
}
}
return(reMapped);
}
public void ApplyImpulse(float Delta)
{
if ((bodyA.Mass + bodyB.Mass) == 0)
{
InfiniteMassCorrection();
return;
}
for (int i = 0; i < Contacts.Count; i++)
{
vector2 rada = Contacts[i] - bodyA.Postition;
vector2 radb = Contacts[i] - bodyB.Postition;
vector2 rev = bodyB.Velocity + Vector2.Cross(bodyB.AngularVelocity, radb) - bodyB.Velocity - Vector2.Cross(bodyA.AngularVelocity, rada);
float ContactVelocity = Vector2.Dot(rev, Normal);
if (ContactVelocity > 0)
{
return;
}
///Apply Impulse
float radaCrossN = Vector2.Cross(rada, Normal);
float radbCrossN = Vector2.Cross(radb, Normal);
float InverseMassSum = bodyA.Mass + bodyB.Mass + (float)Math.Sqrt(radaCrossN) * bodyA.InverseInertia + (float)Math.Sqrt(radbCrossN) * bodyB.InverseInertia;
float ImpulseScaler = -(1 + CombinedRestitution) * ContactVelocity;
ImpulseScaler = (ImpulseScaler / InverseMassSum) / (float)Contacts.Count;
vector2 Impulse = Normal * ImpulseScaler;
bodyA.ApplyImpulse(-Impulse, rada);
bodyB.ApplyImpulse(Impulse, radb);
///Apply Friction Impulse
vector2 Tangent = rev - (Normal * Vector2.Dot(rev, Normal));
Tangent.Normalize();
float TangentScalar = -Vector2.Dot(rev, Tangent);
TangentScalar = (TangentScalar / InverseMassSum) / (float)Contacts.Count;
if (TangentScalar < 0.00f)
{
return;
}
vector2 TangentImpulse;
if (Math.Abs(TangentScalar) < ImpulseScaler * StaticFriction)
{
TangentImpulse = Tangent * TangentScalar;
}
else
{
TangentImpulse = Tangent * -ImpulseScaler * DynamicFriction;
}
bodyA.ApplyImpulse(-TangentImpulse, rada);
bodyB.ApplyImpulse(TangentImpulse, radb);
}
}
public static void SendMouseAngle(float rad, int id, int num)
{
var context = GlobalHost.ConnectionManager.GetHubContext <DaggerHub>();
if (num == 1)
{
PointObject temp = new PointObject(daggersrage.nextid);
daggersrage.nextid++;
PlayerObject result = (PlayerObject)daggersrage.playerArray.Find(x => x.id == id);
if (result != null)
{
temp.currentstate.x_position = result.currentstate.x_position;
temp.currentstate.y_position = result.currentstate.y_position;
temp.currentstate.y_velocity = (float)(300 * Math.Sin(rad));
temp.currentstate.x_velocity = (float)(300 * Math.Cos(rad));
temp.currentstate.y_position += result.currentstate.y_velocity;
/*
* if (temp.currentstate.y_velocity >= 0)
* {
* temp.currentstate.y_position += 16;
*
* }
* else
* {
*
* temp.currentstate.y_position -= 16;
* }
*/
daggersrage.pointArray.Add(temp);
context.Clients.All.addProjectile(temp.id, temp.currentstate);
}
}
else
{
PlayerObject result = (PlayerObject)daggersrage.playerArray.Find(x => x.id == id);
if (result != null)
{
vector2 temp = daggersrage.beamProjection(result.currentstate.x_position, result.currentstate.y_position, rad, 160);
vector2 tempend = new vector2(result.currentstate.x_position, result.currentstate.y_position);
context.Clients.All.addEffect(temp, tempend);
}
}
//Debug.WriteLine("projectiles : " + daggersrage.pointArray.Count + " latest : " + temp.id);
}
private double[] normalize(vector2 toNormalize)
{
double[] f = new double[2];
f[0] = (double)toNormalize.x / (double)size.x;
f[1] = (double)toNormalize.y / (double)size.y;
return(f);
}
public perlin(int seed, int octaves, float persistance, List <int> playersUid, int tilemapScaleX, int tilemapScaleY)
{
this.seed = seed;
this.octaves = octaves;
this.persistance = persistance;
this.players_uid = playersUid;
this.tilemap_scale = new vector2 <int>(tilemapScaleX, tilemapScaleY);
}
public LevelGenerator(int heightTiles, int widthTiles, int pixelPerTile, int roomCount)
{
utils.setSeed(Random.Range(int.MinValue, int.MaxValue));
sizePixels = new vector2(widthTiles * pixelPerTile, heightTiles * pixelPerTile);
sizeTiles = new vector2(widthTiles, heightTiles);
this.pixelPerTile = pixelPerTile;
this.roomCount = roomCount;
}
public static List <vector2> FloodFill(float[,] map, vector2 pt, int worldSize)
{
var badvector2s = new HashSet <vector2>();
var vector2s = new HashSet <vector2>();
var pixels = new Stack <vector2>();
pixels.Push(pt);
while (pixels.Count > 0)
{
var a = pixels.Pop();
if (a.x < worldSize - 1 && a.x > 0 && a.y < worldSize - 1 && a.y > 0)
{
// make sure we stay within bounds
if (map[a.x, a.y] <= 0)
{
if (!vector2s.Contains(new vector2(a.x, a.y)))
{
vector2s.Add(new vector2(a.x, a.y));
}
if (!vector2s.Contains(new vector2(a.x - 1, a.y)) && map[a.x - 1, a.y] <= 0 &&
!pixels.Contains(new vector2(a.x - 1, a.y)) && !badvector2s.Contains(new vector2(a.x - 1, a.y)))
{
pixels.Push(new vector2(a.x - 1, a.y));
badvector2s.Add(new vector2(a.x - 1, a.y));
}
if (!vector2s.Contains(new vector2(a.x + 1, a.y)) && map[a.x + 1, a.y] <= 0 &&
!pixels.Contains(new vector2(a.x + 1, a.y)) && !badvector2s.Contains(new vector2(a.x + 1, a.y)))
{
pixels.Push(new vector2(a.x + 1, a.y));
badvector2s.Add(new vector2(a.x + 1, a.y));
}
if (!vector2s.Contains(new vector2(a.x, a.y - 1)) && map[a.x, a.y - 1] <= 0 &&
!pixels.Contains(new vector2(a.x, a.y - 1)) && !badvector2s.Contains(new vector2(a.x, a.y - 1)))
{
pixels.Push(new vector2(a.x, a.y - 1));
badvector2s.Add(new vector2(a.x, a.y - 1));
}
if (!vector2s.Contains(new vector2(a.x, a.y + 1)) && map[a.x, a.y + 1] <= 0 &&
!pixels.Contains(new vector2(a.x, a.y + 1)) && !badvector2s.Contains(new vector2(a.x, a.y + 1)))
{
pixels.Push(new vector2(a.x, a.y + 1));
badvector2s.Add(new vector2(a.x, a.y + 1));
}
}
else
{
badvector2s.Add(a);
}
}
}
return(vector2s.ToList());
}
public clientInfo(string userName, string passcode, int xSize, int ySize)
{
this.userName = userName;
this.passcode = passcode;
initFrameBuffer(xSize, ySize);
pcPos = new vector2(10, 10);
screenPos = new vector2();
message = "";
}
public (bool, ChexelEntity) chexelCollide(vector2 pos)
{
if (entities.ContainsKey(pos))
{
return(true, entities[pos]);
}
return(false, null);
}
public ChexelEntity getEntityAt(vector2 pos)
{
if (entities.ContainsKey(pos))
{
return(entities[pos]);
}
return(null);
}
private bool isAlreadyFound(vector2 toCheck, HashSet <vector2> clearAreas)
{
if (clearAreas.Contains(toCheck))
{
return(true);
}
return(false);
}
public void update(updateableObject gameObject)
{
vector2 newPos = doInputCheck();
if (gameObject.move(newPos))
{
pos = newPos;
}
}
public static vector4 getSplit(vector2 pos, int chunkSize)
{
var chunkX = pos.x / chunkSize;
var chunkY = pos.y / chunkSize;
var tileX = pos.x % chunkSize;
var tileY = pos.y % chunkSize;
return(new vector4(chunkX, chunkY, tileX, tileY));
}
public void move(vector2 movement)
{
if (!Program.getWorld().getTile(movement).ground.isCollideable)
{
displayName(true);
pcPos = movement;
screenPos = updateScreenPos();
displayName(false);
}
}
public void updateBegin()
{
if (!hasMoved)
{
Program.uiManager.AddMessage(new Message((int)((1.0 * Program.frameManager.width) / 3.0), (int)((2.0 * Program.frameManager.height) / 3.0), "press w to walk up.", ConsoleColor.White, ConsoleColor.Black), true);
}
if (waitCounter > waitFrames)
{
vector2 movement = new vector2();
if (Program.input.IsKeyHeld(OpenTK.Input.Key.W) && controllable)
{
movement.y--;
hasMoved = true;
}
if (Program.input.IsKeyHeld(OpenTK.Input.Key.S) && controllable)
{
movement.y++;
}
if (Program.input.IsKeyHeld(OpenTK.Input.Key.A) && controllable)
{
movement.x--;
}
if (Program.input.IsKeyHeld(OpenTK.Input.Key.D) && controllable)
{
movement.x++;
}
if (Program.tileMapManager.moveEntity(follow, new vector2(follow.pos.x + movement.x, follow.pos.y + movement.y)) && controllable)
{
Program.tileMapManager.centerOnCell(follow.pos);
}
else
{
(bool, FrameEntity)col = Program.tileMapManager.frameCollide(new vector2(follow.pos.x + movement.x, follow.pos.y + movement.y));
if (col.Item1)
{
CockpitCComponent cockpit = (CockpitCComponent)col.Item2.GetComponent(new CockpitCComponent().GetType().ToString());
cockpit.activateCockpit();
Program.tileMapManager.removeEntity(follow);
}
}
}
else
{
waitCounter++;
}
Program.uiManager.AddMessage(new Message(0, 1, follow.pos.toString(), ConsoleColor.White, ConsoleColor.Black), true);
}
public bool Equals(vector2 X, vector2 Y)
{
if (X.x == Y.x && X.y == Y.y)
{
return(true);
}
else
{
return(false);
}
}
public (bool, FrameEntity) frameCollide(vector2 pos)
{
for (int i = 0; i < frameEntities.Count; i++)
{
if (frameEntities[i].isActive && frameEntities[i].frame.hasChexel(pos.x, pos.y))
{
return(frameEntities[i].frame.getChexel(pos.x, pos.y).t != ' ', frameEntities[i]);
}
}
return(false, null);
}
public bool updateTargetPos()
{
vector2 newPos = new vector2(target.pos.x, target.pos.y + target.frame.height);
if (targetOldPos.x != newPos.x && targetOldPos.y != newPos.y)
{
targetOldPos = newPos;
return(true);
}
return(false);
}
private void doMoveMode(char command)
{
vector2 pos = new vector2(pcPos.x, pcPos.y);
if (command == 'w')
{
if (pcPos.y - 1 >= 0 && pcPos.y - 1 < worldManager.size.y)
{
pos.y -= 1;
}
}
if (command == 's')
{
if (pcPos.y + 1 >= 0 && pcPos.y + 1 < worldManager.size.y)
{
pos.y += 1;
}
}
if (command == 'a')
{
if (pcPos.x - 1 >= 0 && pcPos.x - 1 < worldManager.size.x)
{
pos.x -= 1;
}
}
if (command == 'd')
{
if (pcPos.x + 1 >= 0 && pcPos.x + 1 < worldManager.size.x)
{
pos.x += 1;
}
}
if (command == '~')
{
if (iMode == inputMode.movementMode)
{
iMode = inputMode.textMode;
displayName(true);
message = "";
}
else
{
iMode = inputMode.movementMode;
}
}
move(pos);
}
public vector2 getMove(gameState state)
{
vector2 toReturn = pc.getMove(state);
if (!toReturn.Equals(vector2.zero))
{
return(toReturn);
}
else
{
return(ai.getMove(state));
}
}
public bool hasChexel(int x, int y)
{
vector2 worldPos = ScreenToWorldPos(new vector2(x, y));
List <FrameEntity> frameEntityCollection = new List <FrameEntity>(frameEntities);
foreach (FrameEntity v in frameEntityCollection)
{
v.frame.hasChexel(x, y);
}
return(tileMap.hasChexel(worldPos.x, worldPos.y) || entities.ContainsKey(worldPos));
}
public bool moveEntity(ChexelEntity toMove, vector2 newPos)
{
if (checkCollide(toMove.pos, newPos))
{
return(false);
}
else
{
removeEntity(toMove);
toMove.pos = newPos;
return(addEntity(toMove));
}
}
public Tile[,] getTiles(vector2 offset, int range)
{
Tile[,] temp = new Tile[2 * range + 1, 2 * range + 1];
for (int i = offset.x - range; i <= offset.x + range; i++)
{
for (int j = offset.y - range; j <= offset.y + range; j++)
{
temp[offset.x - i, offset.y - j] = getTile(new vector2(i, j));
}
}
return(temp);
}
class.class306_0.vmethod_5(vector2, false);
