LibGDX : Scene2D – Box2d – Bumpers Demo
This demo encapsulates some of the Scene2D and Box2D integration I have been playing around with. Specifically collision detection and selection by touch/mouse.
Below is a screenshot with random numbered elements bouncing around inside the view. The walls are supposed to act like pinball bumpers so that when an element hits them they give the element a ‘kick’. The implementation for this is pretty experimental but seems to work well enough for illustration.
I have implemented a layer which lets you ‘grab’ an element body. When picked up a selection animation is run around the selected element (the zooming white square). The selection mechanism is actually completely generalised in the sense that it broadcasts events which another layer responds to for the animation. Nice and loosely coupled.
When an element hits the wall it will bounce and make a clonk sound but when hits another element it will run a flashing animation at the points where the bodies touch and play a boing sound. This illustrates I am detecting what sort of collision is taking place. The layer which has the bouncing elements also has a pool of contact listeners which it can dish out to elements in the view. They are released from the pool when an element is removed (by clicking on it).
There is some neat stuff here (at least I think so).
- Separate ’netthreads’ LibGDX extension library which gathers together most (but not all) of the scene, layer, action and event handling classes I have written to support my approach to the design of these demos so far. There is a pom for generating the library as a Maven component although it’s not used as such here. Note it pulls the LibGDX libraries as scope “system”.
- Gravity update Action which gives bodies in the World lighter than air behaviour.
- Body update Action as seen in the previous demo which maps a Box2D body to a Scene2D Actor.
- Walls to enclose the World.
- Contact listener elements which implement ‘bumper’ behaviour to the Box2D World walls.
- Touch Layer which decouples the selecting of bodies in the view through the use of the event pipeline.
- Pointer Layer which implements a nice ‘selection’ animation around the selected Actor when touched. Try grabbing one of the rolling numbers with your mouse and you will see what I mean.
- Clonk sounds for hitting the walls and a satisfying boinging sound for when elements hit each other.
These features will hopefully find their way into an actual application at some point. I have a whole load of bits and pieces which are slowly coalescing into something.
I haven’t created the Android wrapper for this. It’s trivial to put this together and it saves me using my webspace which I am starting to fill at an alarming rate.
Demo code here.
There is a test application bundled as well which uses the LibGDX debug renderer.
This uses LibGDX 0.9.3.
All the code is licensed as Apache 2.0.
LibGDX: Scene2D with Box2D
Here is another LibGDX demo. This one uses Box2D to build a simple model of a box with a gear cog spinning in the centre. If you click on the screen a ball is released which will drop into the view and bounce off the gear and walls. I am no expert in Box2D but I think you may find this useful if you are trying to combine it and LibGDX Scene2D elements.
This demo is heavily indebted to the ideas from the demo provided for the Box2D editor which I used to create the polygon model for the central cog.
Few things of note to point out:
- Each body in the world has an associated Actor sprite. I am using an Action to map the position and rotation of each body to the linked Actor. The conversion from Box2D position to pixels is by a conversion factor (the pixel width / the Box2D world width).
- Bodies loaded from the Box2D editor have their position-origin on the bottom left corner. The bodies created from the Box2D ‘primitives’ are positioned at their centre. Handling this inconsistency is a bit of a pain and makes the code a lot less elegant.
- When you close the view (select the BACK key for Android or ESC for Windows) the world is not destroyed, only the balls are marked for removal and subsequent clean-up. When you close the application it will re-claim the memory used.
- There is actually two demos in the source. Under the ‘test’ package you will find a view which uses the LibGDX Box2D debug renderer. You kind of need this to build a ‘world’ before trying to map Scene2D elements to it.
- When you click on the screen fading text is displayed with the pixel co-ordinates. This is just for fun and to show off the sort of things you can do with actions.
Here is a screenshot of the debug rendered ‘world’.
The demo code is licensed under the same license as LibGDX itself with Apache 2.0.
Demo code here.
LibGDX: Scene2D demo with Scene Transitions
Anyone familiar with Cocos2d will recognise the concept of Scene transitions. These are classes which compose an incoming and outgoing scene and apply an effect to them to a transition from one to the other.
I have updated my simple demo to apply slide-in scene transitions using the magic of the Java Universal Tween Engine (although I guess I could have used the stock actions). They use the TimeLineAction class I built in the previous demo to run two seperate TimeLines on the incoming and outgoing scenes (stages). I am quite pleased how elegant the code has turned out to be for these. The “settings” and “about” screens have bounce applied to them as they ease-out which gives a nice effect.
Implementation
First we define the base class which composes the two scenes and runs the in and out actions on the contents of the composed scenes. We don’t have to manually clean up any actions because we will always let them run until they are “done”.
public class TransitionScene extends Scene implements TweenCallback
{
private boolean complete;
private float inX;
private float inY;
private float outX;
private float outY;
private Scene inScene;
private Scene outScene;
private Group inSceneRoot;
private Group outSceneRoot;
private int durationMillis;
private TweenEquation easeEquation;
/**
* Enter handler makes a note of scene contents position.
*
*/
@Override
public void enter()
{
this.complete = false;
inX = inSceneRoot.x;
inY = inSceneRoot.y;
outX = outSceneRoot.x;
outY = outSceneRoot.y;
}
/**
* Exit handler resets scene contents positions.
*
*/
@Override
public void exit()
{
this.complete = true;
inSceneRoot.x = inX;
inSceneRoot.y = inY;
outSceneRoot.x = outX;
outSceneRoot.y = outY;
}
/**
* Draw both scenes as we animated contents.
*
*/
@Override
public void draw()
{
// Move
inSceneRoot.act(Gdx.graphics.getDeltaTime());
outSceneRoot.act(Gdx.graphics.getDeltaTime());
// Draw
if (!complete)
{
outScene.draw();
}
inScene.draw();
}
/**
* Default transition handlers
*/
@Override
public void onEvent(EventType eventType, BaseTween source)
{
switch (eventType)
{
case COMPLETE:
Director.instance().setScene(this.inScene);
break;
default:
break;
}
}
/**
* Transition complete.
*
* @return The transition complete handler.
*/
public boolean isComplete()
{
return complete;
}
}
So an actual transition class like “MoveInRTransitionScene” (Move In From the Right) looks like this below.
public class MoveInRTransitionScene extends TransitionScene
{
private static Pool _pool = new Pool()
{
@Override
protected MoveInRTransitionScene newObject()
{
MoveInRTransitionScene transitionScene = new MoveInRTransitionScene();
return transitionScene;
}
};
/**
* Create transition.
*
* @param inScene
* The incoming scene.
* @param outScene
* The outgoing scene.
* @param durationMillis
* The duration of transition.
* @param easeEquation
* The easing type.
*/
public static MoveInRTransitionScene $(Scene inScene, Scene outScene, int durationMillis, TweenEquation easeEquation)
{
MoveInRTransitionScene transitionScene = _pool.obtain();
transitionScene.setInScene(inScene);
transitionScene.setInSceneRoot(inScene.getRoot());
transitionScene.setOutScene(outScene);
transitionScene.setOutSceneRoot(outScene.getRoot());
transitionScene.setDurationMillis(durationMillis);
transitionScene.setEaseEquation(easeEquation);
return transitionScene;
}
/**
* On entry build easing TimeLines.
*
*/
@Override
public void enter()
{
super.enter();
// In Scene TimeLine.
Timeline inTimeline = Timeline.createSequence()
.beginSequence()
.push(Tween.to(getInSceneRoot(), GroupAccessor.POSITION_XY, 0).target(getInScene().width(), 0).ease(getEaseEquation()))
.push(Tween.to(getInSceneRoot(), GroupAccessor.POSITION_XY, getDurationMillis()).target(0, 0).ease(getEaseEquation()))
.end()
.start();
// In Scene TimeLine Action.
TimelineAction inTimelineAction = TimelineAction.$(inTimeline);
getInSceneRoot().action(inTimelineAction);
// Out Scene TimeLine.
Timeline outTimeline = Timeline.createSequence()
.beginSequence()
.push(Tween.to(getOutSceneRoot(), GroupAccessor.POSITION_XY, 0).target(0, 0).ease(getEaseEquation()))
.push(Tween.to(getOutSceneRoot(), GroupAccessor.POSITION_XY, getDurationMillis()).target(-getOutScene().width(), 0).ease(getEaseEquation()))
.addCallback(EventType.COMPLETE, this)
.end()
.start();
// Out Scene TimeLine Action.
TimelineAction outTimelineAction = TimelineAction.$(outTimeline);
getOutSceneRoot().action(outTimelineAction);
}
/**
* On exit tidy up.
*
*/
@Override
public void exit()
{
super.exit();
_pool.free(this);
}
}
Some stuff to note here.
- I am applying the trick of initialising the TimeLine by applying a tween of duration zero.
- I am using a pool and cleaning it up in the node enter and exit methods. These methods are very similar to their counterparts in Cocos2d .
- It is actually possible to draw multiple stages in this fashion which was a bit of an experiment and somewhat of a pleasant surprise when I tried it.
Usage
To actually use the transition you give references to the incoming and outgoing scenes along with duration and easing type. The transitions are pooled so they can be reused.
private void transitionToSettingsScene()
{
Scene inScene = getSettingsScene();
Scene outScene = this.director.getScene();
TransitionScene transitionScene = MoveInLTransitionScene.$(inScene, outScene, DURATION_SETTINGS_TRANSITION, Bounce.OUT);
this.director.setScene(transitionScene);
}
I have tidied a great deal of the code up but there are still a few funnies hanging around.
- The LED font looks terrible on the Android emulator. My Nexus phone won’t talk to my Windows 7 machine since I had to replace the USB cable (never lend your phone to anyone) so I have no idea what this looks like on an actual phone. BTW this font is not free for commercial use. I am going to find one which is and replace it.
- The ship rotation sometimes gets confused. Needs investigated.
The demo now has all of the features that were in my original example using my own framework. I am going to concentrate on fixing the above issues next.
Demo code here. The code is licensed under the same license as LibGDX itself with Apache 2.0.
Update #2
There was an issue with the first version of the code. It was leaking objects. I have fixed this and made some improvements to the life-cycle of the sprites.
Update #3
In the process of looking at something else I realised I was creating multiple instances of the SpriteBatch object by having Scene subclass from Stage. I have fixed this and added disposal of the batch contents on cleanup from the controller.
LibGDX: Scene2d Demo with Java Universal Tween Engine
So I have modified my original demo somewhat to implement the Asteroid and ship pulse animations to use the Java Universal Tween Engine. I have also fixed some stuff and added some new features.
-
Menu Layer with star field
I put the star field behind the menu layer.
- Multiple LED fonts
I used Hiero to convert an existing free font to bring it into the application. BTW you can declare multiple fonts in the uiskin.json file i.e.
com.badlogic.gdx.graphics.g2d.BitmapFont:
{ default-font: { file: digital-7_60.fnt },
large-font: { file: digital-7_70.fnt }
},
I had to generate a second json file to hold a different sized default font because you can’t specify the font name for TextButton and I wanted a bigger size to match a phone touch-screen real-estate.
- CallBack Action
Taking a nod from the Tween engine I have created a proper callback action. This will take a count (<0 for infinite) and duration and repeatedly execute a call-back method. I could not use the completion handler in LibGDX actions as it resets the handler reference every time it get's called.
- Tween Actions
I have created two new action types TimelineAction and TweenAction. These encapsulate the running and management of the tweens. They are associated with an Actor and will animate it until complete. They manage the release of the tween back into the pool
(more about this further on).
- Tweens
The movement and rotation of the asteroids is implemented using the Timeline feature from the tween engine. Note the COMPLETE event callback to send an event which will trigger the removal of the element from the view.
int durationMove = (int) ((Math.random() * MAX_DURATION + MIN_DURATION) * 1000); int rotate = (int) (Math.random() * 1440)-720; Timeline timeline = Timeline.createParallel() .beginParallel() .push(Tween.to(this, ActorAccessor.POSITION_XY, durationMove).target(x, 0 - this.height).ease(Linear.INOUT)) .beginSequence() .push(Tween.to(this, GroupAccessor.ROTATION, 0).target(0)) .push(Tween.to(this, GroupAccessor.ROTATION, durationMove).target(rotate)) .end() .end() .addCallback(EventType.COMPLETE, this) .start(); TimelineAction timelineAction = TimelineAction.$(timeline); action(timelineAction);
Something of interest to note here. I want the rotation to last the length of the screen traversal and I want it to start from zero. I could set the “rotation” value of the sprite explicitly at the start of each run or I can do a non-Tween which will initially rotate to zero. This is what I have done here. There doesn’t seem to be a way to set the initial value in the Timeline/Tween setup itself any other way although I am open to suggestions.
The pulse is a straight Tween. Again, note the COMPLETE event callback to send an event which will trigger the removal of the element from the view.
Tween tween = Tween.to(this, ActorAccessor.POSITION_XY, duration)
.target(x, height)
.ease(Quad.OUT)
.addCallback(EventType.COMPLETE, this)
.start();
tweenAction = TweenAction.$(tween);
action(tweenAction);
-
A Note About Action Management
I have extended the Actor and Group classes to manage the clean up of actions which are prematurely removed from the view. What I mean by this is – imagine a pulse is moving up the screen, animated by TweenAction. In normal operation the animation would complete, the “done” flag would get set and the “act” method would call the “finish” method on the associated actions which will put the respective actions back in the pool. If the pulse hits an Asteroid on the way up we should probably set the “done” flag on the PulseSprite and let it clean up itself but because of the way I am pooling these items I am having to override the “remove” method and force the “finish” method on all associated actions myself. This is a work in progress and I am still having a think about the best approach here. It works for now and you should have no leaking objects.
Demo code here.
LibGDX: Example of Scene2D application with Event Handlers.
I have written a simple demo using LibGDX and some of the ideas I had kicking around from a previous demo. I am quite pleased how this has turned out. I’m going to join the chorus of praise for LibGDX and say it is a lot easier to use than I thought it would be. I was putting off ditching my own framework and adopting it but it was actually fun to use and has an impressive amount of knowledge behind it. The ability to develop on the desktop and then run it on Android is a killer feature.
This demo is a kind of mixture of framework items and source artefacts to implement a noddy shoot-em-up. The point is to show off how to assemble something which uses mostly the Scene2d classes.
Here is the application running on the desktop.
So what is interesting about this demo?
- Uses Scene2d classes throughout i.e. Actor, Group and Action.
- Framesprite class which will take spritesheet and run animated sprite.
- Animated sprite class which composes Framesprite and will respond to actions like rotate and scale.
- Director class which routes events and updates actions and maintains the current “scene”.
- Event driven design which is used to post and respond to actions in the view.
- Scenes and layers which are used to build up the view.
- Simple collision detection between Actors
- Resizable window with constant viewport where touch and mouse position events are adjusted to the window size.
- Spaceship sprite class with nice interpolated drag-follow action.
- Texture cache backed by a Texture Atlas (to be honest I’m still not sure if I am using this properly).
- Nice background Sprite which loops a star-field image down the screen in old-skool fashion.
This is a bit of an experiment to see if I could take what I had and make it scale up a bit more. The key concept is as follows:
- You do not have a big blob of code which maintains a world state which is examined and updated according to a set of rules with lots of if..then and case statements
- You do have pooled objects which can send and receive events as the render loop runs and respond to events to perform some action on the view. Actors in the view are more autonomous and encapsulate their logic and the actions which they can perform.
The demo code is here.
Some of the source code below is abbreviated, use the source download rather than cutting and pasting if you are interested in the source.
The Frame animation Sprite implements an Actor which takes spritesheet and implements straighforward animation. You cannot run actions like rotate on this as Actor does not have this attribute. You can make it move though. This lifts some of the example code from the LibGDX samples and reworks it into an Actor.
public class FrameSprite extends Actor
{
private TextureRegion[] frames;
private Animation animation;
private TextureRegion currentFrame;
private float stateTime;
private boolean looping;
public FrameSprite(TextureRegion texture, int rows, int cols, float frameDuration, boolean looping)
{
this.looping = looping;
int tileWidth = texture.getRegionWidth() / cols;
int tileHeight = texture.getRegionHeight() / rows;
TextureRegion[][] tmp = texture.split(tileWidth, tileHeight);
frames = new TextureRegion[cols * rows];
int tileWidth = texture.getRegionWidth() / cols;
int tileHeight = texture.getRegionHeight() / rows;
TextureRegion[][] tmp = texture.split(tileWidth, tileHeight);
frames = new TextureRegion[cols * rows];
int index = 0;
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++)
{
frames[index++] = tmp[i][j];
}
}
width = tileWidth;
height = tileHeight;
animation = new Animation(frameDuration, frames);
stateTime = 0f;
}
/**
* Reset animation.
*
* You can use this to ensure the animation plays from the start again. It's
* handy if you have one-shot animations like explosions but you are using
* re-usable Sprites. You must reset the animation to ensure the animation
* plays back again.
*/
public void resetAnimation()
{
stateTime = 0;
}
/**
* Check to see if animation finished.
*
* @param stateTime
*
* @return True if finished.
*/
public boolean isAnimationFinished()
{
return animation.isAnimationFinished(stateTime);
}
}
The Animated Sprite class composes the FrameSprite to allow actions such as rotate and scale to work upon it.
public class AnimatedSprite extends Group
{
private FrameSprite frameSprite;
/**
* Create sprite.
*
* @param texture
* The animation texture.
* @param rows
* The animation texture rows.
* @param cols
* The animation texture rows.
* @param frameDuration
* The animation frame duration.
*/
public AnimatedSprite(TextureRegion textureRegion, int rows, int cols, float frameDuration)
{
frameSprite = new FrameSprite(textureRegion, rows, cols, frameDuration, true);
this.width = frameSprite.width;
this.height = frameSprite.height;
addActor(frameSprite);
}
@Override
public Actor hit(float x, float y)
{
return super.hit(x, y);
}
}
A scene is a Stage whichs maps to the size of the view and implements an InputMultiplexer to which input events are routed. When the Director makes a scene active it sets the chosen Scene multiplexer as the destination for all input events. Note also “entry” and “exit” scene methods. These get called when a scene is activated and removed respectively.
public class Scene extends Stage implements Node
{
private static final int DEFAULT_LAYER_CAPACITY = 10;
/**
* Associated input multiplexer.
*/
private InputMultiplexer inputMultiplexer;
/**
* Stage elements as nodes. We need this so we can call enter and exit on
* actors in order to manage registration and de-registration of event
* handlers.
*/
private Array nodes;
public Scene()
{
super(Director.instance().getWidth(), Director.instance().getHeight(), Director.instance().isStretch());
inputMultiplexer = new InputMultiplexer(this);
nodes = new Array(DEFAULT_LAYER_CAPACITY);
}
/**
* Get input multiplexer.
*
* @return The input multiplexer.
*/
public InputMultiplexer getInputMultiplexer()
{
return inputMultiplexer;
}
/**
* Add scene layer ensuring it adopts the same size as the owning scene.
*
* Note layer in nodes list.
*
* @param group
*/
public void addLayer(Layer layer)
{
layer.width = this.width;
layer.height = this.height;
nodes.add(layer);
super.addActor(layer);
}
/**
* Handle pre-display tasks.
*
*/
@Override
public void enter()
{
int size = nodes.size;
for (int i = 0; i < size; i++)
{
nodes.get(i).enter();
}
}
/**
* Handle post-display tasks.
*
*/
@Override
public void exit()
{
int size = nodes.size;
for (int i = 0; i < size; i++)
{
nodes.get(i).exit();
}
}
}
The Director maintains a note of the chosen size. It handles setting the current scene, running the render “tick”, updating the event mechanism and updating current actions associated with the active scene. It also handles recalculating the scaling offsets for touch/mouse events if you stretch the size of the screen.
public class Director
{
private static final boolean DEFAULT_STRETCH = true;
private static Director instance = null;
private ActorEventSource eventSource;
private int width;
private int height;
private boolean stretch;
private Scene scene;
private float scaleFactorX;
private float scaleFactorY;
/**
* Access singleton instance
*
* @return instance of class
*/
public synchronized static Director instance()
{
if (instance == null)
{
instance = new Director();
}
return instance;
}
/**
* Create reference to command pipeline.
*
*/
public Director()
{
scene = null;
stretch = DEFAULT_STRETCH;
// Latch onto event source.
eventSource = ActorEventSource.instance();
// These are scale factors for adjusting touch events to the actual size
// of the view-port.
scaleFactorX = 1;
scaleFactorY = 1;
}
/**
* Update main loop.
*
*/
public void update()
{
// Update events.
eventSource.update();
// Update View
Gdx.gl.glClearColor(0, 0, 0, 1);
Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
if (scene != null)
{
scene.act(Gdx.graphics.getDeltaTime());
scene.draw();
}
else
{
Gdx.app.log("WTF!", "No scene");
}
}
/**
* Set the current scene.
*
* @param scene
*/
public synchronized void setScene(Scene scene)
{
// If already active scene...
if (this.scene != null)
{
// Exit stage left..
this.scene.exit();
}
this.scene = scene;
if (this.scene != null)
{
// Enter stage right..
this.scene.enter();
// NOTE: Route input events to the scene.
Gdx.input.setInputProcessor(scene.getInputMultiplexer());
}
}
/**
* Adjust the scale factors for touch/mouse events to match the size of the
* stage.
*
* @param width
* The new width.
* @param height
* The new height.
*/
public void recalcScaleFactors(int width, int height)
{
scaleFactorX = (float) this.width / width;
scaleFactorY = (float) this.height / height;
}
}
A Layer is a holder which implements InputProcessor and the default “enter” and “exit” handlers.
A scene can hold multiple layers which may or may not receive input. Here is the main GameScene.
public class GameScene extends Scene
{
private Layer gameLayer;
private Layer shipLayer;
private Layer pulseLayer;
private Layer asteroidLayer;
private Layer explosionLayer;
private Layer statsLayer;
/**
* Main game scene.
*
*/
public GameScene()
{
// ---------------------------------------------------------------
// Control layer
// ---------------------------------------------------------------
gameLayer = new GameLayer(this.width, this.height);
getInputMultiplexer().addProcessor(gameLayer);
addLayer(gameLayer);
// ---------------------------------------------------------------
// Pulse layer.
// ---------------------------------------------------------------
pulseLayer = new PulseLayer(this.width, this.height);
addLayer(pulseLayer);
// ---------------------------------------------------------------
// Asteroid Layer
// ---------------------------------------------------------------
asteroidLayer = new AsteroidLayer(this.width, this.height);
addLayer(asteroidLayer);
explosionLayer = new ExplosionLayer(this.width, this.height);
addLayer(explosionLayer);
// ---------------------------------------------------------------
// Ship layer
// ---------------------------------------------------------------
shipLayer = new ShipLayer(this.width, this.height);
getInputMultiplexer().addProcessor(shipLayer);
addLayer(shipLayer);
// ---------------------------------------------------------------
// Statistics layer
// ---------------------------------------------------------------
statsLayer = new StatsLayer(this.width, this.height);
addLayer(statsLayer);
}
public Layer getShipLayer()
{
return shipLayer;
}
public Group getPulseLayer()
{
return pulseLayer;
}
public Group getAsteroidLayer()
{
return asteroidLayer;
}
}
Implemented layers register themselves with the event mechanism when visible and de-register when they are no longer within an active scene. This is to avoid routing events to elements which do not need them and also means you can (technically) generate new instances without having to get weird behaviour where events are getting sucked up elsewhere. NOTE: I learnt the hard way to keep this stuff as simple as possible from my previous attempt at this demo. I was routing everything through source and observers including input events and it was a nightmare to debug.
Events
Lets look into the event handling more closely.
/**
* Launch a sprite from pool (if one available).
*
*/
private void handleStartAsteroid()
{
// Get free sprite from pool.
AsteroidSprite sprite = pool.obtain();
// Set running.
sprite.run();
// Add to view.
addActor(sprite);
}
Once the asteroid is “running” it too has a periodic call back which checks to see if it has collided with anything and if so send an event to indicate which kind of collision.
Listening for collision events are the layers:
- PulseLayer which will remove the Pulse which ‘hit’ the Asteroid from the view.
- AsteroidLayer which will remove the Asteroid Sprite and replace it with a one-shot “explosion” animation. Also it will update the global score value which the StatsLayer will pick up and display.
- ShipLayer which would normally do something like remove the ship and run an explosion but here just spins the ship around because I am shit at creating explosion graphics.
Lets take a look at an event handler for the AsteroidLayer:
/**
* Handle events.
*
*/
@Override
public boolean handleEvent(ActorEvent event)
{
boolean handled = false;
switch (event.getId())
{
case GameActorEvents.EVENT_START_ASTEROID:
handleStartAsteroid();
handled = true;
break;
case GameActorEvents.EVENT_COLLISION_ASTEROID_PULSE:
handlePulseCollision(event.getActor());
handled = true;
break;
case GameActorEvents.EVENT_END_ASTEROID:
handleEndAsteroid(event.getActor());
handled = true;
break;
default:
break;
}
return handled;
}
/**
* Launch a sprite from pool (if one available).
*
*/
private void handleStartAsteroid()
{
// Get free sprite from pool.
AsteroidSprite sprite = pool.obtain();
// Set running.
sprite.run();
// Add to view.
addActor(sprite);
}
/**
* Handle pulse hitting asteroid.
*
* @param actor
*/
private void handlePulseCollision(Actor actor)
{
// Run explosion sprite
this.director.sendEvent(GameActorEvents.EVENT_START_ASTEROID_EXPLOSION, actor);
handleEndAsteroid(actor);
// Update score.
GameStats.instance().incScore();
}
/**
* Handle controller events.
*
* @param event
* The actor event.
*
* @return True if handled.
*/
private void handleEndAsteroid(Actor source)
{
// Free this from pool so it can be re-used.
pool.free((AsteroidSprite) source);
// Remove from view.
removeActor(source);
}
You can see that as events are routed to the layer it responds accordingly. If the handler returns true the event will be removed from the event list and will not be passed on to any any other handlers.
Actions
Actions are used to run the sprite movements. As an example lets examine the PulseSprite, which is a simple animation, it has to move from the ship position to the top of the screen.
/**
* Run actions for actor.
*
* @param x
* @param y
*
* @return The main actions object.
*/
public void run(float x, float y)
{
// ---------------------------------------------------------------
// BECAUSE THE 'ACTION' METHOD DOES NOT CLEAR THE EXISTING LIST IT ADDS
// TO IT YOU MUST CLEAR ACTIONS ASSOCIATED WITH ACTOR. THIS IS
// BECAUSE WE ARE RECYCLING SPRITES.
// ---------------------------------------------------------------
clearActions();
// Set initial position
this.x = x;
this.y = y;
// Calculate the duration to cover distance at pixels-per-sec.
float height = Director.instance().getHeight();
float distance = height - y;
float duration = PIXELS_PER_SEC_FACTOR * distance;
// Move from source to top of screen.
MoveTo moveTo = MoveTo.$(x, height, duration);
moveTo.setCompletionListener(this);
// Run
action(moveTo);
}
/**
* Handles pulse action complete.
*
*/
@Override
public void completed(Action action)
{
// Send notification that pulse has completed.
Director.instance().sendEvent(GameActorEvents.EVENT_END_PULSE, this);
}
Note, we assign a completion handler to the move actions. If the pulse reaches the top of the screen without hitting anything then the completion handler will get triggered and it will send a event from the sprite to the PulseLayer which will remove it from the view, killing any further action execution as of course actions are associated with their Actor.
Because the PulseSprite is pooled we have to clear the associated action list when it is reused to clear out any unfinished or complete actions.
The demo code is here. This uses 0.9.3 snapshot from the Google Code subversion repository.
I am currently rewriting this again to bring in the Universal Tween Engine. That will be the next post.
Important
Only the “Menu”, “About” and “Game” view are implemented. To navigate out of a view PRESS THE ESC KEY. In Android you can press the back key.
Android: Simple Weather UI
Another update to the UI for new version of Simple Weather a very early Android application I wrote back in 2008.
I went though all the layouts and changed the LinearLayout references to RelativeLayout instead.
I think I will move the date up the top. It looks kind of strange where it is.
Android: Simple Weather UI
This is a work in progress.
I have been trying to learn how to write slicker interfaces for Android as the stock styling is fairly boring.
Note the rounded edges to the list activity and the colours nicked from the iPhone weather app.
Data: Google Correlate and Stock Prices.
I have to admit this one went right under my radar until recently. FT.com put up an interesting and amusing (as you will see) article on matching stock price against Google Correlate.
I leave it to the reader to look over the Google Correlate FAQ but in short it finds the closest match for a time series (dates against values) and frequency of search activity. In other words we can put in stock prices for a period of time and it will find the “closest fit” for search terms. As Google warn “Correlation is not causation” but it can be illuminating to try.
Anyway, I love this kind of thing so I thought I would plug a few time-series for some of our favourite technology giants and see what came up. I haven’t put a link to the time-series files as I am unsure what Yahoos policy is about publishing this data but I’ve put instruction on how to get it and format it. If you are clueless email me and I will send the files.
Apple Inc
To start off lets get the Apple stock prices data from Yahoo finance. Go to Yahoo Finance, search for AAPL and then select “Historical Prices” from the menu on the left. This will take you here. Download the CSV file spreadsheet.
If we open the speadsheet we have a number of columns.
The format that Google Correlate takes is Date|Value so we have to choose a column to plot. I am no financial whizz but I reckon closing price “Adj Close” will do so we’ll edit the file to just have these two columns.
Next we have to alter the date column to be in the format which GC takes so reformat the date column to “YYYY-MM-DD”. Don’t forget to remove the header and save it in CSV format.
Lets plot!
The found correlations are:
I’m going to choose the top correlation in each example. In this case as you can see it is “smartphones”.
I am going to go out on a limb here and say that in this case there is a link from the search results to the share price. From the iPhone launch in 2007 we can see the stock price make a sharp rise as the “early adopters” started to query what exactly a smartphone was and liked what they saw. In 2009 (according to Wikipedia) the “there is an app for that” campaign started so that might account for the greater interest from the general public not savvy yet to the new “big thing” and getting out their credit cards to push Apples fortunes up up and away.
The found correlations are:
Uh, right. Lets plot!
St Louise Backpage is a classifieds site. One to watch clearly for Google shareholders. Maybe time to start putting all that junk you were saving for the charity shop up for sale instead.
Microsoft
The found correlations are:
Plot.
If “Google Interview Questions” means what I think it does then perhaps Microsofts steady (relatively speaking) share price might indicate a steady outflux of engineers looking to find out the secrets of gaining entry to Googles superior canteen. And, why the massive spike in 2010? Androids sudden take-off perhaps.
Hewlett Packard
To be fair I am not sure if I have focussed on the correct HP division. This is the company stock.
The found correlations are:
Plot.
Frankly I am not sure what Ekas Portal is but it’s maybe time a few HP shareholders booted up MS-Paint and joined in as there is it may just boost their share price. Something to do with HP printer prices perhaps??
Conclusion
Finding causality between the fortunes of a company and Googles search terms does sound good on paper. In reality it is clearly a bit of a minefield. It’s an intriguing idea. I would love to see if anyone can come up with some good correlations that make sense.
One final note. It’s interesting to see that all the companies had a dip in 2009. Why?
Thanks to quantly for pointing me to this article and Curated Alpha for finding it in the first place.
Java: pommel
I have written a companion tool to “mavenize” called pommel which automatically replaces dependencies in multiple pom files.
As an example say you want to fix all the junit dependencies to the same version or fix the scope of an item in multiple projects. This tool will do it for you.
The tool takes a top level directory and a mapping file as inputs. It will scan for pom files and process them according to the source and target mappings.
Note, this tool REWRITES your pom file according to whatever rules are build into the org.apache.maven.model.Model class. If you are not happy with this then don’t use it or make sure you have backups of your project pom files first. Don’t say you weren’t warned.
The mapping file format is
<?xml version="1.0"?>
<mappings>
<mapping>
<dependency-source>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.0</version>
</dependency-source>
<dependency-target>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency-target>
</mapping>
</mappings>
or if you want you can use a wildcard for the source version number i.e.
<?xml version="1.0"?>
<mappings>
<mapping>
<dependency-source>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>*</version>
</dependency-source>
<dependency-target>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency-target>
</mapping>
</mappings>
I hope this proves useful to someone.
Java: mavenize
Recently I have been looking at writing a plugin for gephi. This is a open source visualisation tool which lets you create connected graphs of large data sets. I couldn’t get the source code to build and it occurred to me that it might be a good idea to “mavenize” it. After a little investigation I did find the existing maven version of the gephi codebase but after a great deal of effort I still can’t get it to build. Oh well.
One of the pleasures of writing software for your own amusement is you can go off at tangents and investigate whatever catches your interest. With that in mind I found myself pondering - what does it take to “mavenize” an existing java project?
- Put the application code under “src/main/java”.
- Put the resource files (i.e. everything that isn’t a *.java file) under “src/main/resources”
- Put your unit tests under ”src/test/java” (or at least create the directory structure for it)
- Put your test resources under”src/test/resources”
- Generate a pom file with a group and artifact id along with dependencies.
This process isn’t particularly onerous when you have one project to do but if you have a number to convert then it quickly becomes a pain. The gephi application had more than 100 modules so you can see why the thought occurred to me “I can write a tool to do this” and here it is:
“mavenize” is a command line tool written in java which you can point at any number of existing java projects and it will automatically generate a maven project directory structure with all the source and resources in the correct place along with a “best guess” pom file. The best guess bit comes from looking at the source code packages and extracting the package prefix which occurs most often as the group id. The artifact id is merely the project name (i.e. the directory name which contains the “src” dir).
You can pass in a version number and a package type to assign to the generated poms. Also if your project is a NetBeans module it will read the project description file and extract the dependencies and place them into the pom file as rough guide for you.
I wrote this to fill a need and I am guessing someone, somewhere has to have the same need as well so here is the link to the project and instructions for it’s use.
From a developer point of view this tool has some interesting components.
- Uses org.apache.commons.io.DirectoryWalker class to recurse down through directories.
- Uses org.apache.commons.io.filefilter.DirectoryFileFilter and org.apache.commons.io.filefilter.IOFileFilter to compose lists of java and resource files.
- Contains good examples of reading and writing a maven pom file using the org.apache.maven.model.Model class and associated model io classes.
- In order to find the package name prefix with the largest number of occurrences I used the “longest substring” algorithm. The version I used was lifted straight from the this page. Obviously the Apache license doesn’t apply to this since it’s from elsewhere.
- I used a tool called trang to read NetBeans project.xml file and generate a sample xsd file.
- I used jaxb to read the project.xsd file and generate the relevant classes to be able to read the NetBeans project details.
I also have another tool which I have dubbed ”pommel” which I will get round to publishing as well at some point. This will scan your maven projects and replace target dependencies with specific ones defined in a config file. This is extremely useful if you have to do this operation on a large number of projects.