Space Duck Hunting – Made with IwGame

We are very pleased to announce that “One Man Army” have just released their latest game “Space Duck Hunting” for Android using our very own IwGame Engine.

Here’s a little info about the game:

Game with great combination of action & logic. Kill space ducks, earn bucks, and buy specific combinations of temporary gun modes to smash ducks special formation.
You will have to spend your bucks wisely, buy the appropriate improvements, depending on the situation, otherwise you will not beat the ducks.
Face the dodgy ducks and watch out for their special attack formations, shields and mines which they use. You think ducks aren’t that clever and they’re easy to hunt? Wrong. Once you get all of them you can be really proud of yourself as it’s no small feat. Test your skills on over a dozen various levels, beat amazing records and wreak terror in the duck world. You will get a super effective steering system and an array of accesories for your weapons.
Remember, the ducks will try and outsmart you in a thousand ways, keep your eyes in the back of your head at all times, in every gameboard!
Features:
- Hours of great fun
- 16 levels to accomplish
- Great challenge
- 15 achievements to accomplish
- 5 shooting gun modes
- 12 different ducks
- great Boss on the end
- 3 different map types

You can download Space Duck Hunting from Google Play for FREE, so go grab a copy now!

The game will also be available soon on iOS

AppEasy 1.4 available – New Lua API, Web View, Ad Support, Video Cam Streaming

AppEasy Version 1.4 is Now Available

AppEasy the cross platform mobile game and app development system for iPhone, iPad, Android and Windows that is aimed at all levels of experience releases latest update

AppEasy version 1.4 is now available for download from here.

Please upgrade to the latest version. Note that before updating, close down your current version of AppEasy, rename c:\AppEasy to c:\AppEasy2, install and run AppEasy 1.4 then copy any changes / certificates from c:\AppEasy2 to c:\AppEasy. Note that if you install the update before renaming c:\AppEasy then simply exit the AppEasy project manager, rename the folder and run AppEasy again.

Lua API has had a major overhaul

We felt that the Lua API was not going in the right direction and was starting to look messy so we rewrote it. Functions have now been split up into libraries to make the API more organised and easier to use. Heres a full list of the libraries we have planned:

  • actions – Deals with XOML actions
  • actor – Deals with actors
  • brush – Deals with brushes (coming soon)
  • camera – Deals with virtual scene cameras (coming soon)
  • facebook – Deals with facebook interaction (coming soon)
  • font – Deals with fonts (coming soon)
  • sys – Deals with general system interaction
  • http – Deals with HTTP communications (coming soon)
  • image – Deals with images (coming soon)
  • input – Deals with device input
  • market – Deals with in-app purchasing (coming soon)
  • media – Deals with audio and video playback
  • physics – Deals with physics (coming soon)
  • program – Deals with XOML programs
  • resource – Deals with generic resources
  • scene – Deals with scenes
  • shape – Deals with shapes (coming soon)
  • template – Deals with templates
  • timeline – Deals with timelines
  • variable – Deals with XOML variables

Over time new functions and even new libraries will appear

New Lua functionality has been added such as querying collision contacts, creating scenes, appending XOML arrays, controlling device vibration, disabling device power saving etc..

Web View

The Web View now works on iOS and Android. You can create web views of any size modal or none modal and either navigate them to a URL or write html / javascript content to them from actions, commands and scripts.

Video Cam Streaming

A new resource type called VideoCam has been added which enables streaming of the devices video camera to an Image, which can in turn be displayed via actors.

New Actor Properties

Actors have been given some new properties, including:

  • IgnoreCamera – Forces actor to ignore camera transform
  • Orphan – Allows child actors to sort via normal actor layers
  • UserData – A simple integer that can be used to store user data such as an index into a script table

Brush UV coordinates

Brushes got a new property called UV, which allows you to set the UV coordinates of the brush directly instead of using SrcRect. Currently only works with image brushes.

Ad Support Added

We decided to add support for HTML ads to AppEasy as they offer a wide range of features compared to basic text or banner ads. For example using HTML ads you have access to the following types of ads:

  • Animating banner and text ads of any size
  • Video ads
  • Interstitial ads
  • Interactive ads
  • Forms based ads
  • Offer walls

We have added information about ad integration to section 20 of the XOML User Guide. We have also added information showing how to get set up and integrated with Leadbolt. We will include additional integrations on the next release.

Complete list of changed in 1.4 include:

Changes to AppEasy Project Manager

  • If project is saved with no location then the location is set to the folder where the project is saved
  • You can now set the size of the XML pools used by AppEasy. Format is (max-tags,max-attributes). Note that these are preallocated data pools so they will eat into your applications memory, so you may need to increase the amount of memory available to your app. Each tag consumes 104 bytes and each attribute consumes 60 bytes plus additional space for parsed strings

Changes to AppEasy Core Engine

  • Lua API has been replaced with a more intuitive Lua API
  • If you now try to add a resource that already exists in the scope it is loaded then a warning will be displayed and the resource will be overwritten
  • WebView now supports new Html attribute which can be used to pass html to the web view to be displayed
  • WebView now works in screen coordinates and not virtual canvas coordinates
  • Actors now have new UserData property that can be use to store a single integer, can be used to store index into script table / array for additional data
  • Actors now have new IgnoreCamera property that allows them to ignore the scenes camera transform
  • All examples now have schema set
  • All examples have been updated to use new Lua API
  • Actors have new property called Orphan. When set to true, actor is taken out of the usual sprite parent / child hierarchy and moves into the normal layer system. This enables child sprites to sort using layers, however actor to actor clipping may be affected
  • New scene.create() method added to allow creation of scenes from lua
  • New actor.getStartContacts() and actor.getEndContacts() functions added to give access to actors that a particular actor has started or ended collisions with
  • New VideoCam resource added that allows you to stream the devices video cam to an image
  • New ChangeVideoCam action added
  • New Lua functions added to change video cam media.changeVideoCam(), can be used to stop and start feed
  • New Lua variable.add() function added to add a value to a XOML variable
  • New Lua variable.append() function added that enables you to append additional elements onto the end of a XOML array
  • New Lua functions sys.vibrate() and sys.stopVibrate() added to control vibration
  • New Lua function sys.changePowerSaving() added to prevent back-light from switching off
  • New Lua function input.touchInfo() which returns information about touches
  • Image brush now supports setting of UV coordinates directly
  • Ads are now integrated via the web view (see section 20 of XOML User Guide)
  • BUG FIX: Some Lua functions were displaying incorrect errors and warnings
  • BUG FIX: Web view now works on iOS and Android (does not work on Windows)
  • BUG FIX: AspectLock fixed
  • BUG FIX: None batched sprites now render correctly at edges
  • BUG FIX: Some examples were broken
  • BUG FIX: Deleting particle actor that was child of another actor crashed when removing particle actor
  • BUG FIX: Particle actor placed inside parent actor didn’t scale by parents opacity when UseParentOpacity set
  • BUG FIX: Empty Param2 in FromTenplate action / commands crash
  • BUG FIX: Fixed changing orientation resizing
  • BUG FIX: Touch panning glitch fixed

