- 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)
- Fixed BaseCharacter not returning content to the game loop
- Fixed Zone.LinkRooms linking rooms backwards.
MudGame:
- Minor tweaks to the BuildRealms method
- Minor tweaks to the Program.Main method.
- 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.
- Display Game Information at game startup now.
- Checks to make sure the returned Object from Player.ExecuteCommand() is not null before attempting to iterate through the array. The Exit command no loner causes an error due to this fix.
- 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).
- included Player Script in Debug folder. Used for testing the compiler and Game.Start() function which loads the player script and adds it to the PlayerCollection
- 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().
- Now compiles scripts contained under a MUDCompiler/bin/debug/Scripts folder.
MudEngine:
- ScriptEngine now wraps scripts inside a default namespace. MUDScripts MUST not be placed within a namespace inside the script. The Engine handles it automatically.
- Fixed ClientSocket accessor error.
MudCompiler:
- Added new project. This will compile the game scripts along with performing object checks to ensure the game contains no errors prior to publishing a release of the game.
- Created PlayerAdmin class. All admins will be instances of this class; allows for segregating admin code into a different class for easier management and maintenance.
- CommandRestart now checks to make sure the player is of Type PlayerAdmin instead of player.admin
- Added ExecuteCommand to BaseCharacter. All Characters (NPC & Players) can execute commands now. Allows for AI to roam the world at some point in the future by invoking the available move commands.
MUDGame:
- Updated the command execution from CommandEngine.Execute to user.ExecuteCommand to use the BaseCharacter version.
- Changed PlayerBasic to PlayerAdmin for testing purposes.
TODO: Remove command execution from game loop, server should sit and wait for telnet data to be transmitted to it within the loop. That will be the command and passed off to the BaseCharacter/Player/NPC ect ExecuteCommand
- 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.
- Added Look and Walk Commands, however they are not fully implemented.
- Corrected Networking classes having a public de-constructor. These must be private or the compiler fails.
- Corrected Networking classes using an incorrect 'using' statement. You cannot reference classes in the statement, must only reference the namespace itself (i.e. using MUDEngine.Networking).
- Removed using statement for Networking in the Networking classes as all classes created within that namespace automatically are within the same scope.
- 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.
- Minor tweaks to Room.cs for checking file extension validity
- Scripting Engine and related classes added to Solution (Files existed but were not a part of solution)
- Updated MudDesigner to reference the new MudEngine solution.
- MudDesigner currently references engine classes within it's own solution and the MudEngine solution. This will be addressed soon. All classes related to the engine will be moved to the MudEngine project.
- Began prepping for the removal of all UITypeEditor classes and the namespace from the MudDesigner project.
Please note that while this version will compile, it is currently broken. Projects do not get created correctly due to the migration I'm performing. The designer is given less priority at the moment as the engine is the primary focus. Projects will need to be hard-coded using the MudEngine library until the designer is fixed.
- Zones now adjusted to delete rooms matching the new collection method being used.
Designer:
- Room Designer now supports the new Zones.Room collection
- Removed the ManagedScripting Engine from the project. Scripting will be implemented at a later time using a custom build engine.
- Room.Load was re-wrote to allow for loading a supplied room name (not a full filename). The Room will load the supplied Roomname by checking within it's current Zone. Rooms within different Zones can be loaded by supplying a Zone name as one of the optional parameters. Same goes for loading Rooms within a different Realm
- All classes using the original Room.Load code have been tweaked to use the new code. Cuts the needed code used by each individual class by 80%.
- Room.InstallPath Property added for returning the full filename and location of the Room where it's currently installed.
Designer:
- Room Designer now supports deleting Rooms.
- Doorway Editor no longer fails when attempting to change doorway Traveling Directions.
Runtime:
- No longer prints blank lines if the object does not contain any text to print.
- Added a 2nd Print method with a boolean argument for printing blank lines by force if needed.
Note: Room Deleting and Room.Load code was only tested using Rooms within Root Zones. Rooms contained within a Zone owned by a Realm was not tested.
- Now supports the exit command, prevents the designer from crashing.
Runtime:
- Added a GUI based set of buttons for traversing your environments via a click-through method instead of forcing users to type commands.
Engine:
- Added the Exit command to exit the runtime (At this time it shuts down the Designer as well.)
- Changed the IGameCommand Interface constructor for the Execute method.
- Updated all of the game commands to make use of the new Execute Method Constructor requirements set by the updated interface.
- Look command now returns a description of the players current Room.
- Walk command now supports moving players from one Room to another. Use 'Walk Direction' where Direction equals the direction you want to travel (Example: 'Walk North")
- TravelDirections.GetTravelDirectionValue now checks the supplied direction value in a case-insensitive manor.
- Add a new CommandEngine that handles the commands inputed from the user.
- Modified CommandResult to return an array of objects rather than a single object.
Runtime:
- Now scans the supplied collection of objects returned to the runtime after executing a game command, and adjusts the runtime components as needed, including printing information to the console.
- Now displays various warnings during startup to let the user know if certain content hasn't been set within the ProjectInformation yet.
- Now executes the 'Look' command on startup to display the users current location.
- Fully supports the 'Look' and 'Walk' commands.
- Designer now has a status bar to show when various things are completed successfully.
- The Offline Runtime can now be launched via the Designers Project menu.
- Designer now features a 'Set As Initial Location' item within the Right-Click menu. Right Click on a Zone and assign it as your projects initial starting location.
Engine:
- BaseCharacter class fleshed out a little bit. Now includes an OnTravel method for player travel code.
- PlayerBasic class now inherits from BaseCharacter.
- ProjectInformation now supports setting the games initial zone location.
- ProjectInformation.Filename is now placed within a category (Object Settings) within the Property Pane of the Designer.
- Room.GetDoor method added for returning a specified door with the matching travel direction.
- StartingLocation now overrides ToString to return the location that's currently assigned to it for use within the Designer.
- Zone class now has an EntranceRoom Property for settings the default entrance room for the Zone. This is used by the Runtime and the designer when setting and retrieving the InitialLocation.
Offline Runtime:
- Now creates a basic player, loads the project and places the player within the entrance room designated by the InitialLocation.Zone
- Runtime contains code that automatically moves the player to the north during startup. This will be removed, it's only there for testing purposes.
- Runtime does not print anything to the console yet.
- Zone.RefreshRoomList method was renamed to Zone.RebuildRoomCollection.
Designer:
- Room Editor now adjusts all of a Rooms connected doorways to connect to a re-named Room. No need to manually load and edit each Room connected to 'Bedroom' after it was renamed from 'New Room'
- Added Character class PlayerBasic for the lowest authorized level
- Added Character class PlayerAdmin that will provide some additional higher level authorized commands
- Added Character class PlayerGM that will provide high level authorized commands
- Added Factions class for future use of factions
- Added Class class for future use of classes
- Added Race class for future use of Races
- Added NPCFriendly class for future use of Friendly NPCs
- Added NPCHostile class for future use of Monster NPCs
- Added CommandWalk class for future walk command
- Added CommandGMTeleport class for future GM teleporting support.
- Added Description property to the Door class.
- Added GameCommands namespace for holding all of the game command classes
- Added ICommand interface for game commands.
- Added IPlayer interface for player classes.
- Added CommandLook for prepping the Test Runtime for looking at environments.
Misc:
- Updated Mud Designer Project Roadmap file (MudDesigner.pod)
