public void drawSolar(Solar obj, Graphics tool)
{
int r = (int)(obj.radius * zoomLevel);
int ra = (int)((obj.radius + (Globals.gridSize * obj.atmosphere * 0.6)) * zoomLevel);
if (obj.atmosphere != 0)
{
if (obj.fusion)
{
tool.FillEllipse(Brushes.OrangeRed, (float)Globals.xToDisp(obj.x, xcenter, zoomLevel) - ra,
(float)Globals.yToDisp(obj.y, ycenter, zoomLevel) - ra, ra * 2, ra * 2);
}
else
{
tool.FillEllipse(Brushes.DarkCyan, (float)Globals.xToDisp(obj.x, xcenter, zoomLevel) - ra,
(float)Globals.yToDisp(obj.y, ycenter, zoomLevel) - ra, ra * 2, ra * 2);
}
}
if (obj.fusion)
{
tool.FillEllipse(Brushes.Yellow, (float)Globals.xToDisp(obj.x, xcenter, zoomLevel) - r,
(float)Globals.yToDisp(obj.y, ycenter, zoomLevel) - r, r * 2, r * 2);
}
else
{
tool.FillEllipse(Brushes.PaleGreen, (float)Globals.xToDisp(obj.x, xcenter, zoomLevel) - r,
(float)Globals.yToDisp(obj.y, ycenter, zoomLevel) - r, r * 2, r * 2);
}
for (int k = 0; k < 360; k += 5)
{
double angle = k;
double xdist = (obj.gravityRad) * (Math.Cos(Globals.DegToRad((double)angle)));
double ydist = (obj.gravityRad) * (Math.Sin(Globals.DegToRad((double)angle)));
double xdist2 = (obj.gravityRad) * (Math.Cos(Globals.DegToRad((double)angle - 5)));
double ydist2 = (obj.gravityRad) * (Math.Sin(Globals.DegToRad((double)angle - 5)));
tool.DrawLine(new Pen((Brushes.Blue), 1),
(int)Globals.xToDisp(obj.x + xdist, xcenter, zoomLevel), (int)Globals.yToDisp(obj.y + ydist, ycenter, zoomLevel),
(int)Globals.xToDisp(obj.x + xdist2, xcenter, zoomLevel), (int)Globals.yToDisp(obj.y + ydist2, ycenter, zoomLevel));
}
for (int j = 1; j < obj.size; j++)
{
for (int k = 0; k < 360; k += 5)
{
double angle = k;
double xdist = ((0.6 * Globals.gridSize * j) + obj.radius - (0.5 * Globals.gridSize)) * (Math.Cos(Globals.DegToRad((double)angle)));
double ydist = ((0.6 * Globals.gridSize * j) + obj.radius - (0.5 * Globals.gridSize)) * (Math.Sin(Globals.DegToRad((double)angle)));
double xdist2 = ((0.6 * Globals.gridSize * j) + obj.radius - (0.5 * Globals.gridSize)) * (Math.Cos(Globals.DegToRad((double)angle - 5)));
double ydist2 = ((0.6 * Globals.gridSize * j) + obj.radius - (0.5 * Globals.gridSize)) * (Math.Sin(Globals.DegToRad((double)angle - 5)));
tool.DrawLine(new Pen(Color.FromArgb(64, 64, 64), 1),
(int)Globals.xToDisp(obj.x + xdist, xcenter, zoomLevel), (int)Globals.yToDisp(obj.y + ydist, ycenter, zoomLevel),
(int)Globals.xToDisp(obj.x + xdist2, xcenter, zoomLevel),
(int)Globals.yToDisp(obj.y + ydist2, ycenter, zoomLevel));
}
}
for (int j = 0; j < obj.size; j++)
{
if (obj.size > 1)
{
double anglePer = 360.0 / ((double)obj.size);
for (double k = 0; k < obj.size; k++)
{
//((obj.radius - 2 + (k * 6)) * Math.Sin(Globals.DegToRad((double)(anglePer * j) + obj.angle - angleOff)))
double angleOff = anglePer * (k % 2) / 2;
double angle = (j * anglePer) + (anglePer / 2) + obj.angle - angleOff;
double xdist1 = ((obj.radius + (0.1 * Globals.gridSize) + (k * 0.6 * Globals.gridSize)) * Math.Sin(Globals.DegToRad(angle)));
double ydist1 = ((obj.radius + (0.1 * Globals.gridSize) + (k * 0.6 * Globals.gridSize)) * Math.Cos(Globals.DegToRad(angle)));
double xdist2 = ((obj.radius - (0.5 * Globals.gridSize) + (k * 0.6 * Globals.gridSize)) * Math.Sin(Globals.DegToRad(angle)));
double ydist2 = ((obj.radius - (0.5 * Globals.gridSize) + (k * 0.6 * Globals.gridSize)) * Math.Cos(Globals.DegToRad(angle)));
tool.DrawLine(new Pen(Color.FromArgb(64, 64, 64), 1),
(int)Globals.xToDisp(obj.x + xdist1, xcenter, zoomLevel), (int)Globals.yToDisp(obj.y - ydist1, ycenter, zoomLevel),
(int)Globals.xToDisp(obj.x + xdist2, xcenter, zoomLevel), (int)Globals.yToDisp(obj.y - ydist2, ycenter, zoomLevel));
}
}
}
tool.DrawString(obj.name, planetHeader, Brushes.Green,
(float)Globals.xToDisp(obj.x, xcenter, zoomLevel) + 5, (float)Globals.yToDisp(obj.y, ycenter, zoomLevel) + 5);
}
public Solar randomPlanet(int _size)
{
bool planetplaced = false;
bool valid = true;
Solar planet;
int size = _size;
double x = 0;
double y = 0;
int tries = 0;
while (!planetplaced && tries < 100)
{
tries++;
valid = true;
double dist = Globals.randint.Next(250);
double angle = Globals.randint.Next(360);
x = dist * Math.Sin(Globals.DegToRad(angle));
y = dist * -Math.Cos(Globals.DegToRad(angle));
for (int j = 0; j < solars.Count(); j++)
{
double gravityRad = Globals.wellradius(size);
double curdist = Globals.Distance(x, y, solars[j].x, solars[j].y);
double mindist = gravityRad + solars[j].gravityRad + Globals.gridSize;
if (curdist < mindist)
{
valid = false;
}
}
if (valid)
{
planetplaced = true;
}
}
planet = new Solar(x, y, "New ERROR", solars.Count() + 2, size);
if (size == 1)
{
planet = new Solar(x, y, "New Asteroid", solars.Count() + 2, size);
}
if (1 < size && size <= 7)
{
planet = new Solar(x, y, "New Planet", solars.Count() + 2, size);
}
if (7 < size && size <= 8)
{
planet = new Solar(x, y, "New Dwarf Star", solars.Count() + 2, size);
}
if (8 < size && size <= 12)
{
planet = new Solar(x, y, "New Star", solars.Count() + 2, size);
}
if (12 < size && size <= 14)
{
planet = new Solar(x, y, "New Giant Star", solars.Count() + 2, size);
}
if (14 < size)
{
planet = new Solar(x, y, "New Supergiant", solars.Count() + 2, size);
}
return(planet);
}
/// <summary>
/// Creates a polar region of map nodes centered around a solar object.
/// </summary>
/// <param name="obj"></param>
public void gravityWell(Solar obj)
{
for (int j = 0; j < nodes.Count(); j++)
{
MapNode node = nodes[j];
if (Globals.Distance(obj.x, obj.y, node.x, node.y) <= obj.gravityRad)
{
node.suppressionCode = obj.suppressionCode;
}
}
List <List <MapNode> > grid = new List <List <MapNode> >();
double anglePer = 360.0 / (double)obj.size;
double angleOff;
for (int j = 0; j < obj.size; j++)
{
List <MapNode> ring = new List <MapNode>();
grid.Add(ring);
for (int k = 0; k < obj.size; k++)
{
angleOff = anglePer * (k % 2) / 2;
double nodex = obj.x + ((obj.radius - (Globals.gridSize * 0.2) + (k * Globals.gridSize * 0.6)) *
Math.Sin(Globals.DegToRad((double)(anglePer * j) + obj.angle - angleOff)));
double nodey = obj.y - ((obj.radius - (Globals.gridSize * 0.2) + (k * Globals.gridSize * 0.6)) *
Math.Cos(Globals.DegToRad((double)(anglePer * j) + obj.angle - angleOff)));
if (k == 0)
{
if (obj.atmosphere > 0)
{
MapNode l = new MapNode(nodex, nodey, true, true);
ring.Add(l);
}
else
{
MapNode l = new MapNode(nodex, nodey, true, false);
ring.Add(l);
}
}
else
{
if (k < obj.atmosphere + 1)
{
MapNode l = new MapNode(nodex, nodey, false, true);
ring.Add(l);
}
else
{
MapNode l = new MapNode(nodex, nodey, false, false);
ring.Add(l);
}
}
}
}
obj.edge = new List <MapNode>();
if (obj.size != 1)
{
for (int j = 0; j < grid.Count(); j++)
{
List <MapNode> ring = grid[j];
for (int k = 0; k < ring.Count(); k++)
{
MapNode node = ring[k];
addNode(node);
int offset = (k % 2);
if (k != 0)
{
if (j != 0)
{
if (j != grid.Count() - 1)
{
if (offset == 0)
{
node.connect(grid[j + 1 - offset][k - 1]);
}
if (offset == 1)
{
node.connect(grid[j + 1 - offset][k - 1]);
}
}
else
{
if (offset == 0)
{
node.connect(grid[0][k - 1]);
}
if (offset == 1)
{
node.connect(grid[j][k - 1]);
}
}
node.connect(grid[j - offset][k - 1]);
}
if (j == 0)
{
node.connect(grid[j + 1 - offset][k - 1]);
if (offset == 1)
{
node.connect(grid[grid.Count() - 1][k - 1]);
}
if (offset == 0)
{
node.connect(grid[j][k - 1]);
}
}
}
if (k == obj.size - 1)
{
obj.edge.Add(node);
}
if (j == 0)
{
node.connect(grid[ring.Count() - 1][k]);
}
else
{
node.connect(grid[j - 1][k]);
}
}
}
}
else
{
addNode(grid[0][0]);
obj.edge.Add(grid[0][0]);
}
for (int j = 0; j < nodes.Count(); j++)
{
MapNode node = nodes[j];
for (int k = 0; k < node.neighbors.Count(); k++)
{
MapNode sub = node.neighbors[k];
if (sub.suppressionCode == obj.suppressionCode)
{
MapNode closest = obj.edge[0];
MapNode secondClosest = obj.edge[0];
MapNode close = obj.edge[0];
double closestDist = 9999;
double secondDist = 9999;
for (int l = 0; l < obj.edge.Count(); l++)
{
close = obj.edge[l];
if (Globals.Distance(node.x, node.y, close.x, close.y) < closestDist)
{
secondClosest = closest;
secondDist = closestDist;
closest = close;
closestDist = Globals.Distance(node.x, node.y, close.x, close.y);
}
else
{
if (Globals.Distance(node.x, node.y, close.x, close.y) < secondDist)
{
secondClosest = close;
secondDist = Globals.Distance(node.x, node.y, close.x, close.y);
}
}
}
node.connect(closest);
if (secondDist - closestDist < 2)
{
node.connect(secondClosest);
}
}
}
}
}
