Sharendipity - Recently Updated Pages

Sharendipity Home

greg.tracy — Tue, 23 Feb 2010 13:22:33 CST

I Want To Make A Game!!! (jump right in!).

Check it out! If you are creating behaviors for the first time, perhaps the best resource after the tutorials is the object referencing page. You'll learn all about creating and modifying objects, and the most efficient way to do so.

Getting Started

Our Getting Started guide introduces you to some of the basics of our unique casual game creator.

Resources and Tutorials

Learn more about the Sharendipity tools through these tutorials and videos, or find the answer to your question on our FAQ page.

Documentation

Details on how to use the Sharendipity creation tools to build great content. We talk about all of the basic building blocks of the Sharendipity creation tool including the definition of object properties, behaviors of objects, and integrating web services.

Game Elements

Curious how to add scoring to your game? This page documents scoring and other common elements that go into the creation of a game.

Copyright Information

Copyrights and credits for some of the components used in building Sharendipity.

Sharendipity Website

Featured Video

test

PcMan2010 — Sat, 23 Jan 2010 07:41:59 CST

Resources and Tutorials

triptych — Wed, 02 Sep 2009 13:21:58 CDT

Video Tutorials

These video tutorials provide great visual aids demonstrating the construction tools within Sharendipity.

Links

Google group for sharendipity developers.

FAQ

greg.tracy — Thu, 20 Aug 2009 15:14:47 CDT

This page is an on-going effort to collect the answers to frequently-asked questions about Sharendipity. If you can't find an answer to your question, please send us a note at alpha@sharendipity.com

Creation Tools

Can I access the mouse location inside a behavior?

You can if you are operating inside a behavior that was triggered by a mouse event filter. Inside the behavior/method builder, go to the Values tab and select other. This provides access to the details of the event including x/y position. Just click on the Event button to get at the details. See the image below.

More details to the event filter page

Why does every box and circle I draw fall to the ground?

Sharendipity has a built-in physics engine. The physics engine helps you with all kinds of interaction events including the management of collisions between objects, friction, elasticity, velocity, etc. One of the physics properties is gravity. You can turn it on/off as well as control the magnitude and direction of gravity (for instance, you could have some fun by flipping gravity upside down).

There are two ways you can control how objects behave relative to gravity.

1. You can choose to disable gravity for the entire World. You'll find this property by clicking on the astronaut character and selection "Properties..."

2. You can choose to have individual objects ignore gravity as well. To do this, open the properties for the respective object(s) and toggle the 'ignore gravity' flag.

What does the rewind button do? OR How do I restart my application?
The rewind button, located above the Director menu, will cause the application to reset to its initial state. Any object's that were created dynamically will be removed and all properties will be reset to their initial values.

Where do I define global variables?
You can either add them to your Application by opening its class editor. Click the Director menu and choose "Edit Class...". Then add new properties on the property tab.

An alternative is to add the property to your World. The process is the same except you access your World class by clicking on the Astronaut.

How do I import sound into my game?
When you use the "play sound" action, double-click the argument box (that specifies the sound to play). This will launch the Explorer window. You can select "New..." in the lower right-hand corner to upload a new sound or select a sound in the community.

What sound formats do you support?
We support WAV and MP3 formats. We don't recommend using files larger than 256k in your applications because they will have a negative impact on your user's experience.

How do I add high scores to my game?
There is a special action, "set high score", available in the behavior and method builders. You can pass in the integer value representing the score you'd like to save and it will be persisted to the server for your game. Check out the Game Elements page for more information on how to track scores, display them, and set high scores.

Why don't my high scores get saved when I'm creating my game?
Out of convenience and as a deterrent against cheating, we don't save any high scores that come from editor.

How do I change the position of an object that is created within my behavior?
When you've created a new object, always use reference displayed (in orange) on the right hand side of the action. That reference provides access to every property and method for the new object. Simply click on it once and the values panel will refresh with that object's details. Learn more about object referencing on our guidelines page.

Running Sharendipity

What browsers are supported?
We do know that Sharendipity runs well in both Firefox (2+) and Internet Explorer.

Saving Applications

Can other users see and edit my work?
When you save your creations, you have the choice to mark the object as "publicly visible." Choose this option if you want other people, including your friends, to be able to see what you've made. If another user with editing rights opens your creation, they will be able to save a copy of your object if they modify it. Otherwise, no, your creations can not be overwritten by other users. Long term, there will be much finer granularity for creation and editing.

Filter Definitions

greg.tracy — Thu, 20 Aug 2009 15:08:43 CDT

Define when a behavior's actions are executed.

Object Created
Object Destroyed
Key Event Filter
Timer
Collision Event
Object Modified
And/Or Filter
Mouse Event Filter

Mouse Event Filter

When you use a mouse event filter - "when the mouse is [pressed on] []" - you will have access to the position of the mouse when it was clicked. This true for the other mouse event types as well.

To access the position, choose the "other" menu inside the Values tab. The other menu always contains the details of the event.

Mouse event details include...

The actor under the mouse at the time the event fired
Whether or not the control key was pressed
Whether or not the shift key was pressed
The position vector in this World
The x position position
The y position

Properties

greg.tracy — Tue, 18 Aug 2009 10:27:23 CDT

There are two distinct views of your object properties and it's important to understand the distinguishing factors. Each actor in your World is an instance of a particular class, and there are different sets of properties depending on whether or not you are editing the instance in the World or the class definition itself (which affects all of the instances).

You can edit the instance's properties on the actor's primary menu.
You can edit the class's properties by selecting the "Edit Class..." option found on the instance menu or by accessing the class directly via the Explorer dialog.

Note that most changes you make to the classes' properties will affect every instance in the World. However, it will not affect any instance properties that have been modified. For example, the position property is always unique for an instance and will not change when modified in the class editor.

Properties Overview

Custom Properties

Custom properties are the unique, custom attributes that you can define for any object in the system. Each new property has a type associated with it as well as an initial value (the value the property takes each time the application is rewound or loaded).

Note: Any time you change a property's value by hand via the dialog (as opposed via a behavior), the value becomes the new initial state for the object.

Appearance

The appearance properties control general physical appearance as well as the object's visibility relative to other objects in the World.

draw_border - A boolean value that determines whether or not the border of the object is visible. This property overrides the actual color defined by line_color.
true : draw the object's border (default)
false : do not draw the border

fill_color - An RGBA value describing the color used to fill the object. The value can be entered by hand using the text field, or the color chooser can be clicked to choose a color visually.
the last number represents the transparencey of the color (the alpha)

