Booty5 HTML5 Game Maker Manual
Booty5 HTML5 Game Maker is a combination of WYSIWYG game editor and game engine that targets the HTML5 platform for desktops such as Windows, Mac and Linux and mobile devices such as iOS, Android, Windows Phone 8, Blackberry and more. Booty5 enables rapid game development and testing using an intuitive super quick WYSIWYG interface that can easily handle small to super massive projects.
Advertisement
Advertisement
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Booty5 HTML5 Game
Maker Manual v1.4
Developed and maintained by Mat Hopwood of Booty5 ( http://booty5.com
)
This document is protected under copyright to Mat Hopwood @2015.
Page 1 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Changes
1.4 – Added info about web audio
1.3 – New info on pixel rounding, collision flags, new shape editor and font features
1.2 – Tile map sections added
1.1 – Game editor sections added
1.0 – initial release
Page 2 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Table of Contents
Changes.................................................................................................................2
Booty5...................................................................................................................8
What is Booty5?..................................................................................................8
Installing Booty5 Game Maker.............................................................................10
Usage Rights and Warranties...............................................................................10
Brief How To on Booty5......................................................................................11
Booty5 Core Concepts........................................................................................13
Canvas.........................................................................................................13
App, Scenes & Actors......................................................................................13
Animation.....................................................................................................13
Actions.........................................................................................................14
Events..........................................................................................................14
Resources.....................................................................................................14
Namespace...................................................................................................14
Examples and Tutorials.......................................................................................15
Known Issues....................................................................................................15
Booty5 Game Engine..............................................................................................16
The App – The Eye in the Sky..............................................................................16
Introduction..................................................................................................16
Creating the App............................................................................................17
Game Logic and Rendering..............................................................................18
The Main Canvas............................................................................................18
Working with Resources..................................................................................19
Setting up a loading screen.............................................................................20
Working with Scenes......................................................................................21
Handling App Events.......................................................................................22
Working with Variable Frame Rates...................................................................23
App Public Properties......................................................................................24
App Internal Properties...................................................................................24
App Constants...............................................................................................25
App Events....................................................................................................25
App Methods.................................................................................................25
Scenes – A Place for Actors to Play.......................................................................27
Introduction..................................................................................................27
Creating Scenes.............................................................................................28
Scene Events.................................................................................................28
Processing and Visibility..................................................................................29
Local Resources.............................................................................................30
Working with Actors........................................................................................31
The Scene Camera.........................................................................................32
Coordinate System.........................................................................................33
Position and Opacity.......................................................................................33
Child Clipping................................................................................................33
Scene Layering..............................................................................................34
Scene Physics................................................................................................34
Animation Timelines.......................................................................................35
Actions Lists..................................................................................................35
Input Events..................................................................................................36
Detecting when Resources have Loaded............................................................37
Scene Public Properties...................................................................................38
Page 3 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Scene Internal Properties................................................................................38
Scene Setters................................................................................................39
Scene Events.................................................................................................39
Scene Methods..............................................................................................39
Scene Examples.............................................................................................41
Actors – Sprites with Brains.................................................................................43
Introduction..................................................................................................43
Creating Actors..............................................................................................44
Processing and Visibility..................................................................................46
Transforms....................................................................................................47
Child Hierarchies............................................................................................47
Child and Self Clipping....................................................................................48
Layering........................................................................................................49
Opacity.........................................................................................................49
Filling and Outlines.........................................................................................49
Docking........................................................................................................50
Bitmap Animation...........................................................................................51
Adding Physics...............................................................................................52
Actor Animation.............................................................................................57
Input Events..................................................................................................58
Depth...........................................................................................................59
Orphans........................................................................................................59
Virtual Canvas...............................................................................................60
Shadows and Composite Operations.................................................................61
Cached Rendering for Speed............................................................................63
Tagging.........................................................................................................63
Ignoring the Camera......................................................................................64
Particle Systems............................................................................................64
Tiled Maps.....................................................................................................66
Speeding up Rendering...................................................................................67
Miscellaneous................................................................................................67
Actor Public Properties....................................................................................68
Actor Internal Properties.................................................................................69
Virtual Actor Properties...................................................................................70
Actor Setters.................................................................................................70
Actor Constants.............................................................................................70
Actor Events..................................................................................................71
Actor Methods...............................................................................................71
Actor Examples..............................................................................................74
ArcActor Properties.........................................................................................75
ArcActor Methods...........................................................................................76
LabelActor Properties......................................................................................76
LabelActor Methods........................................................................................76
ParticleActor Properties...................................................................................77
ParticleActor Methods.....................................................................................77
PolygonActor Properties..................................................................................78
PolygonActor Methods.....................................................................................78
RectActor Properties.......................................................................................78
RectActor Methods.........................................................................................79
MapActor Properties.......................................................................................79
MapActor Methods..........................................................................................79
Resources – The Stuff that Games are Made of......................................................81
Page 4 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Introduction..................................................................................................81
Resource Paths..............................................................................................82
Bitmap Resources..........................................................................................82
Sound Resources............................................................................................83
Shape Resources............................................................................................84
Material Resources.........................................................................................85
Brush Resources............................................................................................86
Gradient....................................................................................................86
ImageAtlas................................................................................................87
Bitmap Properties...........................................................................................88
Bitmap Methods.............................................................................................88
Sound Properties............................................................................................88
Sound Methods..............................................................................................88
Shape Properties............................................................................................89
Shape Constants............................................................................................89
Shape Methods..............................................................................................89
Material Properties.........................................................................................89
Material Methods............................................................................................90
Gradient Properties........................................................................................90
Gradient Methods...........................................................................................90
ImageAtlas Properties.....................................................................................90
ImageAtlas Methods.......................................................................................90
Animation – Lets Dance......................................................................................92
Introduction..................................................................................................92
Working with Animations.................................................................................92
Working with Timelines...................................................................................94
Animation Events...........................................................................................95
Animation Playback Speed...............................................................................96
Tween or not to Tween....................................................................................96
Animation properties......................................................................................96
Animation Constants.......................................................................................97
Animation Events...........................................................................................97
Animation Methods.........................................................................................97
Timeline Properties.........................................................................................97
Timeline Methods...........................................................................................98
TimelineManager Properties.............................................................................98
TimelineManager Methods...............................................................................98
Actions – Building with Blocks..............................................................................99
Introduction..................................................................................................99
Creating Custom Actions...............................................................................101
Predefined Actions........................................................................................103
Action List Actions....................................................................................103
Actor Actions............................................................................................103
Animation Actions.....................................................................................104
Attractor Actions.......................................................................................104
Audio Actions...........................................................................................105
General Actions........................................................................................105
Movement Actions....................................................................................106
Camera Actions........................................................................................108
Physics Actions.........................................................................................109
ActionsList Properties....................................................................................110
ActionsList Methods......................................................................................110
Page 5 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
ActionsListManager Properties........................................................................110
ActionsListManager Methods..........................................................................110
XOML – Booty5 Editor Data...............................................................................111
Introduction.................................................................................................111
Post Loading Scenes.....................................................................................112
Creating Resources from XOML templates........................................................112
Booty5 Game Editor.............................................................................................113
Introduction to the Editor..................................................................................113
Basic Booty5 Concepts..................................................................................114
The World Tree.............................................................................................115
Resource spaces...........................................................................................115
Scenes........................................................................................................115
Actors.........................................................................................................115
Animation....................................................................................................116
Action Lists..................................................................................................116
Exported Data..............................................................................................116
Working with the Editor.....................................................................................117
Overview.....................................................................................................117
The Main Menu.............................................................................................117
The File Menu...........................................................................................117
The Tools Menu........................................................................................118
The Resource Menu...................................................................................118
World Tree...................................................................................................120
Resource Colour Coding.............................................................................121
Resource Import via Drag / Drop................................................................121
General Drag / Drop..................................................................................122
Tools Panel...............................................................................................122
Context Menu...........................................................................................123
Properties Panel...........................................................................................124
Main Canvas................................................................................................125
Current Scene..........................................................................................125
Drag and Drop.........................................................................................125
Editing on the Canvas................................................................................126
Bookmarks..............................................................................................127
Object Cloning..........................................................................................127
Object Alignment and Spacing....................................................................127
Edge and Vertex Snapping.........................................................................128
Code Editing................................................................................................129
Shape Editing & Tracing.................................................................................130
Animation Timeline.......................................................................................132
Editor Layout...........................................................................................133
Editing Flow.............................................................................................135
Animation and Timeline Properties..............................................................135
Creating an Animation Walk-through...........................................................136
Actions and Action Lists.................................................................................137
Actions Lists.............................................................................................137
Editing Actions Lists..................................................................................138
Resource Paths.........................................................................................139
Creating an Actions List Walk-through.........................................................139
Tiled Maps...................................................................................................140
Project Properties.........................................................................................142
Importing SVG.............................................................................................144
Page 6 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Deploying to Mobile Devices...........................................................................145
Deploying to the Web................................................................................145
Deployment with Marmalade Web...............................................................145
Deployment with Ludei CocoonJS................................................................146
Deployment with Intel XDK........................................................................146
Resource Property Reference.............................................................................147
World Properties...........................................................................................147
Image Properties..........................................................................................148
Brush properties...........................................................................................148
Sound Properties..........................................................................................149
Shape Properties..........................................................................................149
Material Properties........................................................................................149
Script Properties...........................................................................................150
Scene Properties..........................................................................................150
Sprite Actor Properties..................................................................................153
Label Actor Properties...................................................................................157
Basic Tutorials.................................................................................................158
My First Project............................................................................................158
Basic Physics...............................................................................................160
Parallax Scrolling..........................................................................................162
Swinging Barrel............................................................................................164
Ping Pong Game...........................................................................................167
Particle Systems...........................................................................................171
Shuffle Match Game......................................................................................172
Page 7 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Booty5
What is Booty5?
Booty5 is a combination of WYSIWYG game editor and game engine that targets the
HTML5 platform for desktops such as Windows, Mac and Linux and mobile devices such as iOS, Android, Windows Phone 8, Blackberry and more. Booty5 enables rapid game development and testing using an intuitive super quick WYSIWYG interface that can easily handle small to super massive projects.
The Booty5 engine is an evolving open source JavaScript SDK that enables developers to create games and apps using tried and tested industry standard game programming techniques that are widely used across the industry today.
Booty5 is currently maintained on Github at https://github.com/mrmop/Booty5
The fully Booty5 API reference can be found at http://booty5.com/docs/index.html
Support is provided on Facebook, Google+ and Twitter, see here for more details.
Booty5 game maker editor features include:
•
Create and organise game levels / maps and app layouts into scenes and actors
(smart sprites)
•
Create and preview complex Flash style timeline based animations of entire scenes and their game objects
•
Create game logic using action lists that are presented in human readable format
•
Complete game and app creators integrated development environment (IDE)
•
Export in multi-resolution friendly format, allowing exported data to be used on any sized display
•
Assisted layout editing, including tools to enable easy layout / layout management, bookmarking, edge / vertex snapping, directional cloning and so on
•
Full drag and drop support, drop entire folders of resources onto the editor and it automatically sorts them all for you
•
Support for import of SVG, Texture Packer, audio and other formats
•
Support for physics including materials, shapes, fixtures, joints and the ability to test physics
•
Support for tile map and collision map editing
•
Support for Javascript and other language editing, includes syntax highlighting, code folding and search / replace
•
Create and edit shapes, trace bitmaps to optimised shapes and split concave polygons to convex
•
Create and edit gradients then assign to game objects
•
Interactive play mode that launches the game from the editor
•
Create complete working / runnable projects right in the editor, no back-end services required
•
Support for bitmap animation
•
Support for user properties
•
Exports JSON so output can be used by any game engine that can read JSON
Page 8 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
•
Export to Marmalade Web and CocoonJS, also tested with the Intel XDK
Notes:
•
TexturePacker is a tool that is used to combine many images into a single image, usually referred to as a sprite / texture atlas. Packing images into a single image improves rendering performance and download speeds.
•
SVG (Scalable Vector Graphics) format is an XML based format that is used to represent two dimensional vector art work. The editor imports the following tags svg (scene), g (layer), image (actor), rect (shape) and path (shape or geometry).
SVG is used by packages such as Inkscape and Adobe illustrator
Booty5 game engine features include:
•
Free and open source
•
Its tiny and fast, under 120k! (under 90k without pre-defined action)
•
Support for mobile and desktop
•
Global and local resource management
•
Scene and Actor (sprite game object) management / scene graph
•
Particle systems
•
Tile and collision maps
•
Animation via Timeline and tweening
•
Support for action lists
•
Image, text and geometric shape rendering, including rounded rects
•
Physics using Box2D via Box2DWeb including multiple fixtures, joints, materials and shapes
•
Sprite atlas and frame based bitmap animation
•
Game object docking to scene edges and other game objects
•
Scene and game object clipping, including to circular and polygon shapes
•
Scene and game object touch detection
•
Scene cameras and touch panning
•
Scene and actor local layering
•
Image and gradient brushes, shadows, composite operations
•
3D sprite depth
•
Touch event handlers
•
Keyboard support
•
2D canvas
•
Audio play back (with or without Web Audio)
•
Support for automatic scaling / resizing to fit different sized gaming displays
•
Support for cached rendering to speed up shape / gradient / font rendering etc..
•
Support for Booty5 game Editor / IDE
Future planned features include:
•
More HTML5 specific editing options
•
Export to different game engines such as Phaser and Cocos2d-js
Page 9 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Installing Booty5 Game Maker
Firstly, download the latest version of the Booty5 Game Maker from http://booty5.com/download-booty5/ (Windows only)
Unzip the archive and run setup.exe to install.
You should also consider downloading the example projects that accompany the Booty5 game engine from https://github.com/mrmop/Booty5 .
To open an example, run the Booty5 game maker. Click the open button then select one of the example projects project XML file and open. Hit the test button run.
Usage Rights and Warranties
Copyright @2015 Mat Hopwood. All rights reserved.
Booty5 game maker and Booty5 engine and all associated data and components
(collectively known as Booty5) are provided “as is” and “without” any form of warranty.
Yours, your employers, your companies, company employees, your clients use of Booty5 is completely at your own risk. We are not obligated to provide any kind of support in any shape or form.
You are free to use Booty5 in your projects in part or in whole as long as all copyright notifications in any files, applications or data remain in-tact.
You may not claim Booty5 or its documentation as your own work or package it up and include it in any kind of middleware product without express prior written notice from Mat
Hopwood.
Please note that these licensing terms apply to all versions of Booty5.
Note that Booty5 can utilise Box2DWeb, so please take note of this license also.
Page 10 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Brief How To on Booty5
At this stage I think its important for you to have a basic understanding of how to use
Booty5 as this will help you to better understand the rest of this material.
The basic purpose of Booty5 is to enable developers to get a game up and running quickly, with Booty5 taking care of all the basic and mundane tasks.
The easiest way to use Booty5 by far is to use the provided game editor as this will enable you to build much of your game using a point, click and drag interface, which in most cases is much faster than programming and organising / managing your own data for game levels and the like.
If you decide to bypass the game editor then to get up and running requires only a simple text editor and basic knowledge of HTML and JavaScript, although Notepad++ is a much better text editor. However I recommend you take a look at Jetbrains WebStorm.
To include and boot the Booty5 game engine simply make the following changes to your index.html, if you plan on using the Booty5 game maker exclusively then you can skip the rest of this section:
Include the Booty5 game engine into the head section:
< script src ='lib/engine/booty5_min.js'></ script >
Add an HTML5 canvas to the body section that will show the app:
< canvas id ='gamecanvas' width ='1024' height ='768'>
</ canvas >
Add a window onload handler to boot the engine when the page finishes loading: window.onload = function ()
{
// Create the Booty5 app var app = new b5.App(document.getElementById( 'gamecanvas' ), true);
app.debug = false ;
app.setCanvasScalingMethod(b5.App.FitBest);
// Start game
app.start();
};
Of course you will not see anything on the display because you do not currently have a scene or any game objects in there. Here is small example that shows how to create a scene and add a simple game object:
// Create a scene var scene = new b5.Scene();
// Add scene to the app app.addScene(scene);
Page 11 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
// Create an arc actor var actor = new b5.ArcActor(); actor.fill_style = "rgb(80,80,255)" ; actor.x = 100; actor.y = 100; actor.vx = 100; actor.radius = 100;
// Add the actor to the scene scene.addActor(actor);
And to make the actor do something we can attach an onTick event handler:
// Attach an OnTick handler which gets called each frame actor.onTick = function (dt) { if ( this .x > 200) this .x = -200; this .y = Math.sin( this .frame_count / 20) * 100 + 100;
}
Page 12 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Booty5 Core Concepts
In order to facilitate easier explanation of the workings of Booty its essential to give an overview of various concepts that Booty5 utilises.
Canvas
The Canvas is the HTML5 canvas that Booty5 targets for rendering. Currently the Booty5 game engine targets HTML5 canvas only (no WebGL). Future versions of the Booty5 game maker will offer support for other game engines such as Phaser and Cocos2d-js
App, Scenes & Actors
Booty5 uses an hierarchical tree based scene graph to organise, update and display game objects.
The App is the top level container object that is responsible for keeping the game logic up to date, drawing objects to the canvas, monitoring device input, running and rendering scenes etc..
Scenes are containers for actors and are used to separate app functionality into parts. For example, your game could use a scene for each game level that it contains, as well as additional scenes for game HUD overlays, a main menu screen and so on. You can think of a Scene as a game level wide container
Actors represent the individual game objects that make up your game, for example a sprite based actor may represent the main game character, whilst other sprite based actors represent the baddies and the bullets etc.. Like scenes, actors also contain their own hierarchical tree, which can be used to manage sub actors.
When exporting your game from the game editor the canvas and app is automatically created for you. You can create scenes and actors from code or more intuitively using the game editor.
Animation
Animation is a huge part of Booty5 because animation is such a large part of making games. Booty5 supports animation in different ways including:
•
Timelines – A timeline is a collection of animation key frames for the various properties of objects such as position, scale and rotation that change over time
•
Bitmap animation – Using image atlases the bitmap that represents a game object can be changed to show frame by frame animation
•
Physics - Using arcade style physics or full on physics simulation using Box2D, objects can be set up to travel / rotate and interact with the environment
You can create animations either in code or in the game editor. The game editor supports a Flash style timeline animation system based on key frames and tweening.
Page 13 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actions
Action lists offer a way of adding game logic to scenes and actors using bolt together building block style actions. An action is a piece of functionality that can be added to an object to modify and extend its behaviour. An actions list is a collection of such actions that are executed sequentially / concurrently. Action lists can be added in code or in the game editor. The game editor supports the creation of action lists using human readable action commands, making it easy for none programmers to modify game object behaviour.
Events
Many of the objects defined in the Booty5 game engine use event handlers to react to the numerous events that can take place during a game. For example the main App responds to touch / mouse / keyboard input using events and game objects respond to being updated, touched, collided with etc.. Each event can have an event handler associated with it which will respond to the event taking place. For example, you may attach an
OnTick event handler to an actor which will do something with the actor every time the actors logic loop is updated.
The Booty5 game editor makes responding to events very easy by exposing all available events for an object and allowing you to define what happens in response.
Resources
Booty5 supports a multitude of different types of resources from sounds and bitmaps to shapes and brushes. Resources can have local or global scope, resources that are global are accessible to all scenes and objects within the game and will remain in memory until the game is shut down or manually removed. Local resources are local to the scene that contains them and are generally only accessible to the scene and the actors that it contains. When a scene is loaded all of its local resources will be loaded, when a scene is destroyed all of its resources will also be destroyed. This type of resource management system is useful when dealing with games that run on resource constrained devices such as mobile phones.
Note that two resources of the same type should not share the same name within the same scene.
Namespace
All Booty5 engine classes / code are placed within the b5 namespace. For example a
Scene is accessed via b5.Scene instead of Scene, for example: var scene = new b5.Scene();
Page 14 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Examples and Tutorials
A large number of examples are available to download on Github . You can see these examples in action online at the Booty5 web site . A number of walk through style tutorials can also be found here .
Known Issues
•
Sound resources cannot currently be preloaded on some versions of iOS
Page 15 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Booty5 Game Engine
The App – The Eye in the Sky
Introduction
The App object is basically the great eye-in-the-sky controller of the game engine that controls the game logic, rendering update and handling of various events such as input.
The App takes care of many things including:
•
Manages global resources
•
Manages a collection of Scenes
•
Manages a collection of Action Lists
•
Handles touch input and keyboard
•
Finds which Actor was touched when user touches screen
•
Logic loop processing
•
Rendering
•
Manages global animation Timelines via a TimelineManager
•
Controls rescaling of canvas to best fit to different display sizes
•
Tracks time and measures frame rate
Page 16 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating the App
The first task that must be carried out when developing a game with Booty5 is to create the main App object. This object is the main game controller and takes care of processing the entire game. Below is a short piece of example code showing how to set up the app: window.onload = function () {
// Create the app var app = new b5.App(document.getElementById( 'gamecanvas' ));
b5.app = app; // Some classes expect the current app to be assigned to b5.app
app.debug = false ;
app.target_frame_rate = 60;
app.clear_canvas = false ;
app.setCanvasScalingMethod(b5.App.FitBest);
// Start the app
app.start();
};
In the above code we assign a new function to the windows onload event, so it is called once the page has finished loading. Within our onload function we begin by creating an instance of the main app object (App) passing in a reference to the HTML5 canvas that will receive the apps rendering (we created a canvas in our HTML5 page index.html). Note that you can gain a reference to the canvas at any point via b5.App.canvas.
We assign the created app object to b5.app because some areas of Booty5 look there for it later.
We set up a number of initial properties of the app such as no debugging, a target frame rate to aim for, no canvas clearing to save a bit of rendering time and the method of scaling that will be used to fit the canvas to the screen.
Finally we start the app going so that the game can play.
We can set up various properties of the app before calling start() to modify how the app behaves. A complete list of those features are listed below:
• debug – If set to true then debug information will be output to the console
• target_frame_rate – The rate at which to update game logic, pass 0 for variable
• clear_canvas – If set to true then the canvas background will be cleared each frame before the next frame is drawn
• canvas_scale_method – Set via setCanvasScalingMethod() sets how the HTML5 canvas will be scaled to fit the browser window
• allow_touchables - If true then app will search to find Actors that were touched y the user, this can be disabled in apps that have no use for touch input
• adaptive_physics – If true then physics update will be ran more than once per frame if frame rate falls much below target frame rate
• loading_screen – An object that contains properties that affect how the loading screen appears
Page 17 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Game Logic and Rendering
Most games have a main loop that runs game logic. The main logic loop is the central heart beat of the game and is often responsible for updating the game world, game objects, reading input, and so on.
Most games also have a second main loop called the render loop. The render loop defined by App.mainDraw() is ran as often as is possible via requestAnimationFrame().
Logic and rendering are decoupled in Booty5 to allow the games logic loop to be updated at a different rate to the display.
Booty5 runs both main loops separately, the game logic loop is ran on a timer at a rate determined by App.target_frame_rate, executing code that is ran in Scene / Actor update code. The game rendering loop is ran as fast as the browser window can update and executes code that is part of the App / Scene / Actor draw cycle.
Game logic is processed by b5.App.mainLogic() using b5.App.timer, whilst game rendering is processed by b5.App.mainDraw() using requestAnimationFrame().
The Main Canvas
Booty5 has to be able to render its content to a variety of different screen sizes, catering for a huge range of different sizes on a size by size basis is impossible. Instead, Booty5 renders to a virtual canvas of a specific size then scales the canvas to fit to the browser window. So for example, we can render to a fixed sized canvas of 1200x800 but have
Booty5 scale that canvas to best fit the target device display. In Booty5 world the virtual canvas is the fixed size that the game will render to. This enables you to lay out your game levels and art work to fit a specific virtual resolution, saving heaps of time and money.
The following canvas fit options are available:
• b5.App.FitNone- No scaling or resizing of the HTML5 canvas will occur
• b5.App.FitX – The HTML5 canvas will be resized to the full size of the display and the virtual canvas will be scaled so that the entire x-axis is fit onto the display
• b5.App.FitY – The HTML5 canvas will be resized to the full size of the display and the virtual canvas will be scaled so that the entire y-axis is fit onto the display
• b5.App.FitBest – The HTML5 canvas will be resized to the full size of the display and the virtual canvas will be scaled either on the X or Y axis depending on which axis keeps the most of the information on the display
• b5.App.FitSize – The HTML5 canvas will be resized to the full size of the display and the virtual canvas will be set to the same size as the display (no scaling will be performed)
The main canvas will be cleared each time the game is ready to start rendering the game.
If your game covers the entire area of the window then you can disable canvas clearing by setting b5.App.clear_canvas to false, saving a little rendering time.
Page 18 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Working with Resources
Resources that are stored within the main App's resource lists will persist throughout the lifetime of the app, these resources are known as global resources and are accessible to all other objects within the game.
Booty5 supports the following types of resources:
•
Bitmaps – Bitmap images
•
Brushes – ImageAtlas and Gradients that are used to render game objects
•
Shapes - Shapes that can be used for paths, clipping, rendering and physics fixtures
•
Materials – Physics materials
•
Sounds – Sound effects
When a resource is created its best to add the resource to a resource manager to be managed. Lets take a look at an example that shows how to create a resource and add it to the apps global resource manager: var material = new b5.Material( "static_bounce" ); material.restitution = 1; b5.app.addResource(material, "Material" );
In the above code we create a physics material then add it to the apps resource manager.
Later we can search for this material by calling App.findResource(): var material = b5.app.findResource( "static_bounce" , "Material" );
Note that as the App can store resources of different types we must specify the type of resource that we wish to find.
If we need to manually destroy a resource at some point in the future then we can either call App.destroyResource() or we can call destroy() on the resource itself, e.g.:
// If we do not have a reference to the resource then we can find and remove it b5.app.destroyResource( "static_bounce" , "Material" );
// If we already have reference to the material then we can destroy it through itself material.destroy();
Note that the Booty5 game maker exports a JSON data format called XOML which the
Booty5 game engine reads and converts to resources, scenes, actors etc..
Page 19 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Setting up a loading screen
As many HTML5 games are hosted on a server and assets are loaded asynchronously, its usually a good idea to delay game start until all resources have been loaded from the server. During this time it is customary to display a loading screen to provide feedback to the user so they know that the game is doing something and hasn't crashed.
Booty5 provides a resources loading screen feature out of the box. Calling b5.App.waitForResources() instead of b5.App.start() at the start of the app causes Booty5 to wait for all global and loaded scene resources to load before starting the game engine.
In addition, a loading screen will be displayed that shows how far the game data is through being loaded. The loading screen can be customised to your product using the b5.App.loading_screen object. This contains the following properties:
• background_fill - Loading background fill style
• background_image - Loading background image
• bar_background_fill - Loading bar background fill style
• bar_fill - Loading bar fill style
Lets take a quick look at an example:
// Set up a loading screen object b5.app.loading_screen = {
background_fill: "#fffff" , // Loading background fill style
background_image: "loading.png" , // Loading background image
bar_background_fill: "#8080ff" , // Loading bar background fill style
bar_fill: "#ffffff" // Loading bar fill style
};
Note that only resources that are marked to be preloaded will be included when the app determines which resources should be waited for. None preloaded resources will be loaded when they are first requested.
Page 20 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Working with Scenes
The main purpose of the app is to process and display scenes; scenes are containers for game objects. The main App object contains and manages a collection of scenes. All scenes that are currently loaded will be processed every game logic frame, but only ran if their state is set to active and rendered every render update if their visible state is visible.
This system allows you to disable scenes that are not currently in view or not being used, cutting down on overall processing overhead.
Scenes are created and added to the App object using b5.App.addScene(), e.g.:
// Create a scene var scene = new b5.Scene();
// Add scene to the app app.addScene(scene);
Once the scene is added to the app the app will begin processing and rendering it. When we are done with a scene we can remove / destroy it by calling b5.App.removeScene(), e.g.:
// Remove scene from app app.removeScene(scene);
You can also remove / destroy a scene by calling destroy() on the scene object:
// Remove scene from app scene.destroy();
Note that the scene will not be removed until the end of the apps processing loop.
You can search for scenes by name using b5.App.findScene();
Page 21 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Handling App Events
The App takes care of receiving and passing on a variety of input events that it receives such as touch and keyboard events.
At any given time, only a single scene can have the primary focus (App.focus_scene), any events that are received are passed on to this scene and its contained actors. A secondary focus scene (App.focus_scene2) can also be specified which will receive touch events.
Note that game objects within the secondary focus scene will only receive such events if they are “not” processed by an actor in the primary focus scene.
Note that you can change the focus and secondary focus scenes at any time by simply reassigning them.
The App currently responds to the following events:
• touchstart / mousedown – Touch started
• touchmove / mousemove – Touch moved
• touchend / mouseup – Touch ended
• mouseout – Mouse moved out of control
• keypress – A key was pressed
• keydown – A key is down
• keyup – A key is up
• resize – Window resized, Booty5 will automatically resize the canvas to fit the new size
The App supports a number of properties which allow you to test for certain touch conditions at any time or modify the way the system works:
• touched – True if a touch has occurred in any scene
• touch_pos – The last screen position that was touched
• touch_drag_x and touch_drag_y – The last touch drag delta x and y
• touch_focus – The actor that currently has touch focus
• touch_supported – If touch is supported then this property is set to true
• allow_touchables – Setting this property to false will disable checks for touching actors globally
Page 22 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Working with Variable Frame Rates
Its essential when creating games that run across a variety of different speed devices and platforms that we take into account the speed of the device that the game is being played on. (in game development terms we usually refer to this measurement as frame rate and is measured in frames per second or fps for short) The app tracks how much time the last game logic frame took to update so we know how fast our next frame will run. Knowing this information we can adjust how fast things move to ensure that the game play seems consistent and fluid.
The app automatically tracks how long the last game frame took to render via b5.App.dt
(delta time), this value, measured in seconds is also passed on to all scenes, actors, timelines and anything else that relies on time synchronisation. All movement and animation is scaling by this value to ensure that it plays back at a consistent speed regardless of frame rate.
The app also measures the average frame rate in fps via b5.App.avg_fps, measured every
60 frames. You can use this value to determine how fast the device is that you are running your game on. This value is also used with adaptive physics (b5.App.adaptive_physics) which when set to true will run the physics system multiple times during a single game frame to help ensure that constant time step physics behaves better at lower frame rates
(it attempts to match the value set in b5.App.target_frame_rate).
Page 23 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
App Public Properties
• scenes – An array of Scenes
• canvas – The HTML5 canvas
• allow_touchables – if true then app will search to find Actor that was touched
• target_frame_rate – Frame rate at which to update the game logic
• adaptive_physics – When true physics update will be ran more than once if frame rate falls below target
• focus_scene – Scene that has current input focus
• focus_scene2 – Scene that has secondary input focus
• clear_canvas – If true then canvas will be cleared each frame
• touch_focus – The Actor that has the current touch focus
• debug – Can be used to enable / disable debug trace info
• timelines – Global animation TimelineManager
• pixel_ratio – Device pixel ratio
• canvas_width – Virtual canvas width
• canvas_height -Virtual canvas height
• display_width – Width of display (client area)
• display_height – Height of display (client area)
• canvas_scale_method – Method of scaling used to scale virtual canvas to display
• use_web_audio – True if web audio is used
• touch_supported – True if touch is supported
• loading_screen – An object that contains the following properties that affect how the loading screen appears:
• background_fill – Loading screen background colour
• background_image – An image that will be displayed for the loading screen
• bar_background_fill – Loading bar background colour
• bar_fill – Loading bar colour
App Internal Properties
• removals – Array of scenes that were deleted last frame
• touched – true if the screen is being touched, false otherwise
• touch_pos – Position of last screen touch {x, y}
• touch_drag_x – Amount touch position was last dragged on x axis
• touch_drag_y – Amount touch position was last dragged on y axis
• last_time – Time of last frame update in milliseconds
• dt – Time period that has passed since the last update of the app in seconds
• avg_time – Total time since last average time measurement
• avg_fps – Frames per second of last average time measurement
• avg_frame – Counter used to take average time measurements
• canvas_scale – The amount that the virtual canvas is scaled to fit the screen
• canvas_cx – Canvas x-axis centre
• canvas_cy – Canvas y-axis centre
• total_loaded – Total resources that have been loaded so far (only resources that have been marked as preload)
• total_load_errors – Total number of resources that were not loaded due to errors
• order_changed – Set to true when scene order changes, causes a re-sort
• bitmaps – Array of Bitmap resources
• brushes – Array of ImageAtlas (other brush types will be added in future) resources
Page 24 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• shapes – Array of Shape resources
• materials – Array of Material resources
• sounds – Array of Sound resources
App Constants
• b5.App.FitNone
- No scaling or resizing of the HTML5 canvas will occur
• b5.App.FitX
– The HTML5 canvas will be resized to the full size of the display and the virtual canvas will be scaled so that the entire x-axis is fit onto the display
• b5.App.FitY
– The HTML5 canvas will be resized to the full size of the display and the virtual canvas will be scaled so that the entire y-axis is fit onto the display
• b5.App.FitBest
– The HTML5 canvas will be resized to the full size of the display and the virtual canvas will be scaled either on the X or Y axis depending on which axis keeps the most of the information on the display
• b5.App.FitSize
– The HTML5 canvas will be resized to the full size of the display
App Events
• onResourcesLoaded(resource, error) – Called when a resource has been loaded
App Methods
•
App(canvas, use_web_audio) – Creates and instance of the app
â—¦ canvas – The HTML5 canvas object that will be drawn to
â—¦ use_web_audio – If true then Booty5 will attempt to use web audio instead of
HTML5 audio, if not available then will fall back to HTML5 audio
• onTouchStart(e) – Event handler that is called by the system when the user begins touching the display (this includes mouse button down) (used internally)
â—¦ e – A mouse touch event
• onTouchEnd(e) – Event handler that is called by the system when the user stops touching the display (this includes mouse button up) (used internally)
â—¦ e – A mouse touch event
• onTouchMove(e) – Event handler that is called by the system when the user moves a touch around the display (this includes mouse move) (used internally)
â—¦ e – A mouse touch event
• onKeyPress(e) – Event handler that is called by the system registers a key press
(used internally)
â—¦ e – A key event
• onKeyDown(e) – Event handler that is called by the system receives a key down event (used internally)
â—¦ e – A key event
• onKeyUp(e) – Event handler that is called by the system receives a key up event
(used internally)
â—¦ e – A key event
• onResourceLoadedBase(resource, error) – Base event handler for onResourceLoaded. If you override onResourceLoaded then ensure that you call this base to ensure correct operation
â—¦ resource – Resource that was loaded
â—¦ error – true if an error occurred whilst loading
• addScene(scene) – Adds a scene to the app
Page 25 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
â—¦ scene – The scene to add
• removeScene(scene) – Removes the specified scene from the app destroying it.
Note that the scene is not removed immediately, instead it is removed when the end of the frame is reached.
â—¦ scene – The scene to remove
• cleanupDestroyedScenes() – Cleans up all destroyed scenes, this is called by the app to clean up any removed scenes at the end of its update cycle (used internally)
• findScene(name) – Searches the app for the named scene
â—¦ name – Name of the scene to find
â—¦ returns the found scene object or null for scene not found
• addResource(resource, type) – Adds a resource to the global app resource manager
â—¦ resource – The resource to add
â—¦ type – Type of resource to search for (brush, sound, shape, material, bitmap or geometry)
• removeResource(resource, type) – Removes a resource from the global app resource manager
â—¦ resource – The resource to remove
â—¦ type – Type of resource to remove (brush, sound, shape, material, bitmap or geometry)
• findResource(name, type) – Searches the global app resource manager for the named resource
â—¦ resource – Name of resource to search for
â—¦ type – Type of resource to search for (brush, sound, shape, material, bitmap or geometry)
â—¦ returns the found resource or null if not found
• countResourcesNeedLoading(include_scenes) – Counts and returns how many resources that need to be loaded
â—¦ include_scenes – if set to true then resources in all loaded scenes will also be counted
• findHitActor(position) – Searches all touchable actors in all app scenes to see if the supplied position hits them
â—¦ position – The position to hit test
â—¦ returns the actor that was hit or null for no hit
• draw() – Draws the app and all of its contained scenes
• update(dt) – Updates the app and all of its contained scenes
â—¦ dt – The amount of time that has passed since this app was last updated
• mainLogic() – The apps main loop (used internally)
• mainDraw() – The apps draw loop (used internally)
• start() – Starts the app going
• dirty() – Dirties the scene and all child actors transforms
• setCanvasScalingMethod(method) – Sets the method of scaling the virtual canvas to the HTML5 canvas
â—¦ method – The method of scaling to use, can be FitNone, FitX, FitY, FitBest or
FitSize
• waitForResources() – Waits for all preload resources to load before starting the app, also displays a loading screen and loading bar. Use this in place of calling app.start() directly.
• parseAndSetScene(scene_name) – Parses the named scene and sets it as the current focus scene
â—¦ scene-name - The name of the scene, note that the scene name and the exported name of the scene must match
Page 26 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Scenes – A Place for Actors to Play
Introduction
Booty5 is built around Scenes and Actors. A scene is a container for a collection of actors and other resources (such as shapes, materials, bitmaps etc..), whilst an actor is simply a game object that provides some kind of game functionality. A scene will manage the lifetime, processing and rendering of any game objects that are added to it. A scene will also manage the lifetime of any local resources (such as images, sounds etc..) as well as animation timelines (animation timelines are targeted at scenes and game objects to animate them) and actions lists.
It can be easier to think about Booty5 game development if we think in terms of the movie business, we all watch movies and programmes on the TV which makes it easy to relate to. A movie usually consists of a number of scenes that contain the environment, actors (provide the focus and entertainment of the movie) and a view into the scene (a camera).
Booty5 is based on these similar principles, where the scene acts as the game environment where the action takes place, actors represent individual game objects and the camera (which in this case is part of the scene) the view into the game.
A scene contains and manages the following:
•
A hierarchy of actors (game objects)
•
A collection of game resources (bitmaps, sounds, physics materials, shapes etc..) that are local to the scene
•
A collection of local animation timelines
•
A collection of action lists
•
A camera to navigate the scene
•
A clipping region which can be used to clip child game objects
•
Physics world update
Page 27 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating Scenes
Scenes are created by creating an instance of the b5.Scene object which are then added to the main App object for processing using b5.App.addScene(), e.g.:
// Create a scene var scene = new b5.Scene();
// Add scene to the app b5.app.addScene(scene);
Once the scene has been created you can begin setting the various properties of the scene. Its best to always give your new scene a name by assigning the name to scene.name. This will allow you to find the scene at some point in the future by searching for it by name using b5.App.findScene(name).
Once the scene is added to the app the app will begin processing and rendering it. When we are done with a scene we can remove / destroy it by calling b5.App.removeScene(), e.g.:
// Remove scene from app b5.app.removeScene(scene);
You can also remove / destroy a scene by calling destroy() on the scene object:
// Remove scene from app scene.destroy();
Note that the scene will not be removed until the end of the apps processing loop.
Scene Events
The scene handles a number of events that you can tap into:
• onCreate() - When a scene that was exported from the Booty5 game editor is created it will call the this event in response to the scene being created as long as it was defined within the editor
• onDestroy() - When a scene is to be destroyed during tear down this event will be raised
• onTick(delta_time) - This event is raised every time the scene is about to be updated (every logic frame)
• onBeginTouch(touch_pos) – This events is raised when the user touches the scene
• onEndTouch(touch_pos) – This events is raised when the user stops touching the scene
• onMoveTouch(touch_pos) – This events is raised when the user moves a touch around the scene
Lets take a quick look at an example of using scene events: scene.onBeginTouch = function (touch_pos) {
console.log( "Scene was touched" );
}
Page 28 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Processing and Visibility
Scenes are processed when their active property is set to true, if a scene is marked as not active then the scene and all of its actors and timelines will not be updated. Its generally a good idea to deactivate scenes when they are not in use, especially when targeting resource constrained devices such as mobile devices.
Scenes are rendered when their visible property is set to true. If a scene is marked as not visible then the scene and all of its contained actors will not be rendered. Again, its a good idea to hide scenes that are hidden by other scenes or are currently off screen.
Note that each time the scene is updated (each game frame and as long as the scene is active) its onTick() method will be called. You can tap into this event to add scene specific functionality, e.g.: scene.onTick = function (dt) {
// Do something with the scene (dt is delta time passed since last updated)
};
Page 29 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Local Resources
Resources can be local or global. If a resource is global then it is available to all scenes and the objects which they contain. Global resources are also always present in memory and are not freed until the app exits or are removed manually. If a resource is local to a scene then it is usually only accessible to the scene and objects within that scene. In addition, when the scene is destroyed all resources that it contains are destroyed along with it.
Resources can be added to a scene using b5.Scene.addResource(), e.g.: var material = new b5.Material( "static_bounce" ); material.restitution = 1; scene.addResource(material, "Material" );
In the above piece of code we create a physics material then add it to the scenes resources.
To later retrieve that resource we would search for it using: scene.findResource( "static_bounce" , "Material" );
Resources can also be located via their path. A path represents the hierarchical path to the object which consists of the names of the parent objects separated by dots. For example, if you want to locate a physics material called “material1” that is located in a scene named
“scene1” then the path to that resources would be “scene1.material1”. If the material was located in the Apps global resource space then the path would simply be “material1”. To find the instance of the resource from the path you can call b5.Utils.findResourceFromPath(path, type), e.g.: var material = b5.Utils.findResourceFromPath( "scene1.material1" , "material" );
Later if we need to remove and destroy the resource then we can either call:
// If we do not have a reference to the resource then we can tell the scene to find and remove it scene.destroyResource( "static_bounce" , "Material" );
// If we already have reference to the material then we can destroy it through the object itself material.destroy();
Page 30 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Working with Actors
Scenes are designed by their very nature to contain and manage game objects (actors).
An actors life time is determined by the lifetime of a scene, once a scene is killed off so are all of the game objects that it contains. When an actor is first created it needs to be added to a scene in order for it to be processed and rendered.
To add an actor to a scene use b5.Scene.addActor(actor), to later find an actor simply call b5.Scene.findActor(actor_name), you can pass an additional parameter to this method that will force the search to search all child actors also.
Once an actor is part of a scene it can later be removed by calling b5.Scene.removeActor(actor) or by calling b5.Actor.destroy() on the actor object.
Actors can be categorised using a tag name that is specified by the actors tag property.
Game objects can be removed en-mass by tag using b5.Scene.removeActorsByTag(tag_name);, this method will remove all actors within the scene that have the specified tag; tags enable you to mark groups of actors and later remove them all in one go.
Whilst layers can be used to visually order the order in which visible scenes are overlaid, where layers are not used you can bring actors to the front of the visual stack or send them to the back using b5.Scene.bringToFront() and b5.Scene.sendToBack().
Page 31 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
The Scene Camera
The camera is the view into the scene (game world). The scene can be moved around by changing Scene.camera_x and Scene.camera_y or by changing the cameras velocities
Scene.camera_vx and Scene.camera_vy.
A scene has a single camera with a variety of built in functions:
•
Touch panning
•
Target tracking
•
Constrained movement
•
Velocity damping
Touch panning
Touch panning is a feature that allows the user to pan around the game world (a scene) using their finger on touch devices or the mouse on desktop devices. When the user holds down the mouse button or touches the screen and drags, the camera will follow the players finger. This feature is not only great during testing but also very useful for many different types of games that have game worlds that are larger than the screen as it gives the user the opportunity to take a look around the world.
Touch panning can be enabled for each separate axis by setting b5.Scene.touch_pan_x and / or b5.Scene.touch_pan_y to true.
Its often useful to be able to tell if the user is currently touch panning the camera, this can be done by checking the value of b5.Scene.panning, if true then the user is currently panning around the scene. During the development of Leapo I bumped into an issue on mobile devices. I allow the user to pan around the game world, but also when the user taps the screen it causes the frog to jump. On some mobile devices, very small touch pans were causing the game to ignore frog jumps. To fix this I included a tolerance in b5.Scene.min_panning, which sets a minimum amount of panning movement that should be considered a pan (note that this value is the squared distance of the minimum, for example if you want a minimum value of 2 pixels in either direction then set this value to
2*2 + 2*2 = 8).
Target tracking
Target tracking (or camera follow) is a feature that enables the scenes camera to follow a specified actor or pair of actors. The camera can track game objects on separate axis, so for example you could have the camera track a player character on the x-axis, whilst also simultaneously tracking an evil alien on the y-axis.
To enable target tracking simply set b5.Scene.target_x and / or b5.Scene.target_y to the actor that you wish the camera to follow (in the game editor this option is available the the scenes properties), e.g.:
// Camera tracking two actors scene.target_x = b5.Utils.resolveObject( "scene1.actor1" ); scene.target_y = b5.Utils.resolveObject( "scene1.actor2" );
The rate at which the camera follows the targets can be set via b5.Scene.follow_speed_x and b5.Scene.follow_speed_y, higher values will cause the camera to catch up with the
Page 32 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood target more quickly,
Constrained Movement
Scenes have a rectangular boundary (extents) that can be used to constrain the camera and its actors. A scenes extents can be set via b5.Scene.extents which is an array of 4 values that represents the top, left, width, height of the constrained area. (In the game editor the scenes extents is represented by a green rectangle). When the camera hits the edges of the scene extents it will stop, e.g.:
// Limit movement of camera between -200, -200 and 200, 200 scene.extents = [-200, -200, 400, 400];
Coordinate System
A scenes coordinate system is based at its centre, if the scene is located in the middle of the screen then the scenes world origin will be at the centre of the screen. The coordinate system is designed this way to make it easier to design outwards. Designing outwards is incredibly useful when designing games that can be played across a variety of different sized displays as the main focus of the game is at its centre and not at a potentially clipped edge.
Position and Opacity
A scene has position and size (b5.Scene.x, b5.Scene.y, b5.Scene.w, b5.Scene.h) and can be moved around the screen, enabling effects such as scrolling scenes on and off the screen. When a scene is moved all of its contained actors are also moved.
Scenes have an opacity level (b5.Scene.opacity) between 0 and 1 which determines how opaque / transparent the scene and its contained game objects are This values can be used for effects such as fades where the entire scene is faded up and down
Note that within the game editor the opacity values ranges from 0 to 255, instead of 0 to
1 and is the 4th parameter of the scenes Colour property.
Child Clipping
A scene can clip its child actors by enabling Scene.clip_children. By default the scene will clip children against its dimensions (defined by Scene.w and Scene.h), but this can be changed by assigning a Shape to Scene.clip_shape which causes scene objects to be clipped against that shape, e.g.:
// Set clipping shape that scene will use to clip children scene.clip_shape = b5.Utils.resolveResource( "shape1" , "shape" );
Page 33 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Scene Layering
During game development you will find times when you need to display more than one scene at the same time. For example in the game Leapo there is the main game scene which contains the game world and the heads up display (HUD) scene which contains the players lives left. time left, level and pause button. Each scene can have a layer number
(b5.Scene.layer) which determines the visual order in which scenes are drawn to the display, scenes on higher layers will appear above scenes on lower layers.
Note that you should always set the scenes layer via the b5.Scene._layer property setter to ensure that the scene layers get re-sorted, e.g.: scene1._layer = 1; // This scene will appear below layer 2 scene2._layer = 2; // This scene will appear above layer 1
Scene Physics
Scenes can support a Box2D physics world, by default Box2D physics is disabled and has to be enabled. To enable physics you need to include the Box2D JavaScript library into your index.html file:
<script src= 'lib/Box2dWeb-2.1.a.3.min.js' >< /script>
Booty5 uses the Box2DWeb JavaScript library, you can see reference for this library here .
Scenes can selectively use Box2D physics, to enable physics in a scene you need to initialise the scenes physics world by calling b5.Scene.initWorld(), e.g: scene.initWorld(gravity_x, gravity_y, do_sleep);
In the call to initWorld() we pass the x-axis and y-axis gravity (0, 10 as default) and a flag that determines if the physics system should allow objects to sleep. I recommend that you do enable sleeping as it provides a good speed boost on mobile devices.
Once physics has been enabled for the scene you can set a number of other properties that affect how the physics system behaves:
• time_step – This is the amount of time that has elapsed between each call to update physics in seconds. By default this value is set to 0, which causes the scene to pass a variable time step to the physics system, this however is not ideal as physics will not behave consistently across different speed devices. Its generally better to pass a constant value and run the physics system multiple times when the frame rate drops. When exporting from the game editor a default value of 0.033 is passed (30 fps). Note that when adaptive physics is enabled in the App, the physics system will automatically be ran multiple times if the frame rate drops.
• world_scale – This value affects how the physics world maps to the visual world
(default value is 20)
If a scene has any objects that use the Box2D physics system then the scene must have physics enabled for it to work.
When physics is enabled in a scene the physics simulation will be updated during the
Page 34 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood scenes game logic update.
Animation Timelines
A scene manages a collection of animation timelines via its TimelineManager
(b5.Scene.timelines). An animation timeline is basically a collection of animations that are played back asynchronously. Usually objects within the scene or even the scene itself will add its animation to the scene for processing. Timelines will only play whilst the scene is active and destroying the scene will also destroy all contained animation timelines.
To add an animation timeline to a scene you can call b5.Scene.timelines.add(my_timeline), e.g.:
// Create a timeline that scales actor1 var timeline = new b5.Timeline(actor1, "_scale" , [1, 1.5, 1], [0, 0.5, 1], 1,
[b5.Ease.quartin, b5.Ease.quartout]);
// Add timeline to the scene for processing scene.timelines.add(timeline);
Actions Lists
A scene manages a collection of actions lists via the ActionsListManager
(b5.Scene.actions). An actions list is a collection of actions that are executed consecutively. An action is a single unit of functionality such as tween a collection of properties over time, start a sound effect or animation etc..
Usually objects within the scene or even the scene itself will add its action lists to the scene for processing. Action Lists will only play whilst the scene is active and destroying the scene will also destroy all contained action lists.
To add an actions list to a scene you can call b5.Scene.actions.add(actions_list), e.g.:
// Create actions list var actions_list = new b5.ActionsList( "turn" , 0);
// Add an action to actions list actions_list.add( new b5.A_SetProps(actor, "vr" , 2 / 5));
// Add actions list to the scenes actions list manager scene.actions.add(actions_list);
Page 35 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Input Events
Scenes can receive input events if they are set as a focus or secondary focus scene in the
App. When a touch / mouse event occurs it is sent from the app to the focus scene and then the secondary focus scene. In order to act upon these events you need to assign the following event handlers:
• onTapped(touch_pos) – This event is raised when the user taps the screen (a tap is defined as when the user touches the screen then lets go)
• onBeginTouch(touch_pos) – This event is raised when the user touches / clicks the screen
• onEndTouch(touch_pos) – This event is raised when the user stops touching / clicking the screen
• onMoveTouch(touch_pos) – This event is raised when the user moves their finger / mouse around the screen whilst touching it
A scene also receives keyboard input events, but only the main focus scene can receive them and not the secondary focus scene. These events include:
• onKeyDown(e) – This event is raised when the user presses a key, the raised event e contains the keys details with e.keyCode containing the key code
• onKeyUp(e) – This event is raised when the stops pressing a key, the raised event e contains the keys details with e.keyCode containing the key code
Note that within the game editor, the code entered into the event handlers will be called each time the event is raised.
A number of useful properties of the scene can be used to determine if the user is touching or moving a touch:
• b5.Scene.touching – Set to true when the user is touching the screen
• b5.Scene.touchmove – Set to true when the user is moving a touch
Page 36 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Detecting when Resources have Loaded
Booty5 can automatically take care of waiting for resources to be loaded, including loading the resources that need to be loaded for all scenes that are loaded at the start of the app.
However, you may find that you need to load scenes at a later date that contain resources.
Its possible to check when a scenes resources have finished loading using b5.Scene.areResourcesLoaded(), which will return true when all resources have finished loading. You could do this using a timer then update the UI to display a loading bar, e.g.:
// Wait for scene resources to finish loading var resource_check_interval = setInterval( function () { if (scene.areResourcesLoaded()) {
// Resources have finished loading
}
clearInterval(resource_check_interval);
}, 500);
You can also find out how many resources need to be loaded in the scene by calling b5.Scene.countResourcesNeedLoading().
Page 37 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Scene Public Properties
• name – Name of the scene (used to find actors in the scene)
• tag – Tag (used to find groups of actors in the scene)
• active – Active state, inactive scenes will not be updated
• visible – Visible state, invisible scenes will not be drawn
• layer – The visible layer that this object sits on
• x – Scene x axis position
• y – Scene y axis position
• w – Scene canvas width
• h – Scene canvas height
• clip_children – If set to true then actors will be clipped against extents of this scene
• clip_shape – If none null and clipping is enabled then children will be clipped against shape (clip origin is at centre of canvas)
• camera_x – Camera x position
• camera_y – Camera y position
• camera_vx – Camera x velocity
• camera_vy – Camera y velocity
• vx_damping – Damping to apply to camera_vx
• vy_damping – Damping to apply to camera_vy
• panning – Set to true when user is panning the scene
• min_panning – A minimum distance that the user must pan for panning to be set to true (this value is the squared distance)
• follow_speed_x – Camera target follow speed x axis
• follow_speed_y – Camera target follow speed y axis
• target_x – Camera actor target on x axis
• target_y – Camera actor target on y axis
• touch_pan_x – If true then scene will be touch panned on x axis
• touch_pan_y – If true then scene will be touch panned on y axis
• world_scale – Scaling from graphical world to Box2D world
• time_step – Physics time step in milliseconds (1/60 for 60 fps), setting to 0 will run physics at a variable rate based on frame update speed
• extents – Scene camera extents [left, top, width, height]
• opacity – Scene opacity
Scene Internal Properties
• app – Parent container app
• actors – Array of actors
• removals – Array of actors that were deleted last frame
• frame_count – Number of frames that this scene has been running
• world – Box2D world
• touching – Set to true when user touching in the scene
• touchmove – Set to true when touch is moving in this scene
• timelines – Scene local animation TimelineManager
• actions – Scene local ActionsListManager
• bitmaps – Array of Bitmap resources
• brushes – Array of ImageAtlas (other brush types will be added in future) resources
• shapes – Array of Shape resources
• materials – Array of Material resources
Page 38 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• sounds – Array of Sound resources
• order_changed – When layer changes this property is marked as true to let the system know to resort all objects on the layer
Scene Setters
•
_layer – Changes the scenes layer, note that visual ordering of scenes does not take place until the end of the game frame
•
_focus_scene – Sets the current focus scene, can use path to scene or instance of scene
•
_focus_scene2 – Sets the current secondary focus scene, can use path to scene or instance of scene
•
_clip_shape – Sets the clip shape, can use path to scene or instance of scene
Scene Events
• onCreate() – Called just after the scene has been created
• onDestroy() – Called just before the scene is destroyed
• onTick(delta_time) – Called each time the scene is updated (every frame)
• onBeginTouch(touch_pos) – Called when the scene is touched
• onEndTouch(touch_pos) – Called when the scene has top being touched
• onMoveTouch(touch_pos) – Called when a touch is moved over the scene
• onKeyPress(e) – Called when a key is pressed, e is key event
• onKeyDown(e) – Called when a key is down, e is key event
• onKeyUp(e) – Called when a key is up, e is key event
Scene Methods
•
Scene() – Creates an instance of a Scene object. Once a scene has been created it should be added to the main app object to be processed and drawn
• release() – Releases the scene, this is called by the app system when an scene has been destroyed
• destroy() – Begins the destruction of a scene and its content, note that the scene will not actually be destroyed until the end of the apps processing
• addActor(actor) – Adds the specified actor to the scene, returns the added actor
• removeActor(actor) – Removes the specified actor from the scene, destroying it
• removeActorsWithTag(tag) – Removes all actors from the scene that are tagged with the specified tag
• cleanupDestroyedActors() – Cleans up all destroyed scenes, this is called by the app to clean up any removed scenes at the end of its update cycle
• findActor(name, recursive) – Searches this scenes child list for the named actor.
â—¦ name: The name of the actor
â—¦ recursive – If true then the complete child hierarchy will be searched
â—¦ returns the found actor or null if not found
• bringToFront() – Moves the scene to the end of the scenes list, bringing it to the front of all other scenes in the app.
• sendToBack() – Moves the scene to the start of the scenes list, pushing it to the back of all other scenes in the app.
• initWorld(gravity_x, gravity_y, allow_sleep) – Initialises a Box2D world and attaches it to the scene. Note that all scenes that contain Box2D physics objects
Page 39 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood must also contain a Box2D world
â—¦ gravity_x – X axis gravity
â—¦ gravity_y – Y axis gravity
â—¦ allow_sleep – If set to true then actors with physics attached will be allowed to sleep
• draw() – Draws this scene and its children, this method can be overridden by derived scenes
• baseUpdate(dt) – Base update function (used internally) that should be called by all derived scenes that wish to use base scene functionality, this is usually called from your update() method.
â—¦ dt – The amount of time that has passed since this scene was last updated
• update(dt) – Updates the scene (used internally), this method can be overridden by derived scenes
â—¦ dt – The amount of time that has passed since this scene was last updated
â—¦ returns true if active
• updateCamera(dt) – Updates the scenes camera
â—¦ dt – The amount of time that has passed since this scene was last updated
â—¦ returns true if active
• findHitActor(position) – Searches all touchable actors in the scene to see if the supplied position hits them
â—¦ position – The position to hit test
â—¦ returns the actor that was hit or null for no hit
• addResource(resource, type) – Adds a resource to the scenes resource manager
â—¦ resource – The resource to add
â—¦ type – Type of resource to add (brush, sound, shape, material, bitmap or geometry)
• removeResource(resource, type) – Removes a resource from the scenes resource manager
â—¦ resource – The resource to remove
â—¦ type – Type of resource to remove (brush, sound, shape, material, bitmap or geometry)
• findResource(name, type) – Searches the scenes resource manager for the named resource, if the resource is not found in this scene then the apps global resources will be searched
â—¦ resource – Name of resource to search for
â—¦ type – Type of resource to search for (brush, sound, shape, material, bitmap or geometry)
â—¦ returns the found resource or null if not found
• areResourcesLoaded() – Returns true if all scene resources have been loaded, otherwise false
Page 40 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Scene Examples
Creating a scene
var scene = new b5.Scene(); // Create instance of a scene scene.name = "my_scene" ; // Name the scene b5.app.addScene(scene); // Add the scene to the app for processing b5.app.focus_scene = scene; // Set our scene as the focus scene
Adding clipping to a scene
var clipper = new b5.Shape(); // Create a circle shape clipper.type = b5.Shape.TypeCircle; clipper.width = 100; scene.clip_shape = clipper; // Assign the shape as the scenes clip shape
Adding touch panning to a scene
scene.touch_pan_x = true ; // Enable touch panning on x-axis scene.touch_pan_y = true ; // Enable touch panning on x-axis
Adding a physics world to a scene
scene.initWorld(0, 10, true ); // Initialise physics world (gravity_x, gravity_y, do_sleep)
Adding an onTick event handler to a scene
scene.onTick = function (dt) { this .x++;
};
Adding touch event handlers to a scene
scene.onBeginTouch = function (touch_pos) {
console.log( "Scene touch begin" );
}; scene.onEndTouch = function (touch_pos) {
console.log( "Scene touch end" );
}; scene.onMoveTouch = function (touch_pos) {
console.log( "Scene touch move" );
};
Make the scene camera follow a target actor
scene.target_x = my_actor; scene.target_y = my_actor;
Scroll scene off to right using timeline animation
var timeline = new b5.Timeline(scene, "x" , [0, 1024], [0, 2], 1, [Ease.quartin]); scene.timelines.add(timeline); // Add to scenes timeline manager to be processed
Page 41 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Add an actions list
// Create an actions list var actions_list = new b5.ActionsList( "fade" , 1);
// Add an action that moves the camera actions_list.add( new b5.A_CamMoveTo(scene, 100, 100, 2, b5.Ease.linear, b5.Ease.linear));
// Add an action that fades the scene actions_list.add( new b5.A_TweenProps(scene, [ "opacity" ], [1], [0], 2, [b5.Ease.linear]));
// Add actions list to scene and set it playing scene.actions.add(actions_list).play();
Page 42 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actors – Sprites with Brains
Introduction
Going back to our comparison in the scenes introduction section, actors play a pivotal role in our scenes, each actor having its own unique role and visual appearance. Actors are the building block of the game, they provide the unique functionality and visuals that make up the game as a whole, rather like each actor plays his / her role in a movie.
Actors can provide any type of functionality from a simple bullet fleeting across the screen to something as complex as a dynamic machine that modifies its behaviour and appearance based upon data streamed from a web server.
An Actor object represents a game object that can be added to Scenes for processing and display. You can add logic to the actor via its update() method and or by attaching an onTick event handler.
The base Actor has the following features:
•
Position, size, scale, rotation
•
Absolute (pixel coordinate) and relative (based on visible size) origins
•
Layering
•
Support for cached rendering
•
3D depth (allows easy parallax scrolling)
•
Angular, linear and depth velocity
•
Box2D physics support (including multiple fixtures and joints)
•
Bitmap frame animation
•
Timeline animation manager
•
Actions list manager
•
Sprite atlas support
•
Child hierarchy
•
Angular gradient fills
•
Shadows
•
Composite operations
•
Begin, end and move touch events (when touchable is true), also supports event bubbling
•
Canvas edge docking with dock margins
•
Can move in relation to camera or be locked in place
•
Can be made to wrap with scene extents on x and y axis
•
Clip children against the extents of the parent with margins and shapes
•
Supports opacity
•
Can be represented visually by arcs, rectangles, polygons, bitmaps and labels
•
Support for a virtual canvas that can scroll content around
Other Actor types are derived from b5.Actor, including:
• b5.ArcActor - Circular based game objects
• b5.LabelActor - Text based game objects
• b5.ParticleActor - Particle system based game objects
Page 43 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• b5.PolygonActor - Polygon based game objects
• b5.RectActor - Rectangular based game objects
• b5.MapActor – Tiled map based game objects
All shape and text based actors can be rendered filled or unfilled by changing the actors filled property.
Creating Actors
Actors are created by creating an instance of a b5.Actor object or any of the actor types mentioned above then adding that instance to a Scene or another Actor. Lets take a quick look at an example: var actor = new b5.Actor(); // Create instance of Actor scene.addActor(actor); // Add actor to scene to be processed and drawn
Of course this actor will do absolutely nothing as it has no visual component assigned.
Lets take a look at how to create actors of different types.
Creating an Arc Actor
An arc actor represents a circular shaped game object, an example showing how to create one is shown below: var actor = new b5.ArcActor(); // Create instance actor.x = 100; // Set x axis position actor.y = 0; // Set x axis position actor.fill_style = "#00ffff" ; // Set fill style actor.start_angle = 0; // Set start angle actor.end_angle = 2 * Math.PI; // Set end angle actor.radius = 50; // Set radius actor.filled = true ; // Set filled scene.addActor(actor); // Add actor to scene to be processed and drawn
In the above code we first of all create an instance of ArcActor, set some properties of the actor such as position, size, start and end angle etc.. then we add it to the scene to be processed.
Creating a Rectangular Actor
A rectangular actor represents a rectangular shaped game object, an example showing how to create one is shown below: var actor = new b5.RectActor(); // Create instance actor.fill_style = "#40ff4f" ; // Set fill style actor.filled = true ; // Set filled actor.w = 100; // Set drawn width actor.h = 100; // Set drawn height actor.corner_radius = 10; // Set corner radius (this is a rounded ract) scene.addActor(actor); // Add actor to scene for processing and drawing
Page 44 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating a Label Actor
A label actor represents a game object that displays a string of text, an example showing how to create one is shown below: var actor = new b5.LabelActor(); // Create instance of actor actor.font = "16pt Calibri" ; // Set font actor.text_align = "center" ; // Set horizontal alignment actor.text_baseline = "middle" ; // Set vertical alignment actor.fill_style = "#ffffff" ; // Set fill style actor.text = "Hello World" ; // Set some text scene.addActor(actor); // Add to scene for processing and drawing
Creating a Polygon Actor
A polygon actor represents a game object that displays a shape, an example showing how to create one is shown below: var actor = new b5.PolygonActor(); // Create instance of actor actor.name = "polygon1" ; // Set actors name actor.points = [0, -50, 50, 50, -50, 50]; // Set shape actor.fill_style = "#804fff" ; // Set fill style actor.filled = true ; // Set filled scene.addActor(actor); // Add to scene for processing and drawing
Creating a Bitmap Actor
Lets take a look at creating a slightly more complex actor, one with a bitmap attached:
// Create an actor var actor = new b5.Actor(); actor.x = 100; actor.y = 100; actor.w = 200; actor.h = 200; scene.addActor(actor); // Add to scene
// Create and attach a bitmap act.bitmap = new b5.Bitmap( "background" , "images/background.jpg" , true );
Whilst in the above example we create a bitmap and assign it to the actor directly, its better practice to create the bitmap then add it to either the scenes resources or apps global resources so that it may be managed and re-used.
Page 45 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating a Tile Map Actor
A tilemap actor represents a game object that displays an object that is built up out of tiles, an example showing how to create one is shown below: var map = new b5.MapActor(); // Create instance of actor map.map_width = 100; // Set map width in cells map.map_height = 100; // Set map height in cells map.display_width = 16; // Set how many cells to display on x axis map.display_height = 16; // Set how many cells to display on y axis map.generateTiles(32, 64, 64, 256); // Generate the tile set map.bitmap = new b5.Bitmap( "tiles" , "testmap.png" , true ); // Set tile set bitmap for ( var t = 0; t < map.map_width * map.map_height; t++) // Generate a random map
map.map.push((Math.random() * 32) << 0); scene.addActor(map); // Add to scene for processing and drawing
Actors can be destroyed by calling their b5.Actor.destroy() method, this will remove them from their scene and destroy all physics joints, fixtures and so forth that are attached to them. You can also destroy and actor by calling Scene.removeActor().
Note that when an actor is created its onCreate() method will be called to allow any post creation tasks to be carried out (Booty5 game editor only). When an actor is destroyed its onDestroy() method will be called so that any pre destruction tasks can be carried out.
You can see an example of the creation of different types of actors in the shapes demo.
Processing and Visibility
Actors are processed when they are part of a scene or some other actor and their active property is set to true, if marked as not active then it and all of its child actors will not be updated. It can be a good idea to deactivate actors when they are not in use, especially if you have a large number of them within a scene.
Actors are rendered when their visible property is set to true. If marked as not visible then the actor and all of its children will not be rendered.
Note that each time the actor is updated (each game frame and as long as it is active) its onTick() method will be called, e.g.: actor.onTick = function (dt) {
// Do something (dt is time passed since last updated)
};
Its generally here where you will add your actor logic to give your actor its unique functionality, unless of course you plan on deriving your own actor type from one of the existing types and implementing the update() method.
Page 46 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Transforms
All actor types have various properties that can be modified to change the position, rotation and scale of the actor and all of its children. These properties are listed below:
• x – X position in scene
• y – Y position in scene
• ox – X origin
• oy – Y origin
• absolute_origin – If true then ox and oy are taken as absolute coordinates, if false then ox and oy are taken as percentage of width and height
• rotation – Rotation in radians
• scale_x – X scale
• scale_y – Y scale
• depth – Z depth (3D depth), 0 represents no depth
An actors internal visual transform will only be re-calculated when properties such as position, scale and rotation changes, this is an optimisation to cut down on unnecessary processing. Changing these properties after actor creation should be done via the
associated propertiy setters such as _x, _y (see Actor Setters for a full list).to ensure that
the internal transform is updated. Alternatively you can set b5.Actor.transform_dirty to true to force the internal transform to be updated. Note that when an actors transform is dirtied, all of its children’s transforms will also be dirtied.
Note that when setting an actors origin, there are two ways in which the origin properties can be interpreted. If absolute_origin is set to true then the origin will be taken as absolute coordinates. if however it is set to false then the coordinates will be taken as percentage of actor width and height values, so for example an ox value of 0.5 and an actor width of 100 will result in a final x origin value of 50.
Child Hierarchies
Its often very useful when creating game objects to build them out of parts, for example, in the Leapo game, the frog player is built up out of multiple parts. We have the frogs main body, which has a head attached, the head also has two eyes attached to it. This enables me to change the head independent of the body and the eyes independent of the head. However, if the head rotates then I want the eyes to rotate with it. The hierarchical system ensures that changes to the parent are propagated to its children, ensuring children obey the same transforms and opacity settings as their parent.
Each actor maintains its own list of children. To make an actor a child of another, simply call parent_actor.addActor(child). This will add the child to the parents hierarchy, e.g.: var actor1 = new b5.Actor(); var actor2 = new b5.Actor(); actor1.addActor(actor2); scene.addActor(actor1);
To remove a child from the parent simply call child.parent.removeActor(child).
To search an hierarchy for an actor call parent.findActor(“actors name”, recursive). Note
Page 47 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood that if recursive is true then the entire actor hierarchy will be searched for the named actor.
Child and Self Clipping
An actor can clip its children as well as itself against its extents or a supplied clip shape.
To enable clipping of children set b5.Actor.clip_children to true. To enable clipping against itself set b5.Actor.self_clip to true. Without a clip shape defined the actor will be clipped against the natural shape of the actor, for example if the actor is an ArcActor then the clipping region will be the circle area that is generated by the actor. For rectangular clipping regions a clip margin (defined by b5.Actor.clip_margin which is an array of left,top,right, bottom) can be used to shrink or expand the clipping region. If a clipping shape is defined (b5.Actor.clip_shape) then the supplied shape will be used to clip. Note that clipping can be slow on some devices, so you use it sparingly and should test thoroughly.
Lets take a look at how to set up an actor that clips its children:
// Create an actor that will clip its children var actor = new b5.ArcActor(); actor.fill_style = "#000000" ; actor.radius = 50; actor.filled = true ; actor.clip_children = true ; scene.addActor(actor);
// Create a child actor that will be clipped by its parent var label = new b5.LabelActor(); label.font = "30pt Calibri" ; label.fill_style = "#ffffff" ; label.text = "Hello World" ; actor.addActor(label);
In the above example we create a circle actor that contains text reading “Hello World”.
Note how the text is clipped against the circle extents of the parent actor.
Now lets take a look at a self clipping example:
// Create a clip shape var shape = new b5.Shape(); shape.type = b5.Shape.TypePolygon; shape.vertices = [0, -20, 20, 20, -20, 20];
// Create an actor that will clip against the clip shape var actor = new b5.RectActor(); actor.fill_style = "#000000" ; actor.w = 100; actor.h = 100; actor.filled = true ; actor.self_clip = true ; actor.clip_shape = shape; scene.addActor(actor);
In the above example we create a triangular polygon shape then create a rectangular actor and assign it is the clipping shape, we also mark the actor as self clipping which clips the actor against its own clip shape.
Page 48 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
A good example of self clipping can be seen in the self clipping demo .
Layering
As with scenes, actors can also be visually sorted using layers. Each game object has its own layer number, actors on the same layer will be rendered in the order in which they were created. Actors are sorted local to their parent, so all actors that have the scene as a parent are sorted against each other, whilst all actors in a child tree will be sorted against other actors on the same tree level.
Note that you should always set the layer via the Actor._layer property setter to ensure that layers get re-sorted. A good example of dynamically sorted actors can be seen in the planets demo .
Opacity
Actors have an opacity level (b5.Actor.opacity) that ranges from 0 and 1 which determines how opaque / transparent it its child actors are. Child actors can opt to not be affected by their parents opacity by setting b5.Actor.use_parent_opacity to false.
Note that within the game editor the opacity values ranges from 0 to 255, instead of 0 to
1 and is the 4th parameter of the actors Colour and Selected Colour property.
Filling and Outlines
All shape and text based actors can be rendered as filled or outlined. You can change the filled state of an actor by setting its filled property to true for filled or false for outlined.
Filled actors will use the fill_style property to decide how to render the fill style. Outlined actors will use the stroke_style property to decide how to render the outline. A stoke_thickness can also be specified that specifies how thick to render the outline.
Lets take a quick look at a couple of examples:
// Create filled circle var actor1 = new b5.ArcActor(); actor1.x = -100; actor1.radius = 100; actor1.fill_style = "#ff00ff" ; actor1.filled = true ; scene.addActor(actor1);
// Create outlined circle var actor2 = new b5.ArcActor(); actor2.x = 100; actor2.radius = 100; actor2.stroke_style = "#ffff00" ; actor2.stroke_thickness = 5; actor2.filled = false ; scene.addActor(actor2);
Page 49 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
We can also draw an actor filled with a gradient:
// Create gradient var gradient = new b5.Gradient(); gradient.addColourStop( "#ff0000" , 0); gradient.addColourStop( "#ff00ff" , 1);
// Create filled circle var actor1 = new b5.ArcActor(); actor1.x = -100; actor1.w = 100; actor1.radius = 100; actor1.filled = true ; actor1.fill_style = gradient.createStyle(actor1.w, actor1.w, { x: 0, y: 0 }, { x: 1, y:
1 }); scene.addActor(actor1);
A good example of filled and outlined shapes can be seen in the shapes demo .
Docking
Its often useful to be able to arrange parts of a games user interface around the edges of a scene to ensure that they are positioned consistently across different sized displays.
Booty5 enables this using docking.
Docking allows you to dock actors to the edges of a scene so that regardless of how the scene is scaled, docked actors will remain where you expect them to be.
You can dock an actor on the x and y axis by setting its b5.Actor.dock_x and b5.Actor.dock_y property to one of the following:
• b5.Actor.Dock_None
• b5.Actor.Dock_Top
• b5.Actor.Dock_Bottom
• b5.Actor.Dock_Left
• b5.Actor.Dock_Right
When an actor is docked it can be adjusted using a margin. b5.Actor.margin specifies an array of margin values (left, right, top, bottom).
In addition to docking against the scene, actors can be docked against the edges of parent actors that are marked as using a virtual canvas. Note that the virtual actor must be a child of the parent for it to dock.
Lets take a quick look at an example that shows how to dock an actor to the top of the scene:
// Create an actor that is docked against top of scene var actor = new b5.RectActor(); actor.fill_style = "#0000ff" ; actor.w = 100; actor.h = 100; actor.filled = true ; actor.dock_y = 1; actor.margin = [0, 0, 20, 0];
Page 50 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood scene.addActor(actor);
Bitmap Animation
Actors can display animating bitmaps out of the box. Animation is achieved by displaying different rectangular areas of a larger image, this image is often called an image atlas
(see ImageAtlas ). An ImageAtlas is basically a sprite atlas (or sprite sheet) which is a
large image that contains multiple sub images. Each sub image can be identified using a rectangular area to specify where it is located in the larger main image. Bitmap animation is achieved by displaying different areas of the main sprite atlas over time, changing the area of the bitmap that is shown.
Lets take a look at how to create a game object that shows a bitmap animation:
// Create an actor var actor = new b5.Actor(); actor.x = 100; actor.y = 100; actor.w = 200; actor.h = 200; scene.addActor(actor); // Add to scene
// Create an image atlas from a bitmap image then assign as the actors atlas actor.atlas = new b5.ImageAtlas( "sheep" , new Bitmap( "sheep" , "images/sheep.png" , true )); actor.atlas.addFrame(0, 0, 86, 89); // Add frame 1 to the atlas actor.atlas.addFrame(86, 0, 86, 89); // Add frame 2 to the atlas actor.current_frame = 0; // Set initial animation frame actor.frame_speed = 1; // Set animation playback speed
In the above code we create an ImageAtlas and assign it to the actor. We then set the actors frame_speed property to 1 causing the bitmap animation to be played back at speed of 1 frame per second.
The order in which bitmap animations are played can be changed by assigning an array of frame indices to b5.Actor.anim_frames. This array will override the atlases current frame order, e.g.: actor.anim_frames = [1,0,0,0,1,0,1];
Note that you can set frame_speed to 0 and control the animation manually by changing current_frame.
Page 51 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Adding Physics
All actors of all types can be easily turned into physics objects. To turn an actor into one that supports physics you can need to initialise the actors Box2D physics body then add a fixture to allow collision, e.g.:
// Initialise physics body actor.initBody( "dynamic" , false , false );
// Add a physics fixture actor.addFixture({ type: b5.Shape.TypeBox, width: actor.w, height: actor.h });
When we call initBody() we pass 3 parameters, the first is the type of body, in this case
“dynamic” which means the object can move around the physics world. The second and third tell the physics engine if the body uses fixed rotation and can move very fast respectively, in both cases we opt to turn those features off.
Once the actor has a physics body we can add a fixture. A fixture is a shape that describes the physical shape of the actor and how it reacts to other actors in the simulation. In this case we use a simple box shape that is the same size as the actor. We could pass in additional options to addFixture() such as density, friction, restitution etc..
Note that an actor should not be added to a scene that does not support physics.
Its possible to detect if an actor is under control of physics by checking b5.Actor.body, if not null then the actor is under control of Box2D physics.
Physics materials
Physics materials are represented by the Material class and are used to store physical material parameters for the Box2D engine. A Material can be supplied as an option to b5.addFixture() when creating fixtures, e.g.: actor.addFixture({ material: my_material, shape: my_shape, is_bullet: false });
Physics shapes
Physics shapes are represented by the Shape class and are used to store physical dimensions for the Box2D engine. A Shape can be supplied as an option to b5.addFixture() when creating fixtures, e.g.: actor.addFixture({ material: my_material, shape: my_shape, is_bullet: false });
Page 52 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Physics joints
Physics joints enable you to connect physical bodies together in a variety of ways. The following types of physical joints are currently supported:
•
Weld joint – This is a joint that simply attaches two objects together, when one object moves the other is dragged with it
•
Distance joint – A distance joint limits the distance of two bodies and attempts to keep them the same distance apart, damping can also be applied
•
Revolute joint – A revolute joint forces two bodies to share a common anchor point.
It has a single degree of freedom and the angle between the two bodies can be limited. In addition a motor can also be applied to the joint
•
Prismatic joint – A prismatic joint limits movement between the two bodies by translation (rotation is prevented). The translational distance between the two joints can be limited. In addition a motor can also be applied to the joint
•
Pulley joint – A pulley joint can be used to create a pulley system between two bodies so that when one body rises the other will fall.
•
Wheel joint – A wheel joint restricts one body to the line on another body and can be used to create suspension springs. A motor can also be applied to the joint
•
Mouse joint – The mouse joint can be used to move physical bodies towards a location
Joints can be created by calling b5.Actor.addJoint(options), where options includes information about the specific joint that should be added.
For more details regarding initBody(), addFixture() and addJoint() see the Actor Method reference .
Lets take a look at a quick example of creating a joint that joins two actors:
// Create floor var floor = new b5.RectActor(); floor.fill_style = "#00ff00" ; floor.x = 0; floor.y = 300; floor.rotation = 0; floor.w = 500; floor.h = 100; floor.filled = true ; scene.addActor(floor); floor.initBody( "static" , false , false ); floor.addFixture({ type: b5.Shape.TypeBox, width: floor.w, height: floor.h, restitution:
0.9, density: 1.0, friction: 0.1 });
// Create actor 1 var actor1 = new b5.RectActor(); actor1.fill_style = "#0000ff" ; actor1.x = -50; actor1.y = -200; actor1.w = 100; actor1.h = 100; actor1.rotation = -1; actor1.filled = true ; scene.addActor(actor1); actor1.initBody( "dynamic" , false , false ); actor1.addFixture({ type: b5.Shape.TypeBox, width: actor1.w, height: actor1.h, restitution:
Page 53 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
0.9, density: 1.0, friction: 0.1 });
// Create actor 2 var actor2 = new b5.RectActor(); actor2.fill_style = "#ff0000" ; actor2.x = 50; actor2.y = -200; actor2.w = 100; actor2.h = 100; actor2.rotation = 1; actor2.filled = true ; scene.addActor(actor2); actor2.initBody( "dynamic" , false , false ); actor2.addFixture({ type: b5.Shape.TypeBox, width: actor2.w, height: actor2.h, restitution:
0.9, density: 1.0, friction: 0.1 });
// Create joint actor1.addJoint({ type: "weld" , actor_b: actor2, anchor_a: { x: 0, y: 0 }, anchor_b: { x: 0, y: 0 }, self_collide: true });
Physics collision
When two actors that are under the control of the physics system start to collide or stop colliding then their onCollisionStart(contact) and onCollisionEnd(contact) event handlers are called (if specified). This gives you the opportunity to determine when, where and how collisions took place. Lets take a look at a quick example that shows two actors interacting during collision:
// Create floor var floor = new b5.RectActor(); floor.name = "floor" ; floor.fill_style = "#00ff00" ; floor.x = 0; floor.y = 300; floor.rotation = 0; floor.w = 500; floor.h = 100; floor.filled = true ; scene.addActor(floor); floor.initBody( "static" , false , false ); floor.addFixture({ type: b5.Shape.TypeBox, width: floor.w, height: floor.h, restitution:
0.9, density: 1.0, friction: 0.1 });
// Create actor 1 var actor1 = new b5.RectActor(); actor1.name = "actor1" ; actor1.fill_style = "#0000ff" ; actor1.x = -50; actor1.y = -200; actor1.w = 100; actor1.h = 100; actor1.rotation = -1; actor1.filled = true ; scene.addActor(actor1); actor1.initBody( "dynamic" , false , false ); actor1.addFixture({ type: b5.Shape.TypeBox, width: actor1.w, height: actor1.h, restitution:
0.9, density: 1.0, friction: 0.1 });
actor1.onCollisionStart = function (contact) { var actor1 = contact.GetFixtureA().GetBody().GetUserData();
Page 54 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
var actor2 = contact.GetFixtureB().GetBody().GetUserData();
console.log(actor1.name + " hit " + actor2.name);
};
In the above example we create a floor actor and dynamic actor, we assign the onCollisionStart() event handler which will be called when actor1 hits something. You can find out the two colliding actors by checking the user data assigned to the body, which happens to the the actor that contains it.
A number if different collision flags can be set on a per object basis which affects how object interacts with other objects. For example you can allow certain object to collide with one type of object but not another. The following flags are available:
• collision_category - The category bits describe what type of collision object the actor is
• collision_mask - The mask bits describe what type of other collision objects this actor can collide with
• collision_group - The group index flag can be used to override category and mask, but we generally do not need to use it and usually set it to 0 for all actors.
To set these flags, pass them to the options parameter of Actor.addFixture().
Applying force and torque
To apply force to a body you need to call ApplyForce() on the actors body, e.g.: var b2Vec2 = Box2D.Common.Math.b2Vec2; actor.body.ApplyForce( new b2Vec2(fx, fy), pos);
Where fx, fy represents the force to apply and pos the physics body position in Box2D world coordinates to apply the force at. You can get the world position of a body as follows: var pos = actor.body.GetWorldPoint( new b2Vec2(0,0));
If you want to calculate a position that is offset from the body then you can pass the offset to GetWorldPoint(), e.g.: var ws = actor.scene.world_scale; var pos = actor.body.GetWorldPoint( new b2Vec2(dx / ws, dy / ws));
Note that we scale the offset dx,dy by the physics world scale allowing us to specify the offset in scene coordinates
To apply torque (turning force) to an actors body we can call ApplyTorque() on the actors body, e.g.: actor.body.ApplyTorque(torque);
Page 55 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Changing velocity and applying impulses
To set an actors velocity directly you can call SetLinearVelocity() and SetAngularVelocity() on the actors physics body, e.g.: var b2Vec2 = Box2D.Common.Math.b2Vec2; actor.body.SetLinearVelocity( new b2Vec2(vx, vy)); actor.body.SetAngularVelocity(vr);
Here we set the linear velocity to vx,vy and the angular velocity to vr directly.
Note that setting the velocity directly will overwrite the current velocity, if instead you want to apply a new velocity then you should use impulse instead.
To apply impulse to an actors body you should call ApplyImpulse() on the actors body, e.g.: var b2Vec2 = Box2D.Common.Math.b2Vec2; actor.body.ApplyImpulse( new b2Vec2(fx, fy), pos);
As with ApplyForce the impulse can be applied at a specific point on the body.
None Box2D physics
When actors are not under control of the Box2D physics system they have their own linear
/ angular / depth velocity (vx, vy, vr, vd) and linear / angular / depth velocity damping
(vx_damping, vy_damping, vr_damping, vd_damping). This enables you to move objects around under velocity without the need for a full physics simulation, however collision and collision response will not automatically be taken care of for you, you will need to do this yourself by checking for overlap between actors.
Note that when an actor is under control of the Box2D physics system and you find that you need to apply the actors current velocities to the physics system then you can call b5.Actor.updateToPhysics() to force the changes to be written back to the physics system, this will also awaken the actors body if asleep.
Scene extents
When an actor has b5.Actor.wrap_position enabled, if it goes beyond the parent scenes extents then it will wrap back around at the opposite edge.
Page 56 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actor Animation
Actors can be animated using timelines, a timeline is a collection of Animations that change the properties of objects over time. A timeline can target just about any property of an actor. Actors can carry multiple animations that can be played back at the same time, as well as paused and restarted. The actors timeline manager b5.Actor.timelines is a
TimelineManager which allows you to add, remove and find existing animation timelines.
Lets take a look at a quick example of creating an animation timeline that animates a property of an actor:
// Create a timeline that targets the x property of my_object with 4 key frames spaced out every 5 seconds and using QuarticIn easing to ease between each frame var timeline = new b5.Timeline(actor, "_x" , [0, 100, 300, 400], [0, 5, 10, 15], 0,
[b5.Ease.quartin, b5.Ease.quartin, b5.Ease.quartin]); my_object.timelines.add(timeline); // Add to timeline manager to be processed
In the above code we create a timeline with an animation that animates the x coordinate of the actor object. We add the timeline to the actors timeline manager to ensure that it is processed each frame.
Besides bitmap animation and timeline animations, its possible to use velocity to set off simple animations. For example, by setting the b5.Actor vr (rotation velocity) you can set it spinning at a specific speed.
Note that when an animation is finished playing it will automatically be destroyed and cleaned up unless its destroy property is set to false.
Page 57 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Input Events
All actors that are defined as touchable will receive touch input events as long as the scene that contains them is the focus or secondary focus scene. An actor is defined as touchable when the Actor.touchable property is set to true. When the app looks to determine which actor has potentially been touched the fewer actors it has to check the better, so this is a simple optimisation which enables only those actors that need to be checked for touch to be checked, whilst the rest can be comfortably ignored.
Actors can receive the following touch events:
• onTapped(touch_pos) – Called when actor tapped / clicked
• onBeginTouch(touch_pos) – Called when user is touching actor
• onEndTouch(touch_pos) – Called when user stops touching the actor
• onLostTouchFocus(touch_pos) – Called when actor loses touch focus, that is when the user drags their finger off the object but does not lift their finger from the screen
• onMoveTouch(touch_pos) – Called when a touch is moved over the actor
Lets take a look at a quick example: var actor = new b5.ArcActor(); actor.name = "actor1" ; actor.fill_style = "#0000ff" ; actor.radius = 100; actor.filled = true ; actor.touchable = true ; scene.addActor(actor); actor.onBeginTouch = function (touch_pos) {
console.log( "Started touching actor " + this .name);
}; actor.onEndTouch = function (touch_pos) {
console.log( "Stopped touching actor " + this .name);
};
Note that in order for a child actor to receive input events its parent must also be touchable, otherwise touch events will not be passed down the chain.
In the case of overlapping actors, only the top most actor will receive the touch event. You can change this behaviour by allowing touch events from child actors to be passed back up to their parents by setting b5.Actor.bubbling to true, the default behaviour is to not pass events up to parents. Event bubbling is useful especially when creating user interface components. For example, in the list menu demo, the buttons that are contained within the scrolling menu actor are marked as bubbling to enable touch events to be passed to the container which in turn allows the user to scroll the list around whilst still touching child buttons.
Lets take a quick look at an example of event bubbling: var actor = new b5.ArcActor(); actor.name = "actor1" ; actor.fill_style = "#0000ff" ; actor.radius = 100; actor.filled = true ;
Page 58 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood actor.touchable = true ; scene.addActor(actor); actor.onBeginTouch = function (touch_pos) {
console.log( "Started touching actor " + this .name);
}; actor.onEndTouch = function (touch_pos) {
console.log( "Stopped touching actor " + this .name);
}; var child1 = new b5.ArcActor(); child1.name = "child1" ; child1.fill_style = "#00ffff" ; child1.radius = 50; child1.filled = true ; child1.touchable = true ; child1.bubbling = true ; actor.addActor(child1); child1.onBeginTouch = function (touch_pos) {
console.log( "Started touching child actor " + this .name);
}; child1.onEndTouch = function (touch_pos) {
console.log( "Stopped touching child actor " + this .name);
};
You will notice that if you click the cyan coloured circle both touch event handlers for actor and child1 will be called.
Depth
Actors can have 3D depth using the b5.Actor.depth property. For values of greater than 0, the actor will be projected into the screen using the centre of the scene as the projection origin. This is ideal for creating effects such as parallax scrolling where objects in the background move more slowly and appear smaller than objects in the foreground. The parallax scrolling and planets demos show good examples of using depth.
Orphans
An orphan is an actor that sits inside another actors child hierarchy but does not obey its visual transform. This is useful in areas of game play where you need to generate game objects that are attached to the actor but do not follow it. To turn an actor into an orphaned actor simple set its b5.Actor.orphaned property to true.
Page 59 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Virtual Canvas
Actors can be made to act like a scrollable container for their children. This can be done by converting the actor into a virtual canvas actor, which gives the actor a virtual area that the user can scroll the children around in. This type of functionality is perfect for various types of user interface elements such as grids and lists.
When an actor has been made virtual using b5.Actor.makeVirtual(), or by setting true for virtual to the Actor constructor the following properties become available:
• scroll_pos_x – Canvas scroll X position
• scroll_pos_y – Canvas scroll Y position
• scroll_vx – Canvas scroll X velocity
• scroll_vy – Canvas scroll Y velocity
• scroll_range – Scrollable range of canvas (left, top, width, height)
• prev_scroll_pos_x – Previous canvas scroll X position
• prev_scroll_pos_y – Previous canvas scroll Y position
Lets take a quick look at a virtual canvas actor example: var actor = new b5.RectActor(); actor.name = "actor1" ; actor.fill_style = "#0000ff" ; actor.w = 400; actor.h = 400; actor.filled = true ; actor.touchable = true ; scene.addActor(actor); actor.makeVirtual(); actor.scroll_range = [-150, -150, 300, 300]; var child1 = new b5.ArcActor(); child1.name = "child1" ; child1.fill_style = "#00ffff" ; child1.radius = 50; child1.filled = true ; child1.touchable = true ; child1.bubbling = true ; actor.addActor(child1);
In the above example actor acts as a parent for child1, actor has been converted to a virtual canvas actor which can now scroll its content around. Note that we set the scroll_range after the actor has been made virtual and that the child actor uses bubbling to ensure that touch events are passed up to the actor parent.
In addition to the virtual scrolling area, virtual actors also allow child actors to be docked around their edges using b5.Actor.dock_x and b5.Actor.dock_y.
You can see an demo of a virtual actor in the list menu demo .
Page 60 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Shadows and Composite Operations
Actors can be made to render a drop shadow around their edges by setting b5.Actor.shadow to true. When shadowing is enabled the following properties can be used to adjust how the shadow appears:
• shadow_x, shadow_y – Shadow position offset
• shadow_blur – Amount to blur shadow
• shadow_colour- Colour of shadow (e.g. #ffffff)
Lets take a quick look at an example of how to use shadows: var actor = new b5.RectActor(); actor.fill_style = "#0000ff" ; actor.w = 200; actor.h = 200; actor.filled = true ; actor.shadow = true ; actor.shadow_x = 20; actor.shadow_y = 20; actor.shadow_blur = 2; actor.shadow_colour = "#000000" ; scene.addActor(actor);
Shadows should be used sparingly as they can be quite slow to render on some devices.
Actors can be rendered using a variety of different composite operations by setting b5.Actor.composite_op to one of the following:
• source-over- displays the source image over the destination image (default)
• source-atop – displays the source image on top of the destination image. The part of the source image that is outside the destination image is not shown
• source-in – displays the source image in to the destination image. Only the part of the source image that is INSIDE the destination image is shown, and the destination image is transparent
• source-out – displays the source image out of the destination image. Only the part of the source image that is OUTSIDE the destination image is shown, and the destination image is transparent
• destination-over – displays the destination image over the source image
• destination-atop – displays the destination image on top of the source image. The part of the destination image that is outside the source image is not shown
• destination-in – displays the destination image in to the source image. Only the part of the destination image that is INSIDE the source image is shown, and the source image is transparent
• destination-out – displays the destination image out of the source image. Only the part of the destination image that is OUTSIDE the source image is shown, and the source image is transparent
• lighter – displays the source image + the destination image
• copy – displays the source image. The destination image is ignored
• xor – the source image is combined by using an exclusive OR with the destination image
Page 61 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Lets take a quick look at an example of how to use composite operations: var actor1 = new b5.RectActor(); actor1.fill_style = "#0000ff" ; actor1.w = 200; actor1.h = 200; actor1.filled = true ; scene.addActor(actor1); var actor2 = new b5.RectActor(); actor2.fill_style = "#ff0000" ; actor2.x = 100; actor2.y = 100; actor2.w = 200; actor2.h = 200; actor2.filled = true ; actor2.composite_op = "lighter" ; scene.addActor(actor2);
Page 62 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Cached Rendering for Speed
Whilst HTML5 has come along leaps and bounds, it still has speed issues on some mobile devices. I have found that most of these bottle necks are due to rendering shapes, gradient fills and text. To combat this problem caching is built into the actor system. When an actor is marked as cached it is rendered to an off screen HTML5 canvas. When the actor is drawn at a later stage the pre-rendered canvas is drawn instead. This means that gradient fills and shape renders are only done a single time. To mark an actor as cached simply set b5.Actor.cache to true, the next time it is drawn it will be cached. The only downside to this is that once cached you lose some control over the actor, for example when you cache a label you can no longer change the text without firstly destroying the old cache and causing the actor to be re-rendered to the canvas.
Lets take a quick look at an example of how to cache an actor: var actor = new b5.LabelActor(); actor.w = 300; actor.h = 100; actor.font = "30pt Calibri" ; actor.fill_style = "#000000" ; actor.text = "Hello World" ; actor.cache = true ; scene.addActor(actor);
In the above example, setting the actors cache to true has caused the actor to be cached.
Note however that if you do not set the width and height of the actor to a large enough size then the actors content will be clipped. For example, if you change the width of the above actor to 100 you will see that only the central portion of the text will be displayed.
We can take caching one step further using merged caching. Merged caching is the process of merging multiple actors into the same cache, saving on extra memory required for all those off screen canvases. Child actors can be marked as merged via b5.Actor.merge_cache, this causes them to be rendered into a parent cache if one is available. However, when a child actor is merged into its parents cache you can no longer change its position, scale, rotation or opacity.
Tagging
Its sometimes useful to be able to group actors together using some kind of common tag.
All actors contain the tag property which is a string that can be used to tag a group of actors that are somehow related. For example, all actors are bullets.
The scene class contains the b5.Scene.removeActorsByTag(tag_name) method which enables you to remove a collection of actors that all have the same tag. This is very useful for removing a complete group of game objects from the scene. For example, if you want to clear up all bullets in a space shooter, tag them all with “bullet” then call scene. removeActorsByTag(“bullet”) to remove them all at the same time.
Page 63 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Ignoring the Camera
By default all game objects will move in relation to the scenes camera. Whilst this is a nice feature, its not always what we want. For example, if you have a number of game objects that are part of the HUD, you will want them to stay still when the camera moves. By setting b5.Actor.ignore_camera to true these actors will not move with the camera.
Particle Systems
A particle system is a special sort of actor that can handle the generation / re-generation of particle actors. To use a particle system actor you create an instance of b5.ParticleActor
then create and add individual actor particles, specifying a life span (the amount of time the particle exists), a spawn delay (the amount of time to wait before spawning the particle) and the total number of times the particle can be reborn. When a particle system has no particles left alive it will be destroyed. A ParticleActor is derived from an Actor and inherits all of its properties, functions and so forth from its parent, so it can be moved around, rotated, placed under the control of physics etc..
Lets take a quick look at an example that shows how to create a particle actor:
// Create particles actor var particles = new b5.ParticleActor(); scene.addActor(particles);
// Create and add 50 particles for ( var t = 0; t < 50; t++)
{ var particle = new b5.ArcActor();
particle.atlas = scene.findResource( "lives" , "brush" );
particle.radius = 50;
particle.fill_style = "#ffff00" ;
particle.vx = Math.random() * 100 - 50;
particle.vy = -200;
particle.vo = -2;
particle.vsx = -1;
particle.vsy = -1;
particles.addParticle(particle, 1, 1, t * 0.05);
}
A number of utility methods within the ParticleActor class are available for creating different types of effects easier:
• b5.ParticleActor generateExplosion() - Generates an explosion particles actor
• b5.ParticleActor generatePlume - Generates a a smoke / fire plume particles actor
• b5.ParticleActor generateRain - Generates a rain / snow particles actor
Lets take a quick look at an example that shows how to create an explosion one of the utility methods:
// Create explosion var particles = new b5.ParticleActor(); scene.addActor(particles); particles.generateExplosion(10, b5.ArcActor, 1, 200, 1, 10, 1, {
fill_style: "#ffa0e0" ,
Page 64 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
radius: 30,
vsx: 1.5,
vsy: 1.5,
});
The last property passed to generateExplosion() is a properties list that will be transferred to all generated particles.
Page 65 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Tiled Maps
Tile maps are an age old solution to storing large sprawling environments on memory constrained devices which stretches back to the first 8-bit computer games. Instead of storing one huge image the image is built up of small evenly sized images (tiles) that are used to rebuild the image by displaying those tiles in a grid arrangement.
Booty5 supports tiled maps via the b5.MapActor. The MapActor supports the following features:
•
Maps of any size and shape
•
Visual and collision tiles
•
Display of sub area for optimal display
•
Auto tile generation
Lets take a look at an example of how to create a MapActor in code: var map = new b5.MapActor(); // Create instance of actor map.map_width = 100; // Set map width in cells map.map_height = 100; // Set map height in cells map.display_width = 16; // Set how many cells to display on x axis map.display_height = 16; // Set how many cells to display on y axis map.generateTiles(32, 64, 64, 256); // Generate the tile set map.bitmap = new b5.Bitmap( "tiles" , "testmap.png" , true ); // Set tile set bitmap for ( var t = 0; t < map.map_width * map.map_height; t++) // Genmerate a random map
map.map.push((Math.random() * 32) << 0); scene.addActor(map); // Add to scene for processing and drawing
In the above example we create a 100x100 cell map of 64x64 pixel tiles, generate a tile set with 32 tiles then fill it with randomly selected tiles from the tile set.
MapActors have a special feature that can drastically improve the performance when rendering the map. Instead of attempting to render the entire 100x100 cell map every game frame the map_width and map_height properties can be used to specify a sub area of the map to display. The MapActor will take into account the actos position and the camera position to decide which section of the map to display to ensure that the ceklls are always displayed in relation to the cameraas position, this allows the game to scroll the map around and only display cells that are around the camera.
Note that map_width and map_height should be large enough to ensure that the displayed area overhands the edges of the screen, otherwise you will see tiles appear / disappear at the edges.
The MapActor has also been provided with a number of query functions that can be used top determine the tile at positions in the scene
Page 66 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Speeding up Rendering
Each actor can be set to ruond its rendered pixel coordinate up to the nearest integer value which can significantly speed up the rendering of game objects. However, the downside of using this feature is that you will lose visual precision. To force an actor to round pixels set its round_pixels property to true.
Miscellaneous
Testing for actor overlap
You can test if two actors overlap by calling b5.Actor.overlaps(other_actor). Note that this method currently does a simple test and does not take into account shape, orientation, origin or scale.
Transforming a point by an actors transform
You can transform an x,y point by an actors current transform using b5.Actor.transformPoint(x, y)
Test a point for actor hit
You can test to see if an x,y point hits an actor by calling b5.Actor.hitTest(position), where position is {x, y}
Page 67 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actor Public Properties
• name – Name of actor (used to find game objects in the scene)
• tag – Tag (used to find groups of game objects in the scene)
• id – User defined ID
• active – Active state, will not be updated when inactive (update method will not be called)
• visible – Visible state, will not be draw if invisible (draw method will not be called)
• touchable – Touchable state, true if can be touched / clicked and will receive touch events
• layer – Visible sorting layer
• x – X position in scene
• y – Y position in scene
• w – Visual width
• h – Visual height
• ox – X origin
• oy – Y origin
• absolute_origin – If true then ox and oy are taken as absolute coordinates, if false then ox and oy are taken as percentage of width and height
• rotation – Rotation in radians
• scale_x – X scale
• scale_y – Y scale
• depth – Z depth (3D depth), 0 represents no depth
• opacity – Opacity (between 0 and 1)
• use_parent_opacity – Scale opacity by parent opacity fi true
• current_frame – Current bitmap animation frame
• frame_speed – Bitmap animation playback speed in seconds
• anim_frames – An array of frame indices, if set then current frame will be read from this array
• bitmap – Bitmap (used if no atlas defined)
• atlas – Image atlas
• vr – Rotational velocity (when no physics body attached)
• vx – X velocity (when no physics body attached)
• vy – Y velocity (when no physics body attached)
• vd – Depth velocity, rate at which depth changes
• vr_damping – Rotational damping (when no physics body attached)
• vx_damping – X velocity damping (when no physics body attached)
• vy_damping – Y velocity damping (when no physics body attached)
• vd_damping – Depth velocity damping
• ignore_camera – If set to true them then this game object will not use camera translation
• wrap_position – If true then game object will wrap at extents of scene
• dock_x – X-axis docking (0 = none, 1 = left, 2 = right)
• dock_y – Y-axis docking (0 = none, 1 = top, 2 = bottom)
• margin – Margin to leave around game object when it has been docked [left, right, top, bottom]
• bubbling – If true then touch events will be allowed to bubble up to parents
• clip_children – If set to true then children will be clipped against extents of this one
• clip_margin – Margin to leave around clipping [left, top, right, bottom]
• clip_shape – If set then this shape will be used to clip, otherwise the usual extents / shape of this game object will be used to clip
Page 68 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• self_clip – If set to true then this game object will be clipped against its own clipping
• orphaned – If true then will ignore parent transforms
• virtual – Set to true if supports a virtual canvas
• anim_frames – Array of animation frame indices, if not set then frames will be used in order specified in the atlas
• shadow – When set to true this object will show a shadow
• shadow_x, shadow_y – Shadow offset
• shadow_blur – Amount to blur shadow
• shadow_colour – Colour of shadow (e.g #ffffff)
• composite_op – Composite operation to use when drawing this object (e.g sourceover)
• cache – When set to true this actors rendering will be cached (does not apply down the entire child hierarchy)
• merge_cache – When set to true, will try to render this object into a parent cache, if one is available
• round_pixels – When set to true, vertices will be rounded to integer which can speed up rendering significantly but at a loss of precision
Actor Internal Properties
• type – Actor type
• scene – Parent Scene
• parent – Parent actor (If null then this game object does not belong to an hierarchy)
• actors – Array of child actors
• removals – Array of actors that should be deleted at end of frame
• joints – Array of physics joints that are attached
• timelines – A timeline manager that contains and manages animations local to this game object
• actions – An actions list manager that contains and manages actions local to this game object
• frame_count – Number of frames that this object has been running
• accum_scale_x – Accumulated X scale
• accum_scale_y – Accumulated Y scale
• accum_opacity – Accumulative opacity
• body – Box2D body
• transform – Current transform
• transform_dirty – If set to true then transforms will be rebuilt next update
• touching – Set to true when user is touching
• touchmove – Set to true when touch is moving on this game object
• layer – The visible layer that this object sits on
• order_changed – When layer changes this property is marked as true to let the system know to resort all objects on the layer
• cache_canvas – A canvas that contains cached drawing for this actor
Page 69 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Virtual Actor Properties
These properties are only available if created as a virtual canvas or is made to support a virtual canvas using makeVirtual()
• scroll_pos_x – Canvas scroll X position
• scroll_pos_y – Canvas scroll Y position
• scroll_vx – Canvas scroll X velocity
• scroll_vy – Canvas scroll Y velocity
• scroll_range – Scrollable range of canvas (left, top, width, height)
• prev_scroll_pos_x – Previous canvas scroll X position
• prev_scroll_pos_y – Previous canvas scroll Y position
Actor Setters
•
_x – Sets the x property
•
_y – Sets the y property
•
_ox – Sets the ox property
•
_oy – Sets the oy property
•
_rotation – Sets the rotation property
•
_scale – Sets both x and y scale property to the same value
•
_scale_x – Sets the scale_x property
•
_scale_y – Sets the scale_y property
•
_depth – Sets the depth property
•
_layer – Sets visible layer
•
_atlas – Sets the ImageAtlas from a path to or an instance of an ImageAtlas
•
_bitmap – Sets the Bitmap from a path to or an instance of a Bitmap
•
_clip_shape – Sets the slipping shape from a path to or an instance of a Shape
Note: Use these setters instead of the likes of x, y, ox, oy etc.. to ensure that this game objects internal transform gets updated.
Actor Constants
•
Actor.Dock_None
– No docking
•
Actor.Dock_Left
– Docks to the left edge
•
Actor.Dock_Right – Docks to the right edge
•
Actor.Dock_Top
– Docks to the top edge
•
Actor.Dock_Bottom
– Docks to the bottom edge
Page 70 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actor Events
• onCreate() – Called just after creation
• onDestroy() – Called just before destruction
• onTick(delta_time) – Called each update (every frame)
• onTapped(touch_pos) – Called when tapped / clicked
• onBeginTouch(touch_pos) – Called when user is touching
• onEndTouch(touch_pos) – Called when user stops being touching
• onLostTouchFocus(touch_pos) – Called when object loses touch focus
• onMoveTouch(touch_pos) – Called when a touch is moved over the game object
• onCollisionStart(contact) – Called when this game object starts colliding with another
• onCollisionEnd(contact) – Called when this game object stops colliding with another
Actor Methods
•
Actor(virtual) – Creates instance of an Actor object
â—¦ virtual – If set to true then the actor will have a virtual canvas attached that can scroll / dock its child actors
• setPosition(x, y) – Sets the scene position (causes internal transform to be recalculated if values differ to existing values).
â—¦ x – X axis position
â—¦ y – Y axis position
• setPositionPhysics(x, y) – deprecated, use set setPosition instead
• setOrigin(x, y) – Sets the origin (causes internal transform to be recalculated if values differ to existing values).
â—¦ x – X axis origin
â—¦ y – Y axis origin
• setScale(x, y) – Sets the scale (causes internal transform to be recalculated if values differ to existing values).
â—¦ x – X axis scaling factor
â—¦ y – Y axis scaling factor
• setRotation(angle) – Sets the rotation angle (causes internal transform to be recalculated if values differ to existing values).
â—¦ angle – Rotation in radians
• setRotationPhysics(angle) – Deprecated, use setRotation instead
• setDepth(depth) – Sets the actors 3D depth (causes internal transform to be recalculated if values differ to existing values). Actors with a depth value of anything other than 0 and 1 will undergo perspective transformation, the affect of this is that the actor will be scaled in size depending upon distance, the actors position will also be adjusted to take into account its depth.
â—¦ depth – Depth value, 0 is the same as 1.0, greater values will project the actor further into the distance
• release() – Releases the actor, this is called by the scene or actor systems when an actor has been destroyed.
• destroy() – Begins the destruction of this game object, note that it will not actually be destroyed until the end of the scene or parent actors processing.
• changeParent(parent) – Changes the actors parent to the new parent
â—¦ parent – The new parent
• addActor(actor) – Adds an actor to this actors list of children
Page 71 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
â—¦ actor – The actor to add
• removeActor(actor) – Removes the specified actor from this actors list of children
â—¦ actor – The actor to remove
• removeActorsWithTag(tag) – Removes all child actors that have the specified tag.
â—¦ tag – A string tag
• cleanupDestroyedActors() – Cleans up all destroyed actors, this is called by the actor to clean up any removed actors at the end of its update cycle.
• findActor(name, recursive) – Searches child list for the named actor.
â—¦ name: The name of the actor
â—¦ recursive – If true then the complete child hierarchy will be searched
â—¦ returns the found actor or null if not found
• findFirstParent() – Travels up the child hierarchy to return the very first Actor parent
• updateParenTransforms() – Travels up the child hierarchy updating all parent transforms
• bringToFront() – Moves the actor to the end of the child list, bringing it to the front of all others in the parent.
• sendToBack() – Moves the actor to the start of the child list, pushing it to the back of all others in the parent.
• releaseBody() – Releases the attached physics body.
• releaseJoints() – Releases all attached physics joints.
• initBody(body_type, fixed_rotation, is_bullet) – Creates and attached a physics body to this actor, putting it under control of the Box2D physics system.
â—¦ body_type – Type of body, can be either static, dynamic or kinematic
â—¦ fixed_rotation – true if you want to fix rotation so that it cannot change
â—¦ is_bullet – true if this is a very fast moving game object
• addFixture(options) – Creates a new fixture and attaches it to the physics body.
â—¦ options – An object describing the fixtures properties
â–Ş type – Type of fixture (Shape.TypeBox, Shape.TypeCircle or
Shape.TypePolygon)
â–Ş density – Fixture density
â–Ş friction – Fixture friction
â–Ş restitution – Fixture restitution
â–Ş is_sensor – true if this fixture is a sensor
â–Ş width / height – Width and height of box (if type is box), or width is radius for circle type
â–Ş vertices – An array of vertices of form [x1, y1, x2, y2 etc] that define a shape (if type is polygon)
â–Ş material – A Material resource, if passed then density, friction, restitution will be taken from the material resource
â–Ş shape – A Shape resource, if passed then width, height, type and vertices will be taken from the shape resource
â—¦ returns the created fixture or in the case of a multi-fixture shape an array of fixtures
• addJoint(options) – Creates a new joint and attaches it to the physics body.
â—¦ options
â–Ş type – Type of joint to create (weld, distance, revolute, prismatic, pulley, wheel, mouse)
â–Ş actor_b – The other actor that this joint attaches to
â–Ş anchor_a – The joints anchor point on this body
â–Ş anchor_b – The joints anchor point on actor_b’s body
â–Ş self_collide – If set to true then actors that are connected via the joint will
Page 72 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood collide with each other
â–Ş frequency – Oscillation frequency in Hertz (distance joint)
â–Ş damping – Oscillation damping ratio (distance and wheel joints)
â–Ş limit_joint – If true then joint limits will be applied (revolute, prismatic, wheel joints)
â–Ş lower_limit – Lower limit of joint (revolute, prismatic, wheel joints)
â–Ş upper_limit – Upper limit of joint (revolute, prismatic, wheel joints)
â–Ş motor_enabled – if true then the joints motor will be enabled (revolute, prismatic, wheel joints)
â–Ş motor_speed – Motor speed (revolute, prismatic, wheel joints)
â–Ş max_motor_torque – Motors maximum torque (revolute joints)
â–Ş max_motor_force – Motors maximum force (prismatic, wheel, mouse joints)
â–Ş axis {x,y} – Movement x,y axis (prismatic, wheel joints)
â–Ş ground_a {x,y} – Ground offset for this actor (pulley joints)
â–Ş ground_b {x,y} – Ground offset for actor_b (pulley joints)
â—¦ returns the created joint
• removeJoint(joint) – Removes the specified joint from the joints list and destroys the joint.
â—¦ joint – The joint to remove and destroy
• updateTransform() – Forces the internal visual transform to update, call internally when the transform is dirtied.
• draw() – Draws this actor and its children, this method can be overriden by derived actors
• drawToCache() – Draws this actor to a cached canvas, subsequent calls to draw() will cause this cached canvas to be drawn instead
• preDraw() – Pre drawing shared functionality
• postDraw() – Post drawing shared functionality
• baseUpdate(dt) – Base update function that should be called by all derived actors that wish to use base actor functionality, this is usually called from your update() method.
â—¦ dt – The amount of time that has passed since last updated
â—¦ returns true if active
• update(dt) – Updates the actor, this method can be overriden by derived actors
â—¦ dt – The amount of time that has passed since the last update
â—¦ returns true if active
• updateToPhysics() – Copies actor velocities to the physics system
• dirty() – Dirties the game object and all child transforms
• hitTest(position) – Performs a test of the specified position against the boundaries of the actor returning true if a hit occurs
â—¦ position – The 2D position to test
• transformPoint(x, y) – Transforms the point into the actors coordinate system
â—¦ x,y – The 2D position to test
â—¦ returns the transformed point as a point object {x, y}
• overlaps(other) – Tests if two actors overlap
â—¦ other – The other actor to test for overlap
â—¦ returns true if both overlap
• makeVirtual() – Attaches a virtual canvas
• setClipping(context, x, y) – Used internally to set the clipping shape for this actor
â—¦ context – Display context
â—¦ x – x coordinate of clip
â—¦ y – y coordinate of clip
Page 73 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actor Examples
Basic actor creation
var actor = new b5.Actor(); actor.x = 100; actor.y = 100; actor.w = 200; actor.h = 200; scene.addActor(actor); // Add to scene
Adding a bitmap image to an actor
actor.bitmap = new b5.Bitmap( "background" , "images/background.jpg" , true );
Adding a bitmap image from the scene resources to an actor
actor.bitmap = scene.findResource( "background" , "bitmap" );
Adding a bitmap image from the scene resources to an actor using a path
actor._bitmap = "scene1.bitmap" ;
Adding basic physics to an actor
actor.initBody( "dynamic" , false , false ); // Initialise physics body actor.addFixture({type: b5.Shape.TypeBox, width: actor.w, height: actor.h}); // Add a physics fixture
Adding a physics joint
actor.addJoint({ type: "weld" , actor_b: actor2, anchor_a: { x: 0, y: 0 }, anchor_b: { x: 0, y: 0 }, self_collide: true });
Adding bitmap animation to an actor
// Create an image atlas from a bitmap image actor.atlas = new b5.ImageAtlas( "sheep" , new b5.Bitmap( "sheep" , "images/sheep.png" , true )); actor.atlas.addFrame(0,0,86,89); // Add frame 1 to the atlas actor.atlas.addFrame(86,0,86,89); // Add frame 2 to the atlas actor.frame = 0; // Set initial animation frame actor.frame_speed = 0.5; // Set animation playback speed
Add a child actor
var child_actor = new b5.Actor(); // Create child actor actor.addActor(child_actor); // Add as child actor
Adding an onTick event handler to an actor
actor.onTick = function (dt) { this .x++;
};
Adding touch event handlers to an actor
Page 74 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood actor.touchable = true ; // Allow actor to be tested for touches actor.onTapped = function (touch_pos) {
console.log( "Tapped" );
}; actor.onBeginTouch = function (touch_pos) {
console.log( "Touch begin" );
}; actor.onEndTouch = function (touch_pos) {
console.log( "Touch end" );
}; actor.onMoveTouch = function (touch_pos) {
console.log( "Touch move" );
};
Docking an actor to the edges of the scene
actor.dock_x = b5.Actor.Dock_Left; actor.dock_y = b5.Actor.Dock_Top; actor.ignore_camera = true ;
Adding an actions list
var actions_list = new b5.ActionsList( "moveme1" , 0); actions_list.add( new b5.A_MoveWithSpeed(actor,100,2,b5.Ease.linear)); actor.actions.add(actions_list).play();
Create a particle explosion
var particles = new b5.ParticleActor(); scene.addActor(particles); particles.generateExplosion(10, b5.ArcActor, 1, 200, 1, 10, 1, {
fill_style: "#ffa0e0" ,
radius: 30,
vsx: 1.5,
vsy: 1.5,
});
ArcActor Properties
• fill_style – Style used to fill the arc
• stroke_style – Stroke used to draw none filled arc
• stroke_thickness – Thickness of line stroke
• radius – Radius of arc
• start_angle – Start angle of arc in radians
• end_angle – End angle of arc in radians
• filled – if true then arc interior will filled otherwise empty
Page 75 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
ArcActor Methods
•
ArcActor() – Creates an instance of an ArcActor object
• draw() – Draws an arc actor and its children, this method can be overridden by derived actors
• drawToCache() – Draws this actor to a cached canvas, subsequent calls to draw() will cause this cached canvas to be drawn instead
• update(dt) – Updates the actor, this method can be overridden by derived actors
â—¦ dt – The amount of time that has passed since this actor was last updated
• hitTest(position) – Performs a test of the specified position against the circular boundaries of the actor returning true if a hit occurs
â—¦ position – The 2D position to test
LabelActor Properties
• text – The text to display
• font – The font to display the text in
• text_align – Text horizontal alignment
• text_baseline – Text vertical alignment
• fill_style – Fill style for filled text
• stroke_style – Stoke style for none filled text
• stroke_thickness – Thickness of line stroke
• filled – When true filled text will be drawn
LabelActor Methods
•
LabelActor() – Creates an instance of a LabelActor
• draw() – Draws an arc actor and its children, this method can be overridden by derived actors
• drawToCache() – Draws this actor to a cached canvas, subsequent calls to draw() will cause this cached canvas to be drawn instead
• update(dt) – Updates the actor, this method can be overridden by derived actors
â—¦ dt – The amount of time that has passed since this actor was last updated
• draw() – Draws the actor, this version is specific to drawing text instead of images
(called internally)
Page 76 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
ParticleActor Properties
gravity – The amount of gravity to apply to particles within the system onParticlesEnd() – This callback function is called when the particle actor runs out of particle onParticleLost(particle) – This callback function is called each time a particle is about to be destroyed. Returning false will prevent the particle from being destroyed allowing it to be re-used
Additional particle properties
• vo – Opacity velocity
• vsx – X axis scale velocity
• vsy – Y axis scale velocity
ParticleActor Methods
•
ParticleActor() – Creates an instance of a ParticleActor
• resetParticle(actor) – Resets the particle to its initial spawn state (used internally)
• addParticle(actor, life_span, num_lives, spawn_delay) – Adds an actor to the particle system as a particle
â—¦ actor – The actor to add as a particle
â—¦ life_span – The life span of the particle in seconds
â—¦ num_lives – The number of times a particle will re-spawn before it is destroyed
(0 for infinite)
â—¦ spawn_delay – The number of seconds to wait before spawning this particle
â—¦
Returns the created particle actor
• update(dt) – Updates the actor, this method can be overridden by derived actors
â—¦ dt – The amount of time that has passed since this actor was last updated
• generateExplosion(count, type, duration, speed, spin_speed, rate, damping, properties) – Utility method that automatically generates an explosion type particle system
â—¦ count – Total number of particles to create
â—¦ type – The actor type of each particle created, for example b5.ArcActor or
“ArcActor”
â—¦ duration – The total duration of the particle system in seconds
â—¦ speed – The speed at which the particles blow apart
â—¦ spin_speed – The speed at which particles spin
â—¦ rate – rate at which particles are created
â—¦ damping – A factor to reduce velocity of particles each frame, values greater than 1 will increase velocities
â—¦ properties – A collection of actor specific properties that will be assigned to each created particle
• generatePlume(count, type, duration, speed, spin_speed, rate, damping, properties) - Utility method that automatically generates a smoke plume type particle system
â—¦ count – Total number of particles to create
â—¦ type – The actor type of each particle created, for example b5.ArcActor or
“ArcActor”
â—¦ duration – The total duration of the particle system in seconds
Page 77 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
â—¦ speed – The speed at which the particles rise
â—¦ spin_speed – The speed at which particles spin
â—¦ rate – rate at which particles are created
â—¦ damping – A factor to reduce velocity of particles each frame, values greater than 1 will increase velocities
â—¦ properties – A collection of actor specific properties that will be assigned to each created particle
• generateRain(count, type, duration, speed, spin_speed, rate, damping, width, properties) – Utility method that automatically generates weather effects such as rain
â—¦ count – Total number of particles to create
â—¦ type – The actor type of each particle created, for example b5.ArcActor or
“ArcActor”
â—¦ duration – The total duration of the particle system in seconds
â—¦ speed – The speed at which the particles fall
â—¦ spin_speed – The speed at which particles spin
â—¦ rate – rate at which particles are created
â—¦ damping – A factor to reduce velocity of particles each frame, values greater than 1 will increase velocities
â—¦ width – The width of the area over which to generate particles
â—¦ properties – A collection of actor specific properties that will be assigned to each created particle
PolygonActor Properties
• fill_style – Style used to fill the arc
• stroke_style – Stroke used to draw none filled arc
• stroke_thickness – Thickness of line stroke
• filled – if true then arc interior will filled otherwise empty
• points – An array of points that describe the shape of the actor in the form
[x1,y1,x2,y2,....]
PolygonActor Methods
•
PolygonActor() – Creates an instance of a PolygonActor object
• draw() – Draws a polygon actor and its children, this method can be overridden by derived actors
• drawToCache() – Draws this actor to a cached canvas, subsequent calls to draw() will cause this cached canvas to be drawn instead
• update(dt) – Updates the actor, this method can be overridden by derived actors
â—¦ dt – The amount of time that has passed since this actor was last updated
RectActor Properties
• fill_style – Style used to fill the rect
• stroke_style – Stroke used to draw none filled rect
• stroke_thickness – Thickness of line stroke
• filled – if true then rect interior will filled otherwise empty
• corner_radius – Radius of corner for rounded rects
Page 78 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
RectActor Methods
•
RectActor() – Creates an instance of a RectActor object
• draw() – Draws a rect actor and its children, this method can be overridden by derived actors
• drawToCache() – Draws this actor to a cached canvas, subsequent calls to draw() will cause this cached canvas to be drawn instead
• update(dt) – Updates the actor, this method can be overridden by derived actors
â—¦ dt – The amount of time that has passed since this actor was last updated
MapActor Properties
• tiles – The tile set array, each tile contains {x, y} which represents the top left hand corner of the tile in the source bitmap
• map – An array of tile indices into the tiles set that represents the visual map
• collision_map – An array of collision tile indices into the collision tiles set that represents the collision map
• tile_width – Width of tiles in the tile set
• tile_height – Height of tiles in the tile set
• map_width – Width of map in cells
• map_height – Height of map in cells
• display_width – Number of cells to display across the screen
• display_height – Number of cells to display down the screen
MapActor Methods
•
MapActor() – Creates an instance of a MapActor object
• draw() – Draws an arc actor and its children, this method can be overridden by derived actors
• generateTiles(count, tile_w, tile_h, bitmap_w) – Generates a tile set from the supplied parameters
â—¦ count – Total tiles to generate
â—¦ tile_w – Width of each generated tile
â—¦ tile_h – Height of each generated tile
â—¦ bitmap_w – Width of the source tile bitmap
• setTile(x, y, tile, collision) – Sets the tile at cell x,y
â—¦ x – Map horizontal cell coordinate
â—¦ y – Map vertical cell coordinate
â—¦ tile – Tile number
â—¦ collision – If true then tile in the collision map will be written instead of visual map
• getTile(x, y, collision) – Gets the tile at cell x,y
â—¦ x – Map horizontal cell coordinate
â—¦ y – Map vertical cell coordinate
â—¦ collision – If true then returned tile will be taken from collision map instead of visual map
â—¦ returns tile at coordinate
• getTileXY(x, y) – Converts the supplied scene coordinate to a map cell coordinate
â—¦ x – x-axis coordinate in scene space
â—¦ y – y-axis coordinate in scene space
Page 79 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
â—¦ returns {x, y} map coordinate
• getTilePosition(x, y) – Calculates the scene coordinate for the specified edge of a tile
â—¦ x – x-axis coordinate in scene space
â—¦ y – y-axis coordinate in scene space
â—¦ position – Can be one of the following strings:
â–Ş t – Returns coordinate of top edge of tile
â–Ş m – Returns coordinate of middle of tile
â–Ş b – Returns coordinate of bottom edge of tile
â–Ş l – Returns coordinate of left edge of tile
â–Ş c – Returns coordinate of centre of tile
â–Ş r – Returns coordinate of right edge of tile
â—¦ returns {x, y} map coordinate of tile edge
• getTileFromPosition(x, y, collision) – Gets the tile at cell position x, y
â—¦ x – Scene coordinate on x-axis
â—¦ y – Scene coordinate on y-axis
â—¦ collision – If true then returned tile will be taken from collision map instead of visual map
â—¦ returns tile at coordinate
Page 80 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Resources – The Stuff that Games are Made of
Introduction
One of the central features of Booty5 is the management of resources. Resources are assets that the game needs to help it function such as bitmaps and sound effects. Booty5 supports a number of different types of resources including:
•
Bitmaps – Bitmaps are represented by bitmap files
•
Sounds – Sounds are represented by audio files
•
Brushes – Brushes represent something that can draw a game object, such as an
ImageAtlas or a Gradient
•
Shape – Shapes are geometric shapes that can be used for clipping, rendering, physics fixtures and paths
•
Materials – Materials represent physical materials that can affect how physics objects behave and interact
Resources can be stored and managed locally by scenes or globally by the main App object. Local resources are loaded with the scene and destroyed when the scene is destroyed, whilst global resources are loaded and managed by the global App object and will remain in memory for the duration of the application or until removed manually. This type of resource management system is useful when dealing with games that run on resource constrained devices such as mobile phones.
Each resource has its own name which should be unique to its category of resource that can be used to find the resource at a later date. For example, you should not have two images called “player”, although you can have an image called player and a shape called
“player”.
You can add a resource to a scene or the main App by calling addResource(), e.g.:
// Create a bitmap resource var bitmap = new b5.Bitmap( "background" , "images/background.jpg" , true );
// Add to a scene to be managed scene.addResource(bitmap, "bitmap" );
Resources can be manually removed from a scene or the main App by calling removeResource(), e.g.: scene.removeResource(bitmap, "bitmap" );
You can also call destroy() on the resource to remove and destroy it, e.g.: bitmap.destroy();
Once a resource has been added to a resource manager it can later be searched for using findResource(), e.g.: var bitmap = scene.findResource( "background" , "bitmap" );
Page 81 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Note that if you call the scene version of findResource() and the resource is not found in the scene then it will automatically check the global App's resource list.
Resource Paths
All resources in Booty5 can be located using their child hierarchy path. A child hierarchy path is a string that consists of the names of the parents separated by dots. For example, if you want to locate a physics material called “material1” that is located in a scene named
“scene1” then the path to that resources would be “scene1.material1”. If the material was located in the Apps global resource space then the path would simply be “material1”. To find the instance of the resource from the path you can call b5.Utils.findResourceFromPath(path, type), e.g.: var material = b5.Utils.findResourceFromPath( "scene1.material1" , "material" );
This method of locating a resource is so convenient that many parts of the Booty5 engine utilise it. For example, all resources that are passed to actions accept either an instance of a resource or a path to the resource. Many object properties also accept paths, such as b5.Actor._clip_shape and b5.Actor.bitmap etc...
Scenes, actors, timelines and actions lists can also be searched for using paths using the b5.Utils.findObjectFromPath(path, type), where type can be timeline, actions or null for scene / actor.
Bitmap Resources
Bitmap resources are resources that hold image data that is loaded from a file. Bitmaps are commonly used as the visual representation for sprites (Actors). To create a bitmap you create an instance of a b5.Bitmap class, for which the prototype is: b5.Bitmap(name, location, preload, onload)
Where name is the name of the Bitmap object, location is the location of the bitmap, preload is a flag that tells Booty5 to load the image immediately and onload is an optional callback function which will be called when the bitmap has finished loading.
Lets take a quick look at an example: var bitmap = new b5.Bitmap( "player" , "images/player_anims.png" , true );
Lets take a quick look at an example of how to create a Bitmap that notifies us when it has finished loading: var bitmap = new b5.Bitmap( "player" , "Textures.png" , true , function (b) {
console.log( "bitmap loaded " + b.name);
});
You can check to see if a Bitmap has finished loading by checking its loaded property.
You can tell a Bitmap to load itself by calling b5.Bitmap.load().
Bitmaps are usually assigned to an Actor via its bitmap property or _bitmap property
Page 82 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood setter. Remember that a property setter can take an instance of a resource or a path to a resource.
If you intend to manage the Bitmap yourself then you do not need to add the Bitmap to a scene or the main App objects resource managers.
Bitmaps can also be assigned to an ImageAtlas brush if the bitmap contains multiple subimages. More on this later.
Sound Resources
Sound resources are resources that hold audio data that is loaded from a file. Sounds are commonly used to play back music and sound effects. To create a sound you create an instance of a b5.Sound class, for which the prototype is: b5.Sound(name, location, reuse)
Where name is the name of the Sound object, location is the location of the sound file, reuse is a flag that tells Booty5 that it should be created only once and re-used.
Lets take a quick look at an example: var sound = new b5.Sound( "explosion" , "sounds/explosion.mp3" , true );
Sounds are usually added to a scene or the main App object for management
Because not all sound file types are supported across all platforms, Booty5 supports a fallback option when loading sound effects by assigning a second sound effect to the
Sound object, if the first sound fails to load then Booty5 will attempt to load the second,e.g.: var sound = new b5.Sound( "explosion" , "sounds/explosion.ogg" , true ); sound.location2 = "sounds/explosion.mp3" ;
In the above example, if the ogg sound file fails to load then Booty5 will attempt to load the mp3 instead.
A sound can be made to automatically play once loaded by setting its auto_play property to true.
You can tell a Sound to load itself by calling b5.Sound.load().
You can play, stop and pause a playing sound by calling b5.Sound.play(), b5.Sound.stop() and b5.Sound.pause(). When you call play() an instance of the created HTML5 Audio object (or equivalent) will be returned. You can also get access to this instance via b5.Sound.snd property. Note that in the case of playing multiple copies of the same sound, a different instance of Audio will be returned for each one if the sound is not set as reuse.
Note that if using the Web Audio API then an object consisting of {source, gain} is returned from play(), where source represents the AudioBufferSourceNode and gain the
GainNode. You can use the GainNode to modify the volume of the sound, e.g.:
Page 83 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood var sound = music.play(); sound.gain.gain.value = 0.5;
In addition, sound.snd will contain this object if the sounds auto_play property is set to true.
The sound can be told to loop by setting b5.Sound.loop to true.
One important note, when testing locally Web Audio sounds will not be played as they cannot be loaded locally, so disable web audio usage when testing locally.
Shape Resources
Shape resources are resources that hold information about a geometric shape or path.
Unlike bitmaps and sounds, shapes are not stored in separate files. Shapes are commonly used as the geometric visual representation for sprites, as fixtures for physics bodies, as clipping regions for actors and scenes or as paths for objects to follow. To create a Shape you create an instance of a b5.Shape class, for which the prototype is: b5.Shape(name)
Where name is the name of the Shape object. However, this only creates an instance of a
Shape object, we still need to fill in the rest of the information.
Shapes can be of 3 different kinds:
• b5.Shape.TypeBox – A rectangular box with width and height
• b5.Shape.TypeCircle – A circular shape with a radius
• b5.Shape.TypePolygon – A polygonal shape made from vertices
All 3 types can be used for rendering, physics fixtures and as clippers. However, only polygon shapes can be used as paths.
Lets take a quick look at an example that shows how to create a shape of each type:
// Create a box shape var box = new b5.Shape(); box.type = b5.Shape.TypeBox; box.width = 100; box.height = 50;
// Create a circle shape var circle = new b5.Shape(); circle.type = b5.Shape.TypeCircle; circle.width = 100;
// Create a polygon shape var polygon = new b5.Shape(); polygon.type = b5.Shape.TypePolygon; polygon.vertices = [0, -100, 100, 100, -100, 100];
Page 84 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Material Resources
Material resources are resources that hold information about physical properties of an object. Like Shapes, Materials are not stored in separate files. To create a Material you create an instance of a b5.Material class, for which the prototype is: b5.Material(name)
Where name is the name of the Material object. However, this only creates an instance of a Material object, we still need to fill in the rest of the information.
Materials carry the following pieces of information:
• type – Type of material (can be static, dynamic or kinematic), default is static
• density – Material density, higher values make for heavier objects, default is 1
• friction – Material friction, lower values make objects more slippery, default is 0.1
• restitution – Material restitution, higher values make the object more bouncy, default is 0.1
• gravity_scale – Gravity scale, lower values lessen the affects of gravity on the object, default is 1
• fixed_rotation – Set to true to prevent objects from rotating, default is false
You can use material properties when you add physics fixtures to an Actor, e.g.:
// Add a physics fixture from a shape and material actor.addFixture({ shape: circle_shape1, material: material1 });
Page 85 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Brush Resources
Brush resources are resources that are used to fill shapes and create bitmap animations.
Booty5 currently supports two kinds of brushes:
•
Gradient – A gradient brush is used to create fill styles that draw gradients on shape and text based actors (ArcActor, RectActor, PolygonActor and LabelActor)
•
ImageAtlas – An ImageAtlas brush is used to draw different bitmap animations frames on an Actor
Note that all brush types use the resource type “brush”, so when searching for a Gradient or ImageAtlas resource ensure that you search for the “brush” type.
Gradient
The Gradient is a an object that stores gradient information. A gradient is made up of a number of colour stops which define a colour and distance along the gradient at which the colour should appear. For example, if I specify a colour at distance 0 then this colour will appear at the start of the gradient. If I specify a distance of 1 then the colour will appear at the end of the gradient. All colour in between will be smoothly interpolated to create the gradient. Lets take a quick look at an example that shows how to create a gradient: var gradient = new b5.Gradient(); gradient.addColourStop( "#ff0000" , 0); gradient.addColourStop( "#00ff00" , 0.5); gradient.addColourStop( "#0000ff" , 1);
In the above example, we create a gradient with 3 colour stops:
•
A gradient stop with colour red at distance 0 (start of gradient)
•
A gradient stop with colour green at distance 0.5 (half way through the gradient)
•
A gradient stop with colour blue at distance 1 (end of gradient)
Once a Gradient has been created you should add it to a Scene or App resource manager so that it can be managed.
Once we have a gradient brush we can create a fill style from it and assign that to an
Actor to be rendered, e.g.:
// Create fill style from gradient var fill_style = gradient.createStyle(actor1.w, actor1.w, { x: 0, y: 0 }, { x: 1, y: 1 });
In the above example we call the b5.Gradient.createStyle() method to generate a fill style.
createStyle takes 4 parameters:
• w – Width of the gradient area (usually width of fill area)
• h – Height of the gradient area (usually height of fill area)
• start – Start point of gradient {x, y}
• end – End point of gradient {x, y}
To see the gradient we set it to either the fill_style or stoke_style of the actor.
Page 86 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
// Create an actor and assign the gradient fill style var actor = new b5.ArcActor(); actor.x = -100; actor.w = 100; actor.radius = 100; actor.filled = true ; actor.fill_style = fill_style; scene.addActor(actor);
ImageAtlas
Booty5 creates bitmap animations by displaying one image after another, or more accurately one area of an image after another. The ImageAtlas brush is used to store bitmap frame information as rectangular areas as well as a sprite sheet based bitmap image. Each frame of animation has an x,y location in the bitmap and a frame width and height. Animation is achieved by displaying those different areas over time.
Lets take a quick look at how to create an ImageAtlas: var atlas = new b5.ImageAtlas( "sheep" , sheep_bitmap); atlas.addFrame(0, 0, 86, 89); // Add frame 1 to the atlas atlas.addFrame(86, 0, 86, 89); // Add frame 2 to the atlas
In the above example we create an ImageAtlas object called sheep using the bitmap sheep_bitmap. We then add two frames, the first is located at x=0,y=0 in the bitmap and the second is located at x=86, y=0, both frames are the same size 86x89 pixels.
Once an ImageAtlas has been created you should add it to Scene or App resource manager so that it can be managed.
We can now assign this atlas brush to an actor to make it animate. Lets take a quick look at an example: var actor = new b5.Actor(); actor.w = 86; actor.h = 89; scene.addActor(actor); actor.atlas = atlas; actor.current_frame = 0; // Set initial animation frame actor.frame_speed = 1; // Set animation playback speed
In the above example we assign the atlas to the atlas property then set the frame_speed to begin the playback of the bitmap animation.
The b5.ImageAtlas.generate() method has been added to ImageAtlas to enable easy automatic generation of frames. Lets take a quick look at an example of how to use it: var atlas = new b5.ImageAtlas( "car_anim" , car_bitmap); atlas.generate(0, 0, 64, 32, 10, 20);
The above example will generate 20 animation frames each 64x32 pixels in size, starting at x=0,y=0 on the bitmap, picking 10 frames across the bitmap then moving down 32 pixels then picking another 10 frames.
Page 87 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Bitmap Properties
• name – The name of the bitmap, this name is used when searching for bitmap resources in a Scene’s resources or the the App’s global resources
• location – The location of the bitmap file that is used to create the image
• parent – The parent container
• onload – Callback function which will be called when the bitmap has been loaded
• loaded – Set to true when the bitmap has been loaded
•
Private properties
• image – An image object that represents the bitmap
Bitmap Methods
•
Bitmap(name, location, preload, onload) – Creates an instance of a Bitmap object.
• name – Name of the bitmap
• location – The bitmap file location
• preload – If set to true then the bitmap will be loaded when created
• onload – Callback function that will be called when the image has been loaded
• load() – Loads the bitmap, used in cases where the bitmap is not preloaded
• destroy() – Removes the bitmap from the scene / app and destroys it
Sound Properties
• name – The name of the sound, this name is used when searching for sound resources in a Scene’s resources or the the App’s global resources
• parent – Parent container scene or app
• location – The location of the sound file that is used to create the audio object
• location2 – The location of the sound file that is used as a fall back if sound at location does not load
• reuse – When set to false the generated sound Audio will be re-used, this can prevent sounds that are currently playing being replayed whilst currently being played but can help resolve audio playback issues
• loop – If set to true then sound will be looped
• preload – if set to true then this sound will be preloaded
• loaded – If set to true then this resources has finished loading
• auto_play – If set to true then this sound will automatically play once loaded
• snd – Local audio object
• buffer – AudioBufferSourceNode containing decoded audio data (Web Audio only)
Sound Methods
•
Sound(name, location, reuse) – Creates an instance of a Sound object.
â—¦ name – Name of the sound
â—¦ location – The sound file location
â—¦ reuse – Mark the sound to be re-used
• load() – Loads the sound
• play() – Plays the sound
â—¦ returns Audio object representing the playing sound or a {source, gain} object if using Web Audio API, this values is also set to the snd property of the Sound
Page 88 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood object
• stop() – Stops playback of the sound
• pause() – Pauses playback of the sound
• destroy() – Removes the sound from the scene / app and destroys it
Shape Properties
• name – The shapes name
• parent – Parent container scene or app
• type – Type of shape
• width – Width of shape (or radius if circle)
• height -Height of shape
• vertices – Array of vertices for a polygon type shape in the form [x1,y1,x2,y2,....]
• convexVertices – If shape is concave then contains an array of array of vertices that make up convex shapes, if empty then shape is convex and vertices should be used
Shape Constants
• b5.Shape.TypeBox
– A box shape type
• b5.Shape.TypeCircle
– A circle shape type
• b5.Shape.TypePolygon
– A polygon shape type
Shape Methods
•
Shape(name) – Creates an instance of a Shape object
â—¦ name - The name of the geometry, this name is used when searching for resources in a Scene’s resources or the the app’s global resources
• typeToConst(type_name) – Converts a string based shape type name to a Shape type constant
â—¦ type – Name of the shape type (box, circle or polygon)
• destroy() – Removes the shape from the scene / app and destroys it
Material Properties
• name – The name of the material, this name is used when searching for bitmap resources in a Scene’s resources or the the App’s global resources
• type – Type of material (can be static, dynamic or kinematic)
• density – Material density, higher values make for heavier objects
• friction – Material friction, lower values make objects more slippery
• restitution – Material restitution, higher values make the object more bouncy
• gravity_scale – Gravity scale, lower values lessen the affects of gravity on the object
• fixed_rotation – Set to true to prevent objects from rotating
Page 89 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Material Methods
•
Material(name) – Creates an instance of a Material object.
â—¦ name – Name of the bitmap
• destroy() – Removes the material from the scene / app and destroys it
Gradient Properties
• name – The name of this object
• parent – The parent container scene or app
• stops – An array of colour stops
Gradient Methods
•
Gradient(name, colour_stops) – Creates an instance of a Gradient object
â—¦ name – The name of the gradient
â—¦ colour_stops – An array of colour stops
• addColourStop(colour, offset) – Adds a gradient stop to the gradient
â—¦ colour – Colour of gradient stop
â—¦ offset – Offset of gradient stop
• getColourStop(index) – Returns the colour stop at the specified index
• getMaxStops() – Returns the total number of colour stops in the gradient
• destroy() – Removes the gradient from the scene / app and destroys it
• createStyle(w, h, start, end) – Creates a style from this gradient that can be used by fills and strokes
â—¦ w – Width of the gradient area (usually width of fill area)
â—¦ h – Height of the gradient area (usually height of fill area)
â—¦ start – Start point of gradient {x, y}
â—¦ end – End point of gradient {x, y}
ImageAtlas Properties
• name – The name of the ImageAtlas, this name is used when searching for brush resources in a Scene’s resources or the the App’s global resources
• parent – The parent container
• bitmap – The bitmap object that images will be used as a source for sub images
•
Internal properties
• frames – Array of atlas frame objects in the form {x, y, w, h}
ImageAtlas Methods
•
ImageAtlas(name, bitmap, x, y, w, h) – Creates an instance of an ImageAtlas
â—¦ name - The name of the ImageAtlas, this name is used when searching for brush resources in a Scene’s resources or the the App’s global resources
â—¦ bitmap – The source bitmap object
â—¦ x, y, w, h – The top-left position and width / height of the initial atlas frame
(optional)
Page 90 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• addFrame(sx, sy, sw, sh) – Adds a new frame to the atlas
â—¦ sx, sy – Top-left hand position of sub image
â—¦ sw. sh, Width and height of the sub image
• getFrame(index) – Returns the frame at the specified index
â—¦ index – The index of the requested frame
â—¦ returns the specified frame object
• getMaxFrames() – Returns total number of available frames in this atlas
• generate(start_x, start_y, frame_w, frame_h, count_x, count_y, total) – Generates multiple atlas frames, working from left to right, top to bottom
â—¦ start_x – Start x position
â—¦ start_y – Start y position
â—¦ frame_w – The width of each frame
â—¦ frame_h – The height of each frame
â—¦ count_x – Total frames to generate across the image
â—¦ count_y – Total frames to generate down the image
â—¦ total – Optional parameter that can be used to limit total number of generated frames
• destroy() – Removes the atlas from the scene / app and destroys it
Page 91 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Animation – Lets Dance
Introduction
One of Booty5's biggest and best features is its animation editor. The Booty5 timeline animation editor enables rapid production of Flash style animations. Booty5 exports animations that utilise the Booty5 engines timeline animation system. The animation system is split over a number of classes:
• b5.Animation – An animation is a collection of animation frames
• b5.Timeline – A timeline is a collection of animations
• b5.TimelineManager – A collection of timelines
Each Scene, Actor has its own TimelineManager that generally manages its local timelines.
In addition, the global App object has its own TimelineManager that handles global animations.
To see what type of animations Booty5 can create take a look at the basic animation demo and world animation demo .
Working with Animations
Animations are created by creating instances of b5.Animation objects that target specific objects and their properties. Created animations are added to a Timeline (a container for multiple animations), usually all of the animations that target a specific object are added to the same Timeline although this is not a restiction. Timelines are then added to the
TimelineManager to be processed each frame.
An Animation consists of a target, a property and a collection of key frames and key times. A key frame is the value of a property at a specific point in time stipulated by the key times. For example, the target could be an actor called player, the property could be the x position of the actor and the key frames could be an array of numbers that specify the values of the actors x position at specific points in time. e.g.:
•
At time 0 seconds objects x position is 0
•
At time 2 seconds objects x position is 200
Whilst the animation is playing it will interpolate the values of the objects property over time to create a smooth transition from one value to the next, so for example at time 1 second the value will be 100 (half way between 0 and 200). You can modify how this interpolation (tweening) is applied by using easing functions. Easing functions affect how the value is tweened from one value to the next, the default is Linear easing which simply smoothly tweens from one value to the next. You can specify which tweening function to apply to each individual frame by passing in an optional array to the animation creation function that specifies which tweening functions to use for each frame. The current list of available tweening functions includes:
Page 92 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• b5.Ease.linear
• b5.Ease.quadin
• b5.Ease.quadout
• b5.Ease.cubicin
• b5.Ease.cubicout
• b5.Ease.quartin
• b5.Ease.quartout
• b5.Ease.sin
Lets take a quick look at an example that shows how to create an Animation: var anim = new b5.Animation( null , actor1, "_x" , [0, 200], [0, 2], 0, [b5.Ease.quartin]);
In the above example we create an animation that targets the _x property of actor1, it changes this property from 0 to 200 over 2 seconds, using the quartic-in easing function.
Note that we target the _x property setter instead of the x property of an actor because internally the actor system has to rebuild its visual transform, which the property setter does.
Simply creating the animation is not enough, it must be added to a Timeline and then that
Timeline must be added to a TimelineManager, e.g.:
// Create a timeline var timeline = new b5.Timeline();
// Add the animation timeline.add(anim);
// Add the timeline to the actors timeline manager actor1.timelines.add(timeline);
// Start the timeline playing timeline.play();
Once an animation has been created and added to a Timeline, you can later locate it by calling b5.Timeline.find(animation_name). You can also locate a timeline using a path, e.g.: b5.Utils.resolveObject( "scene1.actor1.timeline1" , "timeline" );
Animations can repeat playback multiple times by passing in the number of times to repeat when creating the Animation object, passing a value of 0 will repeat the animation forever.
Once an animation reaches the end of its duration it will automatically be destroyed, unless you set the b5.Animation.destroy property to false. You can also remove an animation from a Timeline by calling b5.Timelime.remove(animation).
Page 93 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Working with Timelines
Timelines represent collections of animations with each animation potentially targeting a different property and a different object. Timelines are a way of creating a complete set of animations that represent a complete sequence of animation. For example, a timeline could contain all of the animations that represent a cut scene sequence during a game, or all of the animations that represent an action that takes place when a certain event occurs, such as a pick-up animation when the player picks up certain objects.
To create a Timeline we create an instance of a b5.Timeline object, e.g.: var timeline = new b5.Timeline();
Once a Timeline is created we can begin adding animations to it using b5.Timeline.add(), which has two flavours:
• b5.Timeline.add(anim) – Adds the supplied Animation instance “anim” to the timeline
• b5.Timeline.add(target, property, frames, times, repeat, easing) – Creates an animation with the specified properties then adds it to the timeline. This is a convenience function that allows you to add animations without having to create the animation up front. Internally an Animation object will be created for you
Once a Timeline has been created it should be added to a TimelineManager in order to be processed each game frame, e.g.: scene.timelines.add(timeline);
Once a timeline has been created and added to a TimelineManager, you can later locate it by calling b5.TimelineManager.find(timeline_name).
The main App, Scenes and Actors all have their own TimelineManager's (e.g. scene.timelines) that you can add created timelines to. However, you can create and manage your own as long as you call b5.TimelineManager.update() on a regular basis.
To later remove a Timeline from its manager you can call b5.TimelineManager.remove(timeline). Be aware that the timeline may no longer be present as timelines clean themselves up when all animations within the Timeline have been destroyed; an animation object will destroy itself when it reaches the end of its playback, unless its destroy property is set to false.
A number of methods are available which can affect the timeline:
• b5.Timeline.play() - Plays all animations in the timeline, resumes play back it is paused
• b5.Timeline.pause() - Pauses playback of all animations in the timeline
• b5.Timeline.restart() - Restarts all animations from their starts, also resets the total number of times to repeat each animation to their original values
These methods are also available within the TimelineManager and operate across all
Timelines that the manager contains:
Page 94 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• b5.TimelineManager.play() - Plays all timeline in the timeline manager, resumes play back it is paused
• b5.TimelineManager.pause() - Pauses playback of all timelines in the timeline manager
• b5.TimelineManager.restart() - Restarts all timelines in the timeline manager from their starts
Animation Events
Animations can fire off various events based on the status of the animation. The following events are currently supported:
• onEnd – Called when the animation finishes playing
• onRepeat – Called when the animation repeats
•
Frame hit – Called when a specific animation frame is hit
The first two events are simple to to set up and use, lets take a quick look at an example:
// Create animation var anim = new b5.Animation( null , actor1, "_x" , [0, 200], [0, 2], 2, [b5.Ease.linear]); anim.name = "anim1" ;
// Set callbacks anim.onEnd = function (e) {
console.log( "Animation ended " + e.name);
}; anim.onRepeat = function (e) {
console.log( "Animation repeated " + e.name);
};
// Create a timeline var timeline = new b5.Timeline();
// Add the animation timeline.add(anim);
// Add the timeline to the actors timeline manager and play actor1.timelines.add(timeline).play();
The animation system can also fire events when each individual frame is hit by setting action functions (not to be confused with action lists) with b5.Animation.setAction(index, action_function). Lets take a quick look at an example: var timeline = new b5.Timeline(); var anim = timeline.add( this , "x" , [0, 100, 300, 400], [0, 5, 10, 15], 0, [b5.Ease.quartin, b5.Ease.quartin, b5.Ease.quartin]); anim.setAction(0, function () { console.log( "Hit frame 0" ); }); anim.setAction(1, function () { console.log( "Hit frame 1" ); }); anim.setAction(2, function () { console.log( "Hit frame 2" ); });
In the above example, we create an animation with 4 key frames then assign an action to the first 3 frames, note that we do not assign an action to the last frame as that frame will call either onEnd or onRepeat. When the animation reaches each of the frames the corresponding action function will be called.
Page 95 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Responding to animation events are great for setting off other animations, updating game logic, playing sound effects and so on.
Animation Playback Speed
You can change the speed at which an animation is played back by setting the b5.Animation.time_scale property. Setting it to a value less than 1 will play the animation back at a slower speed, whilst setting it to a value of greater than 1 will play back the animation at an higher speed. For example, setting time_scale to 2 will play back the animation at double its intended speed, whilst setting it to 0.5 will play back the animation at half the intended speed.
Adjusting the time_scale of animations can be used to create temporal distortion effects.
Tween or not to Tween
Each animation has a tween property which when set to true will cause animation key frames to be smoothly interpolated. This is however not appropriate for all types of object properties. For example, if we create an animation that changes the text of a label over time, tweening is not possible as we want the text to change to a discrete value. In this case tweening can be turned off by setting the tween property of the animation to false.
Lets take a quick look at a none tweened animation: var timeline = new b5.Timeline(); var anim = timeline.add(actor, "text" , [ "Hello" , "World" , "" ], [0, 1, 2], 0); anim.tween = false ; actor.timelines.add(timeline);
Animation properties
• name – Name of the animation
• target – Target object to tween
• property – Property to tween
• frames – Key frame data (array of key frame values)
• times – Key frame times (array of key frame times)
• easing – Key frame easing functions (array of easing functions, see Ease reference)
• repeat – Total number of times to repeat animation (0 for forever)
• destroy – If true then animation will be destroyed when it finishes playing (default is true)
• actions – Array of action functions (called when each frame is reached)
• time_scale – Amount to scale time (default is 1.0)
• tween – When set to true, key frames will be smoothly interpolated, if set to false then frames will not be interpolated
• timeline – Parent timeline
• state – State of playback (AS_playing or AS_paused)
• time – Current time
• repeats_left – Number of repeats left to play
• index – Optimisation to prevent searching through all frames
Page 96 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Animation Constants
• b5.Animation.AS_playing – Animation is playing
• b5.Animation.AS_paused
– Animation is paused
Animation Events
• onEnd() – Called when the animation ends
• onRepeat() – Called when the animation repeats
• actions – Each frame can be assigned a function that is called when that start of that frame is reached
Animation Methods
•
Animation(timeline, target, property, frames, times, repeat, easing) – Creates an instance of an Animation object
â—¦ timeline – The parent Timeline that will manage this animation
â—¦ target – The target object that will have its properties animated
â—¦ property – The name of the property that will be animated
â—¦ frames – An array of key frame values that represent the value of the property at each time slot
â—¦ times – An array of time values that represent the time at which each key frame should be used
â—¦ repeat – the total number of times that the animation should repeat (0 for forever)
â—¦ easing – An array of easing values (optional), see Ease for reference
• pause() – Pauses the playback of the animation
• play() – Plays / resumes the animation
• restart() – Restarts the animation from its beginning
• update(dt) – Updates the animation (called internally)
â—¦ dt – The amount of time that has passed since this animation was last updated
• setTime(time) – Sets the current playback time value of the animation
â—¦ time – Playback time of animation in seconds, a negative value can be used to delay the start of the animation
• setAction(index, action_function) – Sets an action function that will be called when the animation reaches the frame specified by index
â—¦ index – The frame at which to set the action function
â—¦ action_function – function to call when the specified animation frame is reached
Timeline Properties
• anims – An array of Animations
• manager – The parent timeline manager that manages this timeline
• name – The name of this timeline
Page 97 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Timeline Methods
•
Timeline(target, property, frames, times, repeat, easing) – Creates an instance of a
Timeline object
â—¦ target – The target object that will have its properties animated
â—¦ property – The name of the property that will be animated
â—¦ frames – An array of key frame values that represent the value of the property at each time slot
â—¦ times – An array of time values that represent the time at which each key frame should be used
â—¦ repeat – the total number of times that the animation should repeat (0 for forever)
â—¦ easing – An array of easing values (optional), see Ease for reference
• add(animation) – Adds an Animation object to this timeline
â—¦ animation – Instance of animation to add
• add(target, property, frames, times, repeat, easing) – Adds an Animation object to this timeline
â—¦ target – The target object that will have its properties animated
â—¦ property – The name of the property that will be animated
â—¦ frames – An array of key frame values that represent the value of the property at each time slot
â—¦ times – An array of time values that represent the time at which each key frame should be used
â—¦ repeat – the total number of times that the animation should repeat (0 for forever)
â—¦ easing – An array of easing values (optional), see Ease for reference
• remove(animation) – Removes the specified animation from the timeline
• find(name) – Finds and returns the named animation or null if not found
• pause() – Pauses all Animations in the timeline
• play() – Plays all Animations in the timeline
• restart() – Restarts all Animations in the timeline
• print() - Debug method which prints out a list of animations in the timeline
• update(dt) – Updates all Animations in the timeline
â—¦ dt – The amount of time that has passed since this timeline was last updated
TimelineManager Properties
• timelines – Array of Timelines
TimelineManager Methods
•
TimelineManager() – Create an instance of a TimelineManager object
• add(timeline) – Adds a timeline to this TimelineManager
â—¦ timeline – The timeline to add to this manager
• remove(timeline) – Removes the specified timeline from the TimelineManager
â—¦ timeline – The timeline to remove from the manager
• find(name) – Finds and returns the named timeline, or null if not found
• pause() – Pauses all Timelines in the manager
• play() – Plays all Timelines in the manager
• restart() – Restarts all Timelines in the manager
Page 98 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• print() - Debug method which prints out a list of Timelines in the manager
• update(dt) – Updates all Timelines in the manager
â—¦ dt – The amount of time that has passed since this manager was last updated
Actions – Building with Blocks
Introduction
Actions are pieces of pre-defined logic that can be added to Actors and Scenes to extend their functionality. There is no particular base class for an action, instead actions conform to a strict frame work which consists of the following:
•
A constructor which creates an instance of the action
•
An onInit() method which is called when the action is first executed or when it is executed again after it has finished executing and ran again
•
An onTick() method which is called each time the action is updated
Actions once created are added to an actions list, each action in an actions list is executed consecutively, which means that the next action will not execute until the current action has finished executing. For example:
•
Move object to position 100,100 over 5 seconds
•
Move object to position 0,0 over 2 seconds
•
Play a sound effects
The 2
The 3 nd action will not execute until the object reaches position 100,100 after 5 seconds. rd action will not execute until the object reaches position 0,0 after a further 2 seconds, so the sound effect will not play until 7 seconds have passed.
Action lists can repeat any number of times or can play forever, you can specify the number of repeats when creating an instance of b5.ActionList.
By building up a library of actions, game functionality can be bolted together by creating lists of those actions and assigning them to game objects.
Actors and Scenes both contain an ActionsListManager which allows the object to run multiple action lists simultaneously
Lets take a quick look at an example that shows how to add some of the pre-defined actions that ship with Booty5 to an actor object to modify its behaviour:
// Create actions list that repeats forever var actions_list = new b5.ActionsList( "moveme1" , 0);
// Add an action that will move the object to position 100,100 over 5 seconds actions_list.add( new b5.A_MoveTo(actor, 100, 100, 5));
// Add an action that will move the object to position 0,0 over 2 seconds actions_list.add( new b5.A_MoveTo(actor, 0, 0, 2));
// Add the actions list to the actor and start it playing
Page 99 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood actor.actions.add(actions_list).play();
In the above example, we create an actions list called “moveme1”, we add two actions to the actions list that moves the object then we add the actions list to the actors actiosn list manager for processing and set if off playing.
Actions are added to the ActionsList using b5.ActionsList.add(), they can later be removed by calling b5.ActionsList.remove(). Once an ActionsList has been added to the manager you can later find it by calling b5.ActionsList.find(actions_list_name). You can also find an actions list from a path, e.g.: b5.Utils.resolveObject( "scene1.actor1.actionslist1" , "actions" );
An ActionsList has a number of methods that can affect its behaviour:
• b5.ActionsList.play() - Starts the actions list playing or resumes if paused
• b5.ActionsList.pause() - Pauses playback of the the actions list
• b5.ActionsList.restart() - Restarts the actions list from the beginning, also resets the number of repeats
Page 100 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating Custom Actions
Whilst a large collection of pre-defined actions have been created for you, you can easily create and register actions of your own that fit your specific game.
To create an action you need to create an actions class then optionally register it with the actions register ActionsRegister. An action class consists of a constructor, an onInit() method and an onTick() method:
• constructor – The constructor creates an instance of the action remembering any passed parameters
• onInit() – This method sets up the initial state of the action
• onTick() – This method is called every time the action is executed (every frame)
Each time an action is encountered in the actions list it is initialised, this includes when the actions list repeats. Once initialised the action will call its onTick() method until false is returned from the onTick() method. Note that if no onTick() method is supplied then the action will exit immediately.
Lets take a quick look at an example that shows how to create our own action: b5.A_StopMove = function (target, stop_vx, stop_vy, stop_vr, duration)
{ this .target = target; this .stop_vx = stop_vx; this .stop_vy = stop_vy; this .stop_vr = stop_vr; this .duration = duration;
}; b5.A_StopMove.prototype.onInit = function ()
{ this .target = b5.Utils.resolveObject( this .target); this .time = Date.now();
}; b5.A_StopMove.prototype.onTick = function ()
{ if (!((Date.now() - this .time) < ( this .duration * 1000)))
{ var target = this .target; if ( this .stop_vx)
target.vx = 0; if ( this .stop_vy)
target.vy = 0; if ( this .stop_vr)
target.vr = 0; return false ;
} return true ;
}; b5.ActionsRegister.register( "StopMove" , function (p) { return new b5.A_StopMove(p[1],p[2],p[3],p[4],p[5]); });
In the above code we declare a new action called A_StopMove which accepts 5 parameters. We store these parameters in the instance of the action because we will need them later.
Page 101 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
We have also declared onInit() and onTick() methods. Notice how we return true from onTick() until the action has ran for its duration, at which point we return false to let the actions system know that it should move onto the next action in the list.
Finally, notice how we register the action with the actions register. We pass in the name of the action “StopMove” along with a function that creates an instance of the actions class.
Registering your class with the actions register is only required if you want to make the action callable as a custom action from the Booty5 game maker editor.
Page 102 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Predefined Actions
Booty5 comes with a large range of pre-defined actions out of the box. A complete list of these is shown below:
Action List Actions
The A_ChangeActions action changes the state of an actions list then exits
• actions – Path to actions list (e.g. scene1.actor1.actionslist1)
• action – Action to perform on the actions list (play, pause or restart)
Actor Actions
The A_CreateExplosion action creates a particle system actor then exits
• container – Path to scene or actor that will contain the generated particle actor
(e.g. scene1.actor1)
• count – Total number of particles to create
• type – The actor type of each particle created, for example ArcActor
• duration – The total duration of the particle system in seconds
• speed – The speed at which the particles blow apart
• spin_speed – The speed at which particles spin
• rate – Rate at which particles are created
• damping – A factor to reduce velocity of particles each frame, values greater than 1 will increase velocities
• properties – A collection of actor specific properties that will be assigned to each created particle (e.g. vx=10,vy=10)
• actor – If provided then the generated particle actor will be placed at the same position and orientation as this actor, actor is path to an actor
The A_CreatePlume action creates a particle system actor then exits
• container – Path to scene or actor that will contain the generated particle actor
(e.g. scene1.actor1)
• count – Total number of particles to create
• type – The actor type of each particle created, for example ArcActor
• duration – The total duration of the particle system in seconds
• speed – The speed at which the particles rise
• spin_speed – The speed at which particles spin
• rate – Rate at which particles are created
• damping – A factor to reduce velocity of particles each frame, values greater than 1 will increase velocities
• properties – A collection of actor specific properties that will be assigned to each created particle (e.g. vx=10,vy=10)
• actor – If provided then the generated particle actor will be placed at the same position and orientation as this actor, actor is path to an actor
Page 103 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Animation Actions
The A_ChangeTimeline action changes the state of an animation timeline then exits
• timeline – Path to timeline (e.g. scene1.actor1.timeline1)
• action – Action to perform on the timeline (play, pause or restart)
Attractor Actions
The A_AttractX action pulls objects towards or repels objects away on the x-axis that are within a specific range, does not exit
• target – Path to actor object that will attract other objects (e.g. scene1.actor1)
• container – Path to object that contains the actors (actors that can be attracted have attract property set to true)
• min_x – Minimum x-axis attraction range
• max_x – Maximum x-axis attraction range
• min_y – Minimum y-axis inclusion range
• max_y – Maximum y-axis inclusion range
• strength – Strength of attraction, negative for repulsion
• stop – If set to true then attracted objects will stop when they hit the minimum distance range
• bounce – If set to true then objects when stopped at the minimum distance range will bounce
The A_AttractY action pulls objects towards or repels objects away on the y-axis that are within a specific range, does not exit
• target – Path to actor object that will attract other objects (e.g. scene1.actor1)
• container – Path to object that contains the actors (actors that can be attracted have attract property set to true)
• min_y – Minimum y-axis attraction range
• max_y – Maximum y-axis attraction range
• min_x – Minimum x-axis inclusion range
• max_x – Maximum x-axis inclusion range
• strength – Strength of attraction, negative for repulsion
• stop – If set to true then attracted objects will stop when they hit the minimum distance range
• bounce – If set to true then objects when stopped at the minimum distance range will bounce
The A_Attract action pulls objects towards or repels objects away on the x and y-axis that are within a specific range, does not exit
• target – Path to actor object that will attract other objects (e.g. scene1.actor1)
• container – Path to object that contains the actors (actors that can be attracted have attract property set to true)
• min_dist – Minimum attraction range
• max_dist – Maximum attraction range
• strength – Strength of attraction, negative for repulsion
• stop – If set to true then attracted objects will stop when they hit the minimum distance range
Page 104 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• bounce – If set to true then objects when stopped at the minimum distance range will bounce
Audio Actions
The A_Sound action plays, pauses or stops a sound then exits
• name – Path to sound resource (e.g. scene1.sound1)
• action – Action to perform on sound (play, pause or stop)
General Actions
The A_Wait action waits for a specified time then exits
• duration – Amount of time to wait
The A_SetProps action sets a group of properties of an object to specified values then exits
• target – Path to target object (e.g. scebe1.actor1)
• properties – Property / value pairs that will be set (e.g. vx=0,vy=0)
The A_AddProps action adds the specified values onto the specified properties then exits
• target – Path to target object (e.g. scebe1.actor1)
• properties – Property / value pairs that will be updated (e.g. vx=0,vy=0)
The A_TweenProps action tweens the specified property values over time then exits
• target – Path to or instance of target object (e.g. scene1.actor1)
• properties – Property / value pairs that will be tweened (e.g. vx=0,vy=0)
• start – Array of start values (e.g. 0,0)
• end – Array of end values (e.g. 100,500)
• duration – Amount of time to tween over
• ease – Array of easing functions to apply to tweens
The A_Call action calls a function then exits
• func – Function to call
• params – Parameter to pass to function (passed to function as an array)
The A_Create action creates an object from a xoml template then exits
• objects – Collection of objects in XOML JSON format (as exported from Booty5 editor) that contains the template (e.g. gamescene)
• scene – Path to scene that contains the template and its resources (e.g. gamescene)
• template – The name of the object template (e.g. actor1)
• type – The type of object (e.g. icon, label, scene etc)
• properties – Property / value pairs that will be set to created object (e.g. vx=0,vy=0)
Page 105 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
The A_Destroy action destroys an object then exits
• target – Path to object to destroy (e.g. scene1.actor1)
The A_FocusScene action sets the current focus scene then exits
• target – Path to scene to set as focus
• focus2 – Set as secondary focus instead
The A_Custom action is used to call your own custom actions (Booty5 editor only)
• name – Name of custom action
• target – Path to actor or scene
• params – Parameter to pass to function (passed to function as an array)
Movement Actions
The A_StopMove action stops an object from moving then exits
• target – Path to target object (e.g. scene1.actor1)
• stop_vx – Stops x velocity
• stop_vy – Stops y velocity
• stop_vr – Stops rotational velocity
• duration – Amount of time to wait before stopping
The A_Gravity action applies gravity to an object, does not exit
• target – Path to target object (e.g. scene1.actor1)
• gravity_x – Gravity strength on x-axis
• gravity_y – Gravity strength on y-axis
The A_Move action moves an object dx, dy units over the specified time then exits
• target – Path to target object (e.g. scene1.actor1)
• dx, dy – Distances to move on x and y axis
• duration – Amount of time to move over
The A_MoveTo action moves an object to a specific coordinate over the specified time then exits
• target – Path to target object (e.g. scene1.actor1)
• x, y – Target position to move to
• duration – Amount of time to move over
• ease_x – Easing function to use on x-axis
• ease_y – Easing function to use on y-axis
The A_MoveWithSpeed action moves an object at specific speed in its current direction over the specified time then exits
• target – Path to target object (e.g. scene1.actor1)
• speed – Speed at which to move
• duration – Amount of time to move over
Page 106 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
• ease – Easing function used to increase to target speed
The A_Follow action follows a target, does not exit
• source – Path to target object (e.g. scene1.actor1)
• target – Path to target object (e.g. scene1.actor2)
• speed – Speed at which to follow, larger values will catch up with target slower
• distance – Minimum distance allowed between source and target (squared)
The A_LookAt action turns an object to face an object, does not exit
• source – Path to target object (e.g. scene1.actor1)
• target – Path to target object (e.g. scene1.actor2)
• lower – Lower limit angle
• upper – Upper limit angle
The A_FollowPath action follows a path, does not exit
• target – Path to target object (e.g. scene1.actor2)
• path – Path to shape to follow (e.g. ecene1.shape1)
• start – Distance to start along the path
• speed – Speed at which to travel down the path
• angle – If set to true then angle will adjust to path direction
The A_FollowPathVel action follows a path using velocity, does not exit
• target – Path to target object (e.g. scene1.actor2)
• path – Path to shape to follow (e.g. ecene1.shape1)
• start – Distance to start along the path
• speed – Speed at which to travel down the path
• catchup_speed – Speed at which object catches up with path target modes
• angle – If set to true then angle will adjust to path direction
The A_LimitMove action limits movement of object to within a rectangular area, does not exit
• target – Path to target object (e.g. scene1.actor2)
• area – Rectangular area limit [x,y,w,h] (e.g. -100,-100,100,100)
• hit – Action to perform when object oversteps boundary (bounce, wrap, stop)
• bounce – Bounce factor
Page 107 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Camera Actions
The A_CamStopMove action stops a scene camera from moving then exits
• target – Path to target scene that contains camera (e.g. scene1)
• stop_vx – Stops x velocity
• stop_vy – Stops y velocity
• duration – Amount of time wait before stopping
The A_CamGravity action applies gravity ti a scene camera, does not exit
• target – Path to target scene that contains camera (e.g. scene1)
• gravity_x – Gravity strength on x-axis
• gravity_y – Gravity strength on y-axis
The A_CamMove action moves a scene camera dx, dy units over the specified time then exits
• target – Path to target scene that contains camera (e.g. scene1)
• dx, dy – Distances to move on x and y axis
• duration – Amount of time to move over
The A_CamMoveTo action moves a scene camera to a specific coordinate over the specified time then exits
• target – Path to target scene that contains camera (e.g. scene1)
• x, y – Target position to move to
• duration – Amount of time to move over
• ease_x – Easing function to use on x-axis
• ease_y – Easing function to use on y-axis
The A_CamFollow action causes scene camera to follow a target, does not exit
• source – Path to scene that contains camera that will follow the target (e.g. scene1)
• target – Path to target object to follow
• speed – Speed at which to follow, larger values will catch up with target slower
• distance – Minimum distance allowed between source and target (squared)
The A_CamFollowPath action causes scene camera to follows a path, does not exit
• target – Path to target scene that contains camera (e.g. scene1)
• path – Path to shape to follow
• start – Distance to start along the path
• speed – Speed at which to travel down the path
Page 108 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
The A_CamFollowPathVel action causes scene camera to follow a path using velocity, does not exit
• target – Path to target scene that contains camera (e.g. scene1)
• path – Path to shape to follow (e.g. ecene1.shape1)
• start – Distance to start along the path
• speed – Speed at which to travel down the path
• catchup_speed – Speed at which object catches up with path target modes
The A_CamLimitMove action limits movement of scene camera to within a rectangular area, does not exit
• target – Path to target scene that contains camera (e.g. scene1)
• area – Rectangular area limit [x,y,w,h] (e.g. -100,-100,100,100)
• hit – Action to perform when object oversteps boundary (bounce, wrap, stop)
• bounce – Bounce factor
Physics Actions
The A_SetLinearVelocity action sets the linear velocity of an actors body for a duration then exits
• target – Path to actor that will be changed
• vx – x-axis velocity
• vy – y-axis velocity
• duration – Duration of action
The A_SetAngularVelocity action sets the angular velocity of an actors body for a duration then exits
• target – Path to actor that will be changed
• vr – Angular velocity
• duration – Duration of action
The A_ApplyForce action applies force to an object over a period of time then exits
• target – Path to actor that will be changed
• fx – x-axis force
• fy – y-axis force
• dx – x-axis offset to apply force
• dy – y-axis offset to apply force
• duration – Duration of action
The A_ApplyImpulse action applies an impulse to an object then exits
• target – Path to actor that will be changed
• ix – x-axis impulse
• iy – y-axis impulse
• dx – x-axis offset to apply force
• dy – y-axis offset to apply force
Page 109 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
The A_ApplyTorque action applies torque to an object over a period of time then exits
• target – Path to actor that will be changed
• torque – Torque
• duration – Duration of action
ActionsList Properties
• manager – The ActionsListManager that manages this actions list
• name – The name of this actions list
• repeat – The total number of times to repeat this actions list before exiting, 0 is forever
• actions – A collection of actions
• current – The index of the currently active action
• destroy – When set to true this actions list will be destroyed when it finishes executing
• playing – The playback state of this actions list
ActionsList Methods
•
ActionsList(name, repeat) – Creates an instance of an ActionsList
â—¦ name- The name of the actions list
â—¦ repeat – Number of times to repeat playback of the actions list, 0 is forever
• add(action) – Adds the specified action to the list
â—¦ action – The action to add to the list
• remove(action) – Removes the specified action from the actions list
â—¦ action – The action to remove from the list
• execute() – Executes this actions list
• pause() – Pauses execution of the actions list
• play() – Starts or resumes execution of the actions list
• restarts() – Restarts execution of the actions list from the beginning
ActionsListManager Properties
• actions – An array of action lists
ActionsListManager Methods
•
ActionsListManager() - creates an instance of an ActionsListManager
• add(actionlist) – Adds the specified actions list to the manager
â—¦ actionlist – The actions list to add to the manager
• remove(action) – Removes the specified actions list from the manager
â—¦ actionlist – The actions list to remove from the manager
• find(name) – Returns the named actions list or null if not found
â—¦ name – The name of the actions list
Page 110 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
XOML – Booty5 Editor Data
Introduction
The Booty5 game editor exports data for your game in a JSON format called XOML. The
Xoml class reads this data and converts it into scenes, game objects and resources etc..
Booty5 will export a JSON file for each of your scenes as well as globals,js that contains information about all of your global app resources.
To parse a XOML JSON file, you need to create an instance of the Xoml class then call
Xoml.parseResources() to parse the file. Lets take a look at a quick example:
Below is a small example of an exported XOML file: window.globals = [
{
"ResourceType" : "Shape" ,
"Name" : "circle1" ,
"ShapeType" : "Circle" ,
"Width" :40,
"Height" :40,
"Absolute" : false
},
{
"ResourceType" : "Shape" ,
"Name" : "rect3761" ,
"ShapeType" : "Polygon" ,
"Width" : 0,
"Height" : 0,
"Absolute" : false ,
"Vertices" : [-126.336, -106.399, -42.018, -90.992, 153.614, 46.411, -66.468, 106.4,
-153.614, -7.28]
}
];
Now lets take a look at how we parse the data to generate Booty5 compatible objects:
// Create XOML loader var xoml = new b5.Xoml(app);
// Parse and create global resources placing them into the app xoml.parseResources(app, xoml_globals);
Page 111 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Post Loading Scenes
In the Booty5 game editor you can mark scenes as “do not load” which means they will not be parsed when the app begins. At a later date you will need to load this exported scene XOML, the example below shows how to do this: new b5.Xoml(app).parseResources(app, xoml_data);
In the above example we create an instance of the Xoml class then call parseResources(), passing in the app as the place to put global resources and the object that contains the
XOML JSON data. Note that all exported scenes data is placed in the window object, so accessing for example a scene called level1 you would pass [window["level1"]] as xoml_data.
Creating Resources from XOML templates
You can create a copy of any object / resource that exists in the XOML JSON data, you can think of the XOML data as a collection of templates. Lets take a quick look at an example: var app = b5.app;
// This scene will receive a copy of ball object var game_scene = app.findScene( "gamescene" );
// Search Xoml gamescene for ball icon actor resource var ball_template = b5.Xoml.findResource(window.gamescene, "ball" , "icon" );
// Create ball from the Xoml template and add it to game_scene var xoml = new b5.Xoml(app); xoml.current_scene = game_scene; // Xoml system needs to know current scene so it knows where to look for dependent resources var ball = xoml.parseResource(game_scene, ball_template); ball.setPosition(0, -350); ball.vx = 4; ball.fill_style = "rgb(" + ((Math.random() * 255) << 0) + "," + ((Math.random() * 255) << 0)
+ "," + ((Math.random() * 255) << 0) + ")" ;
In the above example we find the XOML template for the ball actor. We create an instance of the Xoml class that parses this template and creates a ball Actor object from it. We pass in the scene that contains resources that the ball object is dependent upon, such as bitmaps, timelines etc... Finally we modify the generated Actor object to add our own changes, such as give it a random fill style, a position and a velocity.
Page 112 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Booty5 Game Editor
Introduction to the Editor
The Booty5 HTML5 game editor is a complete integrated development environment (IDE) that helps you to quickly create and test HTML5 2D games featuring Flash style animation for mobile devices and desktop using the Booty5 HTML5 game engine (other game engines will be supported in the future).
Lets take a quick look at what the game editor looks like:
Whilst the editor looks quite busy, once you get used to the basics of the layout, you will find creating games and Flash style animations will become incredibly quick and easy.
Page 113 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Basic Booty5 Concepts
Before we look into the Booty5 editor in more depth lets discuss a number of core Booty5 concepts. Booty5 uses a scene hierarchy to store game objects and resources in a way that is optimal for game development.
A resource as far as Booty5 is concerned is anything that is added to or created in the editor. Many types of resources are supported including:
•
Image (Bitmap) resources – An image represents an image file
•
Sound resources – A sound represents either a sound effect or streamed audio file
•
Brush resources – A brush represents a rectangular area of an image by way of an
ImageAtlas or a Gradient that can be used to fill an area, brushes are generally attached to actors to give them a visual appearance. ImageAtlas brushes enable multiple images to be stored in a single image (sprite atlas)
•
Shape resources – A shape resource represents a physics shape, visual shape, clipping shape or a path. Shapes can be attached to actor based resources such as
Sprites (a Sprite is a basic image or shape based game object) and Labels (display text) to modify their physics shape in the physics engine and rendered shape. They can also be attached to scenes and actors as clippers to affect how child objects are clipped. Actions can also use shapes to make actors follow paths
•
Material resources – A material resource represents a physics material. Materials can be attached to actor based resources such as Sprites and Labels to affect how they interact with other physical components
•
Script resources – A script resource represents a script file, such as JavaScript,
HTML, CSS, XML and other languages
•
Actor resources – An actor represents a game object (sprite) that provides some kind of game functionality or interaction. Actors come in two flavours:
â—¦
Sprite actor – A sprite actor resource represents an image or shape based game object
â—¦
Label actor – A label actor resource represents a text based game object that shows text
•
Scene resources – A scene resource represents a game scene / level, a game can contain multiple overlaid scenes
Whilst the following are not resources that sit in the tree hierarchy, they are resources that do play very important roles in Booty5:
•
Timeline resources – Timelines allow you to create complex sets of animations that can target any property of any object. Each scene and actor can contain and manage its own collection of animations.
•
Action list resources – Action lists allow you to create game logic and assign it to actors and scenes in a none programmer way, allowing designers to chip into game production without the need for in-depth programming skills
Page 114 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
The World Tree
The World Tree is the parent / global controller of everything that exists in the game. The world tree contains all of the scenes that make up the game as well as any global resources that are made available to all resources across the entire game. The world tree is an accurate representation of the scene hierarchy in-code, much like the HTML DOM.
Resource spaces
The editor supports two resource spaces:
•
Local – Any resources located in a local scene resource space (appear in the scenes hierarchy) are generally only available to objects within that scene because local resources will be released when the scene is destroyed
•
Global – Any resources that are placed in the global resource space (outside the scenes hierarchy) are available to every object in the game and are only released when the game shuts down
Global resources are listed in the root of the world tree, whilst local resources are listed within the scene that they belong to. A scene is basically a way to separate out different parts of the game into separate sections You can think of scenes as the unique levels / different overlays in your game. For example you may have a scene that represents the user interface and additional scenes that each represent a unique game level in the game.
All scenes appear in the root of the world tree and cannot be made a child of any other resource.
Scenes
A scene is a container for resources that have limited application life time. The idea is that when the scene is loaded, all of its contained resources will be loaded, created and made available for use. When the scene is destroyed, all of its contained resources will be destroyed freeing up memory to the application. As well as an effective resource management system a scene also manages game objects (referred to as actors) and the cameras view into the world. When a scene is deactivated, all objects, physics, animations etc.. will be paused, when a scene is made invisible actors within the scene will no longer be drawn, by deactivating / hiding scenes that are not currently needed you can improve the performance of your game by many times.
Actors
Actors (game objects / sprites) are active resources, in that they have lives of their own; in-active resources are resources such as Images that never or rarely change state. Actors can only exist inside a scene and cannot be created in the global resource space. They can be arranged into hierarchies, with children adopting various properties of their parents, such as transforms, colour etc.. Actors are central to Booty5 as they provide the games core functionality. The general idea is that the editor is used to create and layout actors in a scene, actions and script are then used to modify their behaviours to add game play and app functionality. Booty5 supports a variety of different types of actor that can draw bitmaps, shapes and text.
Page 115 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Animation
The Booty5 editor / engine handles animation in 4 different ways:
•
Simple velocity – This is where you simply set a linear or angular velocity to an object and the object will move based on that velocity, this offers a limited sort of animation such as drifting and spinning objects
•
Bitmap animation – This is frame based bitmap animation that can be accomplished using brushes. The current bitmap animation frame can be changed over time to change the brush that is displayed on the object
•
Creating animation timelines in code – If you are using the Booty5 engine then you can use the Animation and Timeline classes to create complex re-usable and throwaway animations
•
Create animation using the timeline editor – The editor has a built in animation editor that uses timelines to create and preview animations, making animation creation very simple and easy to use
Action Lists
Actions are pieces of pre-defined logic that can be added to Actors and Scenes to extend their functionality. Actions can be grouped together into a list of actions that are executed one after the other. Booty5 ships with a number of pre-defined actions that can provide additional complex functionality to objects. For example, there are actions for forcing an object to follow another, tween and set properties of an object, play sounds and more. A
complete list of available actions can be viewed in the Predefined Actions section .
Exported Data
When Booty5 exports its data (when you hit test or run in the editor) it exports to the
“html” sub folder in your project. The following files will be exported:
• index.html – A basic html page that can be used to view your game
• styles.css – A basic style sheet
• main.js -This loads and starts the Booty5 engine
• game.js – This is your main game entry point which loads the global resources and scene jSON files that were exported from the Booty5 editor
• globals.js – JSON that represents the global resources in your project
•
<scene names>.js – A JSON file for each scene in your project that represents all of the objects and resources in each scene. Note that if a scene is marked as
“Load” in the Booty5 editor then it will be loaded on boot up by game.js. If you wish to late load a scene then you should untick the “Load” property of the scene
• lib/engine – This folder contains the source to the Booty5 game engine
• lib/Box2dWeb-2.1.a.3.min – If you have opted to use Box2D physics in your game then this file will be exported
•
Other files – The file based resources that are part of your project such as images, scripts and sounds. If you have set the destination folder for any resources then they will be exported to that sub folder
Note that the JSON data files that are exported from the Booty5 editor are loaded using
Page 116 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Working with the Editor
Overview
The Booty5 game editor main screen is split into 5 sections:
•
Main Menu – The main menu bar is the panel that runs across the top of the window and contains a tabbed view with different options. Clicking a tab will change the displayed menu
•
World tree – To the left of the window is the world tree panel, this panel displays all resources, scenes and actors that make up the game
•
Properties – The properties panel is situated to the right of the window and displays the properties associated with the currently selected resource
•
Main Canvas – The canvas panel is situated in the centre of the display and shows the currently selected game scene and all of its resources
•
Animation Editor – The animation editor is situated at the bottom of the window
(second tab) and is used to create, edit and preview timeline based animations of scenes and game objects
•
Output window – The output window is situated at the bottom of the window (first tab) and is used to display output messages from the editor
The Main Menu
The main menu bar displays a tabbed view with each tab section representing different grouped functionality. The following tabs are currently available:
•
File – Deals with file operations such as New, Open, Save, Save As and Testing
•
Tools – Provides useful tools that can be used to aid editing such as edge / vertex snapping, spacing and alignment
•
Resource – Provides tools for creating new resources
The File Menu
The file menu provides a number of functions including:
•
New – Creates a new project, when creating a new project you will be prompted to select a folder and name for the project
•
Open – Opens up an existing project from disk
•
Append – Opens up an existing project from disk and appends it to the current open project
•
Save – Saves the current project to disk
•
Save As – Saves the current project to disk under a new name
•
Test – Exports the current project and launches the test version of the project, displaying debug output to the JavaScript console
•
Run – Same process as Test except the miniified version of the engine is used and no debug information is output
•
Project – Here you can change various project and deployment settings
•
Open in IDE – This will open the exported HTML5 project in JetBrains WebStorm
Note that if you want to change this then can change the path to the editor of your
Page 117 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood choice in the project settings
•
Help – Shows Booty5 main help documentation
•
Tutorials – Opens the tutorial section of the Booty5 web site
•
Community – Opens up the Booty5 community web site
•
About – Shows information about the editor
The Tools Menu
The tools menu provides a number of tools that can be used to aid editing of games. The following tools are provided:
•
Edge – Switches to edge snapping mode where edges of objects are snapped to the edges of other objects on the canvas when the left control key is pressed whilst moving objects around
•
Vertex – Switches to vertex snapping mode where vertices of objects are snapped to the vertices of other objects on the canvas when the left control key is pressed whilst moving objects around
•
Small – Sets a small inclusion area. The inclusion area is the area that the snapped objects must fall inside of to be included in snapping calculations
•
Large – Sets a large inclusion area. The inclusion area is the area that the snapped objects must fall inside of to be included in snapping calculations
•
Space H – Spaces the selected objects horizontally, starting with the first selected object
•
Space V – Spaces the selected objects vertically, starting with the first selected object
•
Left – Aligns the left edge of all selected objects with the left edge of the first selected object
•
Right – Aligns the right edge of all selected objects with the right edge of the first selected object
•
Top – Aligns the top edge all selected objects with the top edge of the first selected object
•
Bottom – Aligns the bottom edge of all selected objects with the bottom edge of the first selected object
•
Centre – Aligns the horizontal centre of all selected objects with the centre position of the first selected object
•
Middle – Aligns the vertical middle of all selected objects with the middle position of the first selected object
The Resource Menu
The resource menu provides a group of tools that deal with creating and managing resources. The following tools are provided:
•
Scene – Creates a new scene resource
•
Image – Creates a new image (bitmap) resource
•
Sound – Creates a new sound resource
•
Brush – Creates a new brush resource
•
Font – Creates a new font resource
•
Shape – Creates a new shape resource
•
Material – Creates a new physics material resource
•
Sprite – Creates a new image actor resource
•
Label – Creates a new label actor resource
Page 118 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
•
Script – Creates a new script resource
Note that when you add a new resource, if you have a scene or a resource within a scene selected in the world tree then the new resource will be placed into that scene. This applies to all resources except scenes themselves.
Page 119 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
World Tree
World Tree
The world tree (situated to the left hand side of the editor window, see image below) is a tree view that shows the list of all resources that make up the project. It is here where you will see an overview and be able to select all resources such as bitmaps, brushes, shapes, scenes, scripts and so on and so forth that make up the game.
To view a resource simply click on the resource in the world tree. Selecting a resource will display the resources properties in the properties panel to the right. If the resource that you click is a scene or actor (Sprite / Label etc..) then the scene or actor will also be selected on the central canvas.
Double clicking the scene or actor in the world tree will centralise the canvas camera on the selected scene or actor.
Page 120 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Resource Colour Coding
All resources in the world tree view are colour coded to enable easy spotting of resource types. Resources are coloured as follows:
•
Dark blue – image resources
•
Cyan – sound resources
•
Light blue – brush resources
•
Yellow – shape resources
•
Vivid red – material resources
•
White – script resources
•
Red – Sprite resources
•
Light red – label resources
•
Bright green – scene resources
Resource Import via Drag / Drop
Resources can be dragged from explorer onto the world tree to add them to the editor.
Currently the following resource types are supported:
•
TexturePacker XML files – Dragging a texture packer file onto the world tree will import the image and generate brushes for each sprite located in the texture packer file. Dropping the file onto a scene will place the resources into that scene.
Note that, if resources with the same name already exist then they will be replaced.
This offers an easy way to update art work in the editor if it has been modified outside of it
•
PNG / JPEG – Dragging a PNG or JPEG file into the world tree will import the image as an image resource and create a brush that can be used to display the image.
Like with texture packer images and brushes, dropping images onto a scene will place the resources into that scene
•
SVG – Dragging a SVG file onto the world tree will import the SVG data into the editor, generating a scene, images, brushes, shapes and actors. Dropping the SVG file onto an existing scene will import the SVG into that scene
•
Script files – Dragging script files onto the world tree will import the scripts file into the editor. Dropping the script files onto an existing scene will import the scripts into that scene
Note that you can drop a collection of resources onto the editor and they will all be imported. This allows you to drag a complete folder full of resources straight into the editor.
Page 121 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
General Drag / Drop
You can drag various resources around in the world tree and drop them to reposition and assign them. The following drag/drop functionality is available:
•
Setting brush image – Dragging and dropping an image onto a brush will assign the image to that brush
•
Setting actor brush / shape – Dragging and dropping a brush or shape onto an actor will assign it to that actor
•
Setting actor material – Dragging and dropping a material onto an actor will create a physics fixture and attach it to the assigned actor
•
Dropping an actor onto another actor will make the dropped actor a child of the drop target actor. If the left shift key is pressed during the drop then the dropped actor will be placed above the drop target actor in the tree order
•
Dropping an actor onto a scene will move the actor to that scene
•
Dropping an actor onto an empty portion of the world tree will move the actor to the last position in the scene
•
Dropping a general resource (not an actor) onto a scene will move the resource to that scene
•
Dropping a general resource (not an actor) onto an empty area of the world tree will move the resource into the global resource space
A few notes:
•
When moving resources around from scene to scene, if objects that use the moved resource find that it is no longer available then they will not display correctly. For example, if you move an image from scene 1 to scene 2, all brushes in scene 1 that used that image will no longer be valid. Any actors that use those brushes in scene
1 will not display a texture
•
When moving actors between scenes, remember that if the resources that make up that actor such as shapes, geometries, images, brushes, materials etc.. are not available in the new scene or global resource space then the actor will be affected.
For example, if the geometry that the actor is using is not present in the new scene then it will be displayed as a simple sprite instead of a complex geometry.
Tools Panel
The world tree tools panel is located at the top of the world tree and offers a number of useful tools including:
•
Resource hiding – The coloured buttons represent the different types of resources that can be shown / hidden in the world tree. Clicking these buttons will toggle these types of resources on and off. This is useful for making space in the world tree when editing large levels with lots of resources
•
Clone – Selecting a resource then clicking the “+” button will clone the resource and all of its children
•
Delete – Selecting a resource then clicking the “-” button will delete the resource and all of its children
•
Move resource up – Selecting a resource then clicking the “ ” button will move the
• resource and all of its children up in the hierarchy
â–Ľ the resource and all of its children up in the hierarchy
Page 122 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Note that resources are grouped together by type in the world tree.
Context Menu
The world tree supports a context menu that is displayed when right clicking on the world tree or on a resource in the world tree. Right clicking on the resource tree will show a menu with the following options:
•
Scene – Creates a new scene in the global resource space
•
Brush – Creates a new brush in the global resource space
•
Image – Creates a new image in the global resource space
•
Sound – Creates a new sound in the global resource space
•
Font – Creates a new font in the global resource space
•
Shape – Creates a new shape in the global resource space
•
Material – Creates a new material in the global resource space
•
Script – Creates a new script in the global resource space
Right clicking on a resource in the world tree will show a menu with the following options:
•
New – Contains a sub menu that allows you to create resources of a specific type
•
Clone – Clones the resource
•
Delete – Deletes the resource
•
Move Up – moves the resource upwards in the hierarchy
•
Move Down – moves the resource downwards in the hierarchy
Right clicking on an actor in the world tree will show a menu with the following options:
•
New – Contains a sub menu that allows you to create resources of a specific type
•
Clone – Clones the resource
•
Delete – Deletes the resource
•
Clone to all scenes – Creates a copy of the selected actor in every scene
•
Delete from all scenes – Deletes the actor and all actors with the same name in all other scenes
•
Copy to scene – Creates a copy of the actor and sends it to a specific scene
•
Bring to front – Moves the actor to the bottom of the actor list
•
Send to back – Moves the actor to the top of the actor list
•
Move Up – moves the resource upwards in the hierarchy
•
Move Down – moves the resource downwards in the hierarchy
Page 123 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Properties Panel
The properties panel situated to the right of the display shows the properties associated with the resource that is currently selected in the world tree / on the main canvas. Making changes to the properties in this panel will make direct changes to the objects in the world tree. This property panel is the primary way of making changes to most resource properties. Note that each different type of resource has its own custom property panel which shows the properties that are specific to that type of resource.
The property panel is split into a number of collapsible sections to help categorise the properties. You can expand / collapse these by clicking on the section header, making it easier to deal with large numbers of properties. Note that if too many properties are available to fit on screen then a scroll bar will be shown that allows you to scroll through the properties. You can also use mouse scroll to scroll through properties.
Important Note
Any changes made in the property panel will be applied to ALL selected objects. For example, if you have 10 different actors selected on the canvas then the changes in this property panel will be applied to all 10 actors.
For a complete list of properties for all resource types
see the Resource Properties Reference . Also, hovering
over a property in the property panel will display tooltips showing more information about the property.
Page 124 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Main Canvas
The canvas is the main editing area located in the centre of the editor where game layouts are created and edited. The canvas shows a visual representation of scenes and its game
actors. Most of your time will be spent working between the canvas and the Properties
The main canvas has a number of visual aids:
•
Grid – The grid’s purpose is to give spatial and scale feedback
•
Origin – The origin is displayed using horizontal and vertical solid lines that intersect the origin of the world at 0,0
•
Mouse cross-hair – The cross hair intersects the mouse position to aid positioning and alignment
•
Virtual screen – A filled light blue semi-transparent rectangle is used to show the virtual screen dimensions. This is useful when docking objects to the edges of the display
•
Selection boxes – When an object is selected on the canvas it is highlighted with a flashing box to show that it is selected
•
Snap markers – When moving objects around on the canvas they can be snapped against vertices and edges of other objects when the user holds down the control key (CTRL). Snap markers appear when objects are about to snap to show how they will snap
•
Selection rectangle – When holding the shift key and dragging the mouse a selection rectangle will be shown that allows selection of multiple items
Current Scene
To make editing easier the Booty5 editor uses a currently selected scene concept to declutter the screen. The currently selected scene will be made visible, whilst all other scenes will be hidden from view. This enables scenes to be created and worked on in the same screen space without having to manually hide / show different scenes to move them out of the way.
Drag and Drop
The canvas supports drag and drop from the world tree view. Resources can be dropped onto either the scene / main canvas or actors within the scene. The following drag and drop functions are supported:
•
Adding new image based actors (Sprites) – Dragging brushes from the world tree onto the canvas or a scene will create a new Sprite actor with the brush assigned to it. This is a great way to quickly get content into the scene.
•
Changing an actors brush – Dragging a brush from the world tree onto an actor or collection of actors will assign the bush to the actor(s)
•
Adding physics fixtures to actors – Dragging either a material or shape onto an actor or collection of actors will create a new physics fixture and attach it to the actor or selected actors.
Page 125 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Editing on the Canvas
Creating and modifying layouts is done primarily on the canvas, selecting a scene or actor on the canvas will select the scene or actor in the world tree and change the properties panel to show the scene or actors current properties. If multiple actors are selected then the properties for the last selected actor will be shown. You can select multiple objects by holding down the left shift key and dragging the mouse over the objects that should be selected. You can also toggle selections on and off by holding down shift and clicking an object. Note that if you select an actor that is a child of another actor then the parent will automatically be deselected. Clicking on an empty part of the canvas will deselect all objects on the canvas. Note that we use object to denote either a scene or an actor.
The canvas can be panned and zoomed to show more / less of the world. The following mouse actions and keys can be used to modify the camera:
•
Middle mouse – Holding down the middle mouse button and dragging in a direction will move the camera in that direction
•
Mouse wheel – Zoom in and out, hold down left control key to slow down zoom
•
Ctrl + cursor keys – Move around the canvas, hold down left shift key to slow down movement step
•
Numeric pad + / – Zoom in and out, hold down left shift key to slow down zoom
When editing actors or scenes mouse and keyboard actions are:
•
Left mouse button – Select / move selected object(s)
•
Alt + Left mouse button – Clone selected object(s)
•
Right mouse button – Drag to rotate selected object(s)
•
Ctrl + right mouse button – Drag to scale selected object(s)
•
Cursor keys – Move selected object(s), hold down shift to slow down movement
•
Z/X – Rotate selected object(s), hold down shift to slow down rotation
•
Page Up / Page Down – Scale selected object(s) up and down, hold down shift to slow down scaling
•
Delete – Delete selected object(s)
Other useful actions and keys that can be used on the canvas include:
•
Ctrl + Z – Undo the last action or set of actions
•
Ctrl + N – Creates a new project
•
Ctrl + S – Save project
•
Ctrl + O – Open project
•
Ctrl + C – Copy object
•
Ctrl + V – Paste object
•
Ctrl + X – Cut object
•
Ctrl + Tab – Switch between current and previously selected resource
•
F1 – Moves to next actor in scene
•
F2 – Moves to previous actor in scene
•
F3 – Moves to next scene in world
•
F4 – Moves to previous scene in world
•
F5 – Test project
•
Ctrl + F5 – Run project
•
Keys 1-0 – Go to bookmark
•
Ctrl + Keys 1-0 – Set bookmark
Page 126 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
For key based actions to work, the canvas must have the focus.
Note that when you select a script resource in the world tree the main canvas will change to the script editor, to get the main canvas back simply click on a none script resource in the world tree.
Bookmarks
To aid navigation of larger game worlds the Booty5 editor uses a bookmark system. You can bookmark the camera at a specific position and scale. Using Ctrl + keys 1 to 0 will store the current position and scale of the camera. To return to that position and scale in the future press a key from 1 to 0 to go back to that bookmarked point.
Object Cloning
The Booty5 editor provides a very handy tool that enables layouts to be generated very quickly using cloning. By holding down the left Alt key whilst selecting an actor you can create a clone of that actor or group of selected actors. Depending upon which side of the actor you click, the cloning will be done in a specific direction. For example, if you “Alt + click” the right hand side of an actor then the new actor will be cloned to the right of the clicked actor; cloning also works with groups of actors. The newly created actors will be selected so that they can be cloned in the same direction again. This tool enables rapid generation of environments.
Object Alignment and Spacing
A number of tools are provided in the tools menu to aid alignment of objects by their edges or centres. The following alignment tools are currently available:
•
Left – Aligns the left edge of all selected objects with the left edge of the first selected object
•
Right – Aligns the right edge of all selected objects with the right edge of the first selected object
•
Top – Aligns the top edge of all selected objects with the top edge of the first selected object
•
Bottom – Aligns the bottom edge of all selected objects with the bottom edge of the first selected object
•
Centre – Aligns the horizontal centre of all selected objects with the centre position of the first selected object
•
Middle – Aligns the vertical middle of all selected objects with the middle position of the first selected object
A number of tools are provided in the tools menu to aid spacing of objects:
•
Space H – Spaces the selected objects horizontally, starting with the first selected object
•
Space V – Spaces the selected objects vertically, starting with the first selected object
Both sets of tools enable rapid production of tidy layouts, which is especially useful when creating user interfaces.
Page 127 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Edge and Vertex Snapping
When moving objects around on the canvas, holding down the left control key will put
Booty5 into snapping mode. There are two types of snapping modes supported:
•
Edge snapping – In this mode, the edges of the currently selected object will be snapped against the edges of other objects on the canvas. This is especially useful for stacking objects side by side, on top of or underneath each other. Note that when you drag an object close to the snapping edge of another object, guides will be displayed that show where the snap will take place
•
Vertex snapping – In this mode, the vertices of the currently selected object will be snapped against the vertices of other objects on the canvas. Note that when you drag an object close to the snapping vertex of another object, guides will be displayed that show where the snap will take place
Note that snapping only occurs between objects in the same parent of an hierarchy, so for example you cannot snap a child of one actor to the child of another actor, although you can snap the parents.
The current type of snapping that will be used can be changed from the Tools menu.
You can change the range at which objects will be considered for snapping by changing
the inclusion range in the World settings . You can quickly switch between small and large
inclusion ranges by selecting Small or Large from the Tools menu. You can also change the distance at which edges will be considered for snapping by changing the X and Y snap
ranges in the World settings . Note that you can view World settings by clicking on an
empty space on the canvas or by clicking the World button at the top of the canvas.
Page 128 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Code Editing
The code window is where you we will write your game code logic, it replaces the main central canvas area whenever a script resource is selected in the world tree. The code window uses an implementation of Scintilla and has the following features:
•
Syntax highlighting for a number of different languages including JavaScript, HTML,
XML, CSS, LUA and many other languages.
•
Code folding – Sections of code can folded and unfolded
•
Line numbering
•
Find and replace
•
Go to line
•
Basic auto complete
•
Auto reload of script files modified outside the editor when the script file is reselected
•
Undo / redo
•
Zoom
Note that once the code editor view is active it will remain active until you click on a none script resource in the world tree.
The code view looks as follows:
Page 129 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Shape Editing & Tracing
Booty5 contains a built in shape editor that can be used to create / edit shapes as well as generate shapes from bitmaps using bitmap contour tracing. To open the shape editor, select a shape in the world tree then change its type in the shapes property panel to
“Polygon”, this will enable the “Edit Shape” button, click this button to edit the shape.
The shape editor looks as follows:
The shape editors canvas looks much like the main canvas with a grid background and origin. You can use the following controls for navigating the shape editor as you can with the main canvas:
•
Middle mouse – Holding down the middle mouse button and dragging in a direction will move the camera in that direction
•
Mouse wheel – Zoom in and out, hold down left control to slow down zoom
Shapes created in the shape editor can be used as clipping regions for game objects and scenes, to represent game objects visually, as physics fixtures and as paths. Note that you do not need to worry about creating concave physics shapes as the editor will automatically break them into convex shapes during export.
Page 130 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Basic operations in the shape editor are as follows:
•
Select a node by clicking on the node, dragging the node will move it to the new position
•
Adding a new node can be done by either clicking the add node button to insert a node at the end of the node list or by double clicking on the canvas. Double clicking on the canvas will insert the node at the position of the mouse click
•
Deleting a node can be done by selecting a node and then clicking the ‘Remove’ button or by pressing the ‘Delete’ key
•
Clicking the ‘Save Changes’ button will write shape modifications that were made within the shape editor back to the main editor shape and close the shape editor. To discard the changes simply close the shape editor
Vertices can be snapped to an invisible grid by setting the snap vertices to a value other than 0, vertices will be snapped to the nearest grid line when dropped.
Shapes can be generated by tracing a bitmap and converting the generated perimeter to a shape.
To generate a shape from a bitmap select a brush from the drop down brush list then click the ‘Trace Bitmap’ button to generate the shape. A shape with a maximum of 20 sides will be generated by default, you can change the maximum number of sides that the shape will be made from by typing the number of sides into the ‘Edge Count’ box. You can also use the +/- buttons situated at the side of the ‘Edge Count’ box to adjust the maximum number of edges.
During bitmap edge tracing the alpha channel within the bitmap is used to determine edges. You can set a minimum alpha that will be used to consider pixels as solid by entering the value into the ‘Min Alpha’ field.
When a shape is attached to a physics fixture it will be exported as multiple shapes if the shape is concave. You can calculate how many shapes will be exported for a fixture by clicking the ‘Count Fixtures’ button.
If a shape is to be used as a path then ensure that you set the IsPath property of the shape to true.
Page 131 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Animation Timeline
The Animation Timeline Editor is the section of the editor that is located to the bottom of the screen (the tabbed area that contains Output and Animation tabs). In the timeline editor you can create and edit Flash style animations that play over time.
Scenes and Actors (Sprites and Labels) can be animated over time by creating animations, then adding properties and key frames for those properties to the animation timeline.
Animations in the editor are split into the following components:
•
A Property – A property is a specific attribute of an object that is to be animated over time, for example an objects rotation angle. A property has a value that represents its current state, for example 45 degrees
•
A Key Frame – A key frame is the value of a property at a specific time
•
A Timeline – A timeline is a set of key frames that form a complete animation of a specific property, for example, an apple bobbing up and down in the water
•
An Animation – A single animation contains multiple timelines, each one targeting a different property of an object
The following properties are currently supported:
SCENE:
•
Position (x, y) – Position of the scene
•
Camera (camera_x, camera_y) – Camera position, cannot be previewed within the editor
•
Opacity – Opacity level of scene
•
Layer – Scenes current visible layer
•
Visible – Visible state of scene
SPRITE:
•
Position (x, y) – Position of the actor
•
Angle – Angle of rotation of actor in degrees
•
Scale (sx, sy) – Scale of the actor
•
Origin (ox, oy) – Actors transform origin
•
Depth – Actors 3D depth
•
Opacity – Opacity level of actor
•
Bitmap Frame (frame) – Current bitmap animation frame index (used with animating brushes)
•
Layer – Actors current visible layer
•
Visible – Visible state of actor
•
Velocity (vx, vy) – Current velocity of actor
•
Angular Velocity (vr) – Current angular velocity of actor
LABEL:
•
Position (x, y) – Position of the actor
•
Angle – Angle of rotation of actor in degrees
•
Scale (sx, sy) – Scale of the actor
Page 132 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
•
Origin (ox, oy) – Actors transform origin
•
Depth – Actors 3D depth
•
Opacity – Opacity level of actor
•
Bitmap Frame (frame) – Current bitmap animation frame index (used with animating brushes)
•
Layer – Actors current visible layer
•
Visible – Visible state of actor
•
Velocity (vx, vy) – Current velocity of actor
•
Angular Velocity (vr) – Current angular velocity of actor
•
Text – Text to display
Note that you can also add custom properties by adding a timeline for an existing property then editing the property name in the timeline property view.
Actors and scenes can have multiple animations assigned to them that can play either one at a time, all at once or a combination of both
Editor Layout
The animation editor can be seen in the screen shot below:
The animation editor is split into 4 sections:
•
Animation / Properties list – This area is situated to the left hand side and contains the following controls:
â—¦
Add / Remove / Clone animation buttons and animation selection box – These allow you to create, remove and clone entire animations as well as select the currently active animation for the object
â—¦
Add / Remove property buttons and property category selection box – These
Page 133 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood allow you to add new properties and remove old ones from the animation. To add a new property, select the property from the property drop down box then click the “Add property” button, this will add a new property to the timeline and insert a key frame at time 0 in the timeline. To remove a property from the timeline, select the property in the animation property list then click the “Delete selected property” button.
•
Control panel – This area is situated in the middle top area of the animation editor and contains the following controls:
â—¦
Add key frame button – Adds a new key frame at the currently selected time.
Note that at least one property must have already been defined for the animation, also a key frame at the current time will be generated for all properties in the timeline
â—¦
Record button – Starts recording mode, in recording mode changes to objects on the canvas / resource properties areas will create / change key frames in the timeline
â—¦
Play button – Starts / stops animation preview
â—¦
Play children – If ticked then the object will also play the animations of all its children
•
Scrub area – This is the long area in the middle that shows time. You can click or drag the mouse around on this area in playback or record mode to adjust the currently viewed frame
•
Key frame area – This area is the section just below the scrub area which shows and allows the editing of key frames. Here you can double click on the timeline to add new key frames (or right click a key frame to delete it) as well as drag existing key frames around. You can also use the middle mouse button to drag the entire timeline around
•
Key frame properties – This area is situated over to the right and shows the properties of the currently selected key frame
•
Timeline properties – This area is situated over to the lower right and shows the properties of the currently selected timeline
The editor has 3 modes:
•
Recording mode – In this mode changes to objects on the canvas will generate or update key frames in the timeline. Note that if you change an object that has no animation created for it then one will automatically be created for you. Changing the timeline scrub will show changes to object(s) allowing you to preview the changes at different times
•
Playback mode – In this mode the animation is played back allowing you to see a preview of how the animation will look in real-time
•
Passive mode – In this mode (not recording or playing) changes made in the editor will not affect any animations
Its important to note that many functions such as changing scene, saving / loading etc will stop recording automatically. Its also important to note that animation changes cannot be applied to multiple selected objects, only the first selected object will be affected. In fact switching between the various modes will cause selections to be lost
Page 134 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Editing Flow
General editing flow in the timeline happens in this sequence:
•
Click the record button to switch into record mode
•
Select an object on the canvas that you wish to animate
•
Add a new animation by clicking the add animation button in the animation editor
•
Add properties that you would like to change using the add property button and property selection box (all at once or as and when you need them)
•
Add key frames for those properties at the time values you would like them to take affect, adjusting the values for the properties as you create them
•
Preview the animation using the play button or by scrubbing the timeline
•
To make adjustments switch back to record mode and make changes to key frames then hit play again to preview changes
Animation and Timeline Properties
Key frames and timelines have a variety of different properties which can be adjusted that affect how the animation behaves when played back / exported.
A key frame has the following properties:
•
Value – The value of the objects property at a specific time, this is adjusted by changing the various properties of the object
•
Time – The time at which the key frame will be active
•
Ease – Determines how values are tweened between key frames
•
OnHit – When the animation time hits this frame, script that is present here will be called
A timeline (a collection of key frames for an objects property) has the following properties:
•
Key frames – A collection of key frames
•
Property – A property that will be changed by the associated key frames
•
Tween – If set to true then key frame values will be smoothly tweened
•
Time Scale – The speed at which to play back the key frames
•
Start Delay – The number of seconds to delay play back of the key frames
•
Destroy – If set to true then this timeline will be destroyed when it has finished playing
•
Auto Play – If set to true then this timeline will automatically play when the object is created, otherwise it will need to be started manually in code or via an action
•
Repeat – The number of times to repeat play back of this timeline
•
OnEnd – Script that will be called when the animation ends
•
OnRepeat – Script that will be called when the animation repeats
An animation (a collection of timelines) has the following properties:
•
Timelines – A collection of timelines that animate various different properties of an object
•
Name – The name of the animation that can be used to refer to it in script / actions. You can change the name of an animation by clicking the animation selection box then clicking the button at the side of the animation name
Page 135 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating an Animation Walk-through
Here is a quick example that walks through the creation of a quick timeline animation:
•
Start a new project
•
Right click on the scene in the world tree and add a new sprite
•
Select the new sprite by clicking on it on the central canvas
•
In the Animation window click the “Create animation” button to create a new animation called anim1
•
Select “Position” from property type drop down and click the “Add property” button to add the new property. Note that this will add the x and y properties to the timeline
•
If the record button is not toggled on then toggle it on now
•
Move the timeline scrub to time 00:05 (5 seconds)
•
Select the sprite on the canvas and move it to somewhere else, notice how a new key frame will be added at time 00:05 as you move the sprite
•
Now click the play button to play back the animation. You will see that the sprite will move from its original position to the new position over the space of 5 seconds.
Page 136 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actions and Action Lists
The Booty5 editor / engine utilises a feature called Actions which can be used to add additional functionality to scenes and game object actors without having to resort to programming. Whilst actions are not a direct replacement for programming they can help someone with little to no coding experience to add functionality very easily. In addition, you can add your own custom actions to add in extra common functionality that is shared across your games, enabling none programmers to add functionality without the need to code.
An action is a single unit of functionality that affects an object or performs a task, for example moving an object from point A to B or playing a sound effect. Booty5 comes with a collection of pre-made actions that can be chained together to create complex object behaviours that are fired when certain events take place during the game. Actions are presented in the Booty5 editor in human readable format.
To give you can idea what actions look like a couple of example actions are listed below:
•
Move object my_object to position 100,100 over 2 seconds using x-axis linear easing and y-axis quartic in easing
•
Stop moving object my_object on x-axis and y-axis after 3 seconds
•
Object my_object follows path with shape shape1 starting at distance 10 at speed 1 adjusting angle
•
Object my_object follows object my_object2 at speed 10 at minimum distance 50
Each scene and actor can have its own actions list
Actions Lists
Actions lists are collections of actions that are executed one action at a time, the action list will not move on to the next action until the current action has finished executing. So for example, if we move an object from position a to b over 5 seconds, the next action will not run until 5 seconds has passed. You can run actions simultaneously by putting the actions is a separate list and playing that list at the same time.
Actors and scenes have their own local action lists which are ran whilst the object is active
(paused with inactive) and destroyed when the object is destroyed.
The resource properties section of the actor / scene at the right hand side of the display contains an Actions List section, which enables you to create and delete action lists for each object. Each actions list has a name, a repeats (number of times the action list is repeated before stopping), an auto-play check-box and an edit button. If the auto-play check-box is enabled then the actions list will automatically begin executing as soon as the object is created.
To edit an objects actions list click the edit button at the side of the actions list in the objects properties panel, this will open an actions list editor window which looks like the image below:
Page 137 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
The actions list editor window is split into 3 sections:
•
Actions – Displays all available actions, separated by category. To find out more information, select an action and information about the action will be displayed to the right. To add an action to the actions list, click the ‘+’ button next to the action
•
Actions information – Displays in-depth information about the action currently selected in the actions / actions list sections
•
Actions list – A list of actions that will be executed in the order in which they appear in the list. This section also contains 4 buttons which can be used to delete, move up / down actions and get additional help
Editing Actions Lists
You can add an action to the actions list by clicking the ‘+’ button that is situated at the side of the action in the action view. This will append the action onto the end of the actions list. If you wish to change the order of execution of any of the actions then you should select the action and use the up / down buttons to change the order.
Each action has its own unique set of parameters that can be changed, some are presented as text boxes, drop down lists or check boxes. Usually when the action requires some kind of object argument you can type a path to the object directly into the text box or click the ‘…’ button at the side of the text box and select from a list of available objects of the required type.
Page 138 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
If an action requires some kind of properties list then you should enter properties in the following format: x=10,y=20,vx=-10,vy=-50
Resource Paths
Many actions allow you to specify a path to an object, usually you are presented with a button to select the object from a list of available resources. This path represents the hierarchical path to the object which consists of the names of the parent objects separated by dots. For example, if you want to use an actions list called “start_game” that is located in an actor called “start_button” which is located inside a scene called “mainmenu” then the path to this object would be mainmenu.start_button.start_game. This same kind of path location convention is used within the Booty5 engine itself and can be used from
JavaScript.
Creating an Actions List Walk-through
Here is a quick example that walks through the creation of an actions list:
•
Start a new project
•
Right click on the scene in the world tree and add a new sprite
•
Select the new sprite by clicking on it on the central canvas
•
Scroll down to the Actions List section and “+” button that is located in that section to add a new actions list.
•
Enter a name for the actions list and tick the “Play” check box to ensure that it auto-plays
•
Click the “Edit” button at the side of the actions list to go to the actions list editor
•
Select the “Movement” tab in the actions view, this will show a collection of actions that are related to object movement
•
Click the “+” button at the side of the “MoveTo” action, this will add a new action to the actions list
•
Change the position property in the action to 100,100 and the time to value to 5
•
Click the “+” button at the side of the “MoveTo” action again, this will add another new action to the actions list
•
Change the position property in the action to -200,100 and the time to value to 2
•
Exit the actions list editor and click the “Test” button to launch the game. The object will be seen moving to position 100,100 over 5 seconds, then will move to
-200,100 over 2 second.
Page 139 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Tiled Maps
Booty5 features tile and collision map editing via the MapActor type. To turn any ordinary sprite in the game maker into a tiled map actor, change the RenderAs property to “Tile
Map”. This will enable a new section in the sprites property panel called “Tile Map properties”. In this section you can set a number of properties that affect the generated tiled map. These properties include:
•
Tile Size - Width and height of tiles in the tile map in pixels
•
Map Size – Width and height of the tile map in cells
•
Display Size – Width and height of the map area to display on screen when running in the game engine, this can be used to drastically reduce the total number of tiles rendered. If the map is very small or you wish to rotate, scale or translate the map then set the display size to the same size as map size
•
Collision Tiles – Contains a brush that will be used to provide collision tiles, collision tiles should be the same size as visual tiles
•
Export collision – If set to true then collision map tiles will be exported with the visual map
•
Edit Map button – Allows you to edit the tile map
Clicking the Edit Map button will open up the tile map editor that shows the map and its associated tile set. The tile set is taken from the bitmap from the attached brushed. The tile editor looks as follows:
Page 140 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
The tile map editors canvas contains the following basic visual aids:
•
Canvas - The main central area that displays and allows editing of the map / collision map
•
Grid - The grid's purpose is to give spatial and scale feedback
•
Selection area – When an area of the map is selected a green overlay will be displayed over the area
•
Tile set - The area over to the right hand side that displays available tiles / collision tiles
•
Map coordinates - The map coordinate at the current mouse position will be displayed to the top left
Navigation in the tile map editor is similar to navigation on the main canvas:
•
Middle mouse – Holding down the middle mouse button and dragging in a direction will move the camera in that direction
•
Mouse wheel – Zoom in and out, hold down left control to slow down zoom
The main purpose of the tile map editor is to allow the editing of visual and collision tile maps. Operations in this editor include:
•
To select a tile click on the tile in the tileset on the right hand side of the window
•
To paint, click a grid cell or drag the mouse around the map holding down the left mouse button to paint tiles. You can use the right mouse button to remove tiles
(set cells to tile 0 that is)
•
To select a map cell or an area of cells hold down the left shift key then drag the mouse over the area you wish selected
•
Pressing the DELETE key will delete the currently selected area of tiles (sets them all to tile 0)
•
Pressing the SPACE BAR key will fill the currently selected area of tiles with the currently selected tile
•
You can copy and cut the currently selected area of tiles using CTRL + C and CTRL
+ X
•
You can paste the last copied area to a new area by selecting the top left hand corner of where you would like the tiles to go then press CTRL + V
•
Pressing CTRL + Z will undo the last action
•
Exiting the tile map editor will save all changes, to undo changes made after exiting press CTRL + Z on the main canvas
•
To switch between visual and collision tile editing modes click the Visual / Collision toggle button or press the TAB key
Page 141 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Project Properties
To open the project properties widow click the Project button that is located on the main tool bar at the top of the screen. The project properties panel is where you set up the various options that relate to your project, mainly related to export. An image of the project properties window is shown below:
The general section of the project properties panel has the following options:
•
Title – The name of your game
•
Frame Rate – The target rate at which your games logic should be updated in frames per second (default is 60)
•
Override Step – If set then physics in all scenes will be updated at this rate, overriding any values set in the scene
•
Canvas Fit – The method the engine will use to fit the HTML5 canvas to the client browser window
•
IDE Location – An external IDE location, Booty5 automatically searches for a
JetBrains WebStorm IDE by default
•
Clear Canvas – When checked the games background will be cleared at the start of each frame. You can disable this for games that use the entire drawing area to help performance
Page 142 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
•
Adaptive Physics – If set to true then the game will run physics multiple times if frame rate drops considerably below target frame rate
•
Disable shadows – Disables shadow rendering globally
•
Pretty Print – If enabled then exported JSON will be exported in a human readable format
•
Smoothing – If enabled then image smoothing will be applied which cam blur pixel based images substantially but gives an overall smoother look to the game
•
Force Rounding – If set to true then all exported actors in all scenes will round pixels
•
Use Web Audio – If set to true then Web Audio will be used to play audio, if it is unavailable then the engine will fall back to HTML5 Audio
The loading options section of the project properties panel has the following options:
•
Wait for resources – If checked then the game will delay launch until all resources are loaded, displaying a loading screen
•
Loading bar BG – The colour of the loading bar background
•
Loading bar – The colour of the loading bar
•
Loading BG colour – The loading backgrounds colour
•
Loading image – An image that will be displayed in the background of the loading screen
The modules section contains a list of additional modules that can be included with your game:
•
Box2D physics – Includes the Box2D physics module
•
JQuery library – Includes the JQuery library module
•
CocoonJS library – Includes the CocoonJS library module
The Marmalade tab has the following options:
•
Export MKB – When ticked a Marmalade SDK compatible Web Marmalade project will be exported in the marmalade sub folder during test / run. This project can be opened using the Marmalade Hub and deployed to device / app stores.
Page 143 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Importing SVG
Booty5 supports the import of SVG data that is exported by modern SVG editing packages such as Inkscape and Adobe Illustrator. This is useful if you have art work. game layouts, geometries or physics shapes that are in a SVG format as you can import them directly into Booty5. To import a SVG file simply drag and drop it onto the world tree or onto an existing scene within the world tree. The Booty5 game editor will import all scenes, images, brushes, shapes, geometries and actors that are defined within the SVG file.
The SVG importer will convert the following SVG objects:
• svg tag is converted to Scene and will convert attributes as shown below:
â—¦ id – This becomes scene name
â—¦ width, height – These become the scenes CanvasSize
• group tag is not used except for the layer attribute which is applied to all actors within that group and the transform
•
Rects will be imported as and will convert attributes as shown below:
â—¦ id – This becomes the shapes name
â—¦ width, height – These become the shapes width and height
â—¦ label (Inkscape SVG format only) – If label is set to “circle” then the shape will imported as a circle shape with the radius set to half the width of the rect
•
Images will be converted to Sprite actors which support the following attributes:
â—¦ id – This becomes the actors name
â—¦ x, y – These become Position
â—¦ width, height – These become Size
â—¦ transform – These become Position, Scale and Angle (does not support transform hierarchies)
â—¦ style.colour – This becomes Colour
â—¦ onclick – Becomes OnTapped event handler
â—¦ onmousedown – Becomes OnBeginTouch event handler
â—¦ onmouseup – Becomes OnEndTouch event handler
â—¦ onload – Becomes OnCreate event handler
â—¦ description – This is output directly within the tag, which allows you to add your own custom attributes
•
Paths will be converted to shapes which support the following attributes:
â—¦ id – This becomes the geometries name
â—¦
Path commands are converted to coordinates
These features enable you to use SVG editors such as Inkscape as game layout editors to lay out levels and design complex shapes then import them into Booty5.
There are a few tips you should follow when using the likes of Inkscape to create Booty5 compatible data:
•
Only single polygon shapes should be created
•
All nodes are classed as vertices with no rounding and all lines are classed as straight with no control nodes
Page 144 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Deploying to Mobile Devices
There are a number of ways to deploy HTML5 games and apps to mobile. So far Booty5 has been tested using the following methods:
•
Web – This is where you deploy HTML / JavaScript and other assets to a web server. The visitor visits the web site on a mobile device using the devices web browser. Using this method you usually have problems with full screen and lower frame rates. In addition some browsers are slower than others, for example the default Android browser is in the region of 10x slower than Google Chrome on
Android
•
Package app using the Marmalade SDK – Your HTML / JavaScript and assets are packaged into a native app which uses a native web view to run your HTML5 app as well as provides additional API’s that provide access to various device features
(Booty5 uses the Marmalade Media API for audio playback) This method allows you to submit your game to the app stores
•
Package app using Ludei CocoonJS – Your HTML / JavaScript and assets are packaged into a native app which uses a highly optimised custom native web view to run your HTML5 app as well as provides additional API’s that provide access to various device, social and monetisation features .This method allows you to submit your game to the app stores
•
Package app using the Intel XDK – Your HTML / JavaScript and assets are packaged into a native app which uses a native web view to run your HTML5 app as well as provides additional API’s that provide access to various device features .This method allows you to submit your game to the app stores
Deploying to the Web
To deploy your game to the web simply follow these steps:
•
Hit Run from Booty5 game maker, this will export an html folder into your project folder
•
Navigate to the html sub folder in explorer exported from Booty5, copy all files and folders within that folder into your web space
•
Navigate to your web space using a web browser to run your game (index.html)
Deployment with Marmalade Web
To deploy your game using Marmalade Web simply follow these steps:
•
In your projects properties, select the Marmalade tab and tick the “Export MKB” option
•
Hit Run from Booty5 game maker, this will export an html and marmalade folder into your project folder
•
Open the Marmalade Hub, select Marmalade Web, on the next screen select import project then select the MKB file that is located in your exported marmalade folder
•
Now open the project and select which platform you would like to deploy to from the list of available platforms
•
Ensure that release build is selected then hit the package and install button, this will package your app as a native app and install it to the devices that you have plugged into the USB port
Page 145 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Note that once you have imported the exported marmalade MKB from Booty5 you should not need to keep re-importing the MKB
Deployment with Ludei CocoonJS
To deploy your game using Ludei’s CocoonJS simply follow these steps:
•
Hit Run from Booty5 game maker, this will export an html folder into your project folder
•
Navigate to the html sub folder, select all files within the folder and add them to a zip file
•
Visit the Ludei website and go to your projects section and create a new project or edit an existing project
•
Select the “Compile a project” action from the left hand menu
•
Drag the zip file that you created earlier onto the “Zip File” section
•
Select which platforms you would like to deploy your app to then click the “Compile
Project” button
•
After a few minutes your project will be compiled, at which point you can download it from the projects section and install to device to test
Deployment with Intel XDK
To deploy your game using Intel XDK simply follow these steps:
•
Hit Run from Booty5 game maker, this will export an html folder into your project folder
•
Launch Intel XDK and create a new blank project
•
Navigate to the html sub folder exported from Booty5 in explorer, copy all files and folders within that folder into the www sub folder of your created Intel XDK project
•
In Intel XDK select the Test tab and follow the instructions to install your app to device
Page 146 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Resource Property Reference
In this section we cover the various properties for each of the different types of resources to give you a better understanding as to what they all mean. Booty5 supports tool tips which give you a brief description of what each property is. Note that when naming resources, resources of the same type should not generally share the same name. Booty5 in many instances will generate a unique name for each object that is created.
World Properties
World properties relate to the app as a whole and not to any particular resource. To access the World properties click on an empty area of the canvas or lick the World button on the canvas. These properties include:
Precision properties
•
Import precision – Sets the number of decimal places that coordinates will be rounded to when importing geometry data into Booty5
•
Export precision – Sets the number of decimal places that coordinates will be rounded to when exporting data out of Booty5
Editing properties
•
Move speed – Sets the speed at which to move objects on the canvas with cursor keys
•
Rotate speed – Sets the speed at which to rotate objects on the canvas with Z/X keys
•
Scale speed – Sets the speed at which to scale objects on the canvas with Page
Up / Down keys
•
Mouse rotate speed – Speed at which to rotate objects on the canvas when rotating with the mouse
Snapping properties
•
X snap range – Range at which to snap edges and vertices horizontally
•
Y snap range – Range at which to snap edges and vertices vertically
•
Inclusion range – Range at which to consider objects for edge and vertex snapping.
Can be used in heavily populated scenes to improve snapping selection
Virtual screen properties
•
Virtual screen size – Sets the design size of the screen that the app will work with, this also decides where docked actors will be docked.
•
Show screen – Enables a preview of the virtual screen size on the canvas
Page 147 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Image Properties
Image properties relate to image resources and have the following properties:
•
Name – Name of this image resource
•
Folder – Sub folder to export this resource to
•
Tag – Resource tag (used to group resources together)
•
Location – File name of the image file including extension (can include web addresses)
•
Preload – If set to true then the image will be loaded immediately when the game boots (global resources) or when the scene loads (local resources)
The Image properties panel contains a “Locate” button which can be used to locate the images file in explorer.
Brush properties
Brush properties relate to brush resources and have the following properties:
•
Name – Name of this brush resource
•
Tag – Resource tag (used to group resources together)
•
Brush Type – The type of brush (image or gradient)
Image brush properties
•
Image – Sets the image that is associated with the brush. You can click the change image button to choose from a list of available images.
•
Rect (x, y, width, height) – A rectangular area that represents a sub image of a larger image
•
Anim Frames – A collection of rect (x, y, width, height) frames that represent sub images within a larger image that will be used to create a bit-mapped based animation. You can use the Add/Remove buttons to “Add” and “Remove” animation frames. You can also use the “generate” button to auto generate frames from a sprite atlas.
•
The Brush properties panel contains a “Locate” button which can be used to locate the image that is assigned to the brush in the world tree.
The Brush Preview shows you where the brush is located in the source texture, whilst the
Animation Preview shows a preview of the animation.
Gradient brush properties
•
Gradient stops – A collection of gradient stops, each gradient stop has a colour and an offset, with the offset having a value of between 0 and 1, specifying how far along the gradient the colour stop should take affect. You can use the Add/Remove buttons to “Add” and “Remove” colour stops.
Page 148 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Sound Properties
Sound properties relate to sound resources and have the following properties:
•
Name – Name of this sound resource
•
Folder – Sub folder to export this resource to
•
Tag – Resource tag (used to group resources together)
•
Location – File name of the sound file including extension (can include web addresses)
•
Fallback Lcation – File name of the sound file including extension (can include web addresses) that will be used if the sound file at Location is not compatible
•
Preload – If set to true then the sound will be loaded immediately when the game boots (global resources) or when the scene loads (local resources)
•
Reuse – If set to true then this sound effects instance will be shared and re-used instead of creating a new instance each time it is played
•
Loop – If set to true then sound file will be looped when played
•
Auto Play – If set to true then sound will play as soon as it has loaded
The Sound properties panel contains a “Locate” button which can be used to locate the sound file in explorer.
Shape Properties
Shape properties relate to physics, visual and clipper shape resources and have the following properties:
•
Name – Name of this brush resource
•
Tag – Resource tag (used to group resources together)
•
Type – Type of shape (box, circle or polygon)
•
Width – Width of shape if it is a box or radius of shape if it is a circle
•
Height – Height of shape if it is a box
•
Absolute – If true the vertices that make up the polygon shape will be classed as though they are in world coordinates, otherwise shape vertices will be classed as local
•
IsPath – If true then this shape will not be classed as a path and not a shape
When the type of shape is set to Polygon an “Edit shape” button will appear that allows you to edit the shape.
Material Properties
Material properties relate to physics material resources and have the following properties:
•
Name – Name of the physics material
•
Tag – Resource tag (used to group resources together)
•
Type – Type of physics material (values can be static, dynamic and kinematic)
•
Density – The objects density (default is 1.0)
•
Friction – The coefficient of friction (default is 1.0)
•
Restitution – The coefficient of restitution / bounciness (default is 0.1)
•
Gravity Scale – This is the amount to scale the affect of gravity on objects that this
Page 149 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood material is attached to (default is 1.0)
•
IsBullet – If set to true, will force the object that this material is attached to to be treat as a high speed moving object (required more processing so use wisely)
(default is false)
•
Fixed Rotation (boolean) – If set to true then the object that this material attaches to will not be allowed to rotate (default is false)
Script Properties
Script properties relate to script resources and have the following properties:
•
Name – The name of the script file
•
Tag – Resource tag (used to group resources together)
•
Location – The location of the script file
•
Type – The type of script, can currently select between Lua, JavaScript, C#, C++ and Python etc..
•
Load – If true then the script will be loaded on application start, otherwise you will need to manually load the script
Scene Properties
Scene properties relate to scene resources and have the following properties:
General Properties
•
Name – The name of the scene is a very important property and should be chosen so that it does not conflict with names of other scenes that are present at the same time. It is possible to have multiple scenes with the same name, but only one of those scenes can be created. It is possible to destroy a scene and create a new scene of the same name. A scene name should also be memorable as you may want to refer to the scene from other areas in the game
•
Export Name – Name of the scene in its exported file, this allows you to specify a different scene name to its exported file name
•
Tag – Resource tag (used to group resources together)
•
Layer – The visual layer that this scene should be rendered on (not currently used)
•
Extents (x, y, width, height) – A rectangular area that describes the extents of the scenes world. The camera will be prevented from moving beyond the extents range and actors that have Wrap Position set to true will wrap from one side of the extents to the other when they travel beyond the extents
•
Frozen – When scene is frozen it cannot be selected on the canvas
•
Active – The active state of a scene determines if the scene is processing its contents. If not active then scene processing will stop and any content that is contained within the scene will also stop processing
•
Has focus – If true then the scene is made the current focus scene
•
Secondary focus – If true then the scene is made the secondary focus scene.
Objects in the secondary focus scene will receive messages if nothing in the primary focus scene receives a message
•
Export At Origin – The scene will be exported as though it is located at the 0,0 origin regardless of its position
•
Load – If set to true then this scene will be loaded and ran on boot
Page 150 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Camera Properties
•
Position (x, y) – The position of the scene in virtual canvas coordinates
•
Camera (x, y) – Scenes initial camera position
•
Touch Pan – When touch panning is true the user will be able to use their finger or mouse to move the camera around the scene, Panning can be locked to a single axis or both
•
Target X – Sets the actor that the camera will follow on its x-axis. You can click the change target button to choose from a list of available camera targets
•
Target Y – Sets the actor that the camera will follow on its y-axis. You can click the change target button to choose from a list of available camera targets
•
Follow Speed (x, y) – The speed at which the camera should track the specified target actor(s). Higher values will catch the camera up to the actors target position faster
•
Velocity Damping (x, y) – Amount of damping to apply to the cameras velocity (x, y) each frame. This value when set to a value of less than 1.0, 1.0 will cause the camera to slow down over time.
Visual Properties
•
Visible – If a scene is not visible then it will be hidden from view, although the scene and its contents will still be processed.
•
ClipChildren – When true the scene will clip its children
•
Colour (r, g, b, a) – The colour of the scene, Each component red, green, blue and alpha should be between the value of 0 and 255 (0 is no colour, whilst 255 is full colour)
•
CanvasSize (x, y) – The virtual screen size
•
CanvasFit – Currently unused
•
ClipShape – The shape that will be used to clip children, if none supplied then a rectangle the size of scene will be used. You can click the change clip shape button to choose from a list of available shapes.
User Properties
•
Name – The name of the property
•
Value – The properties value
•
Type – The type of the property
To add a new user property click the Add button in the User properties section. To remove user properties, select them in the user properties section then click the Remove button.
User properties will be written to the created scene object and can be accessed as usual properties.
Page 151 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Actions List Properties
•
Name – Name of actions list
•
Repeat – number of times to repeat actions list, 0 is forever
•
Play – If true then actions list will automatically play when object is created
•
Edit – Opens the actions list editor
To add a new actions list click the Add button in the Actions List section. To remove actions lists, select them in the Actions List section then click the Remove button. To Edit an actions list. Click the Edit button at the side of the actions list you wish to edit.
Physics Properties
•
Physics – Enables or disables physics processing in the scene. Can only be set when scene is declared
•
DoSleep – If set to true then actors that utilise physics will be allowed to sleep when they are not moving / interacting, can speed physics simulation up greatly by enabling this options
•
Gravity (x, y) – Box2D directional world gravity (default is 0.10)
•
World Scale (x, y) – Box2D world scale (default is 10,10)
•
Physics Timestep – Sets how fast the physics engine updates the physics world in seconds (default value is 0.3333)
Event Properties
•
OnCreate – Provides a list of actions that is called when the scene is created
•
OnDestroy – Provides a list of actions that is called when the scene is destroyed
•
OnTick – Provides a list of actions that is called every time the scene is updated (30 to 60 times per second), Quick maps this to update event
•
OnTapped – Provides a list of actions that is called when the screen is tapped when this scene has focus
•
OnBeginTouch – Provides a list of actions that is called when the user begins touching screen whilst this scene has focus
•
OnEndTouch – Provides a list of actions that is called when the user stops touching screen whilst this scene has focus
•
OnMoveTouch – Provides a list of actions that is called when the user moves a touch on the screen whilst this scene has focus
•
OnOrientationChange – Not currently used
•
OnKeyPress – Provides a list of actions that is called when the user presses a key
•
OnKeyDown – Provides a list of actions that is called when the user presses a key down
•
OnKeyUp – Provides a list of actions that is called when the user stops pressesing a key down
Page 152 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Sprite Actor Properties
Properties in this section belong to the base Sprite actor type
General Properties
•
Name – Name of the actor, used to refer to the actor from scripts and such. Note that no two actors in the same scene should share the same name.
•
Tag – Resource tag (used to group resources together)
•
Position (x, y) – The actors position within the scene (default is 0, 0)
•
Scale (x, y) – The x and y axis scale of the actor (default is 1, 1, which represents no scaling)
•
Angle (degrees) – The angle of the actor (default is 0)
•
Origin (x, y) – Sets the offset around which the actor will rotate and scale (default is 0,0)
•
Layer – The visible layer that the actor should appear on (Not currently usedr
•
Render As – Change the type of actor from the base Actor to either ArcActor,
RectActor or MapActor. Note that actors that have a geometry attached will automatically be changed to a PolygonActor. Also changing to Tile Map will show a new section of properties called “Tile Map Properties”
•
Frozen – When actor is frozen it cannot be selected on the canvas
•
Active – Active state (default is true), actors that are not active will not be processed
•
Touchable – If true then this actor will receive touch events when touched (default is false)
•
Virtual – If selected the the actor becomes a container that clips its children and allows the user to drag the content around; the scroll range of the canvas is determined by the Scroll Range property and the initial scroll position is set by
Scroll Pos. Child actors that are docked will be docked to the edges of this actor instead of the screen and will not scroll.
Visual Properties
•
Visible – Visible state (default is true), actors that are not visible will not be shown on screen.
•
Filled – If set to true and object is set to render as a shape or has a shape attached then shape will be rendered filled, otherwise it will be rendered as an outline using stokr colour and thickness
•
FlipX – If true then this actors texture is horizontally flipped
•
FlipY – If true then this actors texture is vertically flipped
•
Orphan – if set to true then object will not obey its parents visual transforms
•
Use Parent Opacity – When set to true this actor will scale its own opacity by its parents opacity (default is true)
•
Ignore Camera – If set to true then this actor will ignore the cameras transformation staying in place when when the camera moves (default is false)
•
ClipChildren – if set to true then child actors of this actor will be clipped, if not clip shape is supplied then the extents of the parent actor will be used to clip against
•
SelfClip – if set to true then this actor will be clipped against the supplied clip shape
•
Cache – If set to true then this object will be pre-rendered to an off screen cached canvas when first drawn, subsequent rendering of this object will render the cached
Page 153 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood canvas, this can speed up rendering of geometry many times
•
Merge – if set to true then the object will attempt to render itself into the parents cache
•
Round Pixels – If enabled then vertices will be rounded to integer which can speed up rendering significantly but at a loss of precision
•
Size (x, y) – The world size of the actor
•
Background – This is the background brush that is displayed for this actor. You can click the change brush button to choose from a list of available brushes.
•
Colour (r, g, b, a) – The colour of the actor, Each component red, green, blue and alpha should be between the value of 0 and 255 (0 is no colour, whilst 255 is full colour, default)
•
Stroke Colour (r, g, b, a) – The colour of the actor when rendered unfilled, Each component red, green, blue and alpha should be between the value of 0 and 255 (0 is no colour, whilst 255 is full colour, default)
•
Stroke thickness – The thickness of the stroke
•
Corner radius – The radius of the corner for rounded rects (only works with actors that are overridden as rect)
•
Geometry – Sets the shape that will be used to render the actors shape, if no shape set then a rectangular sprite will be used. if supplied then actor will be exported as a PolygonActor. You can click the change geometry shape button to choose from a list of available shapes.
•
Depth – Depth of the actor in 3D (larger values move the sprite further away, default is 1.0 for parent actors and 0.0 for child actors)
•
Docking – When set will dock the actor to an edge of the scene or canvas (if a child of a canvas based Sprite actor), valid values are top, left, right, bottom, topleft, topright, bottomleft and bottomright
•
ClipShape – A shape that will be used to clip the actor and or its children. You can click the change clipping shape button to choose from a list of available shapes.
•
Composite Op – The composite operation to use when rendering this object
Tile Map Properties
•
Tile Size - Width and height of tiles in the tile map in pixels
•
Map Size – Width and height of the tile map in cells
•
Display Size – Width and height of the map area to display on screen when running in the game engine, this can be used to drastically reduce the total number of tiles rendered. If the map is very small or you wish to rotate, scale or translate the map then set the display size to the same size as map size
•
Collision Tiles – Contains a brush that will be used to provide collision tiles, collision tiles should be the same size as visual tiles
•
Export collision – If set to true then collision map tiles will be exported with the visual map
•
Edit Map button – Allows you to edit the tile map
Brush Animation Properties
•
Anim Frames – A collection of animation frames that specify the index of each frame of animation for an attached brush, not supplying this will force the actor to use the frames in the order in which they are supplied by the brush
•
Playback Speed – The speed at which to play back the attached brush animation in frames per second
•
Start Frame – The first bitmap frame that will be displayed for this object
Page 154 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Shadow and Gradient Properties
•
Shadow – If enabled then this object will be rendered with a shadow
•
Colour (r, g, b, a) – The colour of the shadow
•
Offset (x, y) – The x,y offset at which to render the shadow
•
Blur – The amount to blur the shadow
•
Gradient Start – The start position of the gradient
•
Gradient End – The end position of the gradient
User Properties
•
Name – The name of the property
•
Value – The properties value
•
Type – The type of the property
To add a new user property click the Add button in the User properties section. To remove user properties, select them in the user properties section then click the Remove button.
User properties will be written to the created actor object and can be accessed as usual properties.
Actions List Properties
•
Name – Name of actions list
•
Repeat – number of times to repeat actions list, 0 is forever
•
Play – If true then actions list will automatically play when object is created
•
Edit – Opens the actions list editor
To add a new actions list click the Add button in the Actions List section. To remove actions lists, select them in the Actions List section then click the Remove button. To Edit an actions list. Click the Edit button at the side of the actions list you wish to edit.
Other Properties
•
Spring – If this actor allows scrolling and the user scrolls out of bounds then the actor will spring back into place (much like the iOS UI system) (not currently used)
•
Bubbling – When set to true, touch events can bubble up from child actors to parents,
•
Clip Margin (left, right, top, bottom) – If this element contains children that are clipped then this margin will push the clipping inwards to create a border (left, right, top, bottom)
•
Scroll Range (left, top, width, height) – Sets the range that the contents of this actor can be scrolled. Used by virtual actors
•
Scroll Pos (top, left) – Sets the initial scroll position of the contained content. Used by virtual actors
•
Margin (left, right, top, bottom) – The amount of space to leave around the actor when placed in a container or docked. Used by virtual actors
Page 155 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Physics Properties
•
Velocity (x, y) – Initial velocity of the actor
•
Velocity Damping (x, y) – The amount to dampen velocity each frame, values of less than 1.0 will slow the actor down over time, values of greater than 1.0 will speed the actor up over time.
•
Angular Velocity – The rate at which the orientation of the actor changes in degrees per second
•
Angular Velocity Damping – The amount of rotational velocity damping to apply each frame
•
Wrap Position – If true then the actor will wrap at the edges of the canvas
Actors that do not have any fixtures attached will use a rudimentary fixtures system.
Actors that do have fixtures attached will apply the set velocities as impulses and will only be applied once.
The physics properties section contains two additional sections:
•
Fixtures – This contains a collection of physical fixtures that define the shape of the actor to the physics engine. Each fixture has the following properties:
•
Shape – The name of a shape resource that defines the shape of the fixture. If a physics shape is not supplied then a rectangular shape of the same dimensions as the actor will be used. You can click the select fixture shape button to choose from a list of available shapes.
•
Material – The physics material resource that defines how the fixture behaves. You can click the select fixture material button to choose from a list of available materials.
•
Flags (category, mask, group) – Box2D collision flags
•
SR – Is sensor, sensor objects will recognise collisions but will not respond to them
•
Joints – This contains a collection of joints that connect different actors together.
Each joint has the following potential properties (note that not all joints use all properties):
•
Name – Name of joint
•
Type – Type of joint (weld, distance, revolute, prismatic, pulley and wheel)
•
ActorB – Name of the actor that connects to this actor via the joint. You can click the select Actor B button to choose from a list of available actors.
•
OffsetA – The joint attachment position offset for this actor
•
OffsetB – The joint attachment position offset for other actor
•
GroundA (x, y) – Anchor point where pulley point for this actor is situated (pulley joints)
•
GroundB (x, y) – Anchor point where pulley point for the other actor is situated
(pulley joints)
•
Collide – Self colliding if true
•
Frequency – Oscillation frequency in Hz (distance joint)
•
Damping – Oscillation damping ratio (distance joint)
•
Limit – Limits the range of movement of the joint if enabled (revolute, prismatic, wheel joints)
•
Lower – Lower joint limit (revolute, prismatic, wheel joints)
•
Upper – Upper joint limit (revolute, prismatic, wheel joints)
•
Motor – If true then motor is enabled (revolute, prismatic, wheel joints)
•
Speed – Motor speed (revolute, prismatic, wheel joints)
•
Torque – Maximum motor torque (revolute joints)
Page 156 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
•
Force – Maximum motor force (prismatic, wheel joints)
•
Ref –reference angle, the initial angle between the two bodies. This is calculated if not supplied
•
Axis (x, y) – Axis of movement (prismatic, wheel joints)
Event Properties
•
OnTapped – When the user taps this actor it fires this event and calls the supplied actions list.
•
OnBeginTouch – When the user begins to touch this actor it fires this event and calls the supplied actions list.
•
OnEndTouch – When the user stops touching display and the touch pos hits the actor it fires this event and calls the supplied actions list.
•
OnLostTouchFocus – When the user stops touching this actor it fires this event and calls the supplied actions list.
•
OnMoveTouch – When the user moves a touch over this actor it fires this event and calls the supplied actions list.
•
OnCreate – When this actor is first created it fires this event and calls the supplied actions list
•
OnDestroy – When the actor is about to be destroyed it fires this event and calls the supplied actions list
•
OnTick – Provides an actions list that is called every time the scene is updated (30 to 60 times per second)
•
OnCollisionStart – When two actor that have Box2D physics enabled start to collide it fires this event and calls the supplied actions list
•
OnCollisionEnd – When two actor that have Box2D physics enabled stop colliding it fires this event and calls the supplied actions list
Label Actor Properties
Label properties relate to label (text based actor) resources. Labels are derived from the
Sprite actor inheriting all of its properties. In addition to those properties the following properties are provided to modify the text of the label:
•
Text – The text to display
•
Font – Name of font used to display text, e.g. Arial
•
Font Weight – Weight of font, e.g. Bold
•
Font Size – Pixel size of the font
•
Text Colour (r, g, b, a) – Colour of text
•
Text Stroke (r, g, b, a) – Stroke colour of text
•
AlignH – Horizontal alignment of text (left, right, centre)
•
AlignV – Vertical alignment of text (top, bottom, middle)
•
Wrap – Text will be wrapped if true
Page 157 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Basic Tutorials
In this section we present a number of basic tutorials that you may find helpful. All tutorial projects as well as the demo projects from booty5.com can be downloaded from Github .
My First Project
Creating a new project
To begin lets create a new project, click the “New” button on the main menu. You will be asked for a location to store the project, select a location from the directory selector then click Ok. This will create an empty scene called gamescene and an empty script file called
Common.js. Now save the project by clicking the Save button.
Creating your first scene
Booty5 uses scenes to separate sections of your app into components that contain all of the resources that are specific to that scene. Generally when the scene is loaded all of the resources within that scene will be loaded and when the scene is destroyed, all of the resources that were loaded by the scene will be destroyed. This is a sensible approach to use when developing large game with many resources as its not usually advisable to load all of your resources when the app starts because this would take a long time and would use large amounts of memory.
When we created a new project Booty5 automatically created an empty scene for us.
However, to add new scenes right click on the world tree and select “Scene” from the drop down menu. This will create a scene called “noname” in the world tree, the visual representation of the scene will also appear in the centre of the canvas as a semitransparent rectangle.
Adding an image resource
Image resources (bitmaps) are basically image files in JPEG or PNG format that can be used to supply the visual representation of a game or app object. To add the image resource to the scene simply drag the image file from explorer and drop it onto the scene in the world tree. After dropping the image onto the scene a small arrow will appear at the side of the scene name informing you that the scene now contains resources. To view the resources, click the arrow at the side of the scene name to expand it. You will see that two resources have been added.
The first resource is the image that you dropped onto the scene and has the same name as the file that you dragged on, whilst the second is a brush of the same name. In order to attach an image to an actor in Booty5 it must have a brush. A brush describes to the editor which image and what portion of the image you would like to display on the actor.
Page 158 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Adding a game object (actor)
Actors are the game objects that make up your game. To create one that displays an image simply drag the brush that was previously created onto the main central canvas.
This will create a Sprite actor (image based game object) that now exists inside your game scene. You can click on the actor on the main canvas and move it around by dragging it. You can also rotate it by holding down the right mouse button and dragging it, or hold CTRL + right mouse button to scale it.
If you drag the brush onto the canvas again, a new actor will be created. This is the primary way of adding new actors to the scene. You can also use the Resource menu at the top of the screen in the main menu. To do this, click on the resources tab in the main menu then click the Sprite button. This will create a small white square in the centre of the scene on the canvas, this represents an actor with no visible image attached. To add an image to the actor simply drag the brush from the scenes resources onto the actor on the canvas, alternatively drag the brush resource onto the actor on the world tree, this will assign the brush to the actor. Note however that the actors size will remain 32 x 32 pixels in size. In order to change the size of the actor to the new size you require, click on the actor either in the world tree or on the canvas and change the size parameter in the properties panel over on the right.
Running a test
Now that we have a few objects in the scene, lets see how it looks when ran. To test the project click the Test button that is located under the File tab of the main menu at the top of the screen. This will export your project and open it up in the default web browser. You can use the JavaScript console to view any errors as well as debug output.
Lets make something spin
Animation is a big part of games, Booty5 allows you to set various physical properties of actors such as linear velocity and angular velocity. Angular velocity is the rate at which something is rotating. To make an actor spin, select the actor then locate the Angular
Velocity property under the Physics Properties section, you may need to collapse property sections or scroll down the property panel to find it. Enter the value 100 into the property then press tab to ensure that the value has been written. Now click the Test button again, you will notice that this time the object spins to the right at a rate of 100 degrees per second.
You can see an example of this tutorial running here
Page 159 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Basic Physics
Physics in Booty5
Many modern 2D and 3D games use physics to make interactions within the game more realistic. Many of the modern 2D game engines use physics engines such as Box2D to drive interactions between game objects The internal Booty5 game engine uses the
Box2D engine under the hood.
The Booty5 editor enables you to create and attach physics materials and shapes to objects on the main canvas. Objects that have at least a physics material attached will be placed under control of the physics engine.
A physics shape gives the object that it is attached to its shape in the physical world.
When a physics shape is attached to an actor, it creates a fixture. A fixture defines the physical shape, physical material, collision flags and other properties that are assigned to the actor. You can actually attach multiple fixtures to the same actor to create more complex objects. The physical material describes how the object will behave in the physical world such as how much friction and how bouncy collision should be between the object and others.
Page 160 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating a scene with objects under control of physics
•
Download the tutorial resources from here and unzip them to a folder somewhere
•
Lets begin by creating a new project in Booty5 by clicking the New button in the main menu
•
Now lets create some images and brushes by dragging the supplied resources onto the world tree (crate.png and ground.png), this will create the crate and ground images and brushes
•
Drag and drop the ground brush onto the main canvas, this will create a ground actor
•
Drag and drop the crate brush onto the canvas around 200 pixels above where you dropped the ground, this will create a crate actor that is situated above the ground
•
Right click on the scene in the world tree and select New->Material, this will create a new physics material within the scene
•
Select the new material in the world tree and then change its name in the properties panel to “static”, also change its type to “static”; changing the material type to static tells Booty5 that the objects that are assigned this material will be static and unmoveable
•
Right click on the scene in the world tree and select New->Material again, this will create a new physics material within the scene
•
Select this new material in the world tree and then change its name in the properties panel to “dynamic”, leave the default type as “dynamic”, a dynamic material informs Booty5 that the objects that are assigned this material are dynamic and move around
•
Drag the static material from the world tree onto the ground actor that you placed onto the canvas earlier, this creates a physics fixture that utilises the static material and assigns it to the ground actor. If you look under the physics section of the actors properties you will see that a new fixture has appeared in the fixtures section that contains the static material. We assign the static material to the ground because we do not want it to move
•
Drag the dynamic material from the world tree onto the crate actor that you placed onto the canvas earlier, this creates a physics fixture that utilises the dynamic material and assigns it to the crate actor
Now hit the Test button in the main menu. You will see that the box falls from its original position because it is under the affect of gravity, when it hits the ground actor it stops because the ground is static and cannot move. We can spruce the interaction between the crate and ground up a little by adding some bounciness. To do this we need to make the crate more bouncy:
•
Select the dynamic material in the world tree
•
Change the Restitution property in the properties panel over on the right to 0.5, this makes the interaction between crate and ground more bouncy
Now hit the Test button again an you will notice that the crate bounces on the ground a number of times before settling at rest.
You can view the finished project for this tutorial here
Page 161 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Parallax Scrolling
Parallax scrolling or more commonly known as parallaxing is the effect usually used in 2D games that gives the impression of 3D depth. Whilst Booty5 does not currently support 3D it does support depth sprites / actors.
Depth Sprites
Depth sprites are sprites that are projected into the 3rd dimension. In real terms that means that sprites that are at a greater depth will move more slowly and be smaller than sprites of the same size but at a lesser depth. Actors have a “depth” property that tells the engine at which depth they should be rendered. Note that Depth does not affect visual ordering and Booty5 does not currently apply depth when rendering depth sprites to the editors canvas. Currently you will only see the affect of depth when you run a test from the editor.
Page 162 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Creating our first depth sprite
•
Download the tutorial resources from here and unzip them to a folder somewhere
•
Lets begin by creating a new project in Booty5 and dragging the supplied resources onto the Booty5 world tree to create the images and brushes that are needed for this tutorial
•
Drag and drop the building brush onto the canvas to create a building actor
•
Select the building actor and set its depth to 1.5
•
Clone the building actor 3 times and arrange them across the main canvas
•
Drag and drop the tree brush onto the main canvas to create a tree actor
•
Select the tree actor and set its depth to 1.25
•
Clone the tree actor 9 times and arrange them across the main canvas
•
Drag and drop the ground brush onto the main canvas, this will create a ground actor
•
Select the ground actor and clone it horizontally 3 times (we are creating a long strip of ground)
•
Drag and drop the crate brush onto the main canvas to create a crate actor
•
Select the crate actor and set its depth to 0.75
•
Clone the crate actor 2 times and arrange them across the canvas
•
Select the scene and change Touch Pan to “Both”
•
Set Extents to “-1000,-500,2000,1000″ to limit the cameras extents
•
Hit the Test button
When you hit Test, things will not look exactly as they do within Booty5, objects will not seem to be in their correct places or have the correct sizes. This is normal, because we changed the depth values of various actors they have now been projected into 3D. Pan the camera around and you will see that actors with greater depth values move more slowly the further away they are.
Many developers use parallaxing effects to spruce up their games, now you can too
Visual Ordering
As previously mentioned the Depth of an actor does not determine its visual order. If you take a look at the order in which we created the actors for this project you will notice that we started by creating the objects that were the furthest away (the buildings) and ended with creating the objects that are the closest (the crates). if you are using depth in a scene then you have 3 options to help you sort visual ordering of the objects:
•
Create the objects in back to front order. This basically means what we did above, we create the objects that are the further first and work our way towards the objects that are the closest
•
Create the objects in any order then re-order them manually using the ordering tools in the world tree view
•
Set the actors layer based on its depth
You can view the finished project for this tutorial here .
Page 163 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Swinging Barrel
Many modern games usually feature nice touches such as swinging platforms, ropes and other objects. In this tutorial we are going to look at how we can create such nice effects by creating a swinging barrel on a rope that is completely under control of the physics engine.
The swinging barrel is basically 3 objects tied together using physical joints:
•
The main anchor – This is an object that the top end of the rope connects to, in this case we have used a crate
•
The rope – This is a length of rope that attaches to the bottom of the crate at its top end and to a barrel at its bottom end
•
The barrel – This is an object that attaches to the end of the rope and swings with the rope
Creating the swinging barrel basics
•
Download the tutorial resources from here and unzip them to a folder somewhere
•
Lets begin by creating a new project in Booty5 and dragging the supplied resources onto the Booty5 world tree, this will create the crate and ground images and brushes
•
Drag a crate brush, a rope brush and a barrel brush onto the main canvas to create the crate, rope and brush objects
•
Position the objects so that the rope is stacked on top of the barrel and the crate is stacked on top of the rope
Page 164 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Hooking up the physics
•
Create a new physics material and call it static, also change its type to “static”, this material will be attached to objects that cannot be moved
•
Create a new physics material and call it dynamic, also change its type to
“dynamic”, this material will be attached to objects that can move
•
Drag the static material from the world tree and drop it onto the crate on the main canvas, this will add a fixture to the crate that uses this material
•
Drag the dynamic material from the world tree and drop it onto the rope and then the barrel on the main canvas, this will add a fixture to them both that uses this material
Creating the joints
To attach our physical objects together we need to create joints that describe which objects attach to which and how they attach. We are going to create two joints, the first will attach the rope to the crate and the second will attach the barrel to the rope:
•
Select the crate actor then locate the actors physics section in its properties
•
Click the Add button in the joints section, this will create a new joint
•
Change the joint type to “revolute”, this type of joint attaches objects together but allows the joint to rotate
•
Set the ActorB property of the joint to “rope1″, this tells Booty5 to attach the other end of the joint to the rope, because the joint is defined inside the crate actor,
Booty5 already knows that the first end of the joint should attach to the crate
•
Now set the OffsetA to “0,71”. OffsetA is the offset on the crate where we want the joint to attach, because the origin of the crate is at its centre we want to move the joint attachment point to the bottom of the crate (71 is half the crates height)
•
Select the rope actor and add a new joint
•
Change the joint type to “weld” (weld joint basically attaches two objects together with no freedom of movement) and set ActorB to “barrel1″, this attaches the barrel to other end of the rope
•
We want our rope to swing in a way that makes it look like it is attached to the bottom of the crate, however Booty5’s default origin for an actor is at its centre position. In order to make the rope rotate around the top end of the rope we must move its origin. To adjust the origin so that it does rotate around its top end, select the rope actor and enter “0,76” into the Origin property (76 is half the ropes height)
•
Changing the ropes origin will move the rope on the canvas, reposition the rope so that the top end attaches to the bottom of the crate
•
Now go back to the ropes joint properties and enter “0,152” into the OffsetA property, this will attach the barrel at the very end of the rope (the rope is 152 units long)
•
We want the barrel to be attached to the end of the rope at its top, like we did with the rope we need to adjust its Origin to ensure that it does. Enter “0,51” (51 is half the barrels height) into the barrels Origin property to reposition its origin. You will also need to move the barrel on the canvas so that its top connects with the end of the rope
•
Now in order to see the rope swinging we need to give it some initial angular velocity. Select the rope actor and enter “100” into the Angular Velocity property
•
Hit the Test button to test
Page 165 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
You should now see the rope attached to the crate swinging with the barrel attached to the end of the rope.
You can view the finished project for this tutorial here .
Page 166 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Ping Pong Game
In this tutorial we are going to create a complete working game example, albeit a very simple Ping Pong game. The aims of this tutorial are very simple:
•
Show you how to handle user input
•
Show you how to use a main loop (Scene OnTick)
•
Show you how to detect collisions
•
Show you how to use script to interact with the scene and resources
Creating the playing field
We are going to create a playing field that consists of two bats and a ball. The basic aim of the game is for you to knock the oncoming ball back towards the computer AI player and try to knock the ball past him. Lets take a look at how the play field is laid out in Booty5:
•
Download the tutorial resources from here and unzip them to a folder somewhere
•
Lets begin by creating a new project in Booty5 and dragging the supplied resources onto the Booty5 world tree to create the resources that are needed for this tutorial
•
Drag and drop two bat brushes onto the scene to create 2 bats
•
Select the top bat and change its angle to 180 degrees
•
Drag the ball brush onto centre of the canvas to create a ball at the centre
•
Select the ball actor and change its Velocity property to 50,300
Page 167 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Game Code
At this point we need to copy the game code directly into Common.js. Copy and paste the following code directly into that file: var difficulty = 4 var ball; var player1; var player2; var bat_hit;
// CreateGame is called by the scenes OnCreate event handler function CreateGame(scene) {
// Find ball, players and sound effect
// We cache these resources so we dont have to search for them again
// You do not have to do this but it can help to give a little extra speed
// In more complex games
ball = scene.findActor( "ball1" , false );
player1 = scene.findActor( "player1" , false );
player2 = scene.findActor( "player2" , false );
bat_hit = scene.findResource( "bat_hit" , "sound" );
}
// UpdateGame is called by the scenes OnTick event handler function UpdateGame(scene) {
// Make player1 track players finger var touch_pos = scene.app.touch_pos;
player1._x = touch_pos.x;
// Check for collision between ball and players if (ball.vy > 0) {
// Only check ball against player1 if ball travelling down screen if (player1.overlaps(ball)) { var dx = player1.x - ball.x;
ball.vx = -dx * 6;
ball.vy = -ball.y;
bat_hit.play();
}
} else {
// Only check ball against player2 if ball travelling up screen if (player2.overlaps(ball)) { var dx = player2.x - ball.x;
ball.vx = -dx * 6;
ball.vy = -ball.y;
bat_hit.play();
}
}
// Handle player2 AI if (ball.vy < 0) { var dx = ball.x - player2.x; if (dx < -10)
player2._x -= difficulty; else if (dx > 10)
player2._x += difficulty;
}
// Keep ball within screen boundaries
Page 168 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood if (ball.x < -512 || ball.x > 512)
ball.vx = -ball.vx;
// Reset ball if it gets by a player if (ball.y < -350 || ball.y > 350)
ball._y = 0;
}
Initialising the game
We want to set up some things when our scene is first created, we will only be setting them up once. To do this we add some code to the scenes OnCreate event handler. To do this:
•
Select the scene in the world tree
•
Scroll down to the events section and locate the event handler called OnCreate
•
Click in OnCreate box and enter “CreateGame(this);”, this assigns a small piece if script to be called when the scene is first created. Note that the “this” parameter refers to the scene that is being created
If you take a look at the script file common.js in the world tree you will see the following:
// CreateGame is called by the scenes OnCreate event handler function CreateGame(scene) {
// Find ball, players and sound effect
// We cache these resources so we dont have to search for them again
// You do not have to do this but it can help to give a little extra speed
// In more complex games
ball = scene.findActor( "ball1" , false );
player1 = scene.findActor( "player1" , false );
player2 = scene.findActor( "player2" , false );
bat_hit = scene.findResource( "bat_hit" , "sound" );
}
The above script function is the one that will be called when the scene is created.
Updating the game
Most games use what’s called a main loop or tick function to update objects regularly. This is basically some kind of functionality that is called every time the game needs to update
(most modern devices update at around 60 times per second or more, otherwise known as the frame rate). In order to update our game logic we need to tap into this update mechanism and insert our game logic. To do this:
•
Select the scene in the world tree
•
Scroll down to the events section and locate the event handler called OnTick
•
Click in OnTick box and enter “UpdateGame(this);”, this assigns a small piece of script to be called each time the scene is updated. Note that the “this” parameter refers to the scene that is being created
The scenes OnTick event is raised every time the game needs to update itself, we tap into this mechanism by responding to the OnTick event calling our own script function
UpdateGame()
If you take a look at the UpdateGame() script function in common.js you will see that this
Page 169 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood is the place where our logic resides. This logic does the following:
•
Tracks the players finger and moves player1 to the players finger position
•
Keeps the ball within the scenes boundaries and resets it if it gets by a player
•
Controls the player2 AI opponent bat
•
Checks and handles collision between the bats and ball, playing a sound effect when a collision occurs
Lets take a look at the code for this function:
// UpdateGame is called by the scenes OnTick event handler function UpdateGame(scene) {
// Make player1 track players finger var touch_pos = scene.app.touch_pos;
player1._x = touch_pos.x;
// Check for collision between ball and players if (ball.vy > 0) {
// Only check ball against player1 if ball travelling down screen if (player1.overlaps(ball)) { var dx = player1.x - ball.x;
ball.vx = -dx * 6;
ball.vy = -ball.y;
bat_hit.play();
}
} else {
// Only check ball against player2 if ball travelling up screen if (player2.overlaps(ball)) { var dx = player2.x - ball.x;
ball.vx = -dx * 6;
ball.vy = -ball.y;
bat_hit.play();
}
}
// Handle player2 AI if (ball.vy < 0) { var dx = ball.x - player2.x; if (dx < -10)
player2._x -= difficulty; else if (dx > 10)
player2._x += difficulty;
}
// Keep ball within screen boundaries if (ball.x < -512 || ball.x > 512)
ball.vx = -ball.vx;
// Reset ball if it gets by a player if (ball.y < -350 || ball.y > 350)
ball._y = 0;
}
Now hit Test to run the game, congratulations you just created your first Ping Pong game.
You can view the finished project for this tutorial here .
Page 170 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Particle Systems
Many games feature various effects such as explosions, smoke plumes, weather effects such as rain, snow and so on. Booty5 is equipped with a specific actor type that can generate particles called a ParticleActor. The ParticleActor can generate a range of different types of particles systems for you, or you can use it to generate custom particle systems manually.
This tutorial teaches you how to create a particle explosion using the generateExplosion() method of the ParticleActor object.
•
Lets begin by creating a new Booty5 HTML5 project by clicking the New button in the main menu
•
Now select the gamescene in the world tree then select the OnTapped handler box that is located in the scenes property panel to the right
•
Enter “CreateParticles(this);” into the OnTapped box
•
Now select the Common.js script in the world tree to view the default script that was created for you when you created the project
•
Enter the following code into the script file and then save your project function CreateParticles(scene) { var touch_pos = scene.app.touch_pos; var red = (Math.random() * 20 + 235) << 0; var green = (Math.random() * 20 + 235) << 0; var blue = (Math.random() * 20) << 0; var particles = new ParticleActor();
scene.addActor(particles); // Add particle system actor to scene for processing
particles.generateExplosion(50, ArcActor, 2, 50, 10, 1, 0.999, {
x: touch_pos.x,
y: touch_pos.y,
fill_style: "rgb(" + red + "," + green + "," + blue + ")" ,
radius: 30
});
}
The above code will be called by the scene whenever the user taps on the screen, generating a particle explosion at the position at which the user touched the screen.
Finally, click the Test button to run the project.
You can view the finished project for this tutorial here .
Page 171 of 172
Booty5 HTML5 Game Maker Manual by Mat Hopwood
Shuffle Match Game
Shuffle Match is a full commercial game that is currently available on iOS and Android devices and was converted to HTML5 using Booty5 to assess performance. This tutorial is more of an example, so instead of the usual walk through you will be introduced to the various areas of the game instead. The main purpose of this tutorial is to introduce you to a full commercial quality game that has been developed using Booty5.
You can play the game by going here .
Use of Scenes and Actors
Shuffle Match is split across a number of scenes:
• viewarea – This scene represents the left hand side of the shuffle screen where the user is presented with a grid of numbers to remember
• guessarea – This scene represents the right hand side of the shuffle screen where the user is presented with an empty grid and have to fill it in by guessing the correct numbers
• gameover – This scene represents the game over screen, which comprises of the end of game stats
• mainmenu – This scene represents the main menu which is presented to the user when they first run the game / or pause the game
Each scene contains actors that are specific to that scene. For example, the main menu scene contains actors that represent the menu background and buttons. If you select the
“new_game_button” actor in the mainmenu scene and scroll down to the actors event handlers you will notice that the OnTapped event handler contains the following script: newGame(); window.app.findResource( 'tap' , 'sound' ).play();
The above code calls newGame() which is defined the in the menu.js script file, this function starts a new game. The above code then finds the “tap” sound effect resource that is located the app global resources and sets it off playing.
Scenes are slid in and out using Timeline animations in response to user actions, for example when the user taps the menu icon during game play the main menu is slid into view.
The main game code is situated in the ShuffleMatch class within the shufflematch.js script file.
Page 172 of 172
Advertisement
Key Features
- Create and preview complex Flash style timeline based animations
- Create game logic using action lists
- Complete game and app creators integrated development environment (IDE)
- Support for physics including materials, shapes, fixtures, joints
- Support for tile map and collision map editing
- Support for Javascript and other language editing
- Create and edit shapes, trace bitmaps to optimised shapes
- Interactive play mode that launches the game from the editor
