public ChunkTracker(int sx, int sy)
{
SX = sx;
SY = sy;
mapGen = new MapDataGenerator(SX, SY);
Map = mapGen.map;
}
public Village(Point Position, IslandMap Map, int sx, int sy)
{
CenterPosition = Position;
IslandMap = Map;
SX = sx;
SY = sy;
}
public void createBridge()
{
Point DeltaPosition = IslandMap.GetDeltaPoint(CenterPosition);
Vector dir = new Vector(DeltaPosition.X - CenterPosition.X, DeltaPosition.Y - CenterPosition.Y);
dir.Normalize();
int distance = (int)MathUtil.MathUtil.distance(CenterPosition, DeltaPosition);
dir.Normalize();
int allowedDistance = (int)(distance * 0.25f);
for (int i = 1; i < distance; i++)
{
float wavePosX = (float)(dir.X * i + dir.X * Math.Sin(Math.PI * i / distance) * 10);
float wavePosY = (float)(dir.Y * i + dir.Y * Math.Sin(Math.PI * i / distance) / 10);
int px = (int)(CenterPosition.X + wavePosX);
int py = (int)(CenterPosition.Y + wavePosY);
if (!IslandMap.lk[px, py] && IslandMap.r[px, py])
{
if (i > allowedDistance)
{
Point BridgePosition = new Point(px - 5, py - 5);
int angle = MapUtil.GetDirectionAngle(px, py, IslandMap.lk);
//Debug.WriteLine(BridgePositionB);
IslandMap.StructureNames.Add("Bridge_");
IslandMap.StructurePoints.Add(new Point3D(BridgePosition.X, IslandMap.h[px, py], BridgePosition.Y));
//IslandMap.StructureRotations.Add(new Vector3D(CrossDir.X, 1, CrossDir.Y));
//IslandMap.StructureRotations.Add(new Vector3D(dir.X, 1, dir.Y));
IslandMap.StructureRotations.Add(angle + 270);
return;
}
}
}
}
public LakeVillage(Point Position, IslandMap Map, int sx, int sy) : base(Position, Map, sx, sy)
{
}
public static IslandMap LoadMap(String FileName)
{
//retrieve file
List <byte> Data = new List <byte>();
using (BinaryReader FileReader = new BinaryReader(File.Open(FileName, FileMode.Open)))
{
Data.Add(FileReader.ReadByte());
}
int byteCount = 0;
int SX = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int SY = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedLSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedOSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedLKSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedRSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedMSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedRDSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedMaSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
int CompressedHSize = Data[byteCount++] & 0xFF | (Data[byteCount++] & 0xFF) << 8 | (Data[byteCount++] & 0xFF) << 16 | (Data[byteCount++] & 0xFF) << 24;
List <Boolean> LValues = new List <Boolean>();
List <Boolean> OValues = new List <Boolean>();
List <Boolean> LKValues = new List <Boolean>();
List <Boolean> RValues = new List <Boolean>();
List <Boolean> MValues = new List <Boolean>();
List <Boolean> RDValues = new List <Boolean>();
List <int> MaValues = new List <int>();
List <int> HValues = new List <int>();
List <int> LQuantities = new List <int>();
List <int> OQuantities = new List <int>();
List <int> LKQuantities = new List <int>();
List <int> RQuantities = new List <int>();
List <int> MQuantities = new List <int>();
List <int> RDQuantities = new List <int>();
List <int> MaQuantities = new List <int>();
List <int> HQuantities = new List <int>();
Boolean[,] L = new Boolean[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
Boolean[,] O = new Boolean[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
Boolean[,] LK = new Boolean[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
Boolean[,] R = new Boolean[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
Boolean[,] M = new Boolean[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
Boolean[,] RD = new Boolean[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
int[,] Ma = new int[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
int[,] H = new int[ApplicationSettings.chunkSize + 1, ApplicationSettings.chunkSize + 1];
Decompress(LQuantities, LValues, CompressedLSize, byteCount, Data);
Decompress(OQuantities, OValues, CompressedOSize, byteCount, Data);
Decompress(LKQuantities, LKValues, CompressedLKSize, byteCount, Data);
Decompress(RQuantities, RValues, CompressedRSize, byteCount, Data);
Decompress(MQuantities, MValues, CompressedMSize, byteCount, Data);
Decompress(RDQuantities, RDValues, CompressedRDSize, byteCount, Data);
Decompress(MaQuantities, MaValues, CompressedMaSize, byteCount, Data);
Decompress(HQuantities, HValues, CompressedHSize, byteCount, Data);
ListTo2DArray(L, LQuantities, LValues);
ListTo2DArray(O, OQuantities, OValues);
ListTo2DArray(LK, LKQuantities, LKValues);
ListTo2DArray(R, RQuantities, RValues);
ListTo2DArray(M, MQuantities, MValues);
ListTo2DArray(RD, RDQuantities, RDValues);
ListTo2DArray(Ma, MaQuantities, MaValues);
ListTo2DArray(H, HQuantities, HValues);
IslandMap IslandMap = new IslandMap(SX, SY, L, O, LK, R, M, RD, Ma, H);
return(IslandMap);
}
/*
* public Boolean[,] l { get; set; }
* public Boolean[,] o { get; set; }
* public Boolean[,] lk { get; set; }
* public Boolean[,] r { get; set; }
* public Boolean[,] m { get; set; }
* public Boolean[,] rd { get; set; }
*
* public int[,] ma { get; set; }
* public int[,] h { get; set; }
*/
//Generate CompressedLists
//Add size of Buffers
//add buffers
//convert to byte array
//create file
public static void SaveMap(String FileName, IslandMap IslandMap)
{
BinaryWriter writer = new BinaryWriter(File.Open("WorldSave/" + FileName, FileMode.Create));
List <byte> MapData = new List <byte>();
byte[] CompressedSX = BitConverter.GetBytes(IslandMap.SX);
byte[] CompressedSY = BitConverter.GetBytes(IslandMap.SY);
byte[] CompressedLValues = (byte[])CompressBooleanArray2D(IslandMap.l)[0];
byte[] CompressedOValues = (byte[])CompressBooleanArray2D(IslandMap.o)[0];
byte[] CompressedLKValues = (byte[])CompressBooleanArray2D(IslandMap.lk)[0];
byte[] CompressedRValues = (byte[])CompressBooleanArray2D(IslandMap.r)[0];
byte[] CompressedMValues = (byte[])CompressBooleanArray2D(IslandMap.m)[0];
byte[] CompressedRDValues = (byte[])CompressBooleanArray2D(IslandMap.rd)[0];
byte[] CompressedMaValues = (byte[])CompressIntArray2D(IslandMap.ma)[0];
byte[] CompressedHValues = (byte[])CompressIntArray2D(IslandMap.h)[0];
byte[] CompressedLQuantities = (byte[])CompressBooleanArray2D(IslandMap.l)[1];
byte[] CompressedOQuantities = (byte[])CompressBooleanArray2D(IslandMap.o)[1];
byte[] CompressedLKQuantities = (byte[])CompressBooleanArray2D(IslandMap.lk)[1];
byte[] CompressedRQuantities = (byte[])CompressBooleanArray2D(IslandMap.r)[1];
byte[] CompressedMQuantities = (byte[])CompressBooleanArray2D(IslandMap.m)[1];
byte[] CompressedRDQuantities = (byte[])CompressBooleanArray2D(IslandMap.rd)[1];
byte[] CompressedMaQuantities = (byte[])CompressIntArray2D(IslandMap.ma)[1];
byte[] CompressedHQuantities = (byte[])CompressIntArray2D(IslandMap.h)[1];
byte[] CompressedLSize = BitConverter.GetBytes(CompressedLValues.Length);
byte[] CompressedOSize = BitConverter.GetBytes(CompressedOValues.Length);
byte[] CompressedLKSize = BitConverter.GetBytes(CompressedLKValues.Length);
byte[] CompressedRSize = BitConverter.GetBytes(CompressedRValues.Length);
byte[] CompressedMSize = BitConverter.GetBytes(CompressedMValues.Length);
byte[] CompressedRDSize = BitConverter.GetBytes(CompressedRDValues.Length);
byte[] CompressedMaSize = BitConverter.GetBytes(CompressedMaValues.Length / 4);
byte[] CompressedHSize = BitConverter.GetBytes(CompressedHValues.Length / 4);
if (File.Exists(FileName))
{
//overwrite file
}
else
{
//create new file
BinaryWriter FileWriter = new BinaryWriter(File.Open(FileName, FileMode.Create));
//seedX,seexY
FileWriter.Write(CompressedSX);
FileWriter.Write(CompressedSY);
//buffer value length
FileWriter.Write(CompressedLSize);
FileWriter.Write(CompressedOSize);
FileWriter.Write(CompressedLKSize);
FileWriter.Write(CompressedRSize);
FileWriter.Write(CompressedMSize);
FileWriter.Write(CompressedRDSize);
FileWriter.Write(CompressedMaSize);
FileWriter.Write(CompressedHSize);
//values
//Quantities
FileWriter.Write(CompressedLValues);
FileWriter.Write(CompressedLQuantities);
FileWriter.Write(CompressedOValues);
FileWriter.Write(CompressedOQuantities);
FileWriter.Write(CompressedLKValues);
FileWriter.Write(CompressedLKQuantities);
FileWriter.Write(CompressedRValues);
FileWriter.Write(CompressedRQuantities);
FileWriter.Write(CompressedMValues);
FileWriter.Write(CompressedMQuantities);
FileWriter.Write(CompressedRDValues);
FileWriter.Write(CompressedRDQuantities);
FileWriter.Write(CompressedMaValues);
FileWriter.Write(CompressedMaQuantities);
FileWriter.Write(CompressedHValues);
FileWriter.Write(CompressedHQuantities);
FileWriter.Close();
}
}