I have been working with my team on our SimsUShare Mobile project for the past while, and I’m happy to say we finally got it into the Google Play / Android Market!

It’s not just a mobile app for fire service training, behind the scenes, it is a platform that has the potential for oh so much (not to say fire and safety training is nothing!).  Check it out by visiting http://simsushare.mobi, the product’s micro-site.  We’re launching it this coming week at FDIC, and we plan for it to make a big splash!

I needed to make a MovieClip run potentially at different frame rates.  This is pretty easy to do, but I figured others might want example code, so I’m posting it here.  I noticed over at StackOverflow, people were suggesting using the Timer class, but I think an ENTER_FRAME solution is better, especially for trying to make the MovieClip run faster than the frame rate of the real SWF.

For this code, I used Flash CS5 and created a TextInput instance with the name “newrate“. I created a Button with the name changeratebutton, which reset the processing based on the user’s input. The animation is in a MovieClip on the stage, and the instance name is anim.

The idea is very simple: if the clip is set to run at the same rate as the stage, just use play(). If it’s different, compute the number of frames we need to advance (frameIncrement), knowing that we will be given control on each frame based on the SWF’s frame rate. When we get control in a frame, advance the playhead by the whole number of frames we should advance, but accumulate the decimal portion in another value which accumulates (accumulatedPortion). We add that accumulation into the computation for advancing the playhead. Lastly, if we reach the end of the movie, move the playhead back to the start but add in any frames we should skip based on the frame increment and any accumulated frame amount.

Here is the code:

var desiredrate:int = parseInt(newrate.text);
newrate.text = String(stage.frameRate);
var frameIncrement:Number;
var accumulatedPortion:Number;
 
function changerate (e:Event) {
	stopAnim();
	desiredrate = parseInt(newrate.text);
	startAnim();
}
 
changeratebutton.addEventListener(MouseEvent.CLICK, changerate);
 
function startAnim () {
	if (desiredrate == stage.frameRate) {
		anim.play();
	} else {
		accumulatedPortion = 0;
		frameIncrement = desiredrate/stage.frameRate;
		anim.addEventListener(Event.ENTER_FRAME, checkTime);
	}
}
 
function stopAnim () {
	anim.removeEventListener(Event.ENTER_FRAME, checkTime);
}
 
function checkTime (e:Event) {
	var framesToAdvance:int;
	var nextFrame:int;
 
	framesToAdvance = Math.floor(accumulatedPortion + frameIncrement);
	accumulatedPortion = (accumulatedPortion + frameIncrement) - framesToAdvance;
 
	nextFrame = anim.currentFrame + framesToAdvance;
 
	if (nextFrame > anim.totalFrames) {
		nextFrame -= anim.totalFrames;
	}
 
	if (framesToAdvance >= 1) {
		anim.gotoAndStop(nextFrame);
	}
}
 
anim.stop();
startAnim();

It should be pretty straightforward, but I’m certainly open to clarifying anything people want.

I was checking out cnet.com today and right at the top was an ad for the HP TouchSmart 520t, which had a DEMO button I was eager to check out:

When clicked on, the panel opened up to reveal a graphic overlaid with an animation of a hand that moved in response to my mouse.

When I clicked on something, the hand made a point gesture.  When I moved to the side, it made a swiping gesture.

Though this was incredibly simple, it did give me a sense of the ease in which I could navigate if I had this computer.  I thought it did a nice job of illustrating an important product feature.

Only one small complaint — I am left handed, and the image was for right-handed people.

I really like working in FDT5 and was eager to try out mobile app development. The first test I did I had no problem, then all of a sudden, any new app was not launching, giving the error:

application descriptor not found

adl.exe
-nodebug
-profile
mobileDevice
-screensize
480×816:480×854
C:\Users\Jonathan\workspace\workingapp\bin/workingapp-app.xml
C:\Users\Jonathan\workspace\workingapp\bin

adl.exe
-nodebug
-profile
mobileDevice
-screensize
480×816:480×854
C:\Users\Jonathan\workspace\trycompile
C:\Users\Jonathan\workspace\trycompile\bin

Solution

To say it is a long time coming is an understatement, but I found myself last week with a little time that I could devote to updating my Flash Equipment Interface component set. I didn’t quite get to them all, but I hit the ones I thought were the most important.  Over the next few days, I’m going to clean things up and release them somewhere.  I am not completely decided yet where/how I will distribute them.  When I do that, if you have some need for one or more of the remaining components, let me know and I’ll do my best to create them.

