Projeto Flow

This game was part of a group of educational activities about classic music that took place at SESC Carmo – SP. The challenge was to create some multimedia piece, which could present particular authors.

The final result was an adaptation of the game Auditorium, transported to an installation size. Then we had a puzzle game, developed with Processing/ReactVision, and projections.



This video is demonstrates the Anim-and-play software in action. The software were developed by the instructor Paulo, for vacations activities (July/2010) at SESC Carmo, São Paulo/Brasil.

The software aims to help teaching young kids and children to understand some basic concepts in animation techniques.

The idea behind this software, is to teach children how simple animations works by they creating their own creatures. These creatures will be used in a very simple game based on computer vision techniques.

This project is been developed on Linux (Ubuntu 9.04), using Processing ( as framework. It was also successfully tested on Mac OSX, and Windows(but hard to configured on Win).

It is still a work in progress, so there are some bugs, crashes, and not mature game-play.
The software is available under GPL license, for common usage and development contribution. Check the project web-page:
You must read the wiki page for details.

G.R.E.S. Unidos da Escandinávia (2006-2008)

This project was meant to take place during Carnival season, as an entertainment activity for families visiting SESC Santana facilities. All the three versions were games where people should play Samba loops according to the rhythm. The sound was created by participants in an earlier workshop about Samba percussion instruments.

Software with a very simple mouseover interactivity to play Samba loops.
Environment: Flash.

Software with keyboard interaction, while playing the Samba loops, the player also edit a video clip.
Environment: Blender.

Software with Computer Vision based interactions. The player motion was captured by webcam streaming, the image was analyzed, and according to the player’s motions, the Samba loops were executed.
Environment: Python.

Collisions :: GameDev Unity3D cookbook

Detect collisions between objects is crucial to any game.
The game engines, always have some collision detection mechanism, and this topic is important to take in account before choose the game engine for your project.

The basic points to watch carefully are:
– How to set the collision detection;
– which basic geometric forms available for colliders(spheres, cudes, planes …) are available;
– If the game engine, support 3D mesh collisions.

When collision are detect, in general, event messages are sent through the system. And those event must be “captured” by some game object, in order to execute game routines, that will provide the game dynamics.

For these tutorial, create a scene, as shown in the image bellow:

Attention: In this tutorial I will use the names for the game objects, as the image indicates.

On Unity3D, collision detections are performed by the physics engine, so, the elements for setup your collision can be found in the Componet >> Physics menu, which are Colliders and Rigidbody.

Let’s configure the basic elements to the game objects:
Object SphereTrigger:
– check if it has the component SphereCollider, if positive, check the trigger option. If the sphereCollider is not present, you must include it. go to menu Component >> Physics >> Sphere Collider. Than, check it as trigger.

Object SphereObject:
– Check if the component SphereCollider is present, and uncheck the option “is Trigger”.
– Add a Rigidbody component, if needed (To add the rigidbody, go to menu Component >> Physics >> Rigidbody) . And uncheck the option “Is Kinematic”.

Object Cube:
– Check if it has the Box Collider component, and the “is Trigger” option, unchecked.
– Add the Rigidbody component. To add the rigidbody, go to menu Component >> Physics >> Rigidbody. And check the option “Is Kinematic” – that will allow us to move the object without physics simulations.
– Add the BasicInputHandlerCube script (shown in the user input tutorial).
– Add the BasicCollisionHandlerCube script that you can see bellow:

[code lang=”java”]
private var colisionInfo:String = “Collision info”;

function Update () {

function OnCollisionEnter(col : Collision){
colisionInfo = “Collision Enter (Rigidbody) : “;

function OnCollisionExit(col : Collision){
colisionInfo = “Collision Exit (Rigidbody) : “;

function OnTriggerEnter(col : Collider){
colisionInfo = “Collision Enter (Trigger) : “;

function OnTriggerExit(col : Collider){
colisionInfo = “Collision Exit (Trigger) : “;

function OnTriggerStay(col : Collider){
colisionInfo = “Collision Stay (Trigger) : “;

function OnGUI(){

This demo is very simple. It will show a message in the screen, about the collision nature. The BasicCollisionHandlerCube script changes the value of the colisionInfo variable, according the collision events, and than it prints the collisionInfo variable on the GUI.

The Unity3D, uses it’s physics engine to calculate the collisions, and the colliders (BoxCollider and SphereCollider components) are the sensors used to detect when one collider touch another collider.
When a collision is detect, the Rigidboby component, is informed, and sends an event message to the game object components according the collision’s nature. If one of the colliders were a trigger it sends the messages OnTriggerEnter, OnTriggerStay, and OnTriggerExit. Otherwise the rigidbody send the messages OnCollisionEnter, OnCollisionStay, and OnCollisionExit.
In this example, when the Cube collides with SphereTrigger, the message OnTriggerEnter, is sent when the collision starts; the message OnTriggerStay, is sent while the objects are colliding; the message OnTriggerExit, is sent once the objects stop colliding.
The same thing happens when the Cube collides with the SphereCollider, but in this case the messages are OnCollisionEnter, OnCollisionStay, and OnCollisionExit, because in this collision none of the colliders are set as triggers.

Check the final sample here.

What do you do with the other spheres?? Have fun!! Set their properties as you want, check how they behave in collisions, try to experiment some scripts… explore!!

Messages :: Gamedev Unity3D cookbook

There are two possible ways to send event messages through game objects on Unity3D: 1 – Send messages to linked objects; 2 – Search for objects on scene, and execute components functions.

First, let’s see the how to send messagens to linked objects, using Send Message, BroadcastMessage, and SendMessageUpwards.
You shall create a scene with basic elements as described in the image bellow:
Attention: Use cube elements as shown in the image, use the same names. The fountain, and cannon objects, must have a EllipsoidParticleEmitter, a ParticleRender and a ParticleAnimator, set them as you want.
Attention 2.: In object Cube2, add the BasicInputHandler script, we explored in User Input tutorial.

The method SendMessage will execute a certain function, in any object componen which has the function.

Preparation: In fountain object, set it’s BoxCollider Component as a trigger. Create these two scripts, and drag them to the fountain gameObject.

[code lang=”java”]
function Update () {

function TurnFountainOn( v: boolean){
particleEmitter.emit = v;

[code lang=”java”]
function Update () {

function OnTriggerEnter(col: Collider){
this.SendMessage(“TurnFountainOn”, true);

function OnTriggerExit(col: Collider){
this.SendMessage(“TurnFountainOn”, false);

The SendSimpleMessageScript will detect collisions, and send the message “TurnFountainOn”, along with the boolean value true or false.
the FountainScript, has the function TurnFountainOn, which will turn the particles on, according the argument recieved:true or false.
See the docs here.

The Method BroadcastMessage will do the same job as SendMessage, but with the possibility to send the message to other game object, as far as they are perental linked, the messages are send to the sender’s children objects.

Preparation: Make the cannon object, child of cannonPlat object (use the panel for that).
Make the FountainScript component of cannon object.
Set the cannonPlat’s BoxCollider as trigger.

Crie um novo script, BroadcastMessageScript:
[code lang=”java”]
function Update () {

function OnTriggerEnter(col: Collider){
this.BroadcastMessage(“TurnFountainOn”, true);

function OnTriggerExit(col: Collider){
this.BroadcastMessage(“TurnFountainOn”, false);

As soon as the SendSimpleMessageScript detect collisons, it broadcasts the message TurnFountainOn, to all it’s children objects, and the ones who have the TurnFountaiOn function, can perform actions.

Find Component
Any gameObject on Unity3D can execute the function Find, that will search for gameObjects over the scene. From this search, it´s possible to call for functions on the gameObject found.

Preparation: Set the plat’s BoxCollider as a trigger. Make the FountainScript a component of cannon object.

Create the following script, FindBehaviorScript:
[code lang=”java”]
function Update () {

function OnTriggerEnter(col: Collider){

function OnTriggerExit(col: Collider){

Make the FindBehaviorScript, component of plat object.
Just like the previous scripts, this script will detect collisions, and than search for the cannon and fountain objects. When the object is located, we can access it’s components, and execute their functions.
See the docs for this procedures.

Take aa look to the final sample.

Blender Game Engine Course – class 5

In this videos (portuguese only), we begin a pratical usage of Python scripts controlling BlenderGE API itens.

– Python scripts
– Controllers Python and AND
– Sensors: Collision, Property, Always.
– Actuators: Motion, Property
– Catch objects in scene, via script.
– Usign alignAxisToVect function
– Vectors subtraction.

Blender Game Engine Course – class 3

Video topics (in portuguese):
– Introduction for collision detection, and physics elements – Object’s Physics Properties – Collision Sensors – Visibility, and Property Actuators;
– Collision detection compatibilities among certain physics properties;
– Object’s properties;
– Physics Visualizations;
– Debug Properties Visualizations;