/// <summary> /// The starting function of the announcer thread. /// </summary> private void AnnounceProc() { while (!this.announcementFinished.WaitOne(NetworkingSystemConstants.ANNOUNCEMENT_FREQUENCY)) { LobbyInfo lobbyInfo = new LobbyInfo(this.announcedLobby.Id, "", this.announcedLobby.PortNum); if (null != this.customDataProvider) { lobbyInfo.CustomData = this.customDataProvider.CustomData; } RCPackage lobbyInfoPackage = lobbyInfo.Package; BroadcastPackage_i(lobbyInfoPackage); } /// Announce finished so we broadcast a FORMAT_LOBBY_INFO_VANISHED message. RCPackage lobbyVanishedPackage = RCPackage.CreateCustomDataPackage(Network.FORMAT_LOBBY_INFO_VANISHED); lobbyVanishedPackage.WriteString(0, this.announcedLobby.Id.ToString()); for (int i = 0; i < NetworkingSystemConstants.ANNOUNCEMENT_BROADCAST_MULTIPLICITY; i++) { /// Broadcast more than once because of possible package lost on UDP. BroadcastPackage_i(lobbyVanishedPackage); } }
/// <see cref="ITrace.WriteFork"/> public void WriteFork(RCThread newThread, RCThread parentThread) { if (newThread == null) { throw new ArgumentNullException("newThread"); } if (parentThread == null) { throw new ArgumentNullException("parentThread"); } RCPackage packageToWrite = RCPackage.CreateCustomDataPackage(RCL_FORK_FORMAT); packageToWrite.WriteInt(0, newThread.WrappedThread.ManagedThreadId); packageToWrite.WriteString(1, newThread.Name); packageToWrite.WriteInt(2, parentThread.WrappedThread.ManagedThreadId); packageToWrite.WriteString(3, parentThread.Name); packageToWrite.WriteLong(4, timer.ElapsedMilliseconds); byte[] buffer = new byte[packageToWrite.PackageLength]; packageToWrite.WritePackageToBuffer(buffer, 0); this.outputWriter.Write(buffer); this.outputWriter.Flush(); this.outputStream.Flush(); }
/// <see cref="ITrace.WriteLine"/> public void WriteLine(object obj) { if (obj == null) { throw new ArgumentNullException("obj"); } string strToWrite = obj.ToString(); if (strToWrite == null) { strToWrite = string.Empty; } RCPackage packageToWrite = RCPackage.CreateCustomDataPackage(RCL_EVENT_FORMAT); packageToWrite.WriteInt(0, RCThread.CurrentThread.WrappedThread.ManagedThreadId); packageToWrite.WriteString(1, RCThread.CurrentThread.Name); packageToWrite.WriteLong(2, timer.ElapsedMilliseconds); packageToWrite.WriteString(3, strToWrite); byte[] buffer = new byte[packageToWrite.PackageLength]; packageToWrite.WritePackageToBuffer(buffer, 0); this.outputWriter.Write(buffer); this.outputWriter.Flush(); this.outputStream.Flush(); }
/// <see cref="ITrace.WriteLine"/> public void WriteException(Exception ex, bool isFatal) { if (ex == null) { throw new ArgumentNullException("ex"); } string strToWrite = ex.ToString(); if (strToWrite == null) { strToWrite = string.Empty; } RCPackage packageToWrite = RCPackage.CreateCustomDataPackage(RCL_EXCEPTION_FORMAT); packageToWrite.WriteInt(0, RCThread.CurrentThread.WrappedThread.ManagedThreadId); packageToWrite.WriteString(1, RCThread.CurrentThread.Name); packageToWrite.WriteLong(2, timer.ElapsedMilliseconds); packageToWrite.WriteByte(3, isFatal ? (byte)0x01 : (byte)0x00); packageToWrite.WriteString(4, strToWrite); byte[] buffer = new byte[packageToWrite.PackageLength]; packageToWrite.WritePackageToBuffer(buffer, 0); this.outputWriter.Write(buffer); this.outputWriter.Flush(); this.outputStream.Flush(); }
/// <see cref="ITrace.WriteJoin"/> public void WriteJoin(RCThread runningThread, RCThread waitingThread) { if (runningThread == null) { throw new ArgumentNullException("runningThread"); } if (waitingThread == null) { throw new ArgumentNullException("waitingThread"); } RCPackage packageToWrite = RCPackage.CreateCustomDataPackage(RCL_JOIN_FORMAT); packageToWrite.WriteInt(0, runningThread.WrappedThread.ManagedThreadId); packageToWrite.WriteString(1, runningThread.Name); packageToWrite.WriteInt(2, waitingThread.WrappedThread.ManagedThreadId); packageToWrite.WriteString(3, waitingThread.Name); packageToWrite.WriteLong(4, timer.ElapsedMilliseconds); byte[] buffer = new byte[packageToWrite.PackageLength]; packageToWrite.WritePackageToBuffer(buffer, 0); this.outputWriter.Write(buffer); this.outputWriter.Flush(); this.outputStream.Flush(); }
/// <see cref="IComponent.Start"/> public void Start() { this.tilesetLoader = ComponentManager.GetInterface <ITileSetLoader>(); /// Load the tilesets from the configured directory DirectoryInfo rootDir = new DirectoryInfo(BizLogicConstants.TILESET_DIR); FileInfo[] tilesetFiles = rootDir.GetFiles("*.xml", SearchOption.AllDirectories); foreach (FileInfo tilesetFile in tilesetFiles) { /// TODO: this is a hack! Later we will have binary tileset format. string xmlStr = File.ReadAllText(tilesetFile.FullName); string imageDir = tilesetFile.DirectoryName; RCPackage tilesetPackage = RCPackage.CreateCustomDataPackage(PackageFormats.TILESET_FORMAT); tilesetPackage.WriteString(0, xmlStr); tilesetPackage.WriteString(1, imageDir); byte[] buffer = new byte[tilesetPackage.PackageLength]; tilesetPackage.WritePackageToBuffer(buffer, 0); ITileSet tileset = this.tilesetLoader.LoadTileSet(buffer); if (this.loadedTilesets.ContainsKey(tileset.Name)) { throw new InvalidOperationException(string.Format("Tileset with name '{0}' already loaded!", tileset.Name)); } this.loadedTilesets.Add(tileset.Name, tileset); } }
/// <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); }
public bool ExecuteNextFrame(out RCPackage[] outgoingCmds) { outgoingCmds = null; List <RCPackage> tmpOutgoingCmds = new List <RCPackage>(); UiActionType[] uiActions = null; int[] firstParams = null; int[] secondParams = null; this.ActionQueue.GetAllActions(out uiActions, out firstParams, out secondParams); for (int i = 0; i < uiActions.Length; i++) { if (uiActions[i] == UiActionType.UpKeyPressed) { RCPackage upCmd = RCPackage.CreateCustomDataPackage(TestClientMessages.COMMAND); upCmd.WriteByte(0, (byte)PlayerDirection.Up); tmpOutgoingCmds.Add(upCmd); } else if (uiActions[i] == UiActionType.DownKeyPressed) { RCPackage downCmd = RCPackage.CreateCustomDataPackage(TestClientMessages.COMMAND); downCmd.WriteByte(0, (byte)PlayerDirection.Down); tmpOutgoingCmds.Add(downCmd); } else if (uiActions[i] == UiActionType.LeftKeyPressed) { RCPackage leftCmd = RCPackage.CreateCustomDataPackage(TestClientMessages.COMMAND); leftCmd.WriteByte(0, (byte)PlayerDirection.Left); tmpOutgoingCmds.Add(leftCmd); } else if (uiActions[i] == UiActionType.RightKeyPressed) { RCPackage rightCmd = RCPackage.CreateCustomDataPackage(TestClientMessages.COMMAND); rightCmd.WriteByte(0, (byte)PlayerDirection.Right); tmpOutgoingCmds.Add(rightCmd); } else if (uiActions[i] == UiActionType.LeaveBtnPressed) { return(false); } } if (tmpOutgoingCmds.Count > 0) { outgoingCmds = tmpOutgoingCmds.ToArray(); } /// Step simulations and refresh the display this.simulator.MakeStep(); Rectangle refreshedArea; Display.Instance.RenderOneFrame(out refreshedArea); this.uiCallMarshal.RefreshDisplay(); return(true); }
/// <summary> /// Creates an RCPackage from this command. /// </summary> /// <returns>The created RCPackage.</returns> public RCPackage ToPackage() { RCPackage package = RCPackage.CreateCustomDataPackage(RCCommand.COMMAND_PACKAGEFORMAT); package.WriteString(0, this.commandType ?? string.Empty); package.WriteIntArray(1, this.recipientEntities); package.WriteInt(2, this.targetPosition != RCNumVector.Undefined ? this.targetPosition.X.Bits : -1); package.WriteInt(3, this.targetPosition != RCNumVector.Undefined ? this.targetPosition.Y.Bits : -1); package.WriteInt(4, this.targetEntity); package.WriteString(5, this.parameter ?? string.Empty); return(package); }
/// <see cref="IScenarioLoader.SaveScenario"/> public byte[] SaveScenario(Scenario scenario) { if (scenario == null) { throw new ArgumentNullException("scenario"); } /// Create the packages that describes the entities of the scenario. List <RCPackage> entityPackages = new List <RCPackage>(); int retArrayLength = 0; foreach (MineralField mineralField in scenario.GetAllElements <MineralField>()) { RCIntVector lastKnownQuadCoords = mineralField.MapObject.QuadraticPosition.Location; RCPackage mineralFieldPackage = RCPackage.CreateCustomDataPackage(ScenarioFileFormat.MINERAL_FIELD); mineralFieldPackage.WriteShort(0, (short)lastKnownQuadCoords.X); mineralFieldPackage.WriteShort(1, (short)lastKnownQuadCoords.Y); mineralFieldPackage.WriteInt(2, mineralField.ResourceAmount.Read()); entityPackages.Add(mineralFieldPackage); retArrayLength += mineralFieldPackage.PackageLength; } foreach (VespeneGeyser vespeneGeyser in scenario.GetAllElements <VespeneGeyser>()) { RCIntVector lastKnownQuadCoords = vespeneGeyser.MapObject.QuadraticPosition.Location; RCPackage vespeneGeyserPackage = RCPackage.CreateCustomDataPackage(ScenarioFileFormat.VESPENE_GEYSER); vespeneGeyserPackage.WriteShort(0, (short)lastKnownQuadCoords.X); vespeneGeyserPackage.WriteShort(1, (short)lastKnownQuadCoords.Y); vespeneGeyserPackage.WriteInt(2, vespeneGeyser.ResourceAmount.Read()); entityPackages.Add(vespeneGeyserPackage); retArrayLength += vespeneGeyserPackage.PackageLength; } foreach (StartLocation startLocation in scenario.GetAllElements <StartLocation>()) { RCIntVector lastKnownQuadCoords = startLocation.MapObject.QuadraticPosition.Location; RCPackage startLocationPackage = RCPackage.CreateCustomDataPackage(ScenarioFileFormat.START_LOCATION); startLocationPackage.WriteShort(0, (short)lastKnownQuadCoords.X); startLocationPackage.WriteShort(1, (short)lastKnownQuadCoords.Y); startLocationPackage.WriteByte(2, (byte)startLocation.PlayerIndex); entityPackages.Add(startLocationPackage); retArrayLength += startLocationPackage.PackageLength; } /// Write the packages into the returned byte array. byte[] retArray = new byte[retArrayLength]; int offset = 0; foreach (RCPackage package in entityPackages) { offset += package.WritePackageToBuffer(retArray, offset); } return(retArray); }
/// <summary> /// Creates the header package of the given map. /// </summary> /// <param name="map">Reference to the map.</param> /// <returns>The data package that contains the header of the given map.</returns> private RCPackage CreateMapHeaderPackage(IMapAccess map) { RCPackage mapHeader = RCPackage.CreateCustomDataPackage(MapFileFormat.MAP_HEADER); Version appVersion = new Version(ConstantsTable.Get <string>("RC.App.Version")); mapHeader.WriteInt(0, appVersion.Major); mapHeader.WriteInt(1, appVersion.Minor); mapHeader.WriteInt(2, appVersion.Build); mapHeader.WriteInt(3, appVersion.Revision); mapHeader.WriteString(4, map.MapName); mapHeader.WriteString(5, map.Tileset.Name); mapHeader.WriteShort(6, (short)map.Size.X); mapHeader.WriteShort(7, (short)map.Size.Y); mapHeader.WriteByte(8, (byte)8); // TODO: get the maximum number of players mapHeader.WriteIntArray(9, new int[0] { }); // TODO: get checksum values of the map return(mapHeader); }
/// <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); }
private void Form1_Load(object sender, EventArgs e) { ComponentManager.RegisterComponents("RC.Engine.Maps, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", new string[3] { "RC.Engine.Maps.TileSetLoader", "RC.Engine.Maps.MapLoader", "RC.Engine.Maps.MapEditor" }); ComponentManager.StartComponents(); this.tilesetLoader = ComponentManager.GetInterface <ITileSetLoader>(); this.mapLoader = ComponentManager.GetInterface <IMapLoader>(); this.mapEditor = ComponentManager.GetInterface <IMapEditor>(); /// TODO: this is a hack! FileInfo tilesetFile = new FileInfo("../../../../tilesets/test/test.xml"); string xmlStr = File.ReadAllText(tilesetFile.FullName); string imageDir = tilesetFile.DirectoryName; RCPackage tilesetPackage = RCPackage.CreateCustomDataPackage(PackageFormats.TILESET_FORMAT); tilesetPackage.WriteString(0, xmlStr); tilesetPackage.WriteString(1, imageDir); byte[] buffer = new byte[tilesetPackage.PackageLength]; tilesetPackage.WritePackageToBuffer(buffer, 0); ITileSet tileset = this.tilesetLoader.LoadTileSet(buffer); this.map = this.mapLoader.NewMap("TestMap", tileset, "Yellow", new RCIntVector(64, 32)); this.draw = new IsoDraw(); this.replacedTiles = new RCSet <IIsoTile>(); this.terrainTypes = new List <string>(); foreach (ITerrainType terrainType in tileset.TerrainTypes) { this.terrainTypes.Add(terrainType.Name); } this.selectedTerrain = 0; this.Text = this.terrainTypes[this.selectedTerrain]; }
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); }