- Added FileManager.GetDataCollection() Method for getting a collection of values that match the supplied parameter. This is used by environments for restoring saved object collections
- World Restoration is now fully implemented.
- Removed un-needed Log messages
- Added a pushMessage parameter to Log.Write() allowing messages to be sent directly to the console instead of stacking them in a cache. All log messages now push the message by default.
- World Environment now fully saves to disk; only works with a player that has Admin privileges (All new players currently default to Admin privileges for ease of testing. Use SaveWorld command to save.
- Adjusted how the Game class saved the players to be more efficient.
- Converted all Types from C# types to .NET Types (such as bool changed to Boolean, and int changed to Int32).
- Zone no longer gets saved from within GameWorld.Save, but rather in Realm.Save()
- Room no longer gets saved from within GameWorld.Save(), but rather in Zone.Save();
- Added new SaveWorld command that admins only can execute to force save the world. It's not fully implemented at this time.
MudGame:
- began work on command execution from within the server while it's running.
- Added BaseCharacter.FlushConsole() method. Sends a hex sequence to the clients telnet terminal that clears the screen. If IsMultiplayer=false then it just clears the C# Console.
- Added a 'Clear' command for users to use. It invokes the new FlushConsole command.
- Removed the need for a full file path and filename when calling an objects save method. Now it just needs the path.
- Adjusted the Exit command, Login command and Save command to reflect the objects save parameter changes.
- Removed the Unique ID from objects.
- All objects now reference each other via their filenames rather than their object names. Allows for 3 objects with the name Bedroom to exist, but with different filenames such as Bedroom1, Bedroom2 etc.
- Zone now has a GetRoomByName method that replace the removed GetRoomByID method. Returns a List<> collection of Rooms found with a matching filename.
- BaseCharacter updated to work with the new Zone.GetRoomByName method.
- Realm.GetZoneByID renamed to GetZoneByName()
- All Objects now dynamically create their Filenames after the BaseObject.Name has been set. You can re-specify a custom filename, but do so after setting BaseObject.Name's value.
- Added GameWorld.cs. This will manage the game world itself.
- Moved Realm Initialization from Game.Start() into GameWorld.Start()
- Moved Environment saving from Game.Save() to GameWorld.Save(). However, GameWorld.Save gets invoked from Game.Save()
- GameWorld is now responsible for adding Realms to the Game.
- Fixed ScriptEngine not using Both Scripts and Assemblies at the same time.
- Added BaseAI which inherits from baseCharacter. All AI objects will inherit from this object.
MudGame:
- Modified MyGame.cs script for demonstrating the new way to create environments with the implementation of GameWorld.
- Updated Program.cs to compile both Scripts and Assemblies at once.
- Game World Auto-save property now fully implemented. However, the Game world saving mechanics are not fully implemented. As additional components are implemented, they will be auto-saved if the property is set to true.
- Game.AutoSaveInterval property added for setting how often the Game will save all objects in the world (incase run-time changes to environments/objects were made, they must be saved).
- Player walk command now supports Game.AutoSave. Every-time the player changes location they will be saved.
- ScriptEngine now supports Initializing both Assembly and Source based scripts at the same time via the new ScriptTypes.Both element.
- ScriptEngine now auto-loads previously saved settings from Settings.ini
- Game.ObjectIdentifierCollection renamed to Game.WorldObjects. Type collection changed from that of Int32 to BaseObject.
- Game.update now contains the code needed to update the World Time and Auto-Save the world if needed.
- Game.AddObject method added for adding World Objects to the Game.WorldObjects collection
- Player login now creates the directories needed if they don't exist.
- Added Update method that serves as the game loop now.
- Added additional save code to Game.Save() now saves all realms, zones, rooms and players. Called during server shutdown (Game.Shutdown())
- Began work on implementing a Unique Identifier system for all game objects.
- Renamed GetRealm() and GetZone() to GetRealmByID() and GetZoneByID. Now accepts a Int32 instead of a string as the parameter, returning a reference to the object.
- Added GetRealmByName() and GetZoneByName(). Similar to the old GetRealm and GetZone methods. Accepts a string as a parameter, however it returns a list<> collection of the found objects due to objects with duplicate names are allowed to co-exist in the game world.
- Temp directory that was being generated during server startup within Game.Start() is now deleted once script compilation is completed.
- Added GameTime.cs; contains all the properties and methods needed to have a working time system built into the engine for the game world. Not fully complete.
- Added CommandGetTime.cs which prints the current date and time to the players console. Prints the GameTime.DayNames and GameTime.MonthNames to the player. Defaults to real-world names, however these can be configured and changed, along with the number of days per week, weeks per month, months per year, seconds per minute, minutes per hour and hours per day.
MudGame:
- Now supports Game.AutoSave. If AutoSave is true, then the server loop will call Game.Save() automatically.
- Server Game Loop now calls Game.Update() every loop cycle.
- Login command now supports Offline games. Skips various things that are server related only.
- Added a constructor to SaveDataPaths for quickly being able to assign paths.
- Game.Start is now Virtual so that scripts may override it.
- Game.Start now supports single player games and initializes players within it.
- Log now provides a Verbose mode so that Singleplayer games no longer gets flooded with Game startup messages.
- BaseCharacter.Initialize() Initialize no longer crashes when called with IsMultiplayer set to false.
- BaseCharacter.ReadInput() now supports IsMultiplayer being false.
MudServer:
- Now supports singleplayer and multiplayer games within a single application.
- MudServer is now ready to be re-named to MudGame and will be used for both Offline and Online games.
- Re-organized property layout in Game.cs
- Realm now automatically sets Zone.Realm when a Zone is added via Realm.AddZone()
- Zone now automatically sets Room.Zone and Room.Realm when Room is added via Zone.AddRoom()
MudOfflineExample:
- Updated to reflect the changes made to MudEngine.
- CommandLogin no longer invokes the Look Command
- Fixed CommandWalk no longer telling the player an invalid direction message when trying to walk to someplace that does not exist.
- Moved PlayerCollection array referencing from Game.Start() to the Game's constructor so that scripts may change the player class during its startup.
- BaseCharacter now invokes the Look command after Login command is completed.
- ScriptEngine no longer sets the output path for a compiled script if the script is designated as compile to memory.
- Fixed custom players not being able to access their own Methods and Properties during runtime.
MudServer:
- Additional Console Log Messages added.
- Game now checks to see if there is a initial environment setup, if not an Abyss is created to store players in.
- Game now compiles scripts prior to loading libary assemblies to ensure the latest assembly is loaded.
- BaseCharacter now supports the Abyss room if no initial Game realm is set.
- BaseCharacter will no longer load the player into a room that does not exist (was deleted or something), they are defaulted into the Abyss.
- ScriptEngine checks for errors in the script prior to trying to reference the compiled assembly (was causing errors if scripts failed to compile; no assembly generated to reference)
- Assembly libraries are now only loaded once.
MudServer:
- Example MyGame.cs script now constructs a realm and sets default properties.
- MyPlayer script added to show how to write your own player script.
- Server loop restored and now working correctly.
- Server now outputs additional info regarding startup.
- Server now forces TCP protocol.
- Login command now automatically disconnects a user if they are currently logged into the server when another user attempts to login with the same credentials.
- Login command now loads saved players when a character name is entered that has previously been saved.
- FileManager.GetData() now supports ignoring simi-colons in data files. These can be used as comments if needed.
- MudEngine.GameManagement.Game.TimeOfDayOptions has been removed from the Game Type. It is now just MudEngine.GameManagement.TimeOfDayOptions.
- BaseCharacter will no longer try to save the character if the supplied filename is blank
- BaseCharacter will now send a disconnect message of 'Goodbye!' upon the player being disconnected from the server.
- ScriptEngine.ScriptPath now returns a absolute path.
- Script File compilation within ScriptEngine.Initialization is now supported. This allows developers to write their MUD's using Scripts and letting the server compile them during server startup rather than use the ScriptCompiler.exe to pre-compile scripts now.
- Custom Game Types are now supported. Only 1 Type may inherit from MudEngine.GameManagement.Game at a time. To use, create a file, write a script that inherits from Game and run the server.
- ScriptEngine.GetObjectOf(string) method adding. Returns a object that inherits from the Type supplied in the parameter.
- Deleted StartupObject.cs
- Deleted Startup.dat
MudOfflineExample:
- Updated to reflect the TimeOfDayOptions change in MudEngine.csproj
MudServer:
- Added MyGame.cs inside Debug/bin/scripts. This is a example script showing how to inherit from Game and write a custom Game Type. This Type is used when the Server runs rather than the Engine Game Type.
- Server startup re-wrote to compile scripts during startup, scan them via the script engine for any custom Types that inherit from Game, and use the if needed instead of the default Engine Type.
- Server now uses a Settings.ini file to allow configuration of the Script Engine by users. Provides them the ability to now customize where scripts are stored and their file extension.
- Deleted Scripts.dll, as the Server now generates one at runtime each time it is ran.
As of this commit, users will not need to use C# to compile their MUD's any longer. Compile the Server and run it. Scripts are now fully implemented (however not fully tested).
- Updated all game commands to support the new Player.Send() method. Returning CommandResults is no longer supported.
- Login command now executes the Look command upon completing login.
- Look command now supports Rooms DetailDescription property. Use this for multi-line descriptions.
- Several changes to the Restart command. Still not working fully however, it no longer calls duplicate methods.
- Fixed Walk command not moving players around.
- Loading engine commands no longer happens more than once.
- Added additional Server Console log output
- BaseCharacter.Send() now correctly displays content to the user and prints the "Command:" message to the player after every command completed.
- The Server now sets Player.IsControlled to true when a player connects.
- BaseCharacter.Send() checks if the game is multi-player or not. If it is, it prints to Console, if not then prints to telnet clients.
Mud Offline Example:
- Updated Zeroth Realm creation to use Room.DetailDescription now that the Look command supports it.
- Updated the Game loop. No longer needs to print to the console due to the player.Execute() command automatically printing content to the console.
Mud Server:
- Removed player from server as it was not being used any longer.
- Corrected CommandLogin to support the Player.Send/Receive methods.
- Re-organized the Game class source code and added additional commenting.
- Began adding code to remove un-wanted characters in the received byte stream in Player.Receive()
- Sending messages to the client from the server is now an added feature. Use Game.SendMessage()
- Added Load and Save commands for players.
- Added Missing SaveDataPaths struct file.
- BaseObject Saving and Loading fully implemented.
- BaseCharacter Saving and Loading fully implemented.
- Game.cs now contains SaveDataPaths property for allowing users to define where their data will be saved.
-
- Updated to work with ScriptingEngine changes.
MudEngine:
- Game.PlayerCollection changed to a List<>. Server obtains a array version of it within Server.initialize() via players = pbs.ToArray().
- All BaseObject classes now require a reference to the Game and contain a property called ActiveGame.
- Player.Game removed and now uses it's parent objects ActiveGame property.
- Player.Role property added. Uses the new SecurityRoles enum that specifies what level of access the player has.
- ScriptEngine now loads all libraries found within the specified ScriptsPath directory, instances the scripts and places them into a collection.
- Custom character script instancing is now supported, but not fully implemented throughout the engine. They can be loaded, but not used during runtime at this time.
- FileManager.GetDataPath now returns the actual Root directory when Root is requested rather than Root/Projects. That was considered Root for the older Designer.
- CommandEngine.GetCommands is now a method rather than a property.
- CommandEngine.LoadAllCommands replaced with CommandEngine.LoadBaseCommands for loading Engine specific Game commands. This is called from within Game.Start. A possible property for disabling default commands could be looked at in the future.
- CommandEngine.LoadCommandLibrary method added for loading custom user commands. This is fully implemented.
- CommandEngine.ClearCommands method added for clearing all currently loaded commands.
- Game.IsDebug static property added.
- Added additional logging for testing purposes throughout the project. Changing Game.IsDebug to false will remove the majority of the logged messages.
- Game.IsMultiplayer property added for enabling or disabling the server for Online/Offline support. Fully implemented.
- Game no longer loads user script libraries as this was being handled already by ScriptEngine.Initialize()
- Log now caches messages so consoles can print only content that was logged since the last loop. Using Log.FlushMessages() will clear the cached messages allowing each loop to show only the new logged messages.
- BaseCharacter IsAdmin argument in the constructor has been removed. No longer needed for testing.
- ScriptEngine can now compile more than 1 script without error.
- ScriptEngine.Assembly property added for accessing the currently loaded script library. This should be a List<Assembly> in the future for multiple libraries.
- Removed the last of my BlitScript engine code from ScriptEngine.cs as it was XNA specific. Need to look at StartupObject.cs as I believe that is XNA specific as well and not needed.
MudGame:
- Renamed MudGame to MudOfflineExample as it will be used for testing the game with Game.IsMultiplayer disabled. Makes testing easier then needing to stop/restart the server and connect via telnet constantly.
MudServer:
- Added MudServer project. This is a dedicated server that runs with Game.IsMultiplayer enabled. Developers can connect to it via telnet clients. All engine game commands are implemented.
- MudServer includes bin/Debug/Scripts.dll, which is a compiled library of scripts generated via MudCompiler. MudEngine.Game handles loading the library and there is no additional code required by the developers to implement their libraries into their games provided the name is 'Scripts.dll'
- only TCP, works has been tested
- Commented out Lists and replaced with arrays, the way the list was working it wouldn't have worked, if you can figure out how to make it work feel free to fix it up.
- TODO: When user types exit, the game object becomes useless, I need a Reset function of some kind to reset it for when a new player comes in to reuse that player object.
- TODO: Encryption
- TODO: Fix main person so they have admin commands like list, restart instead of a game with the main server. (ATM Just like that for testing, but now you can test with telnet client)
- Rooms can now be linked automatically via the new Zone.LinkRooms method. Room linking can no longer be done manually as the Doorways property is now read-only.
- Door.Description has been removed. Doorway description will need to be included in Room.Description or Room.DetailedDescription properties.
- Added DetailedDescription to make creating multi-line descriptions easier. Not supported by the Look command yet.
- Game.IsRunning is now read-only. The Game will manage this property on its own.
- BaseCharacter.ExecuteCommand now will always return a string. Simplifying the game loop for users as they no longer need to check what Type was returned by the command.
- Doors now contain a DepartureRoom and a ArrivalRoom property allowing for easy access to Rooms that are linked together.
- Fixed a bug where Game, Realms and Zones always assigned IsInitial to Realms, Zones and Rooms when added to the collections. Collection would contain multiple IsInitial objects.
- Removed Room.InstalledDoorways property as that was used only by the old Designer
- Removed Room.Load() as that implementation of it is obsolete.
MudGame:
- Revised Zeroth to build it's Zone and Rooms using the new Zone.LinkRooms function.
- Greatly revised Program.cs and the Game loop to take advantage of many of the automations provided by the Engine now.
- Player movement command now fully implemented.
- Game.GetRealm() added to retrieve a Realm within the games RealmCollection property
- Game.End() added to perform game ending duties and shut down the Server
- Server now loses opened threads.
- Player.Move() added to move the player from Room to Room.
- Room.DoorwayExist() tweaked to work with the new way Environments are managed.
MudGame:
- Now executes the Look command on startup so the player can see where they are located at.
- Implements the new Game.End() method and fixes the game hanging upon exit.
- Re-worked the command system. All commands now only need 2 arguments rather than 4. The actual command string and the Player
- All commands updated to work with the new command system
- Look command now works in the example MudGame
- Realm now contains InitialZone for the starting Zone within that Realm.
- Zone now contains InitialRoom for the starting Room within that Zone.
- All Environment objects now contains a Initial property and Add() method for adding child objects.
- BaseCharacter now contains a copy of Game
- Revised Realm.GetZone()
- Revised Zone.GetRoom()
- Removed Zone.RebuildRoomCollection as content is currently no longer stored using physical files.
- Added GameManagement.Log for logging errors and warnings to file. Use Log.Write().
- Deleted GameObjects.Characters.Controlled and GameObjects.Characters.NPC namespaces.
- Deleted PlayerBasic & PlayerAdmin classes.
- BaseCharacter now contains IsAdmin property for providing admin privileges to users.
- BaseCharacter now contains IsControlled property for setting user control or AI controlled
- Added startup.dat - This will supply information to the engine as to what Types will be used during runtime. Allowing for custom Types via scripts to be instanced and used (such as a custom player class rather than the default one).
- Changed Player[] array to a List<> Collection of PlayerBasics. This change is reflected across all Types.
- Game now contains a Start() function. StartServer is now called from within here.
- Game now has partial support for the Script Engine
MudGame:
- Game.StartServer has changed to Game.Start(). StartServer is called within Start().
- put server in Game
- created start server function in Game
- created CommandRestart
There are two different 'player classes' which do I use? PlayerBasic and BasePlayer.
- Removed from solution
Mud Engine:
- Moved the CommandEngine, CommandResults and ICommand Interface out from the Commands namespace and into GameManagement since they manage the game commands.
- Added CommandExit class to provide the ability to exit a game once running. This is fully implemented.
- Realms, Zones and Rooms now have an IsInitial property for determining if this is an initial location for the Game.
- Renamed GameSetup to Game.
- Corrected GameObject being in the incorrect namespace.
- Corrected the ScriptEngine not
- CommandEngine no longer needs a Name argument. Arguments changed from 5 to 4 due to this change.
Mud Game:
- Added Example Game used for testing various MUDEngine features and testing constructability of games using the engine.
- Currently only contains 1 Realm, 1 Zone and Two Rooms. Only working command is Exit.
2010-07-18 13:52:16 -07:00
Renamed from MudEngine/GameManagement/GameSetup.cs (Browse further)
