Game creation tools. New domain, same conversation.

Some gaming on the side.....

Yeap.  For the 2E and Plexers out there I am afraid I am between opportunities at the moment so am not using the tools on a daily basis.  In the meantime I have turned my hand to a second love of mine.

Making computer games.  

Some of you may know that I have written games in the past.  I remember demonstrating/hassling my colleagues way back when I was working in London as I was creating a game.  6 months of sweat (some tears) later...... I published a shoot em up (Galaxian style) in 1999 for my cousin who was 13 and totally chuffed when he realised that he could blow up his parents on Level 5 (Phase III).

I am pleased to say that some years later he turned out to be of sound character so killing his virtual parents never crossed contaminated his real word views. :-)

At the time I used a tool called "The Games Factory".  This was a IDE and engine rolled into one and it allowed you to create a game (at that time it targeted windows).  This tool has had a second version and updates ever since and has also been superseded by a tool called "Multimedia Fusion 2".

Nowadays, this tool can create games for Web, Android, iOS (iPad and iPhone) as well as XNA for windows devices.

I decide to blog a little about this as the concept of these types of tools is not too far removed from the ideals behind the 2E and Plex tools (technology insulation, templates, productivity) to name a few of the key features over raw coding.  I am currently using two additional tools from www.gamesalad.com and www.stencyl.com.  Both tools are aimed for lowering the threshold to get into games creation for your favourite devices.

The irony for me is the forums I take part in have the same debates that defenders of 2E and Plex have endured over the years.  i.e. 3GL coding versus 4GL code generation.  Numerous times I have had to draw the comparisons for this generation Y or whatever we are calling youth now.

In one camp is the (take Apple) XCode only guys who have hand crafted every element of the game engine and experience, whereas, on the other side are Stencylites or Saladers who believe in gameplay and quality graphics etc etc.

As always it depends on the project, timescale, developer capability and you guessed it, no one solution to fit all scenarios or game types, they all have there limits, learning curves and price point.

The grand daddy of 3d games in this space (hobby, Independent to Studio) is Unity but that also comes with a price tag to match.  Still all of these are cheaper than licensing a 3rd party engine like Unreal.

On the gaming side of my life at the moment I hit issues with game performance that require tuning, features that are not yet in the tools but on the roadmap and eagerly awaiting updates, 3GL vs 4GL debates within forums etc etc.    In a way a parallel universe to my professional life using 2E and Plex.

If any of you 2E and Plex guru's out there fancy doing something a little different you'd not do much better than the tools I have mentioned.  Unless you are a coder coder and therefore you can utilise some of the SDK's and chose your relevant physics engine for example :-)

Now I just need an excuse to integrate a Plex or 2E server application within a game and be the first person to integrate these technologies......

When the game I am building hits the stores I'll be sure to let you know.

Thanks for reading.
Lee.

Edit 1 - Fixed up a few typo's
Edit 2 - There is also another SDK of interest called CoronaSDK which bridges the gap between the 3GL approach and the 4GL approach.  It's effectively uses and intermediate language that then compiles and uses runtimes for the relevant devices, all packaged neatly and available to download from an app store near you.  Check it out www.coronalabs.com

Job Opportunities

Local or Remote.

Casual or Contract.

No harm getting in touch.

You may also be interested in other areas of skill and expertise so take a look at the LinkedIn profile (in the links section on the right ------>).


My new company (launching in June 2012) will be specialising in custom software development for:-


Business Applications
Web & Cloud Solutions
Mobile Apps
Games


For more information message me at the above email address.


Thanks for reading.
Lee.

You either read my blog because you are a CA Plex and/or CA 2E programmer and you are keen for a different perspective or you may have googled Plex and landed on my site instead of the other technology out there called Plex and not CA Plex.

Anyhow, a few things have happened in the CA Plex and CA 2E marketplace in recent weeks so I though a quick round up would be in order.

1. Plex 7.0 has been released with the new .NET Client generator option.
2. 2E version 8.6 has been released with the marquee feature of passing arrays as parameters and therefore ability to easily deal with result sets.   For both of these look at the CA website for details on how to download etc as well as accompanying web casts and PowerPoint presentations.
3. Is a nice article about Plex.  http://www.mcpressonline.com/dev-tools/ca-plex-could-be-the-best-development-tool-of-all-reader-says.html   There may well be more to come with this.
4. Is that Websydian are launching the latest version of their patterns (version 6.5), that webcast is tonight my time here in New Zealand.
5. The Plex-XML guys are quite busy working in the background as this framework begins to make strong traction in the CA Plex community.

