public void ForYTest()
{
int width = 33;
int height = 80;
BasicMap map = new BasicMap(width, height, 1, Distance.EUCLIDEAN);
List <Coord> pointsSet = new List <Coord>();
int counter = 0;
map.ForY((y) =>
{
double x = 14.75 * Math.Sin(y / 30.0) + width / 2;
Coord fy = new Coord((int)x, y);
pointsSet.Add(fy);
map.SetTerrain(_factory.Generic(fy, counter));
counter++;
});
counter = 0;
for (int y = 0; y < height; y++)
{
double x = 14.75 * Math.Sin(y / 30.0) + width / 2;
BasicTerrain terrain = map.GetTerrain <BasicTerrain>(new Coord((int)x, y));
Assert.NotNull(terrain);
Assert.AreEqual(counter, terrain.Glyph);
counter++;
}
}
public void AddDoesntOverWriteTest()
{
BasicMap newMap = new BasicMap(8, 8, 1, Distance.MANHATTAN);
for (int i = 0; i < 8; i++)
{
newMap.SetTerrain(_factory.Generic(new Coord(i, i), '#'));
}
newMap.Add(_map);
for (int i = 0; i < _map.Width; i++)
{
for (int j = 0; j < _map.Height; j++)
{
BasicTerrain t1 = _map.GetTerrain <BasicTerrain>(new Coord(i, j));
BasicTerrain t2 = newMap.GetTerrain <BasicTerrain>(new Coord(i, j));
if (i == j)
{
Assert.AreEqual('#', t2.Glyph);
}
else
{
Assert.AreEqual(t1.Glyph, t2.Glyph);
}
}
}
}
public void ForXTest()
{
int width = 33;
int height = 80;
BasicMap map = new BasicMap(width, height, 1, Distance.EUCLIDEAN);
List <Coord> pointsSet = new List <Coord>();
int counter = 0;
map.ForX((x) =>
{
double y = 14.75 * Math.Sin(x / 30.0) + width / 2;
Coord fx = new Coord(x, (int)y);
pointsSet.Add(fx);
map.SetTerrain(_factory.Generic(fx, counter));
counter++;
});
counter = 0;
for (int x = 0; x < width; x++)
{
double y = 14.75 * Math.Sin(x / 30.0) + width / 2;
Coord fx = new Coord(x, (int)y);
BasicTerrain terrain = map.GetTerrain <BasicTerrain>(fx);
Assert.NotNull(terrain);
Assert.AreEqual(counter, terrain.Glyph);
counter++;
}
}
public void IsClearOfObstructionsTest()
{
Assert.IsTrue(_map.IsClearOfObstructions(new Coord(0, 0), 8));
_map.SetTerrain(_factory.Wall(new Coord(0, 0)));
Assert.IsFalse(_map.IsClearOfObstructions(new Coord(0, 0), 8));
Assert.IsTrue(_map.IsClearOfObstructions(new Coord(1, 1), 8));
}
public static BasicMap CropToContent(this BasicMap m)
{
int minX = m.Width;
int maxX = 0;
int minY = m.Height;
int maxY = 0;
for (int x = 0; x < m.Width; x++)
{
for (int y = 0; y < m.Height; y++)
{
if (m.GetTerrain <BasicTerrain>(new Coord(x, y)) != null)
{
if (minX > x)
{
minX = x;
}
if (minY > y)
{
minY = y;
}
if (maxX < x)
{
maxX = x;
}
if (maxY < y)
{
maxY = y;
}
}
}
}
int dx = Math.Abs(maxX - minX + 1);
int dy = Math.Abs(maxY - minY + 1);
Coord offset = new Coord(-minX, -minY);
BasicMap map = new BasicMap(dx, dy, EnumUtils.EnumLength <MapLayer>(), Distance.EUCLIDEAN);
map.ForXForY((point) =>
{
if (m.Contains(point - offset))
{
BasicTerrain terrain = m.GetTerrain <BasicTerrain>(point - offset);
if (terrain != null)
{
map.SetTerrain(_factory.Copy(terrain, point));
}
}
});
return(map);
}
public void Setup()
{
_map = new BasicMap(8, 8, 2, Distance.MANHATTAN);
for (int i = 0; i < _map.Width; i++)
{
for (int j = 0; j < _map.Height; j++)
{
Coord c = new Coord(i, j);
_map.SetTerrain(_factory.Generic(c, i + j));
}
}
}
private void TestMap()
{
BasicMap map = new BasicMap(42, 42, 1, Distance.EUCLIDEAN);
int radius = 20;
for (int i = 0; i < map.Width; i++)
{
for (int j = 0; j < map.Height; j++)
{
BasicTerrain t = new BasicTerrain(Color.White, Color.Black, (i + j) % 256, new Coord(i, j), true, true);
map.SetTerrain(t);
}
}
Coord origin = new Coord(21, 21);
Area room = new Area("wiseau's room", new Coord(30, 30), new Coord(30, 10), new Coord(10, 10), new Coord(10, 30));
foreach (Coord c in room.InnerPoints)
{
map.SetTerrain(_factory.MediumHardwoodFloor(c));
}
foreach (Coord c in room.OuterPoints)
{
map.SetTerrain(_factory.BathroomLinoleum(c));
if (c.X == map.Width / 2 || c.Y == map.Height / 2)
{
map.SetTerrain(_factory.ShagCarpet(c));
}
else
{
map.SetTerrain(_factory.DarkHardwoodFloor(c));
}
}
this.ReplaceTiles(map, new Coord(0, 0));
BasicMap rotated = map.Rotate(origin, radius, 45);
this.ReplaceTiles(rotated, new Coord(0, 0));
}
public static BasicMap Rotate(this BasicMap m, Coord origin, int radius, int degrees)
{
BasicMap rotated = new BasicMap(m.Width, m.Height, 1, Distance.EUCLIDEAN);
//only rotating the bottom right corner, and not even rotating it correctly
if (degrees % 90 == 0)
{
//this rotates more than just the circle - bug, deal with it later
rotated.Add(m.RotateDiscreet(degrees));
}
else
{
BasicMap map = m.RotateDiscreet(360);
while (degrees > 45)
{
degrees -= 90;
//rotates more than just this circle - bug - deal with it later
map = m.RotateDiscreet(90);
}
while (degrees <= -45)
{
degrees += 90;
//rotates more than just the circle - bug, fix later
map = m.RotateDiscreet(270);
}
double radians = Calculate.DegreesToRadians(degrees);
for (int x = -radius; x < radius; x++)
{
for (int y = -radius; y < radius; y++)
{
if (radius > Math.Sqrt(x * x + y * y))
{
int xPrime = (int)(x * Math.Cos(radians) - y * Math.Sin(radians));
int yPrime = (int)(x * Math.Sin(radians) + y * Math.Cos(radians));
Coord source = new Coord(x, y) + origin;
Coord target = new Coord(xPrime, yPrime) + origin;
BasicTerrain terrain = map.GetTerrain <BasicTerrain>(source);
if (terrain != null && rotated.Contains(target))
{
rotated.SetTerrain(_factory.Copy(terrain, target));
}
}
}
}
}
return(rotated);
}
public static void ReplaceTiles(this BasicMap m, BasicMap map, Coord origin)
{
for (int i = 0; i < map.Width; i++)
{
for (int j = 0; j < map.Height; j++)
{
Coord target = new Coord(i + origin.X, j + origin.Y);
BasicTerrain t = map.GetTerrain <BasicTerrain>(new Coord(i, j));
if (t != null && m.Contains(target))
{
t = _factory.Copy(t, target);
m.SetTerrain(t);
}
}
}
}
public void RotateTest()
{
BasicMap map = new BasicMap(42, 42, 1, Distance.EUCLIDEAN);
int radius = 20;
for (int i = 0; i < map.Width; i++)
{
for (int j = 0; j < map.Height; j++)
{
BasicTerrain t = new BasicTerrain(Color.White, Color.Black, (i * j + j) % 256, new Coord(i, j), true, true);
map.SetTerrain(t);
}
}
Coord origin = new Coord(21, 21);
BasicMap rotated = map.Rotate(origin, radius, 45);
List <Coord> nullTerrain = new List <Coord>();
Assert.AreNotEqual(map, rotated, "map.Rotate() did not transform the map in any way.");
for (int x = 0; x < map.Width; x++)
{
for (int y = 0; y < map.Height; y++)
{
Coord here = new Coord(x, y);
Coord delta = origin - here;
if (radius > Math.Sqrt(delta.X * delta.X + delta.Y * delta.Y))
{
if (rotated.GetTerrain <BasicTerrain>(x, y) == null)
{
nullTerrain.Add(new Coord(x, y));
}
else
{
//Assert.AreNotEqual(Math.Abs(x * y + y) % 256, rotated.GetTerrain<BasicTerrain>(x, y).Glyph);
}
Assert.AreEqual(Math.Abs(x * y + y) % 256, map.GetTerrain <BasicTerrain>(x, y).Glyph);
}
else
{
Assert.IsNull(rotated.GetTerrain <BasicTerrain>(x, y));
Assert.AreEqual(Math.Abs(x * y + y) % 256, map.GetTerrain <BasicTerrain>(x, y).Glyph);
}
}
}
}
public void CropToContentTest()
{
BasicMap map = new BasicMap(8, 8, 2, Distance.MANHATTAN);
for (int i = 1; i < map.Width - 1; i++)
{
for (int j = 1; j < map.Height - 1; j++)
{
Coord c = new Coord(i, j);
map.SetTerrain(_factory.Generic(c, i + j));
}
}
map = map.CropToContent();
Assert.AreEqual(_map.Width - 2, map.Width);
Assert.AreEqual(_map.Height - 2, map.Height);
Assert.AreEqual(2, map.GetTerrain <BasicTerrain>(0, 0).Glyph);
}
public static BasicMap ReverseHorizontal(this BasicMap m)
{
BasicMap map = new BasicMap(m.Width, m.Height, 1, Distance.MANHATTAN);
for (int i = 0; i < m.Width; i++)
{
for (int j = 0; j < m.Height; j++)
{
Coord source = new Coord(i, j);
Coord target = new Coord(map.Width - i - 1, j);
BasicTerrain t = m.GetTerrain <BasicTerrain>(source);
if (t != null)
{
t = _factory.Copy(t, target);
map.SetTerrain(t);
}
}
}
return(map);
}
public static void Add(this BasicMap m, BasicMap map, Coord origin)
{
if (m.Width < map.Width + origin.X && m.Height < map.Height + origin.X)
{
throw new ArgumentOutOfRangeException(nameof(origin));
}
for (int i = 0; i < map.Width; i++)
{
for (int j = 0; j < map.Height; j++)
{
Coord target = new Coord(i + origin.X, j + origin.Y);
BasicTerrain t1 = (BasicTerrain)map.GetTerrain(new Coord(i, j));
BasicTerrain t2 = (BasicTerrain)m.GetTerrain(new Coord(i, j));
if (t1 != null && t2 == null && m.Contains(target))
{
t1 = _factory.Copy(t1, target);
m.SetTerrain(t1);
}
}
}
}
public void ReplaceTilesTest()
{
BasicMap newMap = new BasicMap(8, 8, 1, Distance.MANHATTAN);
for (int i = 0; i < 8; i++)
{
newMap.SetTerrain(_factory.Generic(new Coord(i, i), i));
}
newMap.ReplaceTiles(_map, new Coord(0, 0));
for (int i = 0; i < _map.Width; i++)
{
for (int j = 0; j < _map.Height; j++)
{
BasicTerrain t1 = _map.GetTerrain <BasicTerrain>(new Coord(i, j));
BasicTerrain t2 = newMap.GetTerrain <BasicTerrain>(new Coord(i, j));
Assert.AreEqual(t1.Glyph, t2.Glyph);
}
}
}
public void ForXForYTest()
{
BasicMap map = new BasicMap(25, 25, 1, Distance.EUCLIDEAN);
int counter = 0;
map.ForXForY((point) =>
{
map.SetTerrain(_factory.Generic(point, counter));
counter++;
});
counter = 0;
for (int i = 0; i < map.Width; i++)
{
for (int j = 0; j < map.Height; j++)
{
BasicTerrain t = map.GetTerrain <BasicTerrain>(new Coord(i, j));
Assert.AreEqual(counter, t.Glyph);
counter++;
}
}
}
public static BasicMap SwapXy(this BasicMap m)
{
BasicMap map = new BasicMap(m.Width, m.Height, 1, Distance.MANHATTAN);
for (int i = 0; i < m.Width; i++)
{
for (int j = 0; j < m.Height; j++)
{
Coord original = new Coord(j, i);
Coord target = new Coord(i, j);
BasicTerrain t = m.GetTerrain <BasicTerrain>(original);
if (t != null)
{
t = _factory.Copy(t, target);
map.SetTerrain(t);
}
}
}
return(map);
}
public static BasicMap Subsection(this BasicMap m, Coord start, Coord stop)
{
int xDiff = stop.X - start.X;
int yDiff = stop.Y - start.Y;
BasicMap map = new BasicMap(xDiff, yDiff, Enum.GetNames(typeof(MapLayer)).Length, Distance.MANHATTAN);
for (int i = start.X; i < stop.X + 1; i++)
{
for (int j = start.Y; j < stop.Y + 1; j++)
{
BasicTerrain t = m.GetTerrain <BasicTerrain>(new Coord(i, j));
if (t != null)
{
Coord c = new Coord(i - start.X, j - start.Y);
t = _factory.Copy(t, c);
if (map.Contains(c))
{
map.SetTerrain(t);
}
}
}
}
return(map);
}