/// <summary>
/// Creates the package that contains the description of the isometric tiles of the given map.
/// </summary>
/// <param name="map">Reference to the map.</param>
/// <returns>The data package that contains the description of the isometric tiles of the given map.</returns>
private RCPackage CreateIsoTileListPackage(IMapAccess map)
{
RCPackage isotileList = RCPackage.CreateCustomDataPackage(MapFileFormat.ISOTILE_LIST);
/// Create the terrain type index table.
List <string> terrainTypeList = new List <string>();
Dictionary <ITerrainType, int> terrainTypeIndexTable = new Dictionary <ITerrainType, int>();
int terrainTypeIndex = 0;
foreach (ITerrainType terrainType in map.Tileset.TerrainTypes)
{
terrainTypeList.Add(terrainType.Name);
terrainTypeIndexTable.Add(terrainType, terrainTypeIndex);
terrainTypeIndex++;
}
isotileList.WriteStringArray(0, terrainTypeList.ToArray());
/// Create the packages of the isometric tiles.
RCSet <IIsoTile> processedIsoTiles = new RCSet <IIsoTile>();
List <RCPackage> isotilePackages = new List <RCPackage>();
int isotileInfoLength = 0;
for (int row = 0; row < map.Size.Y; row++)
{
for (int column = 0; column < map.Size.X; column++)
{
IIsoTile currIsoTile = map.GetQuadTile(new RCIntVector(column, row)).PrimaryIsoTile;
if (!processedIsoTiles.Contains(currIsoTile))
{
RCPackage isotilePackage = RCPackage.CreateCustomDataPackage(MapFileFormat.ISOTILE);
isotilePackage.WriteShort(0, (short)column);
isotilePackage.WriteShort(1, (short)row);
isotilePackage.WriteByte(2, (byte)terrainTypeIndexTable[currIsoTile.Type.TerrainA]);
isotilePackage.WriteByte(3, currIsoTile.Type.TerrainB != null ?
(byte)terrainTypeIndexTable[currIsoTile.Type.TerrainB] :
(byte)0);
isotilePackage.WriteByte(4, (byte)currIsoTile.Type.Combination);
isotilePackage.WriteByte(5, (byte)currIsoTile.VariantIdx);
isotilePackages.Add(isotilePackage);
processedIsoTiles.Add(currIsoTile);
isotileInfoLength += isotilePackage.PackageLength;
}
}
}
/// Write the isometric tile packages into the final package
byte[] isotileInfoBytes = new byte[isotileInfoLength];
int offset = 0;
foreach (RCPackage isotilePackage in isotilePackages)
{
offset += isotilePackage.WritePackageToBuffer(isotileInfoBytes, offset);
}
isotileList.WriteByteArray(1, isotileInfoBytes);
return(isotileList);
}
/// <summary>
/// Creates the package that contains the description of the terrain objects of the given map.
/// </summary>
/// <param name="map">Reference to the map.</param>
/// <returns>The data package that contains the description of the terrain objects of the given map.</returns>
private RCPackage CreateTerrainObjListPackage(IMapAccess map)
{
RCPackage terrainObjList = RCPackage.CreateCustomDataPackage(MapFileFormat.TERRAINOBJ_LIST);
/// Create the terrain object type index table.
List <string> terrainObjTypeList = new List <string>();
Dictionary <ITerrainObjectType, int> terrainObjTypeIndexTable = new Dictionary <ITerrainObjectType, int>();
int terrainObjTypeIndex = 0;
foreach (ITerrainObjectType terrainObjType in map.Tileset.TerrainObjectTypes)
{
terrainObjTypeList.Add(terrainObjType.Name);
terrainObjTypeIndexTable.Add(terrainObjType, terrainObjTypeIndex);
terrainObjTypeIndex++;
}
terrainObjList.WriteStringArray(0, terrainObjTypeList.ToArray());
/// Create the packages of the terrain objects.
List <RCPackage> terrainObjPackages = new List <RCPackage>();
int terrainObjInfoLength = 0;
foreach (ITerrainObject terrainObj in map.TerrainObjects)
{
RCPackage terrainObjPackage = RCPackage.CreateCustomDataPackage(MapFileFormat.TERRAINOBJ);
terrainObjPackage.WriteShort(0, (short)terrainObj.MapCoords.X);
terrainObjPackage.WriteShort(1, (short)terrainObj.MapCoords.Y);
terrainObjPackage.WriteByte(2, (byte)terrainObjTypeIndexTable[terrainObj.Type]);
terrainObjPackages.Add(terrainObjPackage);
terrainObjInfoLength += terrainObjPackage.PackageLength;
}
/// Write the terrain object packages into the final package
byte[] terrainObjInfoBytes = new byte[terrainObjInfoLength];
int offset = 0;
foreach (RCPackage terrainObjPackage in terrainObjPackages)
{
offset += terrainObjPackage.WritePackageToBuffer(terrainObjInfoBytes, offset);
}
terrainObjList.WriteByteArray(1, terrainObjInfoBytes);
return(terrainObjList);
}
public static RCPackage GenerateRandomPackage()
{
int rndType = rnd.Next(0, 3);
int rndFormat = rnd.Next(0, 3);
RCPackage retPack = null;
if (rndType == 0)
{
retPack = RCPackage.CreateNetworkPingPackage(); return(retPack);
}
else if (rndType == 1)
{
retPack = RCPackage.CreateCustomDataPackage(rndFormat);
}
else if (rndType == 2)
{
retPack = RCPackage.CreateNetworkCustomPackage(rndFormat);
}
RCPackageFormat format = RCPackageFormat.GetPackageFormat(rndFormat);
for (int i = 0; i < format.NumOfFields; i++)
{
RCPackageFieldType datatype = format.GetFieldType(i);
if (datatype == RCPackageFieldType.BYTE)
{
retPack.WriteByte(i, (byte)rnd.Next(byte.MinValue, byte.MaxValue));
}
else if (datatype == RCPackageFieldType.SHORT)
{
retPack.WriteShort(i, (short)rnd.Next(short.MinValue, short.MaxValue));
}
else if (datatype == RCPackageFieldType.INT)
{
retPack.WriteInt(i, (int)rnd.Next(int.MinValue, int.MaxValue));
}
else if (datatype == RCPackageFieldType.LONG)
{
retPack.WriteLong(i, (long)rnd.Next(int.MinValue, int.MaxValue));
}
else if (datatype == RCPackageFieldType.STRING)
{
int strIdx = rnd.Next(0, 10);
retPack.WriteString(i, strCollection[strIdx]);
}
else if (datatype == RCPackageFieldType.BYTE_ARRAY)
{
int arrLen = rnd.Next(0, 10);
byte[] arr = new byte[arrLen];
rnd.NextBytes(arr);
retPack.WriteByteArray(i, arr);
}
else if (datatype == RCPackageFieldType.SHORT_ARRAY)
{
int arrLen = rnd.Next(0, 10);
short[] arr = new short[arrLen];
for (int j = 0; j < arrLen; ++j)
{
arr[j] = (short)rnd.Next(short.MinValue, short.MaxValue);
}
retPack.WriteShortArray(i, arr);
}
else if (datatype == RCPackageFieldType.INT_ARRAY)
{
int arrLen = rnd.Next(0, 10);
int[] arr = new int[arrLen];
for (int j = 0; j < arrLen; ++j)
{
arr[j] = (int)rnd.Next(int.MinValue, int.MaxValue);
}
retPack.WriteIntArray(i, arr);
}
else if (datatype == RCPackageFieldType.LONG_ARRAY)
{
int arrLen = rnd.Next(0, 10);
long[] arr = new long[arrLen];
for (int j = 0; j < arrLen; ++j)
{
arr[j] = (long)rnd.Next(int.MinValue, int.MaxValue);
}
retPack.WriteLongArray(i, arr);
}
else if (datatype == RCPackageFieldType.STRING_ARRAY)
{
int arrLen = rnd.Next(0, 10);
string[] arr = new string[arrLen];
for (int j = 0; j < arrLen; ++j)
{
int strIdx = rnd.Next(0, 10);
arr[j] = strCollection[strIdx];
}
retPack.WriteStringArray(i, arr);
}
else
{
throw new NetworkingSystemException("Unknown datatype");
}
}
return(retPack);
}