Example Changes

  • Added New VideoCam example
  • Added new AdvancedCollision example
  • Added new DynamicWebView example

Tic Tank Toe Now Available

New made with IwGame Engine game available for iOS called Tic Tank Toe. Here’s the details:

Play the brand new TicTankToe on your smartphone!
Tired of silly games? This game will challenge you!
TicTankToe is the best TicTacToe game of all-time.

This game supports one player and two player gameplay, so you can play against another human or against your device. You can also play the amazing military campaign divided into 20 levels! Every 5 levels you can unlock deadly new tank! Become the Master of the TicTankToe Universe and send your score online!

TicTankToe offers a host of exciting features, including:
* Great graphics and exciting sound effects
* Undo function
* Post scores on Facebook
* 20 fantastic levels for free! And many more in future versions!

You can download Tic Tank Toe for your iOS device from here

Congratz to zapmobilegames

IwGame Engine v0.370 Released – Marmalade 6.1 Compatibility

It’s been a while since we did an IwGame Engine update because we are so busy working on our new AppEasy service. Marmalade recently released 6.1 of the Marmalade SDK and unfortunately IwGame doesn’t compile against it. IwGame 0.370 will now compile against Marmalade 6.1. There are no other changes at this point as to release the very latest version of IwGame would take an incredible amount of time as well as major documentation updates which we simply do not have the time for at the moment.

You can grab the new version of IwGame from here

AppEasy Closed Beta is now Closed

Hi Everyone,

AppEasy closed beta is now closed to the general public. We may still consider a few exceptional cases such as those that have games or apps that have been released or are closed to being released that use the IwGame Engine as well as larger developers that may be looking to adopt AppEasy technology.

We’re hoping that beta is finished by the end of September 2012.

If you are interested in investing in Phase 2 of AppEasy (WYSIWYG game and app visual editor) then please get in touch at http://www.appeasymobile.com/register-interest

Also, apologies to any IwGame engine users that are still awaiting response to questions. We are currently prioritising AppEasy development and support until the end of beta, so IwGame Engine support will be very slow until after that point.

Thanks

Mat

IwGame Engine – Using Templates Tutorial

New here? What’s IwGame? IwGame is an open source free to use cross platform game engine for iPhone, iPad, Android, Bada, Playbook, Symbian, Windows Mobile, LG-TV, Windows and Mac, built on top of the Marmalade SDK.

A forum poster asked a question recently that made me realise that XOML Templates can quite easily be overlooked as a means for creating re-usable actors and such, so I thought to help make Templates more visible that I would create a very quick tutorial showing how to use them.

To begin with, lets take a look at what a template actually is and does. A template is a XOML tag that allows you to define generic XOML that is not instantiated immediately, yuo can think of a Template as a blue print for something that you will later instantiate into your game or app world. A template also takes any number of parameters that can be passed when you instantiate the template.

When creating items inside a Template, template parameters are defined using a template parameter name that is enclosed inside double dollar signs ($$), for example $position$. When you later instantiate the items within the template the parameters within the template will be replaced by values that are passed to the template.

Lets take a quick look at creating an actor / child actor with a template

    <Template Name="TankTemp">
        <TankActor Name="$name$" Style="TankActorStyle" Position="$pos$″ >
            <TankActor Name="$name$_sel" Style="TankActorSelectedStyle" Position="0, 0″ />
        </TankActor>
    </Template>

Here we create a template called TankTemp that defined an actor with a name of $name$ and a position of $pos$. Note that because these two parameters are enclosed in $$ they are classed as template parameters.

Now to instantiate this elements within this template in XOML we use the following:

        <FromTemplate Template="TankTemp" name="Tank" pos="310, -120" />

The above code will instantiate the following code:

    <TankActor Name="Tank" Style="TankActorStyle" Position="310, -120″ >
        <TankActor Name="Tank_sel" Style="TankActorSelectedStyle" Position="0, 0″ />
    </TankActor>

To instantiate a template from C++, we firstly need to find the template, build the parameters then instantiate the template passing in the parameters:

// Find the tank template
CIwGameTemplate* temp = (CIwGameTemplate*)scene->getResourceManager()->findResource("TankTemp", "template");
if (temp != NULL)
{
	// Create a set of XML attributes that will replace the template parameters
	CIwGameXmlNode* replacements = new CIwGameXmlNode();
	replacements->Managed = false;
	CIwGameXmlAttribute* attrib;

	// Set name template parameter
	attrib = new CIwGameXmlAttribute();
	attrib->Managed = false;
	attrib->setName("name");
	attrib->setValue("Tank");
	replacements->AddAttribute(attrib);

	// Set position template parameter
	attrib = new CIwGameXmlAttribute();
	attrib->Managed = false;
	attrib->setName("pos");
	attrib->setValue("310, -120");
	replacements->AddAttribute(attrib);

	// Instantiate the Tank template
	temp->Instantiate(scene, replacements);

	// Clean up replacement attributes
	delete replacements;
}

