Archive

Archive for the ‘C#’ Category

Unity 3D Thoughts

April 24, 2011 Leave a comment

I’ve spent the last few months working on a project using the Unity 3D engine and have to say that it’s a pretty solid engine. While on any given day, I’d much rather be using the UDK tool kit, I don’t mind using Unity when I need to.

The unity community is very supportive, and the company seems geared towards helping indie game developers out with making their own video games which is a plus. The engine does not have all of the features that UDK does, like a cut-scene editor and point-and-click scripting, but for developers that are used to C# and XNA, I find the Unity is a perfect tool to help keep development costs down. The transition is not that difficult to make.

One of the things I really like with Unity, is the ability to write code, and then run it immediately. I’m not aware of any way to do that with UDK, which I believe requires you to restart the editor each time you want to compile the scripts and have them take affect.

I’m really wanting to get my current project completed, but I’m suffering from lack of 3D math knowledge, which hinders my development speed. That and building some sort of state manager, which is taking some time.

I am going to spend tonight really focusing on fixing some of the issues I have with my project, and getting a working copy uploaded to the teams SVN tonight.

Advertisements

Mud Designer plans

November 14, 2010 3 comments

Now that I’ve got a large chunk of my current Windows Phone 7 application wrote, I’m feeling pretty good with how things work regarding it. I’m slowly understanding Silverlight a little more with each day I work on this app and feel pretty confident with it.

I started thinking what would be a good next app and I think I want to go ahead and start work on the mobile telnet client app for the phone. While I work on that, I’ll resume work on the Mud Designer and try getting a world up and running by february.
I think a mobile MMORPG (even if it’s in the form of a MUD) would be a pretty cool achievement for myself. If I can beat other people to it, be nice to be the person to release the first Windows Phone 7 MMORPG.

The Mud Designer engine is pretty far along IMO. The core engine is finished and I just need to start working on the NPC, Combat and Quest systems. NPC and Combat shouldn’t take to long, and I’m pretty sure I can put together a simple to use Quest system to get the engine into a useable state. As time progresses and income comes in (hopefully) I can improve and build on the systems, adding more content and eventually get the GUI created and working.

Windows Phone 7 MMORPG anyone? It sounds good to me.

Proper .NET Script Engine…Finally

October 17, 2010 Leave a comment

Over the last two years, I’ve wrote several itterations of a Managed scripting solution for the .NET Framework, beginning with DotScript, then I built Managed Scripting, a more robust and simplified version of DotScript. It didn’t take off very well and I assume more or less because I didn’t really go around advertising it much.

After the lack of interest in the previous two script engines, I decided that I might receive more interest in the product if I wrote it for the XNA Framework, and so I migrated Managed Scripting into another product called BlitScript which died off due to my lack of knowledge with the XNA Framework and how it uses Components. After spending time messing with various game engine’s and frameworks over the last week, I decided I wanted to get back to the things I enjoy the most, and that’s utilities development. Since I had simi-finished three scripting engine’s in the past and a fully functional one within the Mud Designer project I decided I’d go ahead and focus on a complete script engine solution. More or less to see if I’d do anything differently this time around from my past learning experiences.

I created rScript (temporary name), and had it put together in just a couple hours tonight. The Scripting Engine is more of a Compiler Engine at the moment, with a complete C# Raw Compiler implemented as well as a Interface for allowing custom compilers from 3rd party being wrote and used with it. It works pretty good at the moment and can be used in .NET applications that want to add some extensibility to their software. Assuming you have a .cs file in your applications root directory, you can use the following code to compile the file.

static void Main(string[] args)
{
    rScripting.CompileEngine com = new rScripting.CompileEngine();
            
    com.Compiler = "C#";
    com.Compile();
}

Pretty simple and straight forward, the engine will automatically check for .cs files and compile them. If you want to use a custom file extension or change the path to your script files, you can do so as well.

The engine also supports the creation of custom compilers provided they implement the ICompiler interface. Below shows a application using it.

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace RuntimeExample
{
    public class SampleCompiler : rScripting.ICompiler
    {/// <summary>
        /// The location where the Script files are stored. rScript will compile them within that directory.
        /// </summary>
        public String ScriptRepository { get; set; }

        /// <summary>
        /// The file extension used for the script files.
        /// </summary>
        public String ScriptExtension { get; set; }

        /// <summary>
        /// Provides a collection of Assemblies that the compiler will add to its reference list.
        /// </summary>
        public List<String> AssemblyReferences { get; set; }

        public System.CodeDom.Compiler.CompilerResults Results { get; set; }
        
        public String[] Source { get; set; }

        public Boolean Compile(System.CodeDom.Compiler.CompilerParameters param)
        {
            Source = new string[] {
                "namespace RuntimeExample { public class MyClass {} }"
            };

            Microsoft.CSharp.CSharpCodeProvider code = new Microsoft.CSharp.CSharpCodeProvider();
            Results = code.CompileAssemblyFromSource(param, Source);

            if (Results.Errors.HasErrors)
                return false;
            else
                return true ;
        }
    }
}