Thanks for reading.
Lee.

Beginners Guide to the CA Plex Model API using C# .NET - Part IV – ‘Some DotNet Tips and Tricks’

I have written about the inspiration behind using the ModelAPI and alluded to some good examples of where it is being used in the real world including my own ‘Entity Creator’ project.

I have covered the concepts behind the ModelAPI and its relation to the Plex IDE and in particular to the Model Editor and Object Properties windows in Plex which are critical in helping you understand the ModelAPI.

I have blogged about some of the methods that are available to Plex developers to manipulate and extract information from the underlying model.  

Plex 7.0 is here now (available via electronic download and going GA soon) and it introduces 5 new methods that would be useful for us ModelAPI converts.

• FindRealObj
• FindOrAddRealObj
• ShowObjHelp
• GetObjSurrogate
• GetObjPackageName

To my surprise after a count in Plex 7.0 (Version 4.0 of the Model API) there is now a staggering 92 methods and I have enhancement requests in the pipeline for a further 3.

The Tutorial

Part IV in this series I promised to walk you through a C#.NET tutorial for building your first (basic) ModelAPI program outside of Plex.  If you prefer to use Java or even Plex then some of the concepts and the code outline will help but you are on your own from the implementation syntax perspective.

To keep it simple we are going to create a standard WinForm application.  

Assumptions

This tutorial assumes you are using CA Plex 6.1 and will work with all build levels.  If you are serious about the ModelAPI then upgrade to build 32 ASAP, there have been lots of improvements made in the API and some critical fixes to some of the methods.  You could also upgrade to 7.0 too.

Visual Studio 2008 is used in this tutorial.  I would suggest that 2010 can also be used although the screen layouts and some menu options may differ.  

Directory locations implied or pictured may need to be altered for your environment depending on your own personal setup.

I assume that you have some Visual Studio programming knowledge and are aware of the control types of TextBox, Label and DataGridView and basic syntax like declaring of fields in C#.  However, I think that you will be able to follow this through as I have written with the 100% novice in mind.

 

Disclaimer

This is my crappy C# coding.  I haven’t been formally trained and there may be better ways of achieving some of the coding I have created but I am willing to receive feedback and will adjust as required.

Let the tutorial begin.

A screen print of the finished tutorial is below so you know what you are creating and you can add your controls to forms canvas in a similar manner. 

Links to these posts, a PDF document consolidating all posts and a ZIP archive for the completed source code will be available on the Plex Wiki.

1. Create a new folder on your C:\ called C:\PlexTutorials
2. Open Visual Studio
3. From the main menu select File, New, Project
4. Complete the New Project dialog as follows

Note: If C# doesn’t appear then you will need to look at your Visual Studio installation.  
Also understand that your screen might be slightly different depending on what project templates you have installed in your environment.

5. Click Ok to confirm
6. Your screen should like something like this

The key windows are Toolbox, Solution Explorer and Properties.  If you don’t get these showing you can toggle them on via the View menu or by using the keyboard shortcuts.

If these are not shown it might be that they are hidden on the screen.  In which case like this example with a hidden toolbox you need to click as below.

You need to click the Toolbox tab and it will automatically reveal.  Then just toggle the Auto Hide option.

GUI Layout

7. If you haven’t already, click on the Form1 in the main canvas.  It will now have the control handles around the outside if you have, then  adjust the following properties in the properties window (See screen below) – Note they are in bold if different from the default.  Same as Plex and the L (local) override indicator.
a. Text = Show Field Triples
b. Size = 600,400

8. Now let’s add the controls we need to the Form.  In the Toolbox click on the Label control and drag it across to the canvas, let go of mouse and then set its properties as follows
a. Text = Field name:

9. Now add a TextBox next to the label on the Form and set the following properties (Remember the complete image above)
a. Name = TextBoxFieldName
b. Size = 250,20
10. Now ‘Double Click’ the Button control in the ToolBox and it will automatically be added to the Form.

11. Now drag this new button to be to the right of the TextBox just added and set its properties as follows:-
a. Name = ButtonShowTriples
b. Text = Show Triples
c. Size = 100,23

The Form should look something like this...