AppEasy – Coming Soon – Beta Testers Wanted

I would like to mention a new service that we plan to roll out very soon called AppEasy. AppEasy is a game and app development system that enables anyone to develop cross platform games and apps for iOS, Android (soon Samsung Bada and BlackBerry PlayBook) without the need for C++, Objective-C, Java or compilers / other SDK’s etc.. The AppEasy system involves using XOML and Lua (other script languages to be added soon) to create apps. To build an app you simply drag and drop all of your assets onto a web app, set some parameters for your game or app, such as icons, app name etc.. then hit deploy. Builds for each platform are then created that you can submit to the app stores. You can also hit a debug button to test your app locally. The system will be Windows only to begin with as we cannot gain elevated security permissions on Mac from Silverlight 5, we are still looking into options for Mac and Linux. If you are interested in beta testing this new service then get in touch with us at http://www.pocketeers.co.uk/?page_id=8. We are only offering a limited number of spots initially, so grab them whilst they are available. Now for a quick poll:

Is AppEasy something you are interested in?

View Results

Loading ... Loading ...

Whilst the pricing structure is not yet final, AppEasy will be priced competitively, although a free version will most likely be made available that embeds an Ad into deployed apps that generate revenue for us on start up. Money made from AppEasy will be spent on improving IwGame / AppEasy and other cool developer tool projects (such as the IwGame editor) that we have in the works.

If there is anything that you strongly agree / disagree with then please feel free to comment.

IwGame Engine Tutorial – Image, Brush, Animation and Timeline Overview

New here? What’s IwGame? IwGame is an open source free to use cross platform game engine for iPhone, iPad, Android, Bada, Playbook, Symbian, Windows Mobile, LG-TV, Windows and Mac, built on top of the Marmalade SDK.

This tutorial is a basic overview of the image, brush, animation and timeline systems.

Images

Art work definition in XOML is separated into images, each image represents a single image file in PNG, JPEG, BMP, GIF or TGA format

To create an image in XOML the following tag is used:

<Image Name="ui_image" Location="ui.png" Preload="false" Blocking="true" Format="RGBA_8888" Filter="true" Tag="Level1" Condition="variable" />

Parameters are:

  • Name – Name of the image
  • Location – filename, local or web based
  • Preload – If true then the image will be preloaded, if false then the image will be loaded when first used (optional)
  • Blocking – If true then execution will be paused until the image is fully loaded (optional)
  • Format – Format to convert the image to when loaded, supported formats include RGBA_8888, RGB_565, RGBA_4444, RGBA_5551, RGB_888, RGBA_6666, RGB_332 (optional)
  • Filter – When set to true filtering will be used when rendering sprites that utilise this image (optional)
  • Tag – A resource tag name, allows resources to be grouped, so they can be removed in groups (optional)
  • Condition – The name of a condition variable that must evaluate to true (false if !variable is specified) for this resource to be loaded (optional)

Brushes

An Image represents a single image file whilst an image brush represents a rectangular area within an image (used with sprite atlases). A 9patch image brush represents a special type of image that preserves the edges of an image whilst scaling its inner features.

To create an brush in XIOML the following tag is used:

<Brush Name="Button1Brush" Image="ui_image" SrcRect="320, 70, 200, 70" Type="9patch" ScaleArea="7, 8, 186, 54" Tag="Level1" Condition="variable" />

Parameters are:

  • Name – Name of the brush
  • Image – Image to use for this brush
  • SrcRect – A rectangular area in the image that will be used to limit the part of the image drawn (x, y, w, h)
  • Type – The type of brush (image or 9patch currently supported)
  • ScaleAea – The scalable area of a 9patch brush (optional)
  • Tag – A resource tag name, allows resources to be grouped, so they can be removed in groups (optional)
  • Condition – The name of a condition variable that must evaluate to true (false if !variable is specified) for this resource to be created (optional)

Animation

XOML supports a versatile and complex animation system that allows animation of all types of data. However for the purpose of image animation we can narrow it down to just rect animations. Here is an example of creation of rect animation:

<Animation Name="PlayerImageAnim" Type="rect" Duration="0.8" Tag="Level1" >
    <Frame Value="0, 0,   36, 40" Time="0.0" />
    <Frame Value="0, 40,  36, 40" Time="0.1" />
    <Frame Value="0, 80,  36, 40" Time="0.2" />
    <Frame Value="0, 120, 36, 40" Time="0.3" />
    <Frame Value="0, 160, 36, 40" Time="0.4" />
    <Frame Value="0, 200, 36, 40" Time="0.5" />
    <Frame Value="0, 240, 36, 40" Time="0.6" />
    <Frame Value="0, 280, 36, 40" Time="0.7" />
</Animation>

Here we enclose a number of Frame tags inside an Animation tag, each frame specifies a rectangular area within the sprite atlas, whilst Animation defines the actual animation that will be available.to the user.

Animation parameters are:

  • Name – Name of the animation
  • Type – Type of animation data (bool, float, vec2, vec3, vec4, rect and string) – Images animation use rect
  • Duration – The length of the animation in seconds
  • Tag – A resource tag name, allows resources to be grouped, so they can be removed in groups (optional)

Frame parameters are:

  • Value – The value for this frame, in the case of a rect this value is x, y, w, h
  • Time – The time at which this frame will be used
  • Easing – The easing method used (linear, quadin,quadout, cubicin, cubicout, quarticin, quarticout)

An Animation tag can also contain another tag called Atlas that is used to automatically generate a number of frames of type rect:

<Animation Name="PlayerImageAnim" Type="rect" Duration="0.8" Tag="Level1" >
    <Atlas Count="8" Size="36, 40" Position="0, 0" Pitch="1024, 40" Width="1024" Duration="0.1"/>
</Animation>

Atlas parameters are:

  • Count – number of frames to generate
  • Size – The size of each frame (w. h)
  • Position – Position where to start creating frames (x. y)
  • Pitch – The amount to step to move to the next line of sprites within the image (x, y)
  • Width – The width of the source image
  • Duration – The amount of time to assign to each frame