While the example implements the CSharpCodeProvider to do the actual compiling, you can write your own compilers and perform the compiling from within your ICompiler class, providing support to your 3rd party users for scripting with your custom compiler.

The example demonstrates hard-coded source code, but your ICompiler implemented class can pull source from either the user during your applications run-time or via source code files.

Next on the agenda, run-time script instancing, method invoking and property access.

Mud Engine + GUI = Mud Designer

September 27, 2010 Leave a comment

Yesterday i put together a quick UI for creating Rooms using the Mud Engine and liked how easy it was to access & use the engine. It’s come a long ways since my last GUI was developed on. I’ll spend today working on implementing a full UI for the designer & see about getting networking up and running within it as well. Shouldn’t take to much to get it done right.

Delaying the release another week

September 5, 2010 Leave a comment

Yeah, another delay with the release of Alpha 1.4 will prevent my release of it today like I had originally planned. The delay is caused by a set of new scripts I’m currently working on and they’re pretty large and complex so it’s taking me quiet a bit of time to write them and get them fleshed out. When they’re finished, I think it will be time for me to graduate to Alpha 2.0 as I will have a complete real-time editing package implemented.

So what are these scripts I’m working on? They belong to the aforementioned real-time editing package I mentioned. A series of commands have been re-wrote and new ones added to allow for creation of new world objects, editing of world objects, deleting and moving of world objects along with linking of Rooms.

All of these commands will be released as part of the script package, allowing developers to edit the scripts to suit their needs for what ever requirements that their project might have. Additional information on the way these commands will be used will come soon.

Restoration!

September 3, 2010 Leave a comment

Wow, it’s been nearly two weeks since I committed a change to the Mud Designer source code repository. I liked having my weekly releases at the site, but these past two weeks have been busy for me and there was a lot of work that needed to be done to the engine when I could get the time to work on it, thus causing the missed weekly release.

The Mud Engine now fully restores the game world environment! It’s taken a lot of work and re-writing various methods within classes to get things working the way they should. Saving and loading the game world is fully implemented and now allows for the environments to be restored after the server has shut down. The Server will re-create the game world with everything defaulting to the scripts. Once the world is created, all of the environment objects have their saved state loaded from the saved files and restored. Admin’s can now construct their environments and make changes to existing objects without worrying about loosing their changes if the server goes down.

While object creation other than Environment objects is not implemented yet, this feature needed to be fully implemented prior to working on adding new content to the engine in order for new content to support saving and restoring.

Alright, so what’s next… I will spend my free time working on the Create script. Environments now have a ‘Path’ Property that can be used such as:

FileManager.WriteLine(filename, this.RoomLocation, "RoomLocation");

If the Room is within a Realm called MyRealm and a Zone called MyZone then Room.RoomLocation will return

MyRealm.Realm>MyZone.Zone>MyRoom.Room

You can also call Room.RoomLocationWithoutExtension and it will return:

MyRealm>MyZone>MyRoom

I want to do something along these lines for Environment creation, using a command like ‘Create MyRealm>MyZone2’ will create a new Zone called MyZone2 within the MyRealm Realm. No longer would admins need to go through a long process of entering filenames and using the current menu system. It’s a more simplistic approach and with a possible ‘List Zones MyRealm’ command that could list all of the Zones within the Realm MyRealm, a Admin can easily find what Zone names have already been taken prior to creating one.

That’s what’s next on the addenda, and hopefully I can get it finished up by Sunday and have Alpha 1.4 released this weekend.

Room Restoration

August 30, 2010 Leave a comment

This weekend I spent time working on finishing up the environment restoration. Yeah I know, it’s still not done. I ran into an issue with re-linking Rooms that’s forced me to re-think and re-implement the how Rooms are restored. When a Room is loaded it will create it’s doors and link them to the required Rooms. However, if the Room is not loaded yet, the Door loads it on its own. Then the Zone goes on and keeps loading the rest of it’s Rooms.

As a example, what happens when Bedroom has a Door linking to Hallway? The door will load the hallway. When Bedroom is finished the zone loads the next Room which will eventually be the Hallway. So now I have two Rooms loaded in memory and independent of each other which isn’t a good thing. Bedroom within the Zone will be different then Bedroom connected to the Hallway.

Because of this I will instead, load all of the rooms and ignore the Doors, once every Room is loaded the engine will perform the linking.
This isn’t the best approach in my opinion but it works for the moment. Hopefully I can wrap it up by Friday & spend the weekend tightening things up and release on Sunday.