12. Now add a DataGridView (Grid) control to the Form.  These are located further down the toolbox in the Data folder.  Add to the form and accept the defaults from the DataGridView Tasks pane for now.

13. If not selected, select the grid and set the following properties:-
a. Size = 560,280
b. Location = 14,70
c. Name = GridTripleDetails
d. AllowUserToAddRows = False
e. AllowUserToDeleteRows = False

14. You will notice that the Grid has a small right facing arrow at the top right hand side.  Click this to show the Tasks pane again and then select Edit Columns... to bring up the editor for the grid control.  (The tasks pane shows the most common properties and editor for a particular control).

15. Currently we have no columns.  As you can see with our completed project we want one column in the Grid called Triple Details where we show the full triple details for the YesNo field.

16. Click Add to add a new column and complete the Add Column dialog as below and the press Add button.

17. Now click the Close button to close the Add Column dialog which returns you to the edit Columns dialog.

18. Now set the Column Width property to 500 and press the OK button to close.

19. Your form should now have a Grid Header row with ‘Triple Details’ and the width of the field should cover most of the grid.

20. That’s it for now with the Form Design to this would be a good time to save progress so far using the familiar save icon on the toolbar.


Coding

Now for the coding but before we start I’ll give you a quick overview of what we are about to do.

We are going to declare the Plex ModelAPI and then instantiate it in C#.
Then we are going to write the code that reacts to the ‘Show Triples’ button being pressed.  As with Plex we link the act of clicking the button to a logical event that executes the code.  If you have used Visual Basic or Access you would have done this a hundred times.

21. Right click anywhere on the Form but not on a control and select the View Code menu shortcut.

If you have more menu items than this then it is likely you have selected a control and NOT the form.  Anyhow, View code will open a new tab and show the Form as Code View.  It should as below.

22. In order to program against the CA Plex Model API COM Component Visual Studio must know about it.  This is what we call a reference.

23. In the Solution Explorer window (The one on the right hand side of the code window), right click on the ShowFieldTriples project and the select ‘Add Reference’ menu option.  You could also have selected Project from the Main Menu and selected Add Reference from there.

24. WAIT....This will bring up the Add Reference dialog but depending on the speed of your system and the number of potential references that can be added this might take a few seconds to appear (over 30 seconds elapsed on my laptop).  See below.

If you have by now upgraded to Plex 7.0 then this might say PlexAPI 4.0 Type Library (Depending on what CA do here).

25. Click on COM tab and then scroll down to select the PlexAPI Library.
26. Click OK to add the reference.
27. PlexAPILib should now appear in the Solutions explorer under the References folder.

28. Back to the Code View tab and immediately under the last using statement enter the following.


using PlexAPILib; //Declare Plex Model API

29. After

public Form1()
        {
            InitializeComponent();
  }

        Enter

    //Instantiate a version of the Model API in memory and refer to it as "_Plex" from now on.
    private static PlexAPIClass _Plex = new PlexAPILib.PlexAPIClass();

Note:  For Visual Studio 2010 you will need the following instead.

    //Instantiate a version of the Model API in memory and refer to it as "_Plex" from now on.
    private static PlexAPI _Plex = new PlexAPILib.PlexAPI();

30. Your code should now look like this

Screen print is for Visual Studio 2008 solution – see note above.

Recap.

Now Visual Studio references the Plex API and will load a copy of the interface into memory when the application is run and is named _Plex.  All we have to do now is react to the form and interrogate the model via the API methods and display them in the grid.  Simple!!!!


31. Click on the Form1.cs [Design] tab above your code window
32. Double Click the Show Triples button to create the ButtonShowTriples_Click event handler.  The following should now be shown in your code window.

        private void ButtonShowTriples_Click(object sender, EventArgs e)
        {


        }

33. Position your cursor between the braces and enter the following.

        //This is the area where I declare ALL the variables that are used by this program
        int MyFieldObjID = 0;

The MyFieldObjID field above may be underlined green (like the Word grammar checker) at this point. Don’t worry about this, this is just Visual Studio telling you that a field has been declared but is not used.

As mentioned in a previous post all objects in CA Plex have a unique internal number.  In order to obtain this we use the FindObj method from the ModelAPI.  You will recall it takes three parameters the object name, object type and returns the ID of the object.

