public GridSystem(Room room, int cellsX, Vector2 position, int? GridWidth = null, int? GridHeight = null)
{
linesToDraw = new List<Rectangle>();
this.position = position;
this.room = room;
this.gridWidth = GridWidth ?? room.worldWidth;
this.gridHeight = GridHeight ?? room.worldHeight;
this.cellsX = cellsX;
//this.cellReach = cellReach;
cellWidth = (int)Math.Ceiling((double)gridWidth / (double)cellsX);
cellHeight = cellWidth;
this.cellsY = (gridHeight - 1)/ cellHeight + 1;
//cellheight = gridheight / cellsY;
grid = new List<Collider>[cellsX, cellsY];
for (int i = 0; i < cellsX; i++)
{
for (int j = 0; j < cellsY; j++)
{
grid[i, j] = new List<Collider>();
}
}
//
arrayGrid = new IndexArray<Collider>[cellsX][];
for(int i = 0; i < cellsX; i++)
{
arrayGrid[i] = new IndexArray<Collider>[cellsY];
for(int j = 0; j < cellsY; j++)
{
arrayGrid[i][j] = new IndexArray<Collider>(100);
}
}
bucketBags = new IndexArray<IndexArray<Collider>>[cellsX][];
for (int i = 0; i < cellsX; i++)
{
bucketBags[i] = new IndexArray<IndexArray<Collider>>[cellsY];
for (int j = 0; j < cellsY; j++)
{
bucketBags[i][j] = new IndexArray<IndexArray<Collider>>(20);
}
}
//
distToOffsets = GenerateReachOffsetsDictionary();
//Stopwatch stopwatch = new Stopwatch();
//stopwatch.Start();
int generateReach = gridWidth / 3;
//GenerateAllReachOffsetsPerCoord(generateReach); //takes a shitload of time.. but only for the temproom?
//stopwatch.Stop();
//string taken = stopwatch.Elapsed.ToString();
//Console.WriteLine("gridsystem generation time taken: " + taken);
bucketLists = new List<List<Collider>>[cellsX, cellsY];
///new attempt
GenerateReachOffsetsArray();
}
public Level(Room room, int cellsX, int cellsY, int cellWidth, int? cellHeight = null)
{
this.room = room;
this.cellsX = cellsX;
this.cellsY = cellsY;
this.cellWidth = cellWidth;
this.cellHeight = cellHeight ?? cellWidth;
}
//public static Dictionary<string, bool> timerStarteds = new Dictionary<string, bool>();
public Testing()
{
room = OrbIt.game.room;
Redirector.PopulateDelegatesAll();
redirector = new Redirector();
//obints.CollectionChanged += (s, e) => { };
}
public Formation(Link link,
Formation form,
bool InitializeFormation = true)
{
this.room = OrbIt.game.room;
this.link = link;
//this.FormationType = FormationType;
this.Uninhabited = form.Uninhabited;
this.UpdateFrequency = form.UpdateFrequency;
this.NearestNValue = form.NearestNValue;
this.AffectionSets = new Dictionary<Node, ObservableHashSet<Node>>();
if (InitializeFormation) UpdateFormation();
}
public Formation( Link link,
formationtype FormationType = formationtype.AllToAll,
bool Uninhabited = false,
int UpdateFrequency = -1,
int NearestNValue = 1,
bool InitializeFormation = true)
{
this.room = OrbIt.game.room;
this.link = link;
//this.FormationType = FormationType;
this.Uninhabited = Uninhabited;
this.UpdateFrequency = UpdateFrequency;
this.NearestNValue = NearestNValue;
this.AffectionSets = new Dictionary<Node, ObservableHashSet<Node>>();
if (InitializeFormation) UpdateFormation();
}
public Group(Room room, Node defaultNode = null, Group parentGroup = null, string Name = "", bool Spawnable = true, ObservableHashSet<Node> entities = null)
{
if (parentGroup != null) room = parentGroup.room;
this.room = room ?? OrbIt.game.room;
GroupId = -1;
this.defaultNode = defaultNode ?? this.room.defaultNode;
this.entities = entities ?? new ObservableHashSet<Node>();
this.inherited = new ObservableHashSet<Node>();
this.fullSet = new ObservableHashSet<Node>();
if (entities != null)
{
foreach (Node e in entities)
{
fullSet.Add(e);
}
}
this.parentGroup = parentGroup;
//this.groupState = groupState;
this.Spawnable = Spawnable;
this.childGroups = new Dictionary<string, Group>();
this.entities.CollectionChanged += entities_CollectionChanged;
this.inherited.CollectionChanged += entities_CollectionChanged;
if (Name.Equals(""))
{
this.GroupId = GroupNumber;
Name = "Group" + GroupNumber; //maybe a check that the name is unique
GroupNumber++;
}
this.Name = Name;
groupPath = new List<Group>();
if (parentGroup != null)
{
parentGroup.AddGroup(this.Name, this);
Group g = parentGroup;
while (g != null)
{
groupPath.Add(g);
g = g.parentGroup;
}
}
}
public RoomPanel(Sidebar sidebar, Control parent, Room room, bool interactive, int Top = 0, int Padding = 5)
{
this.Padding = Padding;
panel = new Panel(sidebar.manager);
panel.Init();
panel.Top = Top;
panel.Left = Padding;
panel.Width = room.worldWidth;
panel.Height = room.worldHeight;
//roomPanel.Left = (parent.Width - roomPanel.Width)/2;
int col = 30;
panel.Color = new Color(col, col, col);
panel.BevelBorder = BevelBorder.All;
panel.BevelStyle = BevelStyle.Flat;
panel.BevelColor = Color.Black;
parent.Add(panel);
panel.ClientArea.Draw += (s, e) =>
{
e.Renderer.Draw(room.roomRenderTarget, e.Rectangle, Color.White);
};
refreshAction = refresh;
parent.VisibleChanged += (s, e) => {
if (parent.Visible)
OrbIt.OnUpdate += refreshAction;
else
OrbIt.OnUpdate -= refreshAction;
};
panel.Click += (s, e) =>
{
Point innerpos = (e as MouseEventArgs).Position;
//room.spawnNode(innerpos.X, innerpos.Y);
Utils.notImplementedException();
};
}
public CollisionManager(Room room)
{
this.room = room;
CollisionSetCircle = new HashSet<Collider>();
CollisionSetPolygon = new HashSet<Collider>();
colIterations = 1;
collideAction = (c1, c2) =>
{
if (c1.parent == c2.parent) return;
if (c1 is Body)
{
Body b = (Body)c1;
if (gridsystemCollision.alreadyVisited.Contains(c2)) return;
if (c2 is Body)
{
Body bb = (Body)c2;
//if (!b.exclusionList.Contains(bb))
b.CheckCollisionBody(bb);
}
else
{
b.CheckCollisionCollider(c2);
}
}
else
{
if (gridsystemCollision.alreadyVisited.Contains(c2)) return;
if (c2 is Body)
{
Body bb = (Body)c2;
//if (!c1.exclusionList.Contains(bb))
c1.CheckCollisionBody(bb);
}
}
};
gridsystemCollision = new GridSystem(room, room.gridsystemAffect.cellsX, new Vector2(0, room.worldHeight - OrbIt.ScreenHeight), room.worldWidth, OrbIt.ScreenHeight);
}
protected override void Initialize()
{
Assets.LoadAssets(Content);
base.Initialize();
base.MainWindow.TransparentClientArea = true;
room = new Room(this, ScreenWidth, ScreenHeight-40);
setResolution(prefWindowedResolution, false);
globalGameMode = new GlobalGameMode(this);
frameRateCounter = new FrameRateCounter(this);
Player.CreatePlayers(room);
ui = UserInterface.Start();
ui.Initialize();
room.attatchToSidebar(ui);
GlobalKeyBinds(ui);
}
public void Draw(Room room, Vector2 position, Color color)
{
room.camera.AddPermanentDraw(texture, position, color * alpha, scale, rotation, 20);
}
public Formation()
{
//..
this.room = OrbIt.game.room;
this.AffectionSets = new Dictionary<Node, ObservableHashSet<Node>>();
}
public Gametype()
{
room = OrbIt.game.room;
players = new HashSet<Player>();
}
public void DrawGrid(Room room, Color color)
{
room.camera.drawGrid(linesToDraw, color);
linesToDraw = new List<Rectangle>();
}
public RoomGroups(Room room)
{
this.room = room;
}
public ThreadedCamera(Room room, float zoom = 0.5f, Vector2? pos = null)
{
this.room = room;
this.batch = new SpriteBatch(OrbIt.game.GraphicsDevice);
this.zoom = zoom;
this.pos = pos ?? new Vector2(room.gridsystemAffect.position.X + room.gridsystemAffect.gridWidth / 2, 10 + room.gridsystemAffect.position.Y + room.gridsystemAffect.gridHeight / 2);
_worker = new Thread(Work);
_worker.Name = "CameraThread";
_worker.IsBackground = true;
_worker.Start();
//Game1.ui.keyManager.addProcessKeyAction("screenshot", KeyCodes.PrintScreen, OnPress: delegate { TakeScreenshot = true; });
}
public static void MakeBullet(Room room)
{
Dictionary<dynamic, dynamic> props = new Dictionary<dynamic, dynamic>()
{
{ nodeE.radius, 5f},
{ typeof(Laser), true},
{ typeof(ColorChanger), true},
{ typeof(Lifetime), true},
};
bulletNode = new Node(room, props);
bulletNode.Comp<Collision>().isSolid = false;
bulletNode.body.isSolid = true;
bulletNode.body.restitution = 1f;
bulletNode.Comp<ColorChanger>().colormode = ColorChanger.ColorMode.hueShifter;
bulletNode.Comp<Lifetime>().timeUntilDeath.enabled = true;
bulletNode.Comp<Laser>().thickness = 5f;
bulletNode.Comp<Laser>().laserLength = 20;
bulletNode.Comp<Movement>().randInitialVel.enabled = false;
bulletNode.group = room.groups.bullets;
}
public void MakeBigTony(Room room)
{
//if (bigtony != null)
//{
// return;
//}
Dictionary<dynamic, dynamic> tonyProps = new Dictionary<dynamic, dynamic>()
{
{ nodeE.position, new Vector2(room.worldWidth/2,room.worldHeight/2) },
{ nodeE.texture, textures.blackorb },
{ typeof(PhaseOrb), true },
};
Node tony = new Node(room, tonyProps);
room.scheduler.doEveryXMilliseconds(delegate
{
if (OrbIt.soundEnabled) Scheduler.end.Play(0.3f, -0.5f, 0f);
int rad = 100;
for (int i = 0; i < 10; i++)
{
int rx = Utils.random.Next(rad * 2) - rad;
int ry = Utils.random.Next(rad * 2) - rad;
//room.spawnNode(room.worldWidth / 2 + rx, room.worldHeight / 2 + ry);
}
}, 2000);
//tony.body.pos = new Vector2(room.worldWidth / 2, room.worldHeight / 2);
tony.body.radius = 64;
tony.body.mass = tonymass;
tony.body.velocity *= 100;
tony.name = "bigTony";
tony.body.texture = textures.blackorb;
tony.Comp<Queuer>().queuecount = 100;
bigtony = tony;
EventHandler updateScores = null;
updateScores = (ooo, eee) =>
{
foreach (var p in room.players)
{
if (p.node == bigtony)
{
p.node.meta.score += OrbIt.gametime.ElapsedGameTime.Milliseconds;
if (p.node.meta.score >= maxScore)
{
p.node.body.radius += 500;
p.node.body.mass += 100;
foreach (var pp in room.players)
{
//pp.node.body.ClearHandlers();
//pp.nodeCollision.body.ClearHandlers();
pp.node.collision.AllHandlersEnabled = false;
}
if (OrbIt.soundEnabled) Scheduler.fanfare.Play();
bigtony.OnAffectOthers -= updateScores;
}
}
}
};
bigtony.OnAffectOthers += updateScores;
room.masterGroup.fullSet.Add(bigtony); //#bigtony
}