An Atlas tag can be mixed in with normal frames, although such an action would be rare. Atlas tag is useful for sprite atlases where all frames are of equal size and are also spaced equally across and down the image.

Timelines

The Timeline system is a system that allows the user to group together collections of animations and play them all back simultaneously on demand. A timeline can contain any number of animations that can target different properties of actors and scenes.

Below is an example of a timeline that can target an actors SrcRect, allowing sprite atlas bitmap animations to be applied to an actors sprite

<Timeline Name="Player1Intro" AutoPlay="true" Tag="Level1">
    <Animation Anim="PlayerImageAnim" Target="SrcRect" Repeat="0" StartAtTime="0" Delta="false" Interpolate="true" OnEnd="AnimEnded" OnStart="AnimStarted" OnRepeat="AnimRepeated" />
</Timeline>

The Timeline tag enclosed a set of animations that have previously been defined with the Animation tag.

Timeline parameters are:

  • Name – Name of the timeline
  • AutoPlay – If set to true then the animation will automatically play when assigned to an actor or scene< (optional)/li>
  • Tag – A resource tag name, allows resources to be grouped, so they can be removed in groups (optional)

The inner Animation tags define which animations to play and which properties of the target actor or scene to modify, as well as actions that can be called when certain animation events occur.

Timeline Animation parameters are:

  • Anim – The animation to play
  • Target – The target property of the actor or scene to modify (in this case SrcRect modifies the actors sprite source rectangle which defined which portion of the sprite atlas to display)
  • Repeat – Number of times to repeat the animation (0 for infinite)
  • StartAtTime – The number of seconds to delay starting the animation playback (optional)
  • Delta – When set to true animation frames will be added to the objects existing property rather than overwriting it (optional)
  • Interpolate – When set to false frames will be interpolated< (optional)/li>
  • OnEnd, OnStart and OnRepeat are actions that will be called when an animation ends, starts or repeats< (optional)/li>

Marmalade SDK Tutorial – Integrating LUA Script Language

This tutorial is part of the Marmalade SDK tutorials collection. To see the tutorials index click here

Its been a while since I wrote a Marmalade SDk tutorial and to be honest I’ve been itching for the chance to start them back up, so I freed up a little time today to bring you this new tutorial.

Ok, decided that it was high time that IwGame had a proper scripting language, so took a look around various scripting languages including LUA, Javascript and AngelScript. Whilst we like them all and would like to integrate them all at some point, our first choice is LUA.

And as I am a complete LUA noob I decided to write a short tutorial showing how to integrate LUA so a) everyone can see how “not so difficult” (had to avoid the word easy, because that would be wrong) it is to integrate LUA and b) so I don’t forget how to do it myself in the future

I have created a small Marmalade app called lua_test that demonstrates the following:

  • Execute a string containing lua commands
  • Load and execute a lua file from C
  • Load and execute a specific function in a lua file from C
  • Load a lua file that executes a C function

With these basics you should be able to integrate LUA into your own project quite easily.

I’m not going to pretend that I am now a LUA expert after spending but a few hours learning how to integrate it, but I know a few things now to be confident to write this tutorial.

Setting up the MKB to support LUA

The first thing you need to do is edit your projects MKB file and the following sections:

packages
{
    lua
}

subprojects
{
    lua
}

LUA is not distributed with Marmalade, instead it is downloaded from the code repository when you run your MKB file. When you open up your MKB file you will notice a new lua filter has been added

Note that the version of LUA that is supported by the Marmalade SDK is currently 5.1.4

LUA header files

In order to access LUA you need to include the headers. However as we are including C headers into a C++ app we need to let the compiler know. With that in mind we add the headers as follows:

// LUA headers
extern "C"
{
   #include "lua.h"
   #include "lauxlib.h"
   #include "lualib.h"
}

LUA State

LUA holds no global variables so the interpreters current state has to be stored somewhere where it can be accessed from your code. In our simple examples, we create the LUA state using lua_open() which returns a pointer to the state then close it when we have finished using lua_close(). Ideally you would want to manage this pointer to the LUA state, depending on the scope and lifetime of LUA scripts in your app. All of our examples start and end with:

// Open LUA
lua_State *lua = lua_open();

// Add LUA libraries (standard libraries are libraries of code that provide some basic functionality such as print)
luaL_openlibs(lua);                                        // See http://www.lua.org/manual/5.1/manual.html#luaL_openlibs

//
// Do something with LUA
//

// Shut down the lua state
lua_close(lua);                                            // See http://www.lua.org/manual/5.1/manual.html#lua_close

LUA Stack

LUA passes information between C and LAU code via a stack. To pass information to a LUA function from C you push the name of the function that you wish to call onto the stack followed by any parameters that you wish to pass. When the LUA function returns it returns any return values (LUA can return multiple values) or an error on the stack. Similarly when calling a C function from LUA, LUA pushes the parameters onto the stack then calls the C function. The C function examines the parameters on the stack (C does not remove them, LUA removes them when it returns) and utilises the data passed from LUA, carries out some logic and returns.

More info on the LUA stack can be found at http://www.lua.org/pil/24.2.html

Calling a string containing LUA from C

Here’s some example code showing how to execute a piece of LUA contained within a string:

void CallLuaString(const char* string)
{
	s3eDebugOutputString("==== Calling a LUA string");

	// Open LUA
	lua_State *lua = lua_open();

	// Add LUA libraries
	luaL_openlibs(lua);										// See http://www.lua.org/manual/5.1/manual.html#luaL_openlibs

	// Pass the string to lua to execute
	if (luaL_loadbuffer(lua, string, strlen(string), "line") == 0)	// See http://www.lua.org/manual/5.1/manual.html#luaL_loadbuffer
	{
		if (lua_pcall(lua, 0, 0, 0) != 0)
		{
			// Output the error
			s3eDebugOutputString(lua_tostring(lua, -1));

			// Pop error message off the stack
			lua_pop(lua, 1);								// see http://www.lua.org/manual/5.1/manual.html#lua_pop
		}
	}

	// Shut down the lua state
	lua_close(lua);											// See http://www.lua.org/manual/5.1/manual.html#lua_close
}