filled - A boolean value that determines whether or not the object's fill color is applied.. This property overrides the actual color defined by fill_color.
true : draw the object's border (default)
false : do not draw the border

layer - An integer to describe the absolute positioning for the "painting" of an object. Object's with higher layers are show to be "on top of" of other objects.
By default, all object's have a layer of zero.

line_color - An RGBA value describing the color used to outline the object. The value can be entered by hand using the text field, or the color chooser can be clicked to choose a color visually.
the last number represents the transparencey of the color (the alpha)

text_color - An RGBA value describing the color used to outline the object. The value can be entered by hand using the text field, or the color chooser can be clicked to choose a color visually.

the last number represents the transparencey of the color (the alpha)

visible - A boolean describing whether or not the object is visible at all. Note that you can still select non-visible objects with the mouse.
This property is nice to use from a behavior when you want to temporarily hide the object without destroying it.

Position

The position property controls the location and direction of the object within the World. The best way to understand the coordinates is to simply experiment with locations.

orientation - The direction the object is pointed.
The default is zero degrees which points straight right.
You can use positive and negative numbers. Positive degrees will rotate the object counter-clockwise...
90 degrees points up
180 degrees points left
270 degrees points down
360 degrees points right

position - The location of the object in the World represented by an x and y vector coordinate system.
The center of the World always has a position of 0,0!

Image

Images can be applied directly to core components such as rectangles and circles by simply dragging them onto the object from your desktop. Images can also be dragged directly into the application gallery and they can be set and modified using behavior actions.

The property dialog provides a browse button so you can search your file system for the image to be applied. The thumbnail preview window also acts as a drop target so images can be dragged directly into this property dialog.

image_scaling_mode - Describes how the image is scaled within the object

fit : will force the image to fit as best as possible without changing its aspect ratio (default)
stretch : will force the image size to be equal to the size of the object independent of aspect ratio

fit_width : will force the image's width to be equal to that of the object regardless of the aspect ratio
fit_height : will force the image's height to be equal to that of the object regardless of the aspect ratio

hold_on_frame - Will freeze an animated image on a particular frame. If no frame is specified (the default), the animation will be active.

flip_horizontally - Rotates the image 180 degrees left to right.
false : no rotation applied (default)
true : apply rotation

flip_vertically - Rotates the image 180 degrees top to bottom.

false : no rotation applied (default)

true : apply rotation

image_anchor - Controls the location of the center of the image.

center : vertical/horizontal center of object (default)
north : top of object
south : bottom of object
east : left hand side of object
west : right hand side of object
northeast : top right hand corner of object
northwest : top left hand corner of object
southeast : bottom right hand corner of object
southwest : bottom left hand corner of object

Text

The text properties allow you to modify text being displayed inside the object. Note that if you'd like to use specific fonts, it is best to use graphic images since the specified font property may not be available on an end-user's machine.

This is a nice tool for testing, however. You can put all kinds of information in the text field to help explain how your application is running!

font - The font used to display the characters in the object's text field. Format is:
<font name> , <weight>, <font size>

text - Text field that contains the text to be displayed. It defaults to empty.

text_alignment - Alignment of the text relative to the object's width. The property editor provides the following options. Note, however, that if you are dynamically changing the anchor from within a behavior or method, you need to assign the numerical value (shown in parens).
center : horizontaly aligned in the center. (2)
left : left edge aligned. (0)
right : right edge aligned. (1)

text_anchor - Describes where the text starts within the object. The property editor provides the following options. Note, however, that if you are dynamically changing the anchor from within a behavior or method, you need to assign the numerical value (shown in parens).
center : vertical/horizontal center of object (1)
north : top of object (2)
south : bottom of object (3)
east : left hand side of object (4)
west : right hand side of object (5)
northeast : top right hand corner of object (6)
northwest : top left hand corner of object (7)
southeast : bottom right hand corner of object (8)
southwest : bottom left hand corner of object (9)

wrap_text - boolean value describing whether or not the text will wrap and stayed contained within the object itself.
true : wrap the text (default)
false : donot wrap the text

Physics

These properties control the physical properties of the underlying object. Modifying these properties will have an effect on how the object interacts with other objects in the World.

elasticity - determines the flexibility of the object when it collides with other objects.
defaults to 0.8
1.0 has perfect elasticity
0.0 has no elasticity

friction - the surface resistence for the object.
defaults to 0.8
1.0 has absolute friction
0.0 has no friction

ignore_collisions - determines whether or not the object will interact in a physical way to other objects in the World.
false : the object bounces off any other objectthat also has this property set to false (default).
true : the object will not collide with any other object in the system (it appears to pass right through it).

mass - the weight of the object.

motion_constraint - a vector that controls the direction an object is allowed to move. the first value is the horizontal constraint, and the second value controls the vertical constraint.
1.0, 1.0 means the object can move in any direction.
0.0, 1.0 means the object can only move in the vertical plane.
1.0, 0.0 means the object can only move in the horizontal plane.
0.0, 0.0 is equivalent to having the object pinned.

orientation_constraint - a boolean flag the controls whether or not the object can rotate when it collides with other objects.
false : freely rotate (default)
true : no rotation

pinned - a boolean flag the controls wither or not the object can move at all. For instance, if you don't want an object to fall when gravity is enabled, "pin it" in place.
false : position will be affected by colliding objects and the force of gravity (default).
true : object is stationary regardless of external forces.

rotational speed - determines how fast an object is rotating. A positive value indicates a counter-clockwise motion (as the angle increases as you move counter-clocwise away from 0), and a negative value indivates a clockwise motion.

speed - determines how fast an object is moving. the direction is always in line with the orientation of the object.

velocity - the vector describing the direction and magnitude of the speed.
Changing the speed will implictly change its velocity.
Changing the velocity willnot implicitly change its speed.

Geometry

Simple geometry of the underlying object. The actual properties available depend on the object type. All numbers are of type float, and use the global coordinate system of the World (for example, the default width of the World is 47.5).

Circle

radius - The radius of the circle (there is no current support for ellipses).

Rectangle

height - The height - in global coordinates - of the rectangle.

width - The width - in global coordinates - of the rectangle.

Line

height - Ignored.

jointLine - Ignored.

width - The length of the line.

Interaction

This only includes one field at the moment - grabbable - wich is a boolean and describes whether or not the user can select it with the mouse.