34. Leave a couple of lines gap after the last entry and now let’s enter the following code snippet.

       _Plex.FindObj(TextBoxFieldName.Text.Trim(), 6, ref MyFieldObjID);





Here is a summary of what this line is doing....Using the _Plex ModelAPI that we instantiated into memory call, its FindObj method (function) and pass in the contents of the TextBoxFieldName after trimming any trailing blanks.  Let the FindObj API know we are looking only for a field (Object Type = 6) and then store the returned ID of the object (if found) to my new field MyFieldObjID.

35. If an object is found that matches the name and type then the internal ID is returned, otherwise it will be 0.  We only want to proceed if an object exists otherwise we will send a message to the user.  Enter the following immediately below the FindObj statement.

            if (MyFieldObjID != 0)
            {


            }
            else
                MessageBox.Show("Field " + TextBoxFieldName.Text.Trim() + " not found in this local model");

36. If everything has gone to plan then your code window should look like the image below.

37. If not already open, Open Plex and a local model of your choice.  If all is well you can run the tutorial program from inside Visual Studio by pressing the debug button.

38. This will build the project and execute the code.  Try entering a field you know doesn’t exist and you will see our error message and when you type a correct field like YesNo then the message will not appear.

39. Now you have tested what we have so far.  Stop the debugger by clicking on the stop button or close the application using the Windows Close X button.

Now we have covered the basics of ModelAPI and Visual Studio I’ll expedite the completion of this tutorial now by asking you to enter the following two snippets of code.  The first snippet is the declaration of all the variables that we’ll be using and initialisation code to clear the grid after each invocation.  The second snippet is the heavy lifting to interrogate the API and append the details to the Grid.  The comments in the code should suffice.



40. Under the line int MyFieldObjID = 0; Enter the following.

      int MyFieldTriples = 0;   //The enumerator ID for the triples associated with the Field.
      int MyTriple = 0;         //When we loop through the triples this stores the Model ID for the Triple.
      string TripleNameDetails = ""; //The actual Triple returned from the GetTripleName method.
      int NumberOfTriples = 0;   //Stores the count of triples associated with the Field in the enumerator.
      int MyCounter = 0;         //Start point for the loop.


      //Clear the Grid
      GridTripleDetails.Rows.Clear();

Again the green underline will probably appear.  Again don’t worry.

41. Place the cursor inside the braces as below

   if (MyFieldObjID != 0)
       {

       }
       else
       MessageBox.Show("Field " + TextBoxFieldName.Text.Trim() + " not found in this local model");

42. Insert the following code snippet

      //Get all (0 = all i.e. no Verb selection like 'ENT has FLD') triples associated
      //with the object. In this case an entity
      _Plex.EnumTriplesBySource(MyFieldObjID, 0, ref MyFieldTriples);
      //An enumerator is basically an array(list).  
      //In this case it has all the triple(s) surrogate ID in the model
      //We subsequently create a loop to read through the enumerator but before that we 
      //calculate how many to loop through.
      _Plex.GetCountOfItemsInEnumerator(MyFieldTriples, ref NumberOfTriples);
           do
           {
               //Get the next triple in the enumerator (returns its ID)
               _Plex.GetNextTriple(MyFieldTriples, ref MyTriple);
               //Get the Full Triple Name Details
               _Plex.GetTripleName(MyTriple, ref TripleNameDetails);
               //Add to the grid control.
               string[] NewGridRow = new string[] { TripleNameDetails };
               GridTripleDetails.Rows.Add(NewGridRow);
               MyCounter++;  //Increment Counter that is looping through the enumerator (array).
           }
           while (MyCounter < NumberOfTriples); //When done stop querying the enumerator i.e. Exit Loop
           //Destroy the enumerator (Free up memory)
           _Plex.EndEnum(ref MyFieldTriples);   

43. If everything has gone to plan the code snippet for the button click should now look like the following image.

44. Press the debug button again and enter a valid field like YesNo and you should get the following.

Thanks for reading.

Lee.

Beginners Guide to the CA Plex Model API using C# .NET - Part III – ‘Key Model API commands’

For part III in this series I promised that I would look at some of the Model API methods that are most useful to you the ‘ModelAPI programmer’ and to get you started with how the ModelAPI methods help you traverse the Model Editor.  If you have read the other posts in the series you will know I am building Standards based Entity Creation wizard for www.sasit.co.nz

Links

Part 1

Part II