In this example, we open LUA then ad the standard LUA libraries. We then load the supplied string as a LUA chunk using luaL_loadbuffer() then call it using lua_pcall(). If an error occurs then we display the error and pop it off the stack

Calling a LUA file from C

Our next example looks at how to call a LUA file from C, lets take a look at the code:

void CallLuaFile(const char* lua_filename)
{
	s3eDebugOutputString("==== Calling a LUA file");

	// Open LUA
	lua_State *lua = lua_open();

	// Add LUA libraries
	luaL_openlibs(lua);										// See http://www.lua.org/manual/5.1/manual.html#luaL_openlibs

	// Load our test LUA file
	if (luaL_loadfile(lua, lua_filename) == 0)				// See http://www.lua.org/manual/5.1/manual.html#lua_load
	{
		if (lua_pcall(lua, 0, 0, 0) != 0)					// See http://www.lua.org/manual/5.1/manual.html#lua_pcall
		{
			// Output the error
			s3eDebugOutputString(lua_tostring(lua, -1));

			// Pop error message off the stack
			lua_pop(lua, 1);								// see http://www.lua.org/manual/5.1/manual.html#lua_pop
		}
	}

	// Shut down the lua state
	lua_close(lua);											// See http://www.lua.org/manual/5.1/manual.html#lua_close
}

We begin this example much like we did our previous example, but instead of load_buffer() we call luaL_loadfile(), which basically does the same thing except it loads the data from a file.

Calling a LUA function from C

This example gets a little more complicated as we need to begin dealing with pushing data onto the LUA stack. Lets take a look at the code:

void CallLuaFunctionInFile(const char* lua_filename, const char* function_name, double arg0, double arg1)
{
	s3eDebugOutputString("==== Calling a LUA function from C");

	// Open LUA
	lua_State *lua = lua_open();

	// Add LUA libraries
	luaL_openlibs(lua);										// See http://www.lua.org/manual/5.1/manual.html#luaL_openlibs

	// Load our test LUA file
	if (luaL_loadfile(lua, lua_filename) == 0)				// See http://www.lua.org/manual/5.1/manual.html#lua_load
	{
		// Init the loaded lua file
		if (lua_pcall(lua, 0, 0, 0) == 0)					// See http://www.lua.org/manual/5.1/manual.html#lua_pcall
		{
			// Push the name of the function that we want to call onto the stack
			// NB: LUA uses a stack to pass information back and forth between LUA and C (see http://www.lua.org/pil/24.2.html)
			lua_getglobal(lua, function_name);				// Push function name that we want to call ontothe stack (see http://www.lua.org/manual/5.1/manual.html#lua_getglobal)
			lua_pushnumber(lua, arg0);						// Push function call argument 1
			lua_pushnumber(lua, arg1);						// Push function call argument 2

			if (lua_pcall(lua, 2, 1, 0) != 0)				// See http://www.lua.org/manual/5.1/manual.html#lua_pcall
				s3eDebugOutputString(lua_tostring(lua, -1));
			else
			{
				if (!lua_isnumber(lua, -1))					// http://www.lua.org/manual/5.1/manual.html#lua_isnumber
					s3eDebugOutputString("Function muust return a value");
				else
				{
					// Get th result returned from the LUA function
					double result = lua_tonumber(lua, -1);
				}
			}
			lua_pop(lua, 1);								// see http://www.lua.org/manual/5.1/manual.html#lua_pop
		}
	}

	// Shut down the lua state
	lua_close(lua);											// See http://www.lua.org/manual/5.1/manual.html#lua_close
}

Much of the code remains the same as the previous example, where we initialise LUA, load a LUA file and execute it. The difference is that we now push an actual function name and a number of parameters onto the stack using lua_getglobal() and lua_pushnumber(). We then make another call to LUA which executes the LUA function that we just stacked, e then check the return value and if itis not a number we display an error otherwise we pop the returned number off the stack and store it locally.

Calling a C function from LUA

Things get a little more complicated when you find that you need to call C functions from LUA. The first thing that we need to do is let LUA know that our C function is available to be called as well as define a protocol for how it should be called from LUA. Lets take a look at an example:

static int test_function(lua_State *lua)
{
	double d = 0;
	// Get the argument that was passed from lua
	if (lua_isnumber(lua, 1))
		d = lua_tonumber(lua, 1);
	else
		s3eDebugOutputString("test_function can only accept a number");

	// Square it
	d = d * d;

	// Push the result back onto the stack as a return value
	lua_pushnumber(lua, d);

	// Return the number of result arguments that were passed back to lua
	return 1;
}

void CallCFunctionFromLua()
{
	s3eDebugOutputString("==== Calling a C function from LUA");

	// Open LUA
	lua_State *lua = lua_open();

	// Add LUA libraries
	luaL_openlibs(lua);										// See http://www.lua.org/manual/5.1/manual.html#luaL_openlibs

	// Push the test function
	lua_pushcfunction(lua, test_function);					// See http://www.lua.org/manual/5.1/manual.html#lua_pushcfunction

	// Set the global test_function to the pushed C function
	lua_setglobal(lua, "test_function");					// See http://www.lua.org/manual/5.1/manual.html#lua_setglobal

	// Load our test LUA file
	if (luaL_loadfile(lua, "lua_test3.lua") == 0)			// See http://www.lua.org/manual/5.1/manual.html#lua_load
	{
		if (lua_pcall(lua, 0, 0, 0) != 0)					// See http://www.lua.org/manual/5.1/manual.html#lua_pcall
		{
			// Output the error
			s3eDebugOutputString(lua_tostring(lua, -1));

			// Pop error message off the stack
			lua_pop(lua, 1);								// see http://www.lua.org/manual/5.1/manual.html#lua_pop
		}
	}

	// Shut down the lua state
	lua_close(lua);											// See http://www.lua.org/manual/5.1/manual.html#lua_close}
}

Firstly we create a C function called test_function() which is declared from LUA’s standard C function prototype:

static int test_function(lua_State *lua)

This function accepts a lua state which we can query for information that was passed to it by LUA (on the stack). In our example, we firstly check to see if the value on the top of the stack is a number, if not we display an error, if so then we retrieve that number. Next we modify the number then push it back onto the stack so that it can be retrieved (returned to) by the calling LUA function. Note that the value returned from our C function represents the number of arguments that we returned on the stack. Lets take a quick look at the LUA code that made the call to our C test_function in the first place:

d = test_function(12);
print(d);
d = test_function("hello");    -- This will cause an error because we passed a string instead of a number
print(d);

As you can see it calls test_function twice. The first time it is successful because we passed a number, the second time we passed a string which test_function() detected as an error.

Ok, lets now take a look at the code that registers our C function so that LUA can use it (see CallCFunctionFromLua() above)

Firstly we call lua_pushcfunction(lua, test_function); which places our C function onto the stack. Next we call lua_setglobal(lua, “test_function”); to assign the function an actual name that LUA script can use to call the function.

Well that’s about it. I have included the source code for the lua_test app which you can download from here

IwGame Engine v0.36 Released – XML Data bindings, Video, True Type Fonts and First 100% XOML Mark-up Driven Game

New here? What’s IwGame? IwGame is an open source free to use cross platform game and app engine for iPhone, iPad, Android, Bada, Playbook, Symbian, Windows Mobile, LG-TV, Windows and Mac, built on top of the Marmalade SDK. You can find out more and download the SDK from our IwGame Engine page.

Its been a while (again) since we last released an update for IwGame but 0.36 has finally landed. Our plans to make IwGame viable as an app development platform as well as game development platform continue to go ahead as you will see from this update. In particular the supoprt for true type fonts and XML data bindings

Below is the latest list of changes for IwGame 0.36:

  • IwGame can now be put into Open GL compatible mode, which allows mixing of raw GL with IwGame rendering
  • New variable type added called CIwGameXomlVariableXML. This variable type is used to store structured XML data. XML files can be loaded and assigned to an XML variable at which point they will be parsed into an XML tree which can be accessed later.
  • All action parameters can now take variables as parameters as well as values
  • Array variables have a new property called BindXML. BindXML will bind XML data to an array. The binding can pick specific tag / attributes out of XML data and bind it to the array. The format of BindXML is BindXML=”XML_Variable_Name:XML_Tag:XML_Attribute”
  • New File type added to XOML that allows loading, conversion and binding of generic local and remote files to variables
  • New LoadFile action added to XOML which enables files to be force loaded or replacement of an already loaded files data
  • New SetKeyFocus action added which allows you to switch which actor has key focus
  • New IwGameVideo added. Marmalade video play back wrapped up into CIwGameVideoPlayer. XOML also supports Video resource types (local and remote)
  • New UI control added called VideoOverlay. This UI control allows you to display a video located locally or remotely as a UI element. Supports AutoPlay, Volume, Repeat, OnStart, OnEnd, OnPause, OnResume events and control playback using command property
  • Support added to sprites and actors for an AlphaMode
  • Actors can now be conditionally loaded
  • Support added for true type fonts, located in resource groups, in local files or on a web server. Fonts that are generated from the same external font TTF file will re-use already downloaded TTF to save re-download
  • Support added to fonts for auto point size calculation based on max screen dimensions vs number of lines allowed on display when creating fonts from TTF’s
  • Fonts that are defined without preload will only be loaded when an actor that uses it is displayed.
  • Timelines are no longer stored in the resource system. They now have their own timelines manager. Actors and scenes have their own timelines manager and a global timeline manager is also available. This cuts down the noise in the main resource manager, makes resource and timeline searches faster and allows timelines to be declared local to an actor
  • Actions are no longer stored in the resource system. They now have their own actions manager. Actors and scenes have their own actions manager and a global actions manager is also available. This cuts down the noise in the main resource manager, makes resource and actions searches faster and allows actions to be declared local to an actor
  • System:9 added to check if pointer is available
  • Preset animations now resize to fit screen orientation changes
  • Labels now have an AutoHeight parameter that causes them to resize to fit the height of the text that they contain
  • UI components can now be marked as SizeToContent, which causes them to base their size on the content that they contain. Siznig can be locked to a specific axis using x, y, xy or none
  • OnKeyBack / OnKeyHome support added to UI actors
  • List Box now supports key navigation
  • Optimisations: Optimised scene and sprite systems to eliminate the thousands of allocs / deallocs every second in complex scenes (if you check metrics you will notice that free and malloc are being called like mad). Unfortunately this has meant limiting the range of layers for scenes to 10. Any scenes with a layer order of 10 or more will now be rendered after layers 0-9 and in no particular order
  • StackPanel now supports horizontal centering in horizontal orientation and vertical centering in vertical orientation
  • Actor brush can now be the target of an animation
  • Support added to actors for separate x and y position bindings / properties and animation targets
  • XOML variables can now be created conditionally
  • Image based actors / UI now support AspectLock property. This allows you to lock the aspect ratio of an actor that is sized using proportional sizing. For example, if you have an icon inside a horizontal stack panel who’s height is proportional to the size of the scene, ordinarily if you made the proportional size of the icon 50% on both axis, it would get stretched on the x-axis. By setting the AspectLock to the y axis, the height of the icon will be locked to 50% of the height of the stack panel, but the width of the icon will be calculated based on the size of the brush / src_rect that is used to represent the icon.
  • Pre-defined animations PA_ScrollOnFromLeft etc now only affect the relevant axis
  • Timeline has new TimeScale attribute which scales the rate at which animations within the timeline are played back. Actors also have a new target property called TimeScale, which can be used to adjust the TimeScale of the currently attached timeline (can be set via set property, bindings or animation target)
  • New wait_var_is_value command added to program system. This command will pause program execution until a variables value is a specified value
  • CIwGameString now has a Split method which splits a string into an array of strings using a specified separator
  • Images will no longer be converted to a default RGBA5551 format, if no format is specified. You can also set the format via code (must be set before calling Init())
  • Updated grid / list box controls to work with dynamic data
  • Condition variable operands can now be variables and condition variables can now use arrays
  • Inverse conditions are now available for all elements that use conditions by pre-pending the exclamation mark ‘!’ character to the front of the condition variable name
  • Animations now have categories
  • Added new extension modifier CIwGameModCollisionNotiify. If you attach this modifier to an actor and define OnCollisionBegin / OnCollisionEnd event handlers you can execute actions based on collision between different objects. A mask can also be provided when defining the modifier to allow masking of actors by type
  • Added new XMLGrid example app which shows how to bind XML data to a grid
  • Added ActorTest example (shows parent / child actors in XOML)
  • Added ActorTest2 example (shows many actors in XOML)
  • Added GameSceneGL example (shows how to mix raw Open GL with IwGame)
  • Added Game Of 10 example game (100% XOML driven)
  • BUG FIX: Grid auto column / row sizing was broken
  • BUG FIX: Fixed grid cell horizontal alignment. Also fixed grid resizing when orientation changes
  • BUG FIX: ListBox crashes when re-assigning a new array to an already existing ListBox
  • BUG FIX: When an action is declared in the scene and called from an actor event it wasn’t being found
  • BUG FIX: Fonts were not being searched for by name
  • BUG FIX: Sprites transform is now rebuilt when changing opacity from 0 to some other value
  • BUG FIX: Fixed many crashes related to duplicated resources
  • BUG FIX: Ad click not recognised when ads view not inside a scene
  • BUG FIX: Grid row horizontal alignment fixed
  • BUG FIX: Grid orientation change resizing fixed
  • BUG FIX: When a scene / actor is created it will now update its data bindings immediately after creation
  • BUG FIX: Can now set Background, SelectedBackground and DisabledBackground to NULL, which will remove the background image of the control