This is useful if when you are creating game content that you do not want your players moving around with the mouse. It can also be useful when you are editing and have overlapping objects. It's nice to make objects ungrabbable so you don't pick them up by accident.

Important caveats about this field... The property is currently applying itself to other mouse events in the editor that you may not expect. For example:

If an object is NOT grabbable, behaviors that filter mouse clicks on the object will beignored.
If an object is NOT grabbable, you cannot drop things on it. For example, you cannot drop images or behaviors from the search results like you normally would. You will have to use their specific editors to perform those actions.

Web Service How-to

greg.tracy — Wed, 12 Aug 2009 10:38:24 CDT

Several web service interfaces have been built and shared within the Sharendipity community including services for Facebook, Twitter, Flickr, Posterous, and Google Docs. Using these components you can quickly and easily access the data from these sites/services.
But what happens if you can’t find the service you’re looking for? Or if you want to improve on one of the existing services and make a better one yourself? This post is here to help. We’ll walk you through some of the basic elements for building a new component that interfaces with an external web service. To get started, first launch the Sharendipity editor.

Create new object type

Creating a new type provides you with the ability to define custom assets that perform a particular job or store specific data. They don’t necessarily have to be a displayable actor inside your World. The definitions for these new assets are entirely up to you.
In the case of a web service, you’ll define the location of the service, describe inputs, and then define custom actions that let the users of your service interact with it.

Open the Explorer dialog and select New from the Types tab.
Name your new type. For example, “Twitter Service – public timeline”
Declare that your new type “is a REST Web Service” by clicking the + sign next to its name, and selecting the is a button. You can find the REST Web Service type by selecting Other… and navigating to the Local->Types tab in the Explorer that is launched. The following diagram highlights this navigation.

Default properties

Once you have the REST Web Service type defined, you must specify the details of your web service by initializing a couple of parameters.

URL : This property defines the location of the web service. You will need to consult the API documentation for the respective web service to find the URL for your respective web service type.
- For example, Twitter’s public timeline is: http://twitter.com/statuses/public_timeline.xml
proxied : This property defines whether or not your web service calls will be routed through the Sharendipity server. You are required to turn this on for any web service that hasn’t granted domain access for your application. This is part of Flash’s security model, and you’ll find that some services like Flickr’s allow access, but others like Twitter do not.
result : This property is not intended to be initialized. When the web service is called, the data returned from the call will be placed in this property.

Custom properties

Many web services have optional and required parameters. For instance, the Posterous API lets you specify the subdomain of the site you are reading from. In order to define parameters, you must define custom properties in your type that are of type REST Input.
Each REST Input has a name and value pair. The name value should be the parameter name as defined by the web service API you are trying to access. In the Posterous example, the name field is ‘hostname’. The value field carries your parameter value. When the web service is invoked, each REST Input is automatically appended to the end of the URL property.
If you were to look at the full URL when the service is invoked, you’d see something like the following:
http://posterous.com/api/readposts?hostname=gregtracy
As you are making calls to the web service, you can simply manipulate the value parameter of the REST Input to change your query to the respective web service.

Web service actions

By default, there is a single method defined for all web service types called invoke web service. This is the mechanism by which you initiate a call to your web service. It can be called internally as well as externally by users of your component.
Just like other objects in the system, you can create your own behaviors, methods, and properties for your new type. For instance, you may want to create your own invoke method which takes parameters that are passed to the web service. For example, passing in a user ID to a Facebook web service to specify the user whose profile you would like to access.

Referencing the service

Once you’ve defined your web service type, you can share it with the rest of the community with the Save option found in the object builder. Otherwise, the web service will be saved along with the application you’ve defined it in. Whether or not you share it, the new type can now be accessed from anywhere else in the application.

If you drag it into your World and drop it, you will be prompted to create a new custom property for the World.
You can drag it into a behavior or method and drop it to create a local variable inside your logic.
It will also be accessible from the Other tab when you define new properties anywhere within your application.

Just remember that if you don’t save the service by itself, you can only access is from the Local tab of the Explorer within the current application. If you do save it, it will appear in the Types tab for everyone.

Tips for better reuse

Creating an abstraction of the web services call is a nice feature by itself. However, it becomes most useful when you provide really easy access to the data that is returned. For instance, rather than simply providing the invoke web service call and letting the callers parse the data returned, try creating methods that do that parsing for them.

The Twitter service has a method that returns an array of Twitter Status types.
The Posterous service has a method that returns an array of Posterous Blog Post types.
The Facebook User service has a method that returns an array of Facebook User types.

Each of these services define new methods that call the invoke web service method internally and parse the return data automatically. This way, users of the services don’t have to worry about how any of the data is formatted.

Web Services

greg.tracy — Wed, 12 Aug 2009 10:27:27 CDT

Sharendipity is a great platform for visualizing third-party data, and it can be done via our REST web services.. This provides an opportunity to access data from an outside source and include it within your application. For example, you can display photographs from your Flickr account, access your Facebook account, or access weather and stock data.

Example Applications

Here are some of the existing examples...

Flickr Photo Slideshow Template (Flickr) : A customizable web widget that streams photos from Flickr based on a username and/or photo tags.
Flickr Scramble (Flickr) : A customizable puzzle game that uses a Flickr photo as the input to the puzzle.
Facebook Photo Browser (Facebook) : An application that lets you browse all of the photos in you entire Facebook social graph.
Facebook Photo Scramble (Facebook) : Like the Flickr example, this is a puzzle game except it uses a photo from your Facebook friends as the input to the puzzle.
Who Be Me? (Facebook) : This quiz game asks you to pair up random facts about your friends with the correct friend.
Facebook Photo Demo (Facebook) : A demo application that explains some of the integration points for the Facebook web services.
Posterous Photo Stream (Posterous) : A customizable web widget that streams photos from your Posterous blog.
All City Food Drive (Google Docs) : A widget that displays data stored in a Google spreadsheet.

Documented Examples

Facebook API : details on the specific bindings between Sharendipity and Facebook
Google Docs : example components used to access Google spreadsheet data

Creating your own web service interface

Interested in using web services yourself? You have one of two options...

Reuse and existing web service component created by other users. You'll find examples from Facebook, Flickr, Google, Twitter, Posterous, and others. The above example applications are great starting points to learn how some of these are being used today.
Create your own interface to your favorite web service. For step-by-step instructions, check out this how-to page.

Passing Parameters to an Application

dale.beermann — Fri, 07 Aug 2009 11:30:30 CDT

One of the really cool ways that you can integrate Sharendipity into your own web applications is by passing arguments into the Sharendipity player. This functionality allows you to incorporate data such as user session IDs or anything else managed by your own server into a running Sharendipity app.

Accessing Application Parameters

Accessing the parameters to your application is actually really simple. There is a method on the Application called "Get Application Parameter." Access the Application object by clicking on the "Actors" tab in the Values section of the Behavior or Method Builder. Click on the object called "Application" and scroll down to the section where the methods are listed. Just drag the method into the right-hand panel and enter the name of the parameter that you want to access:

Setting up the Embed Code

Now that you have your application set up, you just need to pass the application parameter to the embed code. For example, this is the embed code that is being used for the application we're working on here:
<object width="300" height="200" data="http://static.sharendipity.com/player.swf?aid=3371&appParam=Sharendipity%20Rocks!!!" type="application/x-shockwave-flash">
<param name="src" value="http://static.sharendipity.com/player.swf?aid=3371&appParam=Sharendipity%20Rocks!!!" />
</object>

When you publish your application, an embed code similar to the above one will be given to you so that you can put your application on your own site. The only difference between the code I would have been given and the code above is this section: "&appParam=Sharendipity%20Rocks!!!"
You can see that we're already passing the application ID to the Sharendipity player ("aid=3371" in this case). All we're doing is passing the Flash application another parameter as part of the querystring that can be accessed inside Sharendipity. This is the value that is pulled out when the "Get Application Parameter" method is called with "appParam" as the name of the parameter we want. If you're running a web server, you can set up your pages to dynamically write whatever value you want into the embed code.
If you want to play around with the application, you can edit it and save your own here: http://games.sharendipity.com/create/?aid=3371.

Documentation

dale.beermann — Wed, 05 Aug 2009 15:18:14 CDT

Applications

Make something great today in Sharendipity! Whether it's a game, a slide show, or ... ? You're only limited by your creativity. Use this section to learn more about saving and distributing your next great application.

Behaviors

Want to make an object move? Want to keep track of your game score? Behaviors define the actions that take place during well defined events in your application. Read on to learn more.

Properties

Do you want to change the appearance of your object? Properties define the default and custom attributes of objects in your application.This includes attributes that define an object's appearance as well as physical properties like friction and mass. Check this section for help understanding what's available to you as a creator.

Toolbox

At their most basic level, every object in the world is a simple drawing object. A rectangle, circle, or line. Many times they have images, behaviors, and unique properties, but underneath, they're a simple shape. If you're creating from scratch, all of the tools can be found by clicking on the Builder character.

Web Services

If you'd like to integrate information from other sources into your application, use our web services feature to access it. We've made it easy to access a wide variety of information from your Facebook network and other web services.

Achievements

Interested in adding custom achievements to your application? This sections shows you how to engage your user in fun new ways, by creating secondary goals for application usage.

Developer Tools

Sharendipity provides a few advanced features for developers, including a Problem Viewer as well as debugging and performance tools.

Configuration

Configuration is broken out into two separate sections:

Developer Tools

dale.beermann — Wed, 05 Aug 2009 15:17:35 CDT

This page highlights the advanced developer tools that help make it easier to create and debug applications in Sharendipity.

Console Viewer and Trace Statements

The Console Viewer provides a dialog that the developer can write to in his or her application for debugging purposes.

Problem Viewer

The Problem Viewer provides a rundown of the errors that are preventing parts of an application from running.

Performance Measurement

The Profiler provides low-level access to performance data for a running behavior or method in an application.

Breakpoints

Breakpoints provide a way to halt execution of a behavior or method to analyze property values.

Breakpoints

dale.beermann — Wed, 05 Aug 2009 15:14:57 CDT

Like most debugging tools, Sharendipity also offers a way to halt execution of a thread to examine the current variable data. The current implementation uses a "Breakpoint" statement. Under the hood, this throws an exception that will show up in the Problem Viewer, preventing following statements in the behavior or method from running. Opening the problem viewer and double-clicking on the Breakpoint exception will bring you to the Behavior or Method where the breakpoint was hit. The really handy part is that now you can mouse over variables in the Method Builder or Behavior Builder to see their values:

Performance Measurement

dale.beermann — Wed, 05 Aug 2009 15:13:12 CDT

The Sharendipity editor also includes some new functionality that lets you analyze which parts of your application are taking longer to execute. Similar to the Console Window, the profiler can be accessed from the Director menu:

Clicking on the Performance... item in the director menu will bring up the Performance Management dialog, which looks like this:

In this view, Profiling has already been enabled and data is being collected in the running application. From the menu you can view the current profiling data, and you can also clear the profiling data. Viewing the profiling data will give you a view similar to this:

Similar to the Problem Viewer, double-clicking on one of the rows in the Profiler will allow you to see exactly which calls are taking all of the time, including breakdowns by constructs such as "if" statements:

Problem Viewer

dale.beermann — Wed, 05 Aug 2009 15:12:49 CDT

The Problem Viewer is a dialog that displays issues to the developer that prevent the application from running correctly. When there is a problem in an application, a red notifier saying "Problems" will appear in the top-left corner of the editor. Clicking on this will bring up the Problem Viewer.

Both compilation issues and runtime issues are displayed in the Problem Viewer. What makes the Problem Viewer so helpful is that double-clicking on a row in the Problem Viewer will take you directly to the location of the problem. You don't need to go searching around for the location of the error.

Below is a view of the Problem Viewer in an application I set up to be broken intentionally. You can see that there are a lot of issues and the Problem Viewer allows me to see exactly which classes and methods they're coming from.

Console Viewer

dale.beermann — Wed, 05 Aug 2009 15:12:12 CDT

One of the more basic debugging tools at the hands of the programmer using a traditional IDE is the console, combined with a way to print data to it. Sharendipity also has a Console Window that can receive text output from an application. The console can be accessed through the Director menu:

This will bring up the console window, shown here with output from the Teslaformer game:

The console can be written to with Trace statements inside Behaviors or Methods of a class in Sharendipity. The trace statement can also take just about any type. You can even concatenate values together using the "+" operator as shown here:

The console can be very useful for tracking certain state in an application, especially when you want to see when behaviors are firing or certain property values.

Application Configuration

dale.beermann — Wed, 29 Jul 2009 10:16:14 CDT

One of the things that makes Sharendipity so unique is the ability for anyone in the community to become a producer of components that others can build on top of. This can include small elements like a game actor or a graphic, or perhaps a behavior that can be applied to certain classes of actors.

But perhaps the best example of becoming a power builder is the ability to create entire application templates. These come in all shapes and sizes, but they allow anyone in the community to quickly and easily extend your work at the application level. This is best seen through our configurator feature. Examples include :

Swappers : Simple games that let anyone swap out images and sounds to create custom versions of the game.
Application Kits : A collection of parts that can be assembled in any way to create a unique game or puzzle. For example...
- The Puzzle Popper Creator lets you create your own Popper Puzzle from scratch using the various game elements.
- The Match Template lets you quickly create interactive study guides.

Not everyone realizes this, but anyone can create one of these templates to be re-used by others. This post will walk you through the basics of creating a simple swapper template.

Application Configuration

Once you've built a fully functional application, you have the opportunity to expose different elements to be configured. In order to configure an application to be customized, start by clicking on the Director (the character farthest to the left), and selecting "Edit Class..." as show in the image on the right. This will bring up the Object Builder for the Application class, as shown below.

Clicking on the Advanced menu, and selecting "Integration..." will pop up the "Integration Step Management" dialog. This dialog allows you to set up the individual steps that a user will walk through when they are customizing an application.

Right now there are three types of steps that you can add: Instructional, property modification, and actor placement. Instructional steps require no input from the user, they just allow the author to provide information about the configuration process. Property modification steps, listed as "Ask for one or more property values" in the step addition dialog, allow the user to specify a value for any property on any object. These may be used to set the number of enemies, firing rates, or really anything that the author has set up to be configured. Actor placement steps allow the author to specify certain actors that the user can drag into the world. This allows the configurator to function as a sort of level editor where the user is actually creating the layout of the game that they're making.

Above you can see the integration steps for Floater, one of our customizable games. You can see there are six steps. The first is simply an introduction to the configuration wizard from the standpoint of the Floater author:

The other steps allow the user to configure various properties of the application, including the image for the main character, the number of enemies (1 or 2 in this case), images for two different kinds of enemies, and the background image. When someone wants to configure the actual application, this is what they'll see:

Similarly, editing the second integration step for Floater lets us see how it is set up. The World property "character image" is the one being edited:

You can see allows us to provide some instructions for this step as well, but now user input is required to move on to the next step. Again, the corresponding dialog when the user is actually editing the application looks like this:

For an example of an actor placement step, we'll take a look at the Puzzle Poppers Creator. This is a balloon popping game that has been set up so that the user can place balloons and walls to build their own levels for others to play. The integration step of interest looks like this:

And when the user is configuring the application, the dialog appears as such:

Component Configuration

dale.beermann — Wed, 29 Jul 2009 10:12:11 CDT

Component configuration is very similar to Application Configuration. The main difference is that you're creating objects that others will configure as they're building they're own game. With application customization, the author is defining how the entire application is configured for someone to add their own twist.

An Example: Creating a Flickr Widget

A lot of this is similar to the steps in the Application Configuration page. However, all of the interaction with the customization dialogs happens within the Editor, rather than in the Customizer.

Similar to creating customizable applications, customization of components happens from the Integration menu item in the Advanced section of the Object Builder:

This brings up the Integration Step Management dialog, where you can add, edit, and delete the integration steps.

Clicking on "Add" will let you create new integration steps. The only difference here between Application customization and Component customization is that the "Place Actors" step is invalid in the context of Component customization. In addition, adding integration steps that allow you to modify properties will only provide access to the properties of the component being customized, rather than the entire Application and its children. This is what the editor for the Flickr username property in this component looks like:

You can see that there are a set of instructions that control what happens when the component is consumed by another author, and the correct property being modified is listed.

Once integration is set up for a component, when it is added to a new object by being dragged from the search results, the user will be prompted with a dialog to customize it to their needs:

Once configured, the component should be set up to operate correctly in your application.

Make a Game!

dale.beermann — Tue, 28 Jul 2009 17:50:31 CDT

So you're a little antsy and want to dive in. OK. Click here. The rest of this page will help explain what that template does if you need some help.

The Editor

When the editor first opens, you'll see that there is a little bit of text telling you how to save the game so that you have your own copy. Once you save it, you will be working in your own new game.

The "Click to Continue" Object

When creating games, it's very common that you want to keep track of whether or not the game is currently playing, or if it is in a "paused" state. The "Click to Continue" object controls this. When the player clicks on the world, this object will disappear, and the World's "playing" property will be set to true.

Defining Your Own Playing Logic

Typically you don't want to create game logic that runs when the game is in the "paused" state. To ensure this, when you are creating this type of logic, just use an "if" statement that checks whether or not the World's playing property is set to true. So first create a new behavior (for this example, I just made on on a key press) and choose the right event trigger for your behavior.

Click on the Logic tab. The "if" statement should be the first one. Drag it over to the right-hand panel:

Now click on the "actors" tab, and click on the "World" instance to get to the World properties:

Scroll down to the "playing" property and drag it into the "if" statement, where the "true" value currently is located:

Now any logic that you want to add should go into that if statement, and it will never run until the user clicks the mouse to start the game.

Adding Objects

You can either start by creating your own objects using the tools on the Builder menu, or you can search the community from the Explorer menu (on the right) and dragging actors into your world. Or, you can create your own objects and use the Sharendipity community to find images, behaviors, etc. for your object.

Setting the Score

Once you've figured out how to control your gameplay, you'll want to know how to set the score. It's pretty simple really. All we need to do is modify the world's score property.

You'll probably be adding to the score, so first click on the Logic tab, and then scroll down to the "add" statement. Drag that over into your right-hand panel. You can enter your own value into the add statement by dragging it into the location where the "1" is, or you can drag another property reference over there.

Now navigate to the World properties like you did for your game logic by first clicking on the actors tab, and then clicking on the World instance:

Now scroll down to score and drag it into the right-hand side of the "add" statement and you should end up with this:

Ending the Game

There is also a "lives" property on the World. Just create your own logic as before so that you can add -1 to the World's "lives" property when you want to. When that value reaches zero, an animated "Game Over" object will pop up.

The "Game Over" object takes care of using the World's "score" property to submit the player's score to the server. Then, after a second or two, the stock Sharendipity High Scores dialog will display signifying the end of the game. The player will be given the option to replay at that point. You don't need to deal with any of the logic!

Publish!

Be sure to publish your game so that everyone can see it! Just click on the Director menu, and click on Profile:

The following dialog will display with your application's information. Be sure to update the name and the description, and add an icon. Adding tags may help people find it easier too (is it a "shooter" style game? or a "puzzle" game?) Then check the box to make your application public and save it!

Video Tutorials

dale.beermann — Tue, 28 Jul 2009 10:37:21 CDT

This page contains several video tutorials to help you make your own games in Sharendipity.

Create a Space Shooter in Less than 10 Minutes

This video shows the creation of a simple space shooter game. You can even edit the saved game here.

Creating a Flickr Photo Stream

This video shows in fast motion how a Flickr Stream was created. It uses a combination of homemade components as well as the re-use of some Flickr web services. You can find the fully customizable version of this application here.

Creating a Customizable Application

This video shows in fast motion how the above Flickr app was converted into a customizable application.

Creating Bloomshine

dale.beermann — Fri, 24 Jul 2009 16:30:36 CDT

NOTE: This tutorial was built in the old version of our editor. It is left here as it still provides a guide for creating a full application.

Bloomshine is a Sharendipity-based version of Boomshine, a popular Flash-based casual game. The player is tasked with starting a chain reaction in an attempt to explode as many dots as needed to pass each of it's increasingly difficult levels. The original Boomshine's levels have been attempted more than 30,000,000 times by hundreds of thousands of players.

Because of it's straight-forward rules and collision-based gameplay, Boomshine is a perfect example of the type of game that can be easily created within Sharendipity.

Elements of Gameplay

Bloomshine uses a flower-theme when describing it's gameplay:

A number of colorful ''seeds''are randomly placed in the world. Each is given a random direction and speed. Seeds bounce off of each other as well as the edges of the world.
The player clicks anywhere within the world to initiate the blooming process. Blooms grow to a specific size and then wilt away - disappearing from the world.
Any seed that comes in contact with a bloom begins to bloom itself. On any given level, the player's goal is to get a certain number of seeds to bloom off of their initial bloom. Each bloom counts toward the player's total score.
If the player succeeds in blooming a minimum number of seeds, they move on to the next level where the number of seeds and difficulty increases. Otherwise, they must repeat the current level.

Despite what the the length of this document suggests, Bloomshine is pretty simple. Before we can start on the main game logic, we need to prepare a couple of objects.

Objects

Seed

The Seed is the small circle which briefly transform into colorful blooms and then wilt away. We'll create the those behaviors later - for now it makes World configuration easier if the Seed is created and waiting in the gallery.

Draw out a single circle and open it's properties dialog. Name it "seed" and then configure it's properties in the following way:

Custom Properties

WILTING ("boolean") indicates that the seed has entered the wilting state and will be used later by the seed's behaviors. It defaults to false.

Appearance

DRAW_BORDER and DRAW_CIRCLE_AXIS are unchecked.
FILL_COLOR is set to "1, 1, 1, 1" which is pure white.
FILLED is checked.
LINE_COLOR does not matter because the DRAW_BORDER is disabled.
TEXT_COLOR is set to "1, 1, 1, 0.5" which is pure white.
VISIBLE is true.

Physics

ELASTICITY is "1.0" which ensures perfect bounce after each collision.
FRICTION is "0.0" ensuring that the seed will not slow down during a collision.
PINNED is unchecked.

Geometry
RADIUS is 0.6.

Interaction
GRABBABLE is unchecked. (This disables mouse interaction with the seed during play ensuring it does not interfere with the player's click to create an initial bloom.)

Once the seed's properties have been configured, it should be put in the gallery. Because it is no longer GRABBABLE, you need to press the control key while clicking on it to bring up it's menu. Then choose "Add to Gallery" to save the seed for use later.

Announcement

The ANNOUNCEMENT object is responsible for displaying messags to the user. It is created by dragging out a PINNED BOX in the center of the world. It's properties are configured in the following way:

Appearance

DRAW_BORDER and FILLED are unchecked.
TEXT_COLOR is "1,1,1,1" which is pure white.

Text

FONT is set to "defaultEntity,32" which is an unfortunately complicated way of saying use the default font in 32-point size.
TEXT defaults to "Welcome to Bloomshine" which is the message it will display when the game starts.
WRAP_TEXT is unchecked.

Physics

IGNORE_COLLISIONS is checked to ensure that nothing inadvertently collides with the message.
PINNED is checked.

Geometry
The height and width of the box is "6.0" and "54.0" respectively.

Position

ORIENTATION is "0.0"
POSITION is "0.0, 0.0" ensuring that the box is perfectly centered on the screen.

Interaction
GRABBABLE is unchecked. Once we've configured it's properties, we don't want to inadvertently grab and move the announcement.

Score

The player's score is displayed on a PINNED box in the upper-right corner called SCORE. Like ANNOUNCEMENT, it is configured to be ignored by the physics engine and useful in displaying the player's score.

Appearance

DRAW_BORDER and FILLED are unchecked.
TEXT_COLOR is "1,1,1,1" which is pure white.

Text

FONT is "defaultEntity,18,bold" which, again, is an unfortunately complicated way of specifying the default font in bold and an 18-point size.
TEXT defaults to "0" which is the player's score at the beginning of the game.
WRAP_TEXT is unchecked.

Physics

IGNORE_COLLISIONS and PINNED are checked.

Geometry
The height and width of the box is "3.0" and "9.0" respectively.

Interaction
GRABBABLE is unchecked. Once we've configured it's properties, we don't want to inadvertently grab and move the announcement.

The "Press Space to Continue" Prompt

The final object needed by Bloomshine comes from the community. The "Press Space to Continue" object can be found by searching for it. This is a simple object that flashes a message until the user presses the space bar. Drag it from the search results into the world and then add it to your gallery by (since it isn't grabbable) holding CONTROL while you click on it

The World

Properties

The WORLD plays an important role in Bloomshine. It is responsible for managing the current state (such as the player's current score, the total number of blooms needed in the current chain reaction to complete the level, etc.) and when appropriate, handles the transition to the next level or announces the end of the game.

Appearance
BACKGROUND COLOR is set to "63, 63, 48, 255" - this is a dark gray that will help the colorful blooms stand out during gameplay.

Geometry
The WIDTH and HEIGHT of the world are set to "64.6" and "56.5", respectively. (The dimensions of the Sharendipity application are actually 646 x 565 pixels - so using these measurements ensure that the world exactly matches the size and aspect ratio of the applet.)

World Boundaries

BOUNDRY MODE defaults to"Bounce" which is perfect because we don't want the randomly moving seeds to fall off the edges of the world.
VISIBLE is unchecked.
FRICTION is set to "0.0" so that when objects bounce off the walls, they do not slow down.
ELASTICITY is set to "1.0" which is also necessary to ensure a perfect bounce.

Physics
APPLY GRAVITY is unchecked.

Custom Properties
The world has a number of custom properties that manage the game's state at all times. These properties are:

BLOOMS (''integer'') will be used to keep track of the number of seeds that are currently blooming. Each time a seed begins the blooming process, this value is incremented. When the bloom "pops", the value is decremented. At any given moment, it reflects the number of active blooms in the world.
BLOOMS_MAX (''integer'') will count the total number of blooms resulting from the player's chain reaction. Like BLOOMS, each time a seed starts blooming, this value will be incremented. Unlike BLOOMS, however, this value does not decrement when a bloom pops. The player completes a level when, after all blooms have popped, the BLOOMS_MAX value is greater than or equal to the BLOOMS_MIN value.
BLOOMS_MIN (''integer'') holds the minimum number of blooms required to pass the level. For the first level, this defaults to "2". As the levels progress, this value will be calculated based on the current DIFFICULTY value multiplied by SEEDS_MAX.
DIFFICULTY (''float'') represents the percentage of seeds that must be bloomed in this level. It defaults to 30% ("0.3") and each time the player advances a level, it is increased by 10% ("0.1").
IN_PLAY (''boolean'') indicates whether or not the current level is in-play. When "False" the world is poised to begin a new level. When "True" the game is waiting for the player to start the chain reaction or for it to die off.
LEVEL (''integer'') represents the current level number. The default value is "1" because the game begins on the first level. Each time the player completes a level, this value will be incremented.
SCORE (''integer'') represents the player's total score for each level the player has successfully beaten during this game. The player earns score each time they pass a level. Their score is incremented by the total number of blooms they created during that level.
SEEDS (''integer'') tracks the number of seeds that will be released at the beginning of the level. For the first level, this defaults to "5". This will be incremented each time the player advances a level.

Here's a screenshot showing what the world's custom properties look like at the beginning of the game:

Behaviors

The world is responsible for initializing each new level, spawing the seeds that bounce randomly around the world and, upon the final bloom popping, determining whether or not the player has succeeded.

Beginning the Level
This behavior responds to the spacebar being pressed and either starts a new level or restarts the current one (if the player was unable to pass it previously). To that end, we setup a new KEY EVENT FILTER:

Here's some pseudo code to illustrate the overall behavior:

When the player presses the Space bar...
If the World is not already IN_PLAY...
Set the World's state to IN_PLAY
Randomly create new seeds
Reset the number of total number of blooms
Notify the player of the current goal

Here are the step-by-step instructions for building the behavior:

The first step is to verify that the World is not in the IN_PLAY state. Pressing the Space bar should have no effect while the game is playing. If it is not IN_PLAY then immediately change the state.
The next step is to create the requisite number of seeds for the current level. Each will be given a random position, color and direction.

These steps will be repeated for as many SEEDs are required on this level. Each pass through this loop a new SEED is created. It's POSITION, FILL_COLOR and ORIENTATION are set randomly. Then it is given an initial SPEED which sets the SEED in motion along it's ORIENTATION. Because the World's borders are enabled, these SEEDs automatically bounce when they hit the edges.
Lastly, the counter which keeps track of the number of blooms created by the player during the level (BLOOMS_MAX) is reset to zero and a message is created which tells the player which level they are on and the number of blooms they need to create.

The completed behavior looks like this:

When the Player Clicks
These actions define how the world behaves when the player clicks somewhere. Assuming the world is IN_PLAY, the player's click creates the bloom that will hopefully cause a chain reaction large enough to complete the level. To achieve this, we create a new MOUSE EVENT FILTER:

Here's the pseudo code for this behavior:

When the mouse is pressed anywhere in the World...
If the game is IN_PLAY and no other blooms exist...
Create the first bloom at the mouse position

Here are the step-by-step instructions for building this behavior:

The first thing the action needs to do is verify that the game is in a state to accept the mouse click. Once the player has clicked, they can not click again. This is achieved by verifying that the world is IN_PLAY and that there are no BLOOMS already in existence.
Next the total number of BLOOMS is set to one. This represents the player's initial bloom but does not count toward their score.
Lastly, a SEED is created and it's POSITION is set to the MOUSE POSITION. By setting it's PINNED flag is set to true which is necessary for it to begin blooming.

The completed behavior looks like this:

When the Number of Blooms Changes
The World's last behavior is one that is invoked each time the number of blooms in the world changes. Of primary interest is when the last bloom disappears and the number of BLOOMS returns to zero. When this happens, the world is no longer IN_PLAY, all remaining SEEDS are destroyed and the results are displayed to the user. To achieve this, we start with an OBJECT MODIFIED FILTER:

Here's the pseudo code for this behavior:

When the number of BLOOMS in the World changes...
If the World is in the IN_PLAY state and there are no remaining BLOOMS...
Change out of the IN_PLAY state.
Destroy all remaining SEEDs
If the required number of blooms was created...
Advance to the next level
Increment the player's score
Notify the player that the level is complete
Otherwise
Encourage the player to try again
Save the player's score to the server
Ask the player to press Space to continue

Here are the step-by-step instructions for building this behavior:

The first step is to verify that the world is both IN_PLAY and that there are no remaining blooms. (This event is processed each time the number of BLOOMS changes and we're only interested in the case where the last bloom has wilted away.) If this is the case, it resets the state back to not IN_PLAY.
Next, each of the remaining SEEDs (those that were not bloomed by the player's chain reaction will still be bouncing around the world) are destroyed.

The EXECUTE ACTIONS ON EACH control runs a set of child actions on each of the objects of that type in the world. Each pass through the loop, ACTIVE OBJECT is set to the next object of that type. That's why we destroy the ACTIVE OBJECT rather than a SEED.
Next, we'll check to see if the player has passed the level. If the total number of blooms created (BLOOMS_MAX) is greater than or equal to the number required to pass the level (BLOOMS_MIN) then the player has won the level.

Advancing to the next level involves several steps. First, the World's LEVEL is incremented. Second, the number of SEEDS is incremented by "5" ensuring the next level has more seeds than the previous one. DIFFICULTY is also updated as long as it never goes above 90%. Lastly, the minimum number of blooms needed to pass the next level (BLOOMS_MIN) is calculated by taking the number of SEEDS and multiplying it by the DIFFICULTY.

Since the player just completed a level, the final step is to add the number of blooms they created (BLOOMS_MAX) to their total SCORE.

If the player did not pass the level, they are encouraged to try again.
Lastly, regardless of whether or not the player has won the level, their current score is sent to the server. Since Bloomshine does not have an end, by sending the score during each level, the number of plays count will reflect the number of levels that have been attempted.

Afterwards a "Continue" object is created which will prompt the user to press the Space key to continue.

The complete behavior looks like this:

Seed Behaviors

While the World plays an important role in managing the game's overall state, the individual SEED objects need to manage their own blooming and wilting effects. These behaviors are added to the SEED instance in Bloomshine's gallery.

When a Seed Collides with a Bloom

This behavior is triggered when a SEED collides with another SEED that is in the blooming state. The blooming state is signified by a SEED that has been PINNED. This COLLISION EVENT trigger will enable the chain reaction we desire.

The pseudo-code for this action is:

When a SEED collides with another SEED...
If one of the SEEDs is PINNED...
Pin the appropriate SEED
Increment the number of active bloomsIncrement the total number of blooms achievedNumber the SEED visually

Here are the step-by-step instructions for building this behavior:

The first step is to determine if an free-floating SEED has collided with a PINNED SEED. PINNED SEEDs will never generate collision events so this action only tests to see if the second collision body's PINNED flag is true and for sanity verifies that the ACTIVE OBJECT is not already PINNED. Otherwise, the event is ignored.
Now the number of active blooms and the total number involved in the chain reaction are incremented. When the bloom eventually wilts, the number of active blooms is decremented.
As a courtesy to the user, the final step positions the newly blooming SEED on the highest layer and set's it's TEXT to the bloom count giving the player a hint on their progress through the level.

The complete behavior logic looks like this:

Blooming Behavior

Once any seed has been PINNED, it starts blooming. When it reaches a certain size, it immediately and rapidly wilts. This behavior is controlled by an EVERY N-STEPS filter:

The pseudo-code for this behavior is:

Every frame...
If this seed is WILTING...
Decrement the seed's RADIUS
If the seed is too small to see...
Decrement the number of remaining blooms
Destroy this seed.
Otherwise if the seed is PINNED
Increment the seed's radius
If the seed's RADIUS has reached it's maximum size....
Begin WILTING

Here are the step-by-step instructions for assembling this behavior:

First we need to see if this SEED is WILTING. This is accomplished by testing if the SEED's WILTING property is set to true. The wilting process involves reducing the SEED's RADIUS by a large amount. Once the SEED reaches a specific size, the number of active blooms is decremented and the SEED is destroyed.
Otherwise, if the SEED has been PINNED (set in the previous behavior as a result of colliding with another blooming SEED) it's RADIUS is increased. If it reaches a maximum size, WILTING begins by setting the custom property to "True"

Because fonts render strangely and jump around when the object they're on becomes too small, the text of the SEED (which was set when it started to bloom) is cleared as wilting begins.

The complete behavior pieces these two sections together:

Next Steps

Building Bloomshine is a great way to get started in Sharendipity. You've seen how custom properties can be used to track game state and created a variety of behaviors that each handle a different aspect of of the game's play. Try loading Bloomshine from the community search, choose Edit from the Professor menu and you can start exploring the properties and behaviors discussed in this article. What's really exciting is the enhancement possibilities that Bloomshine offers.

Difficulty

Bloomshine's difficulty is derived from several simple components. It's fun to change one or more of these aspects and immediately see the imact on gameplay. Small tweaks can make Bloomshine much easier or much harder!

In the World's "When Space is pressed" behavior, the initial SPEED given to new SEEDs seems to have a big impact on the average number of blooms a player will achieve on any given level. The faster the seeds, the more likely that they'll reach the chain reaction area before it wilts.
In the Seed's "Every 1 step(s)" behavior, the maximum RADIUS of the SEED's bloom also has a big impact on how easy it is to complete a level. Larger blooms fill the screen with color and make the levels easier. It doesn't take a big adjustment to the maximum radius to have a big effect.

Also in the Seed's "Every 1 step(s)" behavior, the speed at which the SEED blooms (or wilts) has interesting results. Slow the blooming or wilting process down and the levels get a lot easier.
The World's DIFFICULTY property controls the percentage of seeds that need to be bloomed during each level. Modifying it's default value can make the first few levels much easier to harder.

Try experimenting with these values and see how it affects game play. Since Sharendipity is a live environment, your changes take effect each time a level begins - so it's easy to fine tune gameplay.

Another consideration would be to incorporate behaviors that modify these parameters over time. Perhaps the maximum bloom size should shrink as the levels get harder or the seeds get random speeds when the level starts.

Graphics & Sound

While it's bright colors are attractive, Bloomshine lacks for graphics and sound. It's easy to add media to a Sharendipity application so try adding some nice tones or ringing when blooms are created. Or put a nice texture on the actual bloom.

To see an example of how Bloomshine's look and feel can be upgraded, check out Bloomshine 2 which takes the garden theme to a whole new level.

Sharendipity - Recently Updated Pages

Sharendipity Home

Sharendipity Website Featured Video

test

Resources and Tutorials

Video Tutorials

Links

FAQ

Creation Tools

Running Sharendipity

Saving Applications

Filter Definitions

Mouse Event Filter

Properties

Properties Overview

Custom Properties

Appearance

Position

Image

Text

Physics

Geometry

Interaction

Web Service How-to

Create new object type

Default properties

Custom properties

Web service actions

Referencing the service

Tips for better reuse

Web Services

Example Applications

Documented Examples

Creating your own web service interface

Passing Parameters to an Application

Accessing Application Parameters

Setting up the Embed Code

Documentation

Configuration

Developer Tools

Breakpoints

Performance Measurement

Problem Viewer

Console Viewer

Application Configuration

Application Configuration

Component Configuration

An Example: Creating a Flickr Widget

Make a Game!

The Editor

The "Click to Continue" Object

Adding Objects

Setting the Score

Ending the Game

Publish!

Video Tutorials

Create a Space Shooter in Less than 10 Minutes

Creating a Flickr Photo Stream

Creating a Customizable Application

Creating Bloomshine

Elements of Gameplay

Objects

Seed

Announcement

Score

The "Press Space to Continue" Prompt

The World

Properties

Behaviors

Seed Behaviors

When a Seed Collides with a Bloom

Blooming Behavior

Next Steps

Difficulty

Graphics & Sound

Sharendipity Website

Featured Video