As there are more than lots of methods available to you I am not going to give a blow by blow breakdown of each one and where best to use them. That would be overkill, quickly forgotten and isn't that was the RTFM is for :-)

If you look at the API documentation you can see that the API allows you to:-

• Open and close models, interrogate the model details like Path, Name and Variants etc.
• Find, Add, Change and Delete objects from the model. i.e. Entities and Fields etc.
• Manipulate the properties of these objects. i.e. Narratives, Owner and Permissions etc.
• Navigate the triples associated with the objects as if you were reading the Model Editor.

All in all the potential is there to create a whole ecosystem around the outside of your Plex environment like George has with Stella Tools. I am sure that CMFirst’s Matchpoint uses the technology extensively too. I have used it for my Entity Creator (In house) and I know of others doing some cool stuff with it too.

The ModelAPI methods are broken down into 6 categories

• Enumerators & Safe Arrays – Lists of xxx things in the model like triples or entities.
• Object(s) – Entities, Fields, Tables, Views etc
• Environment – Open, Close, Variants etc
• Triples – As per entries shown in the model editor
• Verbs – All the verbs we use to model our systems
• Automation – Generate & Build or executing commands

So we are going to look at the following methods. I have highlighted the methods category in brackets.

• OpenModel (Environment)
• FindObj (Object)
• EnumTriplesBySource (Enumerators & Safe Arrays)
• GetCountOfItemsInEnumerator (Enumerators & Safe Arrays)
• GetNextTriple (Triples)
• GetTripleName (Triples)
• GetTripleVerb (Triples)
• EnumVerbs (Enumerators & Safe Arrays)
• GetVerbName (Verbs)
• EndEnum (Enumerators & Safe Arrays)
• AddTriple (Triples)

Hopefully this will be enough to whet your appetite and encourage you to delve a little further.  Output parameters are indicated in bold.

OpenModel

Parameter	Description
Path (string)	The full path to the local model that you wish to open “C:\MyFolder\MyLocalModel.mdl”

Put simply this will open the model supplied.  If Plex is not open and calling the Model API for the first time will instantiate a copy of Plex.  The OpenModel needs the full path and if not correct then will throw an exception so use some defensive programming techniques.  

Related methods of note CloseModel, SaveModel, GetVersionName, GetVariantName and GetLevelName with the last three being based on the current configuration of the local model.

FindObj

Parameter	Description
FullyScopedName (string)	The name of the object you are searching for
ObjectType (int)	The type of object.  Used to narrow down the returned triples e.g. Entity or Field but can be set to 0 for All
Object (int)	**The Model’s internal ID for the object.  i.e.  the model surrogate ID that you weren’t supposed to see J.  For each object that you want to query or manipulate you need this ID.  FindObj is how you get it.  FindObj will return a 0 ID if the object/type is not found in the model so no ‘try/catch’ for you C# guys but be weary of what 0 really means for your program.

Probably the most used method in the ModelAPI I would suggest.  The principle is simple.  Virtually all methods relate to objects or triples etc by their ModelIDSurrogate.  Not to be confused with the Surrogate on the Object Details (Information) tab or for Information menu option (See below).

There is a list of all the object types in plex and their underlying ObjectTypeID in the ModelAPI help.  For ease of use I will tell you that Entity is 5 and a Field is 6. 

There are some smart ways of shielding yourself from having to remember these ID’s that I will go into with post IV next time when we will build a small ModelAPI program in a tutorial in C# .NET. 

Related methods of note AddObj, ChangeObj, DeleteObj and other methods that do get the information in the information tab above like GetObjOwner, GetObjPermissions, GetObjLastChangedDate and GetObjSurrogate (Yes that one in the information window) has been implemented in version 4.0 of the ModelAPI that ships with Plex 7.0. J

EnumTriplesBySource

Parameter	Description
Obj (int)	The ID of the Object on the left of the Model Editor (Source Object)
VerbID (int)	The verb.  Used to narrow down the returned triples but can be set to 0 for All
Enumerator (int)	An API generated ID that points to the list in memory that is created by the ModelAPI

Now would be a good time to explain what a ModelAPI enumerator is.  www.dictionary.com supplies the following interpretation on Enumerator (Enumerate) which is pretty good so we’ll run with this.

To mention separately as if in counting; name one by one;specify, as in a list:

Once we have the enumerator ID we would then use a loop (Do While or For loop etc) to get the details and parse the triples, in context of Triples we could use GetFirstTriple and GetNextTriple.

Related methods of noteEnumTriplesByTarget.

If we were to use the EnumTriplesBySource for the YesNo field and VerbID of 0 for All.  We would get the following from my local model

Enumerator 87200904 (This changes every call). 

The enumerator will have 9 entries which are the underlying internal ID’s (don’t change) :-

87814200
87814344
87814488
87805848
87812760
87812904
87813048
87813192
87813336

All of these relate to the triples (real or inherited) that define the field as defined in the Object Properties window.

So to summarise an enumerator is a list of ID’s that point to objects or triples within the plex model, the enumerator is created on the fly with a unique ID.

GetCountOfItemsInEnumerator

Parameter	Description
Enumerator (int)	The ID of the enumerator created by the Enum* method.  Note that these are temporary ID’s that are generated uniquely each time an Enum method is called.
Count (int)	Integer value of the number of triples in the enumerator.

Once you have an enumerator you need to loop though it.  Understanding how many items have been returned can be useful for ‘Count Fields’ or of course enabling you to safely control the calls to the GetNextTriple method without causing you ‘Index out of bounds’ type errors.

GetNextTriple

               

Parameter	Description
Enumerator (int)	The ID of the enumerator created by the Enum* method.  Note that these are temporary ID’s that are generated uniquely each time an Enum method is called.
Triple (int)	The ID for the individual triple

Each time GetNextTriple is called it advances on one from within the Enumerator. 

Related methods GetFirstTriple always gets the first triple in the enumerator.  Note, this can be useful for resetting the underlying pointer for the GetNextTriple if you need to read through the enumerator more than once.

GetTripleName

Parameter	Description
Triple (int)	The ID for the individual triple
Name (string)	A string with the full triple name i.e. Source, Verb and Target.  i.e. My Entity/ENT known by FLD/My Key

GetTripleVerb

Parameter	Description
Triple (int)	The ID for the individual triple
Verb (int)	The internal ID for the Verb.

Currently there are over 640 verbs in plex and this grows with every release.  These verbs like the ObjectType have unique internal ID’s

GetTripleVerb returns the ID of the verb for the triple.

Related methods GetTripleSource, GetTripleTarget and GetVerbName (covered later).

EnumVerbs

Parameter	Description
SrcType (int)	As ObjectType i.e. Entity or Field.  Can be 0 for All.
TgtType (int)	As ObjectType i.e. Entity or Field.  Can be 0 for All.
Enumerator (int)	An API generated ID that points to the list in memory that is created by the ModelAPI

You can show all verbs related to Entity by select SourceObjectType as Entity and TargetObjectType as All.  Or be really specific with as Entity and Entity which brings back verbs like ENT Refers To ENT and ENT Owned By ENT etc

GetVerbName

Parameter	Description
Verb (int)	Internal verb ID i.e. FLD Displayed as FLD = 8 and is an example of a verbs FullName
WhichName (int)	See table below.
VerbName (string)	An API generated ID that points to the list in memory that is created by the ModelAPI

Assuming we use the example above i.e. Verb = 8 then WhichName will return the verb formatted as follows:-

WhichName (int)	Description	Verb = 8 returns...
0	AliasName	displayed as FLD
1	FullName	FLD Displayed as FLD
2	ResolvedName	FLD Displayed as FLD
3	SimpleName	FldDisplayedFld

This return the formatted name is various way and also saves us having to parse the GetTripleName string.

EndEnum

Parameter	Description
Enumerator (int)	Deletes the enumerator from memory.

Every enumerator you create using an Enum* method creates a new enumerator list with a new ID.  If you don’t destroy these they will stay in memory until you close the program.  Basic housekeeping to reduce memory usage.

AddObj

Parameter	Description
SourceObj (int)	The object you wish to link (scope) the new object with.  Tip. Leave as 0 for an unscoped object.
Name (string)	The name of the new object (Remember to conform to Plex naming standards i.e. restricted characters and 32 in length.
ObjType (int)	Same is ObjectType i.e. Entity = 5 etc
Object (int)	The ID of the object just created in case you want to add other stuff like narratives etc.  Saves you finding the object you just created.

Next time we will put most of these into action with a C#.NET Tutorial using Visual Studio 2008. You won’t need the professional edition either although I will be using it.

See you then.

Thanks for reading.

Lee.