Ben demonstrates competency in a long series of projects. He worked on the Torque Game Engine with GarageGames at www.garagegames.com (Site No Longer Live), the PushButton Game Engine for Flash with PushButton Labs at www.pushbuttonlabs.com (Site No Longer Live). Support from PushButton (including its website, updates to its source code and forums) abruptly ended in 2012. PBE’s spiritual successor launched in 2012 as Smash Game Framework at www.smash.io (Project apparently dead after no updates since more than ‘a year ago’).

Now he and his team have Loom, The Loom Game Engine at www.theengine.co. The word ‘loom’ is used for a device used for weaving textile projects and Loom is also a popular 80′s computer game, both spiritually aligned with game development. However, I wish it had a more unique name to facilitate online searches.

Pros of Loom (Paraphrased from theengine.co);

• Pragmatic Development - Loom features a lean and fast workflow without strict development rules or required frameworks.
• Freedom Of Choice - Access and edit C++ core source code, access and edit LoomScript core source code, or simply add your own custom LoomScript. LoomScript sits atop C++ and can access any C++ library.
• LoomScript - LoomScript is an easy to use, new language modeled after AS3 with features inspired by C#. LoomScript is based on Lua which is concise, robust, proven, and supported by tools, debuggers, and community.
• Useful Libraries - CSS Styling, UI Markup, Tweening, Dependency injection, JSON/XML and more…
• Loom Architecture - Three parts; Call LoomCLI from your command line to create ‘new’ projects and ‘run’. The LoomSDK is precompiled LoomScript with powerful libraries. The NativeSDK is the raw C++.
• Built For Teams - Three tiers; Artists can create & integrate assets into the latest build without bothering others. Scripters use LoomScript for the bulk of development. Need extra power? Extra features? Coders can access the C++ layer.

When and where it is manageable, I am a huge fan of using  and reusing the same project for multiple platforms. Loom 1.x currently exports to TV (Ouya), Desktop (Mac & Windows), and Mobile (iOS & Android). Future support for other platforms is in discussion on the loom forums.

Checkout the screenshots of Loom’s Workflow;

1. Create a new project via command line.
2. Create your raster assets using your favorite creative programs.
3. Create your LoomScript code using any text editor. While a Loom IDE is a top feature request which is in active discussion, SublimeText is the current free, recommendation.
4. Compile (run) the project via command line.

1. Project	2. Assets
3. LoomScript	4. Compile

Development Philosophy

We believe that fast iteration times across multiple devices simultaneously lead to better, faster, cheaper game development. – Loom Documentation

Loom‘s design goal is to keep you on the fast development path as much as possible, while still preserving access to slower, more difficult, but still essential development paths. This gives a substantial benefit to development teams without blocking them.

The Loom GameFramework

Loom offers a powerful (optional) Loom GameFramework (LGF). A game framework is a system to organize your code specific for game projects.

LGF is made of three general types of classes. There may be many of each type in each game project:

• Manager – Managers are the brains of the operation — each one has a unique task; for instance one focuses on the spatial area of the screen and the objects within it and one on graphics rendering of visible objects. Depending on its role in the game, a manager may or may not relate to entities and components directly.
• Entity – Each visual element in your game is represented by an entity. This could be anything; your player, the enemies, collectible items, etc…. Entities can be non-visual too.
• Component — Each entity contains components. This is where the bulk of your game code lies. Each components handle a specific responsibility. For instance perhaps one component handles rendering the entity in which it resides.

Developers can extend existing managers and create new managers too. LGF ships with managers for our most common needs. Here is a partial list of the managers packaged with the core Loom.GameFramework package:

• TimeManager – Manages all time related functionality in the engine. It provides mechanisms for performing actions every frame, every tick, or at a specific time in the future. A tick happens at a set interval defined by the TICKS_PER_SECOND constant. Using ticks for various tasks that need to happen repeatedly instead of performing those tasks every frame results in much more consistent output. However, for animation related tasks, frame events should be used so the display remains smooth. You can pause/play your game easily here too.
• ConsoleCommandManager – Process and dispatch commands issued via the asset agent.
• PropertyManager – Properties are like public variables; set/get manually or bind automatically.

Entities are essentially empty shells. As a developer you fill them with the core components &custom components needed. Each component has access to any Loom API desired and responds to custom events as well as the following built-in Loom events:

• onFrame – Best used for graphics rendering-routines; this occurs once per frame-rate (e.g. 60 times per second for 60 FPS). Included for AnimatedComponent
• onTick – Ticks are guaranteed to happen at a fixed interval. If the frame-rate slows down due to some number-crunching or heavy rendering, Loom will attempt to ‘catch up’ by calling more ticks. It balances the run-time experience well. Included for TickedComponent.
• onThink – Based on an arbitrary, per-use timer. This is ideal for AI code which can be processed slowly (e.g. every 1–5 seconds). Included for QueuedComponent.

Getting Started

If you have setup a programming environment before (Flash, Java, HTML5), then you should find Loom easy to setup and use.

Here are the links and tips;

1. Download Loom (CLI & SDK Together) – Visit the Loom downloads page.
2. Download examples - See the list of examples or download and view the source-code from the Loom downloads page.
3. Learn to run code with the examples and create new projects – Visit Loom getting started page and the Loom documentation page. Curiously, the class-by-class documentation is not available online, but is indeed downloadable.

Creating My ‘FlyerGame’

To learn Loom, I followed my own ‘Getting Started’ steps above and then created my own complete game. I used assets and game logic from “FlyerGame”, a game that I have recoded many, many times using game frameworks. The HD Video Screencast and source assets are available (See ‘Member Resources’ below).

Optimizations

I have limited experience with Loom, but from reading the Loom forums and reviewing the Loom example code I understand that optimizing a project – especially rendering with a constant frame-rate on a variety of devices takes time.

Conclusion

I like what Loom does well; LoomScript is light and powerful, the workflow is VERY fast. I haven’t tapped into the full strengths of device-specific CSS (e.g. to size a button uniquely on iPad vs iPhone) yet, but it looks really compelling.

Library of Libraries

Loom is based in great part to Cocos2d, a free community-based library for 2D gaming. Some people love and some people hate Cocos2D. A consciousness I see throughout the Loom forums is for ‘Loom’ itself to provide minimal functionality and instead depend on 3rd party libraries to provide developers with needed functionality. Some libraries will be folded into the Loom API and for others developers can mix and match libraries as they like. This ‘borrow vs build’ approach is not new. It is what provides huge functionality within the Javascript gaming world too. However, as a developer having a big bag of separate APIs (separate syntax, separate terminology, inconsistent value ranges…0 to 1 vs 0 to 100 vs 0 to 256) is not intuitive and severely hurts the learning curve. Furthermore such separation makes it hard in my opinion for Loom to compete in an all-too-crowded world of cross platform mobile game development tools.

Maturity

The product is both at “1.0″ and costs money which to me means The Engine Co is positioning it as a finished product. However a look at the feature requests from the community and bug reports/omission from the forums, which include countless bare essentials (e.g. complete code documentation & incomplete method override support) is a sign it is not yet ready to stand against full realized competitive cross-platform mobile engine.

The engine also misses many device-specific features and most every OS-specific integration features (e.g. in-app purchase, social network integration, ad monetizations) which the forum promises are coming soon.

When the docs & wiki are complete and describe features which are implemented bug free the product can be recommended with more confidence. The team is working fast and communicates so frequently, that we may see that level of completeness very soon. A dedicated IDE (currently the #1 feature request) with auto-complete and more will help seal the deal.

The license pricing;

• 1. Starter- Target desktop 0nly – Free!
• 2. Indie – Target mobile too
• 3. Pro – Includes support
• 4. Enterprise – Includes more support

Developer Q&A

NOTE: Bonus Section!!!

Loom is very new and is changing rapidly. I reached out to Loom developers to get a reactions based on Loom CLI v#1.0.506 and Loom SDK v#sprint27.

PROs

• Live Reloading – Greatly accelerates development
• LoomScript – Easy to learn (especially from AS3) and powerful
• Support – Loom dev team is open, responsive, and productive

I find the component-based architecture suggested in the Loom API to be powerful and a distinguishing feature among competitors.

CONs

• Young platform – Has many bugs, missing basic implementations (“lots of loose ends”), and lacks must-have features of competitors
• Lack of documentation, tutorials, & examples.
• Rendering – The “CSS layout is pixel [dependent and] has little practical use”, and overall the “performance is not amazing”.
• No full-featured IDE – Although a 3 code editors already provide partial support.

The lack of IDE is an obstacle for me. And the creator’s conscious choice to use existing 3rd party APIs to solve basic implementation needs is wise (provides functionality) but weakens the platform tremendously as it becomes a ‘bag of APIs’ which hurts the learning curve.

Gotchas & Advice

• Read the docs
• Download, read, and run the examples
• Just “Dive into it!” and remake a basic game from scratch

“Is Loom ready for professional development?”

• No, It is the “early days for the platform so there’s not so much”.
• No, “standard mobile features like reading/writing to camera roll are not exposed yet (as far as I know)”.
• Yes, I think its ready for professional deployment, If you can get over the bugs and [missing] features”.
• No, we’d have to “spend a lot of time working on supplementing the engine, and less on making our games”.
• And as one developer said – I am “not sure. I’d have to make a game with it!”

For me, Loom is absolutely ready for production in a vacuum. However there are many compelling alternatives to use which are more robust.

Next Steps

After ‘Getting Started’ and following my HD Video Tutorials, here are more resources to fuel your Loom savvy.

• VIDEO: Welcome To Loom – Watch the HD Screencast Video Tutorial*
• VIDEO: FlyerGame With Loom – Watch the HD Screencast Video Tutorial*
• SOURCE CODE: FlyerGame With Loom – Download, view, and run the code.
• Find common answers on the Loom forums page
• Post your comments on Loom below on this blog page.

*See ‘Member Resources’ below.

NOTE: Source code is available, but videos are NOT yet available.

Member Resources

Free Talk

Premium Training

This event is deep, premium training. It is a natural follow-up to the Cross Platform Mobile: Free Talk.

In software development, the focus is to offer value to the end users; to include features for their eyes. These are the functional-requirements of the project. But of course there is much ‘under-the-hood’ that the end user never sees. This includes content management systems (CMS) that administer the data, servers that provide that data, and developer tools and architectures to help organize the code-base. We call these ‘under-the-hood’ needs ‘non-functional’ requirements.

This quick primer answers “What non-functional requirements are necessary?”.

NON-FUNCTIONAL REQUIREMENTS

In each project, in addition to serving the end users goals, we must serve the needs of the development team; creating a realistic workflow for all team members, allowing for an extensible architecture for current and future functional-requirement features.

My point in writing this article was to get to a list of what non-functional requirements I setup in my apps or game needs. If you are already doing all this, great. MANY mistaken teams are doing NONE of these. Here is the list I use;

My Recommended Non-Functional Requirements

• Configuration File – Upon project startup, load an externalized set of name/value pairs (typically XML). This allows for developers (and others) to tweak values and reduces the need-for / frequency-of project recompilation. A huge side-benefits is that this ‘light and playful’ environment encourages experimentation.
• Localization – Even for English-only project, centralize (put all together) and externalize (separate from code – typically in XML) all display text. This allows for easier edits and translation to other languages if/when needed.
• Architecture – Sure, smart developers can create their own architectures, but smarter developers choose an off-the-shelf, 3rd-party architecture. Pave the cow-path, point your developers to 3rd party documentation and forums for help, and hire new staff (with experience in that architecture) more easily. If your team is not using ‘any’ architecture, that is probably a huge mistake. There are many available and are often specialized for each platform and project type (i.e. Flash Platform for Game project type)
• Restart Functionality – The app or game should have a restart button. This may be a functional-requirement. If so, great. If not, do it anyway. By requiring your team to implement restart (and garbage collection) your project will probably be far more efficiently written. This is an expensive feature to implement, but if done at the beginning it is very manageable.
• Zero-Memory-Leak Policy – The app or game may be ‘too simple to warrant optimization’. Regardless, do it anyway. Once you have the ‘Restart Functionality’ added, run a memory profiler tool on your project and ensure that with each restart the RAM usage properly reduces to zero (or whatever benchmark you set).  This is an expensive feature to implement, but if done at the beginning it is very manageable.

Game-specific Non-Functional Requirements

• The list above, plus…
• Pause Functionality - A fundamental test of good gaming architecture is ‘can it pause at any time?’. Even if ‘pause’ is not offered to the user, this requirement is helpful.
• Time-based animation – Your game algorithms should be infallible regardless of a faster-than-expected or slower-than-expected frame-rate.

CHAMPIONING DEVELOPERS’ RIGHTS

Depending on your team structure, you may have your software team developing the product ‘for’ the business team. Treating each department within your company as ‘clients’ helps to decouple the responsibilities and make hand-off of project tasks more clear and distinct. However each team, naturally defends their own interests, often at the expense of others. Within this setup, I’ve seen countless times that the dev-team must fight for the time to create non-functional requirements in addition to the functional requirements, where-as the business team’s focus is solely on the functional requirements. The business mind is concerned with ‘add a new button that does X or Y’ and to them that sounds simple. The Dev-team knows there is indeed a quick and dirty way to add that feature but also a more manageable, scalable, well-architected solution. It is a typical time vs quality discussion. Except the business team may not understand why spending more time (and money) is valuable when they don’t see more value in the end product.

Addressing developer’s needs helps to reduce burnout of your team. Happy developers are productive developers. Unproductive developers leave your team. Also an objective development leader can add ‘just enough’ non-functional requirements to respect the long-term plans of the project. Obviously a project with a long development cycle (days until launch) and long shelf-life (days between launch and unlaunch) benefits most from good non-functional requirements.

Arguing for the additional time needed to ‘do things right’ is a common struggle as dev teams champion their rights. Depending on the project, I can be on either side of this discussion. Generally I try to create an environment that makes the developers comfortable yet gets the job done. To facilitate that, I recommend separating time-estimations for functional-requirements from non-functional. One methodology is to take the total time estimate for the project or milestone’s functional requirements (including buffers for unknowns) and then calculate 20% additional. I offer developers that 20% to use as they see fit.

For example the business team can offer to the developers; “Ok, we all agree that our next milestone will take 400 man-hours; so you (developers) will get 480 and can allocate the 80 hours to improve code quality (beyond our minimum standards) and build-out the architecture (beyond today’s immediate needs).” Over -architecture and over-planning is dangerous, so giving free-reign to developers to ‘make it perfect’ is not cost effective, nor does it really improve the project or product. If developers feel they are hitting 80% level of comfort with their code-base, that is a good balance. This is my personal opinion based on years of experience on hundreds of small to mid-size software projects.

Adobe recently announced the details for the annual Adobe Max conference. Thankfully, in 2013 we see a focus on gaming.

Adobe Max 2013

Adobe MAX 2013 will be at the L.A. Convention Center & Nokia Theatre L.A. LIVE on May 4 – 8, 2013

(From Adobe Marketing:) Adobe MAX is all about creativity and expressiveness. If you create, you won’t want to miss MAX. Designers, developers, strategists, video professionals, photographers, and more all come to MAX to exchange ideas and inspiration. Together with industry pros and visionaries, you’ll learn about the latest technologies, techniques, and strategies for delivering your best creative work. Come to MAX and explore how creativity is changing the word and what part you have to play in that change. And every full conference MAX pass includes a one year membership to Adobe Creative Cloud*

Adobe Max 2013: Gaming Sessions

Here are the game-related sessions we can look forward-to;

Next Steps

• Read my recent Introduction: Adobe Game Developer Tools article
• See the full Adobe Max 2013 list of sessions
• We at RMC are excited to collaborate with you. We are experts in Flash Platform Gaming, and more. Not sure if HTML5, Unity, or Flash is right for your next project? Just ask!

UPDATE (January 30th, 2013): ActionScript “Next” (aka 4.0 as I call it here) has been explicably removed from the Adobe Roadmap.

UPDATE (June 15th, 2012): Adobe announces the plan for concurrency in Flash Player and AIR – Workers.

ActionScript 4

The range of applications and content for ActionScript has shifted significantly in recent years, while the ActionScript 3 language remains virtually unchanged since its introduction in 2006. Adobe believes it is time to revise the language to carefully steer its further evolution towards greater expressiveness as well as productivity and performance gains.

From a language design standpoint, Adobe uses the following assumptions as a guide for next-generation ActionScript development:

• Increasing demand for long-term productivity benefits such as robustness, modularity, and maintainability to complement shorter-term productivity benefits characteristic of scripting languages, such as speed of development
• Demand for high performance increases
• Demand for hardware utilization increases

First, Adobe plans to make significant performance increases in the short term with a goal of continuing performance improvements over the long term. Performance is the primary goal when we approach how to evolve ActionScript. Second, Adobe aims to increase developer productivity by simplifying the language, improving tool support, and boosting bug prevention. Finally, having reduced unnecessary complexity, we will be in a position to innovate within the Flash runtimes much more quickly.

Features Currently In Discussion;

• Stringent static typing as default, with optional dynamic typing: Most stretches of most programs are expected to benefit from static typing. However, ActionScript 3 tends to lapse into dynamic typing all too easily in places where absolutely stringent static typing would be preferable. This will be corrected. Dynamic typing will still be available when needed, but it will no longer be the default for ActionScript, and it will need to be enabled explicitly.
• Type inference: Type declarations will only be necessary in certain strategic places. Everywhere else the compiler will automatically infer suitable type declarations and treat the whole program as statically typed, even though the programmer does not have to state any types. Thus the convenience of untyped programming can be approximated quite well, while providing the performance advantages of typed programming.
• Hardware-oriented numeric types: For example, int , uint , float , float4 , byte , short , long , etc. (the exact set of types is still under discussion). Currently in ActionScript 3 integer values can overflow into floating point values. This will be changed so that numeric operations will never change the underlying representation of the numeric. We foresee this addition greatly reducing implementation complexity and improving runtime performance.

These are just a couple of areas that we are focusing on. We will update this document as our thinking evolves and solidifies around how the language and virtual machine will change.

Compatibility

Its is stated that AS4 will not be completely compatible with AS3. So maybe there will be a compiler option and one must choose EITHER one or the other (similar to the mutual exclusive option between AS3 and AS2. Depending on the amount of changes in AS4 we may see a new virtual machine inside the player designed to run only the AS4. Currently there are two VM’s – one for AS3 and one for older ActionScript.

Wishlist

Many developers have been dreaming (ex. here & here) of features for ActionScript for ages. Some features I would love to see;

• Abstract Classes with Abstract Methods (ASL-18) – Well, do I have to have to say something about that wish? Basically abstract classes are such an essential thing, I am still wondering how Action Script made it to 3.0 without them. Just documenting which Methods must be overridden is not enough. And the known workarounds are really… well… hm… forget it – this is a compiler thing, which cannot be checked at runtime.
• Generics (FP-811) – The Vector class is a good start – but it’s not well supported in Flex 3 (keyword: data binding) and it’s not a generic concept. There should be something like Generics in Java that provide type checking at compile time, but can also be used for any custom class, just like in Java.
• Enums – While I have a (almost) perfect workaround for Enums in AS3, it would be great to see native language support.
• Singletons – I have a fantastic workaround for Singletons in AS3
• Improved ‘Event Listener’ syntax and performance. I like the features offered by the AS3-Signals project.
• Operator Overloading (ASL-10) – Still missing it in Java and this is, where Action Script could actually beat Java. I don’t want to have another equals method for comparing arbitrary classes for equality – I want to be able to simply override the == operator to be able to compare any two objects for equality. Or the + operator for concatenating two data structures. Just like in C++ or smalltalk.
• Method Overloading (ASL-9) – While ActionScript provides an easy way to simplify methods with long parameter lists using default values for parameters it’s not enough to justify not having method overloading. I do not want to have to write methods like doSomethingWithString(value:String), doSomethingWithInt(value:int), doSomethingWithObjectA(value:ObjectA),…

ActionScript 4.0 Code Samples (A Proposal)

AbstractClassDemo

package
{
	//class must be subclassed before instantiation
	abstract public class AbstractClassDemo
	{
		public function AbstractClassDemo()
		{
		}
	}
}

AbstractMethodDemo

package
{
	public class AbstractMethodDemo
	{
		public function AbstractMethodDemo()
		{
		}

		//Method must be overridden before usage
		abstract public function sampleMethod () : void
		{
		}
	}
}

DestructorDemo

package
{
	public class DestructorDemo
	{
		//constructor
		public function DestructorDemo()
		{
		}
		//destructor, called upon instance deletion
		public function ~DestructorDemo()
		{
		}
	}
}

Enums

package
{
	public enum EnumSample
	{
		ENUM_SAMPLE_A;
		ENUM_SAMPLE_B;
	}
}

package
{
	public class EnumDemo
	{
		public function EnumDemo()
		{
			trace (ENUM_SAMPLE_A); //[EnumSample ENUM_SAMPLE_A]
			trace (ENUM_SAMPLE_B); //[EnumSample ENUM_SAMPLE_B]
			trace (ENUM_SAMPLE_A is EnumSample); //true
                        trace (ENUM_SAMPLE_A is EnumSample); //true
                        trace (ENUM_SAMPLE_A == ENUM_SAMPLE_B); //false
		}
	}
}

GenericsDemo

package
{
	public class GenericsDemo <AGE_TYPE, NAME_TYPE>
	{
		private var _age  : AGE_TYPE;
		private var _name : NAME_TYPE;

		public function GenericsDemo(AGE_TYPE : aAge, NAME_TYPE, aName)
		{
			_age 	= aAge;
			_name 	= aName;

			//Later, in use, declare types at runtime for the generic
			//var genericsDemo : GenericsDemo<Float,String> = new GenericsDemo<Float,String> (10.0, "Flash");
		}
	}
}

MethodOverloadingDemo

package
{
	public class MethodOverloadingDemo
	{
		public function MethodOverloadingDemo()
		{

			//The implementation of this AS3 Syntax
			//	can now be overloaded in AS34
			_sampleMethod();
			_sampleMethod(10.0);
			_sampleMethod("10.0");
		}

		/**
		 *
		 * @return void
		 *
		 */
		override public function _sampleMethod () : void
		{
			trace ("Parameters - None");
		}

		/**
		 *
		 * @return void
		 *
		 */
		override public function _sampleMethod (aValue_float : Float) : void
		{
			trace ("Parameters - Float: " + aValue_float);
		}

		/**
		 *
		 * @return void
		 *
		 */
		override public function _sampleMethod (aValue_str : String) : void
		{
			trace ("Parameters - string: " + aValue_string);
		}

	}
}

NumericTypesDemo

package
{
	public class NumericTypesDemo
	{
		public function NumericTypesDemo()
		{
			//specificity helps ram usage
			var sample_int 		: int 	= 10;
			var sample_uint 	: uint 	= 10;
			var sample_float 	: Float = 10.0;
			var sample_float4 	: Float4= 10.0;
			var sample_byte 	: Byte 	= 1;
			var sample_short 	: Short = 10;
			var sample_long		: Long 	= 10;
		}
	}
}

OperatorOverloadingDemo

package
{
	public class OperatorOverloadingDemo
	{
		public function OperatorOverloadingDemo()
		{
			//The implementation of this valid AS3 Syntax
			//	can now be overloaded in AS34
			this +  10.0;
			this -  10.0;
			this * 	10.0;
			this /  10.0;
			this == 10.0;
			this += 10.0;
			this -= 10.0;
			this *= 10.0;
			this /= 10.0;

			//Etc...

		}

		/**
		 * Add
		 *
		 * @return Float
		 *
		 */
		override public function operator== (aValue_float : Float) : Float
		{
			//	Mimic default implementation
			if (super.operator==(aValue_float) ) {
				return true;
			} else {
				return false;
			}
		}

		/**
		 * Add
		 *
		 * @return Float
		 *
		 */
		override public function operator+ (aValue_float : Float) : Float
		{
			//	Mimic default implementation
			this = super.operator+(aValue_float);
			return this.toFloat();
		}

		/**
		 * Etc...
		 *
		 *
		 */

	}
}

SingletonDemo

package
{
	public class SingletonDemo
	{
		//private constructor mean 'Singleton'
		private function SingletonDemo()
		{
		}
	}
}

StaticTypingDemo

package
{
	public class StaticTypingDemo
	{
		public function StaticTypingDemo()
		{
			//compiler determines type by default
			var sample1 = 10;
			trace ("sample1: " + sample1); 	//10
			trace (sample1 is uint); //true

			var sample2 = -10;
			trace ("sample2: " + sample2); 	//-10
			trace (sample2 is int); //true

			var sample3 = 10.0;
			trace ("sample3: " + sample3); 	//10.0
			trace (sample3 is Float); 		//true

			//dynamic type in strategic places
			var sample4 : int = 10.0 as int;
			trace ("sample4: " + sample4); 	//10
			trace (sample4 is int); 		//true

		}
	}
}

Next Steps

• What would you like to see in AS4? Comment below!
• Download the Official Adobe Roadmap for Flash / ActionScript 4.0 (See ‘Member Resources’ below)

Member Resources

The Life Of Flash;

• Flash Player Running in the Apple iOS browser, is not possible. This is the ONLY segment where we saw a ‘death’ of Flash, so far. However, Flash-created apps in the iOS app store are possible, powerful, and popular.
• Flash Player Running in the Android browser, is possible on many devices. In my opinion, it will become less popular as HTML5 matures in the next few years. However, Flash-created apps in the iOS app store are possible, powerful, and popular.
• Flash Player Running in the PC computer browser, is popular on PC, Mac, & Linux. In my opinion, it will be continue to be popular.
• Flash content via the computer desktop (as ‘apps) is popular on PC, Mac, & Linux. In my opinion, it will be continue to be popular.
• Flash content via other devices (Smart TV’s and more) will continue to be popular.

The most recent effort by Adobe to push its Flash Platform technology is Adobe Game Developer Tools, announced in December 2012. Here is a recap of the highlights.

Adobe IDEs

From Adobe: You have great ideas for cool games. Now, we’re providing you with the essential tools to rapidly build, optimize, and deliver your games to iOS, Android™, Windows®, and Mac OS.

Here are the IDE’s to help you create your projects;

• Adobe Flash Builder – Build amazing games and applications in ActionScript for Android, iOS, Windows and Mac OS X platforms using a single cross-platform development environment. Now with support for Adobe Scout. In my opinion, its best just for creating and animating assets.

• Adobe Gaming SDK – Adobe Flash Professional software is a powerful authoring environment for creating rich, engaging games and interactive content that reaches desktops, tablets, and smartphones with unparalleled consistency. In my opinion, its best just for coding and integrating existing assets.

What is Adobe Gaming?

• Create games faster. Reach over 1.3 billion people. – Only Adobe® Flash® Player and Adobe® AIR® let you deliver your game to 500 million iOS, Android, BlackBerry, Kindle Fire, and NOOK mobile devices and 99% of connected computers — with no additional install. One codebase. Use amazing tools and take advantage of simple, powerful APIs and frameworks enjoyed by a large and growing game developer community. In my opinion the cross-platform nature and existing community of developers are the most compelling reasons to use Flash Player & AIR.
• Cinematic graphics. Console-quality games. – The Flash runtime now delivers GPU accelerated graphics across browsers and mobile apps for 1000x faster, stunning 2D and 3D games. Craft amazing gameplay with native mouse, multi-touch, accelerometer, camera, and mic support. Code with human-friendly ActionScript®. Or take your C/C++ or Unity games and easily target the Flash runtime. Play beautifully. In my opinion, the quality of graphics & audio what Adobe now offers is first class.
• Make more money. And make more fun. – In my opinion, this is just marketing-speak. However there is a HUGE amount of existing Flash developers (i.e. better talent at lower costs) and the SDK’s exist to make your projects social and sales-friendly.

What are Adobe Game Developer Tools?

You have great ideas for cool games. Now, we’re providing you with the essential tools to rapidly build, optimize, and deliver your games to iOS, Android™, Windows®, and Mac OS. To get started, all you need to do is download the Adobe Game Developer Tools through a free Creative Cloud membership. If you already have a Creative Cloud membership, the Game Developer Tools are included!

Here’s what you’ll get when you download the tools:

• Adobe Scout – Adobe Scout is a new profiling and optimization tool for Flash Player on desktop and mobile to help you get the best performance possible. (Free now, premium later, TBD)

• Adobe Gaming SDK – The Adobe Gaming SDK gives you a complete collection of frameworks, code samples, and learning resources that work together to help you accelerate your productivity.

• Flash C++ Compiler – Cross compile C/C++ to run your game in Flash Player with GPU acceleration. Deliver your back catalog of games to target 1.3 billion connected desktops.

What are Adobe Game Developer Tools? (Really)

Adobe is now attracting non-Flash game development companies. For that market the AGDT is a well-marketed introduction to Flash. Newbies can hit the ground running; (theoretically) using any legacy C++ code, getting started with the frameworks in the SDK, and doing powerful profiling with Scout.

For existing Flash developers perhaps none of this is interesting. There are many Flash experts who use no C++, who already have access to the frameworks in the SDK. Scout is very powerful, and indeed is worth the (unannounced) price of entry. But not every game developer profiles his or her projects or knows the great value in doing so. However, I do think that Adobe’s increasing powerful set of tools, and energized game-specific marketing will help focus the game industry on Adobe’s tools, and too, Adobe-centric game developers. That is great.

Next Steps

• More about Adobe Gaming (Marketing material)
• More about Adobe Gaming (For Developers on Devnet)
• See a HUGE showcase of Flash Games for Browser/Desktop/iOS/Android/More.
• See the Best Gaming Sessions at Max 2013 article
• We at RMC are excited to collaborate with you. We are experts in Flash Platform Gaming, and more. Not sure if HTML5, Unity, or Flash is right for your next project? Just ask!

User Experience Symptoms Of  A Memory Leak

• During regular use the application becomes more and more sluggish/slow. If there is nothing ‘new happening’ onscreen and no heavy ‘rendering’ it is more obvious to notice the Framerate-per-second (FPS) lower. You can use a small debug window (such as Hi-Res-Stats formerly MrDoobs Stats) to show the current FPS and estimated ram usage to help you notice this. If you see the FPS run at 30 for example during the first minute of use and 20 after 5 minutes, there may be a memory leak.
• The application quits suddenly. This could be for many reasons, but it may be that the application runs out of memory.
• Flash throws the memory-specific error ‘flash.errors.MemoryError’

Profiling To Find Evidence Of A Memory Leak

• Run your application with the Flash Builder Profiler. Run -> Profile As… -> etc…
• Watch the ‘Memory Usage’ Panel
• Look at the curves of Peak Memory (Red) and Current Memory (Blue). The analysis is totally application dependent. In your particular application, if you expect memory not to grow, but you see it grow, that is a problem. If you expect the memory to drop (UI removed from stage, arrays and vectors emptied, etc…) and you don’t see it drop, that is a problem. Herein lies the art of memory profiling. Consider to add a button to ‘Reset Application’, then click it and see that indeed the Current Memory drops to zero (0).
• Watch the ‘Live Objects’ panel. Compare the 1. ‘Cumulative Instances’ and 2. ‘Instances’. For each object. #1 shows the total objects every created since the application started and #2 shows only those currently in memory. If these numbers are the same, and should not be, that is a problem. Perhaps you feel you have deleted a sprite from the stage or deleted another object from memory yet it still exists.

Tools And Tips For Finding And Fixing Memory Leaks (Must Read!)

• Memory Tracker – http://divillysausages.com/blog/tracking_memory_leaks_in_as3.
• Solving Memory Leaks (FANTASTIC!) - http://www.tikalk.com/flex/solving-memory-leaks-using-flash-builder-4-profiler

Example 1: Without Memory Leak

package
{
	import flash.display.Sprite;
	import flash.events.Event;

	//USE A LOW FRAMERATE, SO WE CAN STUDY CLOSELY
	[SWF(frameRate="1")]
	public class MemoryLeakDemo extends Sprite
	{

		private var listOfDots_vector:Vector.<CustomDot>;
		public function MemoryLeakDemo()
		{
			//REPEAT SOME CODE EVERY SECOND
			addEventListener(Event.ENTER_FRAME, _onEnterFrame);

			//CREATE A LIST
			listOfDots_vector = new Vector.<CustomDot>();
		}

		protected function _onEnterFrame(event:Event):void
		{
			//EVERY FRAME WE...

			//1. CREATE A NEW 'DOT' (A Red Circle Sprite)
			//MEMORY NOTE: 	'var' is a temporary variable.
			//So CustomDot has 0 (permanent) references
			var customDot : CustomDot = new CustomDot();

			//2. ADD TO THE STAGE
			//MEMORY NOTE: 	So CustomDot has 1 (permanent) reference; 'this'
			addChild(customDot);

			//3. REMOVE TO THE STAGE
			//MEMORY NOTE: 	So CustomDot has 0 reference
			removeChild(customDot);

			//So...
			//THERE IS NO LEAK
			//The GC will *mark* the 'customDot' as having 0 references and
			//The GC will *sweep* it away from memory.

		}

	}
}

Example 2: With Memory Leak

package
{
	import flash.display.Sprite;
	import flash.events.Event;

	//USE A LOW FRAMERATE, SO WE CAN STUDY CLOSELY
	[SWF(frameRate="1")]
	public class MemoryLeakDemo extends Sprite
	{

		private var listOfDots_vector:Vector.<CustomDot>;
		public function MemoryLeakDemo()
		{
			//REPEAT SOME CODE EVERY SECOND
			addEventListener(Event.ENTER_FRAME, _onEnterFrame);

			//CREATE A LIST
			listOfDots_vector = new Vector.<CustomDot>();
		}

		protected function _onEnterFrame(event:Event):void
		{
			//EVERY FRAME WE...

			//1. CREATE A NEW 'DOT' (A Red Circle Sprite)
			//MEMORY NOTE: 	'var' is a temporary variable.
			//   So CustomDot has 0 (permanent) references
			var customDot : CustomDot = new CustomDot();

			//2. ADD TO THE STAGE
			//MEMORY NOTE: 	So CustomDot has 1 (permanent) reference; 'this'
			addChild(customDot);

			//2B. CREATE ANOTHER REFERENCE TO THE DOT
			listOfDots_vector.push(customDot);

			//3. REMOVE TO THE STAGE
			//MEMORY NOTE: 	So CustomDot has 0 reference
			removeChild(customDot);

			//So...
			//THERE *IS* A LEAK
			//While we are correctly calling removeChild
			//There is a reference left in '2B' above.

		}

	}
}

Next Steps

• Download the code and check it out! (See Member Resources)
• Comment below with your thoughts.
• NOTE: Flash Builder 4.7 (BETA2) has new Profiler called “Monocle“. It looks very exciting, yet this article focuses on the currently available (non-BETA) profiler.

Member Resources

During the project, I was surprised to find there is no native java event messaging (event dispatching and event listening). While some UI frameworks have a solution, the solution appears to be coupled to those frameworks.

So I created a custom Java solution to handle it. The system uses common Observer pattern and modeled it after the spirit of what is present in ActionScript 3.0. I used abstraction and interfaces so its fairly decoupled and flexible. Take a look.

Usage

public EventsDemo()
{

	// CREATE
	SampleEventDispatcher s = new SampleEventDispatcher();

	// LISTEN
	s.addEventListener(Event.EVENT_NAME, 		this, "_onEvent1");

	//TEST 'HAS'
	/*
	if (s.hasEventListener(Event.EVENT_NAME, this, "_onEvent1") ){

		//TEST 'REMOVE'
		s.removeEventListener(Event.EVENT_NAME, this, "_onEvent1");
	}
	*/

	// TEST A DISPATCH OF EVENT (IN A FAKE, TEMPORARY WAY)
	s.doDispatchTestEvent(new Event	(Event.EVENT_NAME, this));

}

public void _onEvent1 (Event aEvent)
{
	System.out.println ("	_onEvent1(): " + aEvent + " , " + aEvent.getType() + ", " + aEvent.getTarget()  );
}

It rocks!

Next Steps

• Download the code and check it out! (See Member Resources)
• Comment below with your thoughts.

Member Resources

Maybe I never thought it would be possible. Maybe I never thought the games would be good. Maybe because I knew how to code, I didn’t care. The Stencyl Toolset from Stencyl, Inc. is surprising in both its ease of use and its flexibility to create a variety of games.

But can it replace traditional game-programming? Well, let’s take a look.

Pros of Stencyl (Paraphrased from Stencyl.com);

• Game Studio In A Box – Stencyl is a gorgeous, intuitive toolset that accelerates your workflow and then gets out of the way. In addition to the core tools, there is an included image editor called Pencyl and tile creation and editing tools for tile-based games (i.e. PacMan).
• Show and Tell – Use StencylForge the community-based toolbox of sprites and game logic to power your projects and share your knowledge.
• Design In A “Snap” – Drag-n-drop code like Lego-blocks. If you are a coder, I know this sounds SCARY. Check it out.
• Test it Fast – Run quickly using onscreen emulators for rapid code-test-code cycles. TBD on my opinion of the debugging features.
• Play It Everywhere – Publish to iOS, Flash, Windows, Mac & the Chrome Web Store. (Android / HTML5 Coming Soon)
• Make Money – Well, monetizing games is not unique to Stencyl of course, Stencyl has monetization features but there are many Pros of using one code-base for multiple platforms.

When and where it is manageable, I am a huge fan of using  and reusing the same project for multiple platforms. Stencyl 2.1 (current release) exports to Flash (Desktop/Browser) and Mobile (iOS). Future releases will publish to Android and HTML5.

Checkout the screenshots;

1. Create your game assets (backgrounds and sprites) using your favorite drawing programs or download them from StencylForge.
2. Setup your game sprites. These ‘Actors’ as they are called can be animated and controlled by the computer AI or by the user.
3. Setup your game logic. Stencyl’s most controversial feature is the logic system which requires NO PROGRAMMING. There is comprehensive documentation to help. Check it out.
4. Design your levels. You can drag and drop assets into a grid system or free-form layout. Whatever you like!*

* The potential to use Stencyl JUST for level creation on non-Stencyl projects has me very excited. I haven’t tried that yet, nor know if its possible. Post below if you have some ideas.

Create Assets or Use StencylForge	Setup Game Sprites
Setup Game Logic	Design Levels

Stencyl 2.x maintains separate engines for our Flash and iOS exporters. Something that the team admits has been a challenge to maintain. Stencyl 3.0 (release date TBD 2012) will use a single engine and language that exports native apps to Flash, iOS, Android, Windows, Mac, Linux and HTML5.

Getting Started

If you have setup a programming environment before (Flash, Flex, Java, HTML5), then you should find Stencyl VERY easy to setup and use. Its slick and mainstream in its ease of use from initial install through project building. If you have never used multimedia tools, it may be a bit challenging, but know that you are in good hands. Stencyl’s has some user experience (UX) hiccups, but it is, overall, very impressive.

Here are the links and tips;

1. Download The IDE – Stencyl and install it.
2. Go Through the Crash Course – After downloading Stencyl, I strongly recommend going through the Crash Course. If you’re launching Stencyl for the first time, you’ll be automatically asked to go through the Crash Course. If not, click on the Help Center button to find it.
3. Read Stencylpedia- After you’ve made your first game using the Crash Course, we highly recommend reading through the first few chapters of Stencylpedia (up to the end of Chapter 4).Stencylpedia will teach you the fundamentals of game creation through Stencyl, in a way that poring over many example games won’t do.
4. Inspect Free Games – You can learn a lot as a beginner by looking at the included games and free games on StencylForge. Exame the scenes, actors, and behaviors.
5. Watch My HD Screencast Video – Watch me talk you through as I create a complete game from start through finish. (See ‘Member Resources’ below)

Making ‘FlyerGame’

To learn Stencyl, I followed my own ‘Getting Started’ steps above and then created my own complete game. I used assets and game logic from “FlyerGame”, a game that I have recoded many, many times using game frameworks. The HD Video Screencast and source assets are available (See ‘Member Resources’ below).

Optimizations

With my simple tests, Stencyl games appear to run smoothly. It’s likely that performance problems are run-time performance problems (i.e. Flash or iOS) and not necessarily Stencyl performance problems.

Recommendations;

• Limit number of on screen actors – That’s the fundamental optimization. When not possible use ‘recycling’ (VERY IMPORTANT) which is Stencyl’s version of object pooling.
• Limit number of collisions – Stencyl uses Box2D for its physics engine, and the more Stencyl makes use of Box2D, the more calculations it’s performing in a given frame. Since collisions means the physics engine is working, more collisions means potential slowdown.
• Limit use of effects and transparency
• Limit overlapping actors (i.e. actors on top of actors)

Conclusion

I like Stencyl. I applaud what they are trying to do; create a simple tool to allow newbies to create games and veterans to create more games, more easily. I think many veterans will be turned off by Stencyl as a ‘toy’, and many newbies may be too shy to give it a try. I encourage both groups to give it an honest try. Above all I’m excited for the future of gaming.

Tools like [Stencyl] are yet another sign that game development can be both a great hobby to some and lucrative profession to others. – Me.

There are some other game studios I have yet to fully review such as GameSalad and GameMaker. Stay tuned. I may review them in the future.

Wait, No programming?

I make a few mentions here that Stencyl requires no programming. Really, to be more accurate you ARE coding, you ARE programming and quite deliberately. You have to understand all of the common game logic concepts. What are are NOT doing is typing. Instead you use drop-down menus – part of a layout which Stencyl calls the “block-snapping interface”. Very pretty, helpful, & intuitive. For advanced users there is indeed a code view and programming API (both currently AS3-only). Looking at the code is not only optional, it is not encouraged.

I have some strong opinions by code-generation tools (i.e. Adobe’s Dreamweaver), but I think there is indeed a large audience that can be served well by Stencyl’s ease of use. I am impressed with its power and flexibility. While not the creators intention, I also see Stencyl as a great tool for complete game developer beginners to learn all the fundamentals and then perhaps move on to a more traditional programming environment in the near future or distant future if they have the interest. Academically, Stencyl has fascinating potential too providing a language-agnostic approach to gaming for first year students, before they have the programming skills to power their creative ideas.

In short, after testing Stencyl, my opinion of it changed from just a ‘pretty toy’ to a ‘fun and powerful tool’. The roadmap provided on the Stencyl website looks fantastic too, rounding out more publishing options and hinting at a more robust tool too. Give Stencyl 3-4 hours of your attention over a weekend. It may very well change your mind for the better too!

The license pricing;

• 1. Stencyl 2.x – Publish Flash Games – Free!
• 2. Also Publish Desktop Games – $79 per year
• 3. Also Publish iOS Games – $149 per year
• Combo of 1,2,3 – $199 per year

Developer Q&A

Since I am new to Stencyl and Stencyl is so very different then other game development tools, I met with some Stencyl developers (newbies and veterans) to understand the PROs, CONs, and any gotchas that could help newbies learn from their mistakes.

PROs

• No coding needed (unless you want it) 
• Helpful community
• Cross-platform

CONs

• “Newbies must choose between limited ‘Free’ version and expensive ‘Pro’ version” – Game Developer, Urie Wilson 
•  The learning-curve on more complicated parts (lists, global attributes, collision shapes) can be intimidating

Gotchas

•  ”Always save your project. [Stencyl may crash]” – Game developer, Ridhwaan Patel

Misc / Advice

• Stencyl works well with Pencyl (image editor)
• “Start Small. Reconstruct retro projects like Tic-Tac-Toe, Pong, Pac-Man, & Space Invaders. These simple, familiar games offer many challenges to newbies.” – Game Developer, Djamel Berkaoui (aka Satyre)

Next Steps

After ‘Getting Started’ and following my HD Video Tutorials, here are more resources to fuel your Stencyl savvy.

• VIDEO: Welcome To Stencyl – Watch the HD Screencast Video Tutorial*
• VIDEO: Flyer Game With Stencyl – Watch the HD Screencast Video Tutorial*
• Start with the Stencylpedia – Online. Its the instructions manual. Also checkout the blog and the product roadmap.
• Find common answers – The forums are best when you’ve got a specific question to ask.
• Ask a new question – The Chat Room is great for seeking real-time help.

*See ‘Member Resources’ below.

NOTE: All Member Resources are coming soon. Videos and code downloads are NOT yet available.

Member Resources