Archive for the ‘Scripting’ 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.


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#";

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;
                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.