That’s quite a few changes, although there are quite a few bug fixes in there that will make some of you very happy. Lets take a look at some of the more notable changes:

100% XOML Mark-up Driven Development

We wanted something cool and different to show off for 0.36 so I spent some time over the weekend designing, creating and documenting a small game that is created using entirely in XOML mark-up and no C/C++ / script coding. I’m very pleased with the results and decided to include the game (GameOf10) with the 0.36 release as an example that others can use to try creating their own 100% XOML games and apps. If you do create any 100% XOML apps or games then please get in touch and let us know.

XML Data Bindings

Another new cool feature we have added to 0.36 is the ability to bind data directly parsed from a local or remote XML file to user interface components. This may not seem like a big deal but it is in the app development world and in some respects also in the game development world. Imagine if you will a vendor that wants an app that he / she can give away to customers that shows all of his / her very latest offers. Usually the vendor would need to add the new offers to his app, rebuild it and resubmit it to the app stores. Using XML bindings he / she no longer needs to do that. The vendor simply places the latest products into an XML file and uploads them to the shops web server. The vendor then creates some XOML UI to display the XML file and submits the app to the app stores. Users come along and download the app, the app pulls the vendors latest offers data from the server and displays all of the vendors offers in the app. The vendor has to do nothing else besides maintain his offers XML file. Nice eh? Well the vendor seems to think so because sales are up :)

This very same approach can be applied to game development and many developers already do just that, such as the famous Zygna games. You can store game content on a server and bind the data to your games UI / game objects. You can modify the game any time you like after release. Bugs? What bugs, I just modified my XML files and fixed them :)

So how to use this new cool feature?

Array variables have a new property called BindXML. BindXML will bind XML data to an array. The binding can pick specific tag / attributes out of XML data and bind it to the array. The format of BindXML is BindXML=”XML_Variable_Name:XML_Tag:XML_Attribute”. Lets look at an example:

        <Variable Name="BookXML" Type="xml" />
        <File Name="File3" Location="test1.xml" FileType="xml" Preload="true" Variable="BookXML" />
        <Variable Name="GridItems1" Type="arraystring" BindXML="BookXML:Chapter:Brush" />
        <Variable Name="GridItems2" Type="arraystring" BindXML="BookXML:Chapter:Name" />
        <Variable Name="GridItems3" Type="arraystring" BindXML="BookXML:Chapter:Description" />
        <Variable Name="GridItems4" Type="arraystring" BindXML="BookXML:Chapter:Pages" />

In this example we create an XML variable then load the file test1.xml into BookXML. We then create 4 arrays and bding the Brush, Name, Description and Pages attributes of each Chapter tag to the arrays. Heres the example test1.xml file:

    <Contents>
        <Chapter Name="Chapter1" Description="This is chapter 1" Pages="10" Brush="Button1Brush" />
        <Chapter Name="Chapter2" Description="This is chapter 2" Pages="12" Brush="Button2Brush" />
        <Chapter Name="Chapter3" Description="This is chapter 3" Pages="11" Brush="Button1Brush" />
        <Chapter Name="Chapter4" Description="This is chapter 4" Pages="5" Brush="Button12rush" />
        <Chapter Name="Chapter5" Description="This is chapter 5" Pages="7" Brush="Button12rush" />
        <Chapter Name="Chapter6" Description="This is chapter 6" Pages="9" Brush="Button1Brush" />
        <Chapter Name="Chapter7" Description="This is chapter 7" Pages="2" Brush="Button12rush" />
        <Chapter Name="Chapter8" Description="This is chapter 8" Pages="4" Brush="Button12rush" />
        <Chapter Name="Chapter9" Description="This is chapter 9" Pages="6" Brush="Button1Brush" />
        <Chapter Name="Chapter10" Description="This is chapter 10" Pages="16" Brush="Button1Brush" />
        <Chapter Name="Chapter11" Description="This is chapter 11" Pages="16" Brush="Button2Brush" />
        <Chapter Name="Chapter12" Description="This is chapter 12" Pages="16" Brush="Button2Brush" />
        <Chapter Name="Chapter13" Description="This is chapter 13" Pages="16" Brush="Button1Brush" />
        <Chapter Name="Chapter14" Description="This is chapter 14" Pages="16" Brush="Button1Brush" />
    </Contents>

Now we generate a grid to show the data:

        <Template Name="GridItemTemp">
            <Label Name="Grid1Item$index$" Size="-20, 90" Background="Button1Brush" BackgroundColour="200, 200, 200, 255" SelectedColour="200, 255, 200, 255" Font="trebuchet_12" GridPos="$gridpos$" HitTest="true" SelectType="toggle" Selected="false" />
        </Template>
        <Grid Name="ItemsGrid" Size="-100, -100" Background="PanelBrush" BackgroundColour="255, 255, 255, 255" HitTest="true" ClipMargin="10, 10, 10, 10" MultiSelect="false" SelectedIndex="5" UseParentOpacity="false">
            <RowDefinition Name="r0" AlignV="middle" Height="100" />
            <ColumnDefinition Name="c0" AlignH="left" Width="-20" ItemsData="GridItems1" ItemsTemplate="GridItemTemp" ItemsTargetType="background" />
            <ColumnDefinition Name="c1" AlignH="left" Width="-20" ItemsData="GridItems2" ItemsTemplate="GridItemTemp" ItemsTargetType="text" />
            <ColumnDefinition Name="c2" AlignH="left" Width="-40" ItemsData="GridItems3" ItemsTemplate="GridItemTemp" ItemsTargetType="text" />
            <ColumnDefinition Name="c3" AlignH="left" Width="-20" ItemsData="GridItems4" ItemsTemplate="GridItemTemp" ItemsTargetType="text" />
        </Grid>

Video

A new sub-system called CIwGameVideoPlayer has been added that wraps the Marmalade SDK video playback code up into a nice and easy to use singleton called IW_GAME_VIDEO. We also have a new type called CIwGameVideo which represents a video resource that can be created in code or in XOML. Videos can be loaded from local storage or remotely from a web server either immediately or on-demand via the new VideoOverlay UI component. Lets take a quick look at an example:

        <Video Name="Video1" Location="http://www.drmop.com/video1.mp4" Codec="MPEG4" />

        <StackPanel Name="SP1" Size="300, -100" Background="PanelBrush" Orientation="vertical" AlignH="centre" AlignV="top" SizeToContent="none" >
            <Label Background="Button2Brush" Size="-90, 100" SelectedColour="128, 255, 200, 128" Text="Option 1" Font="trebuchet_12" />
            <Label Background="Button2Brush" Size="-90, 100" SelectedColour="128, 255, 200, 128" Text="Option 1" Font="trebuchet_12" />
            <Label Background="Button2Brush" Size="-90, 100" SelectedColour="128, 255, 200, 128" Text="Option 1" Font="trebuchet_12" />
            <Label Background="Button2Brush" Size="-90, 100" SelectedColour="128, 255, 200, 128" Text="Option 1" Font="trebuchet_12" />
            <VideoOverlay Name="Vid1" Background="Button2Brush" SelectedColour="128, 255, 200, 128" Video="Video1" Size="-90, 100" AutoPlay="false" Volume="0.3" Repeat="1" AspectLock="x" OnEnd="VideoEnd" OnTapped="Play">
                <Actions Name="VideoEnd">
                    <Action Method="HideActor" Param1="SP1" />
                </Actions>
                <Actions Name="Play">
                    <Action Method="SetProperty" Param1="Command" Param2="play" Param3="Vid1" />
                </Actions>
            </VideoOverlay>
            <Icon Background="Button1Brush" />
        </StackPanel>

This example creates a video resource for a video file located on a web server. We then create a stack panel that contains 4 labels and a video overlay stacked on top of each other. The video is not loaded or played until the user taps on the space containing the video. When the video ends the whole UI will be hidden.

Now I don’t think you can ask for a simpler way of integrating video into your products :)

True Type Fonts

The font system has been reworked to add support for true-type fonts that are either located in a Marmalade resource group or located in a local or remote TTF file. Lets take a quick look at an example:

    <Font Name="font1" Location="Serif.ttf" AutoPointSize="50" PointSize="0" Preload="true" />
    <Font Name="smallfont1" Location="Serif.ttf" AutoPointSize="60" PointSize="0" Preload="true" />

In this example, we create two different sized fonts from a local TTF file. We have the ability to auto generate the correct font point size based on the devices screen size. You simply specify how many lines of text you would like to fit onto the display using AutoPointSize. Note that PointSize will be added onto the calculated point size. Also note that, fonts will re-use font files to save having to reload / download them. For example, because font1 already loaded the Serif.ttf file, smallfont1 will re-use that same file.

OpenGL Compatibility

You can now freely mix Open GL with IwGame. A new example has been provided that shows how to mix Open GL with IwGame.

Action Variable Parameters

We have reworked the action parameter system to enable variables to passed as parameters as well as values. For example:

<Action Method=”SetProperty” Param1=”Timeline” Param2=”StillAnim” Param3=”SelectedCardNames:0″ />

This action assigns the “StillAnim” timeline to the actor whos name is stored as the first index in the SelectedCardNames array.

Conditions can now use inverse condition checking by pre-pending an exclamation mark ni front of the condition variable name, this saves having to create inverse conditions. For example, HasBullets becomes !HasBullets

Optimisations and Clean-up

We have reworked the actions and timeline systems to remove them from the resource system as the resource system can quickly become cluttered making searching for resources slower than it should be. A cool side affect of this change is that actors can now have their own local actions and timelines lists, reducing the chances of naming conflicts.

We have also gone through almost every line of code and removed the excessive use of memory allocation / deallocation that were occurring every frame.

New Collision Modifier Added

Added new extension modifier CIwGameModCollisionNotiify. If you attach this modifier to an actor and define OnCollisionStart / OnCollisionEnd event handlers you can execute actions based on collision between different objects. A mask can also be provided when defining the modifier to allow masking of actors by type

There are also a ton of other changes such as Labels that now size to the text they contain and UI elements can be told to size to their content

Well that’s it for this update. We’ve just started looking into LUA integration as well as creating TileMaps. Hopefully those features will make it into IwGame 0.37.