- Removed Game constructor setting default values for GameTime properties as the GameTime constructor does this already.
- Finished the GameTime class. Now fully supports custom Day/Time lengths and keeps track of time in sync with the server time.
- TODO: Read my ReadME
- TODO: Change it into a GUI
- Currently it is a console application, Telnet functionality needs to be added as well as \n\r | \r\n correction.
Simply create a GUI for it and use the Networking/Client.cs file (see how it is used in the Program.cs).
- Script Engine now compiles scripts as C# 4.0 Types instead of 3.5. Scripts can now use Dynamic Types.
MudGame:
- CommandCreate script added. Provides Admins the ability to create Realms and Zones from within the game during runtime. At the moment Realm creation and Zone creation (and placement within Realms) is implemented.
- Fixed the ScriptEngine and CommandEngine not loading Custom game commands from scripts.
- BaseCharacter's Create, Initialize, Send and FlushConsole are now overridable via scripts.
- Invalid commands are now printed to the player "Invalid Command."
MudGame:
- Added CommandSay script that adds primitive chatting support. Only players within the same Room can see the messages.
- Renamed California script to WorldCalifornia
- Renamed MyGame script to EarthGame.
- Added Clear command script for and Say command script for showing how to build custom commands for use with the game. The commands can only be added server-side, but used client-side.
- Removed the need for the old CommandResult Type to be a returned value on all commands. Command.Execute() is now just void.
- All commands updated to now return a value. They use player.Send() to direct messages to the player instead.
- Removed CommandClear from the project and made it a script so that developers can see how to write custom command scripts.
- Bug fixes with object saving and restoration
- Game Deconstructor removed.
- Player Password saving, restoring and varification implemented fully.
MudGame:
- Revised scripts to demonstrate the latest environment creation updates.
- 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.
- Added MyGame script to demonstrate how to write a custom Game script.
- Added Settings.ini with default Values. Note that Removing the value ServerEnabled will cause the MudGame to default into Offline mode. Allowing developers to create single-player games. This can be done by setting ServerEnabled to false, however it's recommended to remove the option from the file all together so that users don't know the option to run a server is available unless you want your single-player game to be ran on private servers as multiplayer.
Run the Game once, then edit the Settings.ini file generated to enable or disable the network server. Setting ServerEnabled to False will enable the Singleplayer offline mode within the engine.
- 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.
- Players that are within the same Room a leaving or entering player are told of the player entering or leaving.
- Players within a occupied Room are now informed when a player enters the Room or leaves
- Players onTravel now sends move messages to other players within the same Room.
- 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.
- No longer holds on startup for other Players
- Was crashing when I exited with multiple players because the filename was "", so I uncommented the line making the filename and that did the trick.
- Fix: Does it really save? lol.
- Fix: On startup I get a spam of "Loaded MudDesigner.dll", I'd fix but I don't know where it is o.O
- Fixed command engine stalling when waiting for one users command to finish before starting another users command.
- Commands are loaded into static List collections, but the Execute command itself is now no longer static.
- Player.CommandSystem property added so each player has their own commandengine to process their input.
- Receives junk sent by telnet client upon established connection
- Fixed up some problems with ReadInput
- Fixed up Disconnect
- Replaced some Log() calls.
- Commented out Initialize on a new thread, will be uncommented when CommandEngine is fixed.
- CommandEngine doesn't want to do things while other things are happening even though they are on different threads... Fix that?
- 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.
-
- BaseObject save code re-wrote
- Added Inventory property to BaseCharacter
- BaseCharacter Save() now called when players are being disconnected.
- Adjusted how objects Filenames are generated.
- 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.
- Began working on in-line commands.
MudEngine:
- Now logs when a player connects. MudServer prints this to the console via Log.GetMessages()
MudCompiler:
- Added /bin/debug to ignore list.
- Added /bin/debug to ignore list. Only file not ignored is Scripts.dll so everyone contains a copy of the dll with the scripts wrote thus far.
MudServer:
- Added /bin/debug to ignore list.
- 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)