Update: I decided to release the components as open source under the New BSD License.  Check out my Google Code project to get them.

First off, I had made AS3 components over the years, here and there, and Jeff Kamerer’s multi-part series is really good (though I seem to discover new things each time I read it!).  Here are few more I found useful to help fill in some details, or get other perspectives:

• ActionScript 3 Custom Components from Hell (Red Bjarne)
• Building an AS3 FLA based component with SWFPanel and LivePreview (FlashGrind)
• Creating Flash Components for Distribution (Andre Cavallari)
• Creating FLA-based Components with ActionScript 3 in Flash CS3 (Flexible Factory)
• Custom Component UI with ActionScript 3.0 (Jeff Kamerer)

In general, it was a somewhat benign (yet tedious) experience, but there were a few gotcha’s that I wanted to document.

Events

The first question I asked myself was whether I should follow the pattern of the standard static constant-based events that are in the AS3 event model, for example, MouseEvent.MOUSE_DOWN.  I realized that at the top of my priorities was integrating the interface components with my State Engine, and the constant-based approach is not directly compatible with that.  For example, if all buttons issue MouseEvent.CLICK, and a state wants to listen to a specific click on a button, it means the state can really only subscribe to one button — without the handler having a mess to distinguish which button sent the event.  I prefer the ability to allow the instance to customize the event message.  Therefore, in my implementation, two buttons can send different events, such as “onPower” and “onNextPage”.  In reality, this gives developers the option to use the default event name, or rename it for their purpose.  I realize one of the complaints of the AS3 event model is that event handler typing is not enforced at compile time, and my approach flies in the face of that direction, but I didn’t see a compatible alternative.

Skinning

Most of my work is done within Flash Professional, FlashDevelop, or FDT.  I have not used CSS much at all, and so I decided for the first go around to make skinning something easy to accomplish with Flash Pro.  I added a property that gives the class name for the skin, using the default skin class name as the default property value.  That way, anyone who wants to create a skin just needs to make a Sprite or MovieClip (depending on the component) and give it a class name, then stick in the class name into the appropriate property.  I need to work on documenting how the skin should be created (rotation base, size, etc.) but I hope it is straightforward.  I played around a bit with setStyle() and the like, but in the end I went with what was easiest.

ASDoc

The most natural way of writing documentation is using ASDoc, but I struggled quite a lot getting it to work with my *.as files.  It was one of those things that I thought would take 30 minutes that turned into more than half a day affair. One big discovery was hearing that I needed to use JRE 5, instead of the more recent JRE 6 or JRE 7 versions.  I am shocked that this could have been the culprit, as Adobe seems to depend heavily on ASDoc and I wonder what the dependency is to version 5.  I am surprised I don’t see it somewhere in Flash CS5, but then again, maybe not so surprised, as Adobe is pushing development through Flash Builder.  This article from Wasted Potential helped a lot, though I still had some tweaks (hard earned through several hours).  BTW, here is my batch file that worked:

cls
set path=C:\Program Files (x86)\Adobe\Adobe Flash Builder 4.5\sdks\4.5.1\bin
set JAVA_HOME="C:\Program Files (x86)\Java\jre1.5.0_22"
asdoc.exe -source-path "C:\Users\Jonathan\Documents\My Dropbox\FMXIS3" -doc-sources "C:\Users\Jonathan\Documents\My Dropbox\FMXIS3\com" -window-title "EqSim Hierarchical State Engine and Equipment Interface Components" -main-title "Flash State Engine and Components" -footer "Copyright 2011<br/>www.eqsim.com" -output "C:\Users\Jonathan\Documents\My Dropbox\FMXIS3\docs" -library-path "C:\Users\Jonathan\Documents\My Dropbox\FMXIS3\fl-shim.swc"
pause

You’ll see I set the path variable at top because I didn’t want to interfere with the real JAVA_HOME (and get inundated with Java update messages, just for ASDoc).  Before having the library-path argument, I remember I had a lot of trouble with weird errors like UIComponent not being defined.  That eventually led me to a site that discussed creating a shim with the UIComponent code, which you can see here.  That site basically said to create a MovieClip that includes any Flash component (from Adobe), then export that clip as a SWC, then add the library-path argument above.  With the benefit of foresight, I bet I could just drop a component on the stage, then go find the ComponentShim component in the _private folder that gets added when one brings in one of those components (I used a Button), and use that, but I’m too lazy to go back and try that.

LivePreview

I struggled with the decision about whether I would produce FLA-based components or SWC-based components.  I have not come down conclusively on either side, yet.  The easiest process seems to be letting Flash produce the file as part of an exported SWC, then using that SWF file in the Components panel under Live Preview.  That wasn’t so helpful for two of my components, Timer and Stopwatch, because they have no visible presence at run-time, so the Live Preview would empty.  I tried to follow Jeff Kamerer’s suggestions in his Part 3 on LivePreview, but I found he glossed over the most important part, unfortunately:

If I had wanted the UILoader Live Preview to handle component parameters, I would have simply implemented those parameters.

He doesn’t say how to implement the parameters, and his example doesn’t show how to retrieve a UILoader-specific parameter — the live preview movie itself is not of the type of the component, so I don’t know how to access the parameters I want to display.  For example, in my Timer component,  I want to show the timing interval.  I don’t know how to access the timing interval of the real instance from the Live Preview movie.  Very frustrating.  Maybe someday I’ll figure it out, but for now I just created a box that shows up if isLivePreview is true (only during Live Preview).  So I will deploy my Timer and Stopwatch as SWC components, and then using the default preview mechanism will show the box I wanted.  Kind of gnawing at me how to access the parameters from a Live Preview movie, though.

UPDATE: I had some insight into the LivePreview, after giving it some more thought, but still did not get it to work.  Here is my comment I added to Jeff Kamerer’s article on making a LivePreview:

This series has been great, but I have one problem for the life of me I can’t overcome (and this part, #3, does not give the details).  I also have searched over the Internet at other tutorials, but to no avail.

I want to create a LivePreview movie for my component that has no visual representation on the stage.  The UILoader example is good, but it leaves out a few critical details.  For example, it says if you need to get component parameters, define them.  However, it does not say how to reach the parameters in the instance.  I looked in fl.livepreview.LivePreviewParent to find the answer: myInstance.  That property is the component instance.  Great, I’m thinking, almost there!

So inside the class I define for my LivePreview, for my component’s property “instance”, I retrieve “LivePreviewParent(parent).myInstance.interval” (because parent inherits from the LivePreviewParent class).  If “interval” is defined as a public variable (with Inspectable), great, I get the value as I want.  However, my “interval” happens to be a getter/setter (with an Inspectable tag, of course), and nothing happens.  I’m stuck.  I don’t know why it works for a public variable but not for a getter/setter.

Furthermore, even with an Inspectable variable, when I update the value in the property inspector, it does not change in the LivePreview.  I see in the LivePreviewParent class there is a method called “onUpdate”.  If I define that in my LivePreview movie, I’m thinking I will get notified when the properties change.  Nope.  I even tried defining it in the parent, and then having a function call into the LivePreview clip, but still nothing.

I have spent many hours on this, and just can’t afford to continue, so I have to go back to my fallback, which is adding the live preview into the real component and using the basic process.  This inflates the size of my component, but it is the only thing I can see reliably working.

The Future

It was a somewhat fun exercises, but it’s time to get back to my other work that has piled up.  It did occur to me that I may in the future want to port these to HTML5/JavaScript, which I don’t think would be too bad, or port them to Flex components (even easier).  Maybe someone out there would like to do this!  Stay tuned and I will post where I ultimately put the component set.

I was going through my usual sources for interesting information about simulations, and came across Karl Kapp’s website and blog.  Karl is a business consultant and professor at Bloomsburg University who writes about games, simulations, and learning, or as he describes it, he “consult[s] with businesses on topics related to the convergence of learning, manufacturing, and e-technology”.  In a world where people like to throw around claims like the superiority of simulations, 3D immersion, etc. Karl seems concerned about substantiating them and digging deeper, kind of what I like about Will Thalheimer.

Here are a few blog posts that really made a lot of sense to me.  I can see investigating these as I work to substantiate my own claims!

• Table: Key Advantages of Serious Games/Immersive Learning Simulations
• Some Shortcomings Around Game/Simulation Research
• The Role of Games and Simulations in Learning

Nice work, Karl!

In this post, I want to discuss some ideas I have had on how to dramatically increase the market penetration of simulations, where it is possible, which offers some insights into why I believe my new project, SimsUShare, is going to be big (and you should sign up here!).  That having been said, what I put here is only a first effort at putting down my thoughts so as to better evolve them.

While my growing experience in simulation-based training and product simulation marketing have continued to move me closer to recognizing solutions to underlying issues preventing widespread adoption of simulation today, I had trouble articulating the issues clearly.  Last year, I think I was able to do so. I believe that widespread adoption and benefit from simulation is held back largely because:

As luck would have it, as I was developing my ideas further, I came across Clark Aldrich’s blog post from June, 2010, “The Next Step for Simulations and Serious Games: Multi-Genre Authoring Tools and a Vibrant Marketplace“, that really summed up this yearning beautifully:

“…the process to create [simulations] today is too long and too expensive for most organizations to use them beyond the 5% to 10% of their high value/mission critical and external facing courses today. Further, the marketplace for selling and otherwise sharing them is too fragmented to provide reliable returns to attract many content creators. This has resulted in an identified, but unfulfilled need….What is now needed are powerful, flexible, and accessible simulation creation tools as well as a viable, persistent simulation repository and marketplace.”

One of the nagging things I walked away from this quote with was the question: why is the penetration stuck in the 5-10% range, and how can it be extended?  The idea of making more powerful tools is the mantra for many technologists — make more features, that’ll get them buying chopsticks (please excuse the Eddie Murphy reference).  I think Clark really nailed the issues — a combination of tools, repository, and marketplace.

On a slight digression, ever since I met David Castillo (my co-author) in about 2000, we have been discussing whether creating a simulation-building tool based on statecharts would bring statecharts and simulations more into the mainstream by making it easier to create simulations (particularly around equipment).  We looked at the Rapid CBT example–a beautiful tool, which seemed to garner more success for its services arm than for its own product sales–and we wondered if having a Flash-based tool would take this further.  Though it went unstated, I hesitated to go ‘all in’ on something like that because I didn’t feel we really nailed the idea of how a Flash-based (or HTML5, or whatever) tool would solve the market problem.  In my heart of hearts, it couldn’t just be about improving the tool itself — there had to be at least a community component.

Distilling Experience into Key Dimensions

Having the years to ponder these thoughts, I have come up with three dimensions that can help me give this problem something visual to work from:

1. Content Creation Simplicity.  How easy is it to use the tool to create appropriate simulation content, that is, what kind of functions does the tool provide to make the task of creating content simpler.  This can range from all content has to be created from scratch, to an ideal, perfect tool in which content can be magically reassembled with no effort.  Clearly, neither extreme is plausible in reality, but there is a great continuum between these points.
2. Cost – I don’t mean purely the purchase price, rather, a more overarching resource cost for what it takes to acquire and apply the tool in the workplace.
3. Community Sharing Proclivity (CSP).  A term I just made up meaning some measure of how inclined the community is to share existing work.

The last dimension requires more explanation and probably more thought to flesh out.  One could argue that if a tool made it easier to share work (i.e., going higher on the scale for #1), then the community sharing would be easier and therefore impact #3.  However, I am aiming at a more subtle definition of #3 — how likely would the community be to share any material generated.  For example, if the community consists of commercial competitors, then making a tool simpler will not affect the CSP.

One of my first observations was that the “community” is not anywhere near a single community.  I even have some trouble circumscribing exactly what is a community.  For my purposes, it is a group of people and businesses that seek to solve a set of common problems.  Therefore, a community can be very specific, or very general.  How you define the community issues is going to be a big factor in how close you can get to the perfect combination, or 100% market penetration (though I assume virtually no practical community could reach 100%).  Maybe that is pretty obvious.  Different communities have different needs and assumptions regarding simulations, and therefore trying to answer how to increase penetration for simulations as a whole is going to fail.

My Hypothesis

My hypothesis is that the potential penetration of simulation in a community is proportional to the closest distance between values assigned for a particular set of tools and the intersection of lines at the maximum of each of those 3 dimensions.  The purpose of declaring a hypothesis is to use it to understand how much we can improve market penetration practically.

Here is a rough sketch of what I propose:

The blue rectangular prism is a range of what one would consider practically achievable for a given community, since it is impossible to reach the perfect target.

To use this practically, you have to assign values (I would say qualitative) to:

1. Tool or set of tools (along the Content Creation Simplicity axis):  Farthest from the perfect target along this axis is a tool in which you have to re-create everything to make a simulation, and closest is a tool in which everything is provided magically so that simulation assembly is effortless
2. How inclined is the community to share work product (Community Sharing Proclivity): Farthest from the perfect target along this axis is a community that refuses to share anything; closest is the community that shares everything
3. The resource costs for implementing simulation solutions (Cost). Farthest from the perfect target is a tool with infinite cost (acquisition and resources); closest is a tool that has no resource costs.

To reiterate my hypothesis, I believe that given some tool (which embodies a methodology and process), given a measure of its cost to implement for an individual or organization in the community, and given some measure of how cooperative the community is at sharing, you can derive a distance to the ‘perfect target’, or maximum of all dimension values.

The Purpose: What the Hypothesis Suggests

Market penetration is important both commercially, for the tool producers, and the community, to help solve problems.  The purpose of defining these dimensions is to permit questions about:

1. What is the best description of a community fit to the tools/processes (for the tool vendor, who is really your target customers and target users?  For the community members, who are the people you need to associate with closer to increase the CSP?)
2. How can we decrease the distance to the perfect target, and thereby increase the market penetration.

Ultimately, by examining the values we assign, and the “maximum values” we determine for each axis given the community’s issues, we need to ask ourselves how difficult it would be to increase each value.  Depending on the extent of this space, we may be able to prioritize increases in which dimension(s) bring us closer to the perfect target at the least effort.  Improving tools may only go so far if the resource costs and the proclivity are working against us.  Similarly, the greatest intentions of a community to share (CSP) can be sidetracked if the tool costs too much to implement, or is not sufficiently easy to accomplish the needs of the community.

This is really a first stab at something that has been gnawing at me for some time.  I hope you can provide some feedback as to the soundness of these ideas and how your own thoughts might influence the direction I’m heading.

It’s been awhile since my last post, but I really haven’t seen anything that has caught my eye enough to comment on.  Of course I am also involved in my super-secret project, called SimsUShare, and then taking care of regular business and such hasn’t left me a lot of time for exploring.  In a few months, I will begin talking about SimsUShare and why I believe it will be the next generation in product marketing (hint: it’s about making simulations easier to build, change, share, and deploy).

Today I came across an intriguing post entitled “What Content Marketing is Really About“, by Robert Rose at the Content Marketing Institute.  In his quest to explain what ‘Content Marketing’ is about, Robert boils it down to:

The content marketing process is really centered on marketers becoming better storytellers. Our jobs are to create a lasting impression with our content with the goal of maintaining or changing behavior.

As I’ve talked about in other posts, I am convinced that simulations lend themselves naturally to develop compelling content that helps tell a story, because they can provide a vivid environment in which stories can be set, even stories that the viewer helps to ‘write’ (albeit in a directed way, “Successful selling by using simulations o put your prospects in their own (future) success story“).  Robert suggests we have to consider how each piece of content fits into an overall theme, into a picture of the kind of story (the ‘theme’) we want to tell about our product(s).

This led to me to think about a conversation I had this past weekend with my cousin Wyatt, a film editor who recently completed editing a major 3-D movie.  I was wondering whether he felt that 3-D was waning, because several of the ones I have seen recently really seemed to use 3-D pretty gratuitously.  In the course of the conversation, he expressed that in his view, movies like Avatar work well for 3-D because an important part of the movie was about inviting the viewers into a world to explore.  With many of the movies that follow (especially, it seems, the ones I’ve seen), the use of 3-D is for pure effect.

The relation I see to storytelling and simulation is that the good simulations, through depictions of meaningful interactions and details, help to recreate a vivid experience in which one can tell a great story.  Just as a great storyteller does not necessarily need a lot of theatrics, a great simulation does not need the full Hollywood effect to be compelling, provided that it has the right elements in which to allow the story to unfold — and resolve the problems/issues.

I came across an interesting post today entitled “Study Demonstrates False Memories Implanted Via Advertising” (which referred to an earlier post at Wired) about a research study I Imagine I Experience, I Like: The False Experience Effect (the odd part is that people say it is published in the Journal of Consumer Research, but I can’t find it in vol. 38 there).

What immediately struck me on my first reading was possibly two opposite feelings it evoked based on the same mechanism, that is, re-creating an experience that results in (‘implanted’) false memories.  In the advertising domain, it made me feel like implanting false memories is a sneaky and almost immoral thing, that is, trying to manipulate our mind towards the product.  In the training domain (especially with simulations), however, we actively strive to re-create experiences exactly for the purpose of having the viewer develop and retain the skills.

This is the crux of why I believe product simulation marketing can be so effective — it employs the same mechanism.  In the study, the authors achieved the results using a ‘high-imagery commercial’, but I think it’s not a big leap from there to a more immersive experience using simulation.  I can see how making the right type of advertising about a product, in which the viewer solves a problem using that product, could implant the memory in the viewer that he or she has solved the problem with that product –thereby making the useful connection for the marketer.  While this may sound a bit slimy, I think it all depends on how much one considers such content as manipulative or helpful.