motion-game 1.1.6 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d99521187e1dd28218c16860e0f724701837f663
-  data.tar.gz: bead34fe7ed7ca5116d1670452e116ec6eb29a27
+  metadata.gz: 9fb5bcabc0166c1bde03a269cfd020229aff8a07
+  data.tar.gz: abbbd7a9a720940f1215fcadb19a53ca13c9a098
 SHA512:
-  metadata.gz: 27130eb08428559c6967ecb694d3f34d3131f8eaa7301463681318024bcb739968b4ebe49eed2be2ca64a7051b59446e0d50d9d81a2c464a79f4137ea4a74381
-  data.tar.gz: b7d0efc945ffcd8776feb9627fac186a76b737b891025b0d815b7905fc4b549d282c5ba359777122ad16a9b39e86dcc77df23d3ef6775d7fd79cc85c0ed7ad49
+  metadata.gz: 3fa98786ace1a42fd4373f3c4b1681ed0f6252da86725ce8ad94a4661453ffcd382c46b614edf8e160cfea3a14a008cfcfd548f9fe041a82694683e09123de8b
+  data.tar.gz: 6c262b3fd8c9de5c0590926555885acf852d80627e43899dda6b0b64cdc6b6b661a501fa9930c7396824f83e13f4f91ae59b5aea4af1ee94bf965efb722951d8

data/README.md

@@ -0,0 +1,120 @@
+# motion-game
+
+[![Gem Version](https://badge.fury.io/rb/motion-game.svg)](https://badge.fury.io/rb/motion-game)
+
+motion-game is a cross-platform mobile game engine for RubyMotion. It lets you write mobile games in Ruby for iOS, tvOS and Android.
+
+motion-game is currently in **beta**. Please give it a try and report problems you find to us.
+
+## Features
+
+ * **Use Ruby :-)** motion-game exposes a pure Ruby API to write games for mobile devices. You can write a video game all in Ruby.
+ * **100% cross-platform**: motion-game projects are fully cross-platform for iOS, tvOS and Android. One codebase runs everywhere.
+ * **Fully-featured**: motion-game has audio, sprites, animations, particles, device sensors / events, scene graph / director, UI widgets, etc.
+ * **Solid foundations**: the motion-game API is implemented using popular and stable opensource libraries, such as [cocos2d-x](http://www.cocos2d-x.org/), [box2d](http://box2d.org/), and more. motion-game projects are also based on RubyMotion which offers portable Ruby runtimes for iOS and Android as well as static compilation of Ruby code.
+ * **Native compilation**: your Ruby code will be compiled into optimized native code for each platform you target. There is no interpreter and the original Ruby code will not be in the app.
+ * **Platform APIs access**: if you need it, you can call the entire set of public iOS, tvOS or Android APIs from Ruby code as well.
+
+## Getting Started
+
+### Installing RubyMotion
+
+[RubyMotion 4.7+](http://rubymotion.com) is required. A starter version can be downloaded for free. You also need to set up your computer for mobile development (iOS and/or tvOS and/or Android). Follow the [Getting Started](http://rubymotion.com/developers) guides after installation.
+
+### Installing motion-game
+
+#### Binaries
+
+motion-game is available as a gem:
+
+```
+$ gem install motion-game
+```
+
+#### Source
+
+You can build your own copy of motion-game:
+
+- Make sure you have your system set up for Android develpment: `motion android-setup --api_version=16`.
+
+```
+$ git clone https://github.com/HipByte/motion-game.git && cd motion-game
+$ git submodule update --init
+$ bundle
+$ rake build:setup
+
+$ rake gem
+$ gem install motion-game-x.x.gem
+```
+
+#### Developing Locally
+
+Once you have the source locally. Create a motion-game project as a sibling to the `motion-game` directory using the `motion create --template=motion-game PROJECTNAME` command.
+
+Update the reference to `motion-game` in your `Gemfile` to point to your local instance of `motion-game`:
+
+    gem 'motion-game', path: '../motion-game'
+
+Chances are all of you changes will be done in the `/src` directory (since it'll probably be adding missing Cocos2dx methods).
+
+Once you've made your change in the correct `.cpp` file, run `rake build:ios`/`rake build:android` to test your changes locally (running `rake gem` is a longer process which you don't have to do).
+
+Here are some examples of how to add missing apis to motion-game:
+
+- [add Draw#triange](https://github.com/HipByte/motion-game/commit/3c32771be11c5715a4922ba45914207b2c6f4d38)
+- [add Draw#line](https://github.com/HipByte/motion-game/commit/972fd115d3ef2816c19618b14823363356ca85b1)
+- [add Draw#clear](https://github.com/HipByte/motion-game/commit/98cc463724153bae1481a9364ef3f166e15f8c0f)
+
+### Hello World
+
+```
+$ motion create --template=motion-game HelloWorld
+$ cd HelloWorld
+```
+
+#### iOS
+
+```
+$ rake ios:simulator
+$ rake ios:device
+```
+
+#### tvOS
+
+```
+$ rake tvos:simulator
+$ rake tvos:device
+```
+
+#### Android
+
+```
+$ rake android:emulator
+$ rake android:device
+```
+
+### API reference
+
+The whole framework API is documented. The [API reference](http://www.rubydoc.info/gems/motion-game/) is available online.
+
+You can also build the API reference locally:
+
+```
+$ rake doc
+$ open doc/index.html
+```
+
+### Samples
+
+The [samples](https://github.com/HipByte/motion-game/tree/master/samples) directory contains sample projects.
+
+## License
+
+Copyright (c) 2015, HipByte (info@hipbyte.com) and contributors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/doc/API_reference.rb

@@ -0,0 +1,1407 @@
+# CAUTION :
+#   This file is automatically generated to creating documents.
+#   Please not use this file for your app.
+#--------------------------------------------------------------
+
+# MG stands for Motion Game. All classes part of the framework are defined under that module.
+module MG
+# The MG::Events module contains classes that represent events received from the game engine. You typically never instantiate these classes yourself.
+module Events; end
+
+class Action < Object
+  # Reverses the action
+  # @return [Action] the reversed action.
+  def reverse; end
+
+end
+
+class Action < Object
+  # Clones the action
+  # @return [Action] the cloned action.
+  def clone; end
+
+
+  # @group Properties
+
+  # Whether the action is done.
+  # @return [Boolean] whether the action is done.
+  attr_accessor :done?
+
+end
+
+class MoveBy < Action
+
+  # @group Constructors
+
+  # Creates an action that will move the position of the receiver to a new location
+  # determined by the sum of the current location and the given +delta_location+ object.
+  # @param delta_location [Point] a point that will be added to the receiver's
+  #   current location.
+  # @param interval [Float] the animation interval.
+  # @return [MoveBy] the action.
+  def initialize(delta_location, interval); end
+
+end
+
+class MoveTo < Action
+
+  # @group Constructors
+
+  # Creates an action that will move the position of the receiver to a new given location.
+  # @param location [Point] where the receiver should be moved to.
+  # @param interval [Float] the animation interval.
+  # @return [MoveTo] the action.
+  def initialize(location, interval); end
+
+end
+
+class JumpBy < Action
+
+  # @group Constructors
+
+  # Creates an action that will jump the receiver to a new location
+  # determined by the sum of the current location and the given +delta_location+ object.
+  # @param delta_location [Point] a point that will be added to the receiver's
+  #   current location during jumping.
+  # @param height [Float] the height of the jump
+  # @param jumps [Float] the number of jumps
+  # @param interval [Float] the animation interval.
+  # @return [JumpBy] the action.
+  def initialize(delta_location, height, jumps, interval); end
+
+end
+
+class JumpTo < Action
+
+  # @group Constructors
+
+  # Creates an action that will jump the receiver to a new location.
+  # @param location [Point] a point that the receiver will jump to
+  # @param height [Float] the height of the jump
+  # @param jumps [Float] the number of jumps
+  # @param interval [Float] the animation interval.
+  # @return [JumpTo] the action.
+  def initialize(location, height, jumps, interval); end
+
+end
+
+class RotateBy < Action
+
+  # @group Constructors
+
+  # Creates an action that will rotates the position of the receiver
+  # to a new angle determined by the
+  # sum of the current rotation and the given +delta_angle+ object.
+  # @param delta_angle [Float] the angle to add to the current rotation
+  # @param interval [Float] the animation interval.
+  # @return [Sprite] the receiver.
+  def initialize(delta_angle, interval); end
+
+end
+
+class RotateTo < Action
+
+  # @group Constructors
+
+  # Creates an action that will rotate the angle of the receiver to a new angle
+  # by modifying it's rotation attribute.
+  # @param angle [Float] the receiver should be rotated to.
+  # @param interval [Float] the animation interval.
+  # @return [RotateTo] the action.
+  def initialize(angle, interval); end
+
+end
+
+class ScaleBy < Action
+
+  # @group Constructors
+
+  # Creates an action that will scale the receiver
+  # @param scale [Float] the receiver should be scaled by
+  # @param interval [Float] the animation interval.
+  # @return [ScaleBy] the action.
+  def initialize(scale, interval); end
+
+end
+
+class ScaleTo < Action
+
+  # @group Constructors
+
+  # Creates an action that will scale the receiver
+  # @param scale [Float] the receiver should be scaled to
+  # @param interval [Float] the animation interval.
+  # @return [ScaleTo] the action.
+  def initialize(scale, interval); end
+
+end
+
+class SkewBy < Action
+
+  # @group Constructors
+
+  # Creates an action that skews a Node object to given angles by modifying it's
+  # skewX and skewY attributes by delta_x_angle and delta_y_angle.
+  # @param delta_x_angle [Float] the skew X delta angle
+  # @param delta_y_angle [Float] the skew Y delta angle
+  # @param interval [Float] the animation interval.
+  # @return [SkewBy] the action.
+  def initialize(delta_x_angle, delta_y_angle, interval); end
+
+end
+
+class SkewTo < Action
+
+  # @group Constructors
+
+  # Creates an action that skews a Node object to given angles by modifying it's
+  # skewX and skewY attributes
+  # @param x_angle [Float] the Skew X Angle
+  # @param y_angle [Float] the Skew Y Angle
+  # @param interval [Float] the animation interval.
+  # @return [SkewTp] the action.
+  def initialize(x_angle, y_angle, interval); end
+
+end
+
+class TintBy < Action
+
+  # @group Constructors
+
+  # Creates an action that tints a Node from current tint to a custom one.
+  # @param delta_red [Float]
+  # @param delta_green [Float]
+  # @param delta_blue [Float]
+  # @param interval [Float] the animation interval.
+  # @return [TintBy] the action.
+  def initialize(delta_red, delta_green, delta_blue, interval); end
+
+end
+
+class TintTo < Action
+
+  # @group Constructors
+
+  # Creates an action that tints the receiver from its current tint to a custom one.
+  # @param red [Float]
+  # @param green [Float]
+  # @param blue [Float]
+  # @param interval [Float] the animation interval.
+  # @return [TintTo] the action.
+  def initialize(red, green, blue, interval); end
+
+end
+
+class FadeTo < Action
+
+  # @group Constructors
+
+  # Creates an action Fades the receiver. It modifies the opacity from the current opacity
+  # to a custom one.
+  # @param opacity [Integer] the opacity to fade the object to (between 0-255)
+  # @param interval [Float] the animation interval.
+  # @return [FadeTo] the action.
+  def initialize(opacity, interval); end
+
+end
+
+class FadeIn < Action
+
+  # @group Constructors
+
+  # Creates an action Fades In the receiver. It modifies the opacity from the 0 to 255.
+  # @param interval [Float] the animation interval.
+  # @return [FadeIn] the action.
+  def initialize(interval); end
+
+end
+
+class FadeOut < Action
+
+  # @group Constructors
+
+  # Creates an action Fades Out the receiver. It modifies the opacity from the 255 to 0.
+  # @param interval [Float] the animation interval.
+  # @return [FadeOut] the action.
+  def initialize(interval); end
+
+end
+
+class Blink < Action
+
+  # @group Constructors
+
+  # Creates an action that Blinks the receiver by modifying it's visible attribute.
+  # @param blinks [Integer] the number of times to blink.
+  # @param interval [Float] the animation interval.
+  # @return [Blink] the action.
+  def initialize(blinks, interval); end
+
+end
+
+class Sequence < Action
+
+  # @group Constructors
+
+  # Creates an action that runs actions sequentially,
+  # one after another on the receiver.
+  # @param actions [Action[]] the array of actions to run in sequence
+  # @return [Sequence] the action.
+  def initialize(actions); end
+
+end
+
+class Spawn < Action
+
+  # @group Constructors
+
+  # Creates an action that spawns actions in parallel on the receiver.
+  # @param actions [Action[]] the array of actions to run
+  # @return [Spawn] the action.
+  def initialize(actions); end
+
+end
+
+class Follow < Action
+
+  # @group Constructors
+
+  # Creates an action that sets up the receiver to follow the 'followed node'.
+  # @param followed_node [Node] the node to follow
+  # @return [Follow] the action.
+  def initialize(followed_node); end
+
+end
+
+class DelayTime < Action
+
+  # @group Constructors
+
+  # Creates an action that delays the action a certain amount of seconds.
+  # @param interval [Float] the interval to delay.
+  # @return [DelayTime] the action.
+  def initialize(interval); end
+
+end
+
+class Speed < Action
+
+  # @group Constructors
+
+  # Changes the speed of an action, making it take longer (speed>1)
+  # or less (speed<1) time. Useful to simulate 'slow motion' or 'fast forward' effect.
+  # ** This action can't be Sequenceable because it is not an IntervalAction.
+  # @param target_action [Action] the action to adjust the speed of
+  # @param speed [Float] the adjustment to make to the speed (>1 longer, <1 shorter).
+  # @return [Speed] the action.
+  def initialize(target_action, speed); end
+
+end
+
+class Repeat < Action
+
+  # @group Constructors
+
+  # Creates an action that repeats the provided action a certain number of times.
+  # @param target_action [Action] the action to repeat.
+  # @param times [Integer] the number of times to repeat.
+  # @return [Repeat] the action.
+  def initialize(target_action, times); end
+
+end
+
+class RepeatForever < Action
+
+  # @group Constructors
+
+  # Creates an action that repeats the provided action forever.
+  # @param target_action [Action] the action to repeat.
+  # @return [RepeatForever] the action.
+  def initialize(target_action); end
+
+end
+
+class Animate < Action
+
+  # @group Constructors
+
+  # Creates an animation action where the sprite display frame will be changed to
+  # the given frames in +frame_names+ based on the given +delay+ and
+  # repeated +loops+ times.
+  # @param frame_names [Array<String>] an array of sprite frames to load and
+  #   use for the animation, which can be either the names of standalone image
+  #   files in the application's resource directory or the names of sprite
+  #   frames loaded from a spritesheet using {Sprite.load}.
+  # @param delay [Float] the delay in seconds between each frame animation.
+  # @param loops [Integer, Symbol] the number of times the animation should
+  #   loop. If given the +:forever+ symbol, the animation will loop forever.
+  # @return [Animate] the action.
+  def initialize(frame_names, delay, loops=1); end
+
+end
+# The application class. A proper subclass is generated for you by the
+# project template with a {#start} method, in which you are responsible
+# to create a scene and ask the director to run it:
+#   class Application < MG::Application
+#     def start
+#       MG::Director.shared.run(MyScene.new)
+#     end
+#   end
+class Application < Object
+
+  # @group Constructors
+
+  # @return [Application] the shared Application instance.
+  def self.shared; end
+
+
+  # @group Entry Point
+
+  # This method is called when the application finished launching. This method
+  # is empty by default, and you are responsible to provide a custom
+  # implementation that will create the interface of your game.
+  # @return [Application] the receiver.
+  def start; end
+
+end
+
+class Audio < Object
+
+  # @group Constructors
+
+  # Creates a new Audio object based on a sound file at the given path and
+  # immediately plays it.
+  # @param path [String] the path of the sound file that should be played.
+  # @param loop [Boolean] whether the sound file playback should loop.
+  # @param volume [Float] the audio volume that should be used to play this
+  #   this sound file, as a +0.0+ to +1.0+ Float range.
+  # @return [Audio] an Audio instance.
+  def self.play(path, loop=false, volume=1.0); end
+
+
+  # @group Instance Method Summary
+
+  # @return [Boolean] whether the sound file should loop.
+  def loop?; end
+
+  # Set whether to loop the sound.
+  # @param value [Boolean] true if the sound should loop.
+  def loop=(value); end
+
+  # @return [Float] the volume of the sound file, from a 0.0 to 1.0 Float range.
+  def volume; end
+
+  # Set the volume of the sound.
+  # @param value [Float] the volume of the sound.
+  def volume=(value); end
+
+  # @return [Float] the position where to play the sound file.
+  def current_position; end
+
+  # Set the position where to play the sound.
+  # @param value [Float] the position
+  def current_position=(value); end
+
+
+  # @group Properties
+
+  # @return [Float] the duration left in the sound file.
+  attr_reader :duration
+
+
+  # @group Instance Method Summary
+
+  # Resumes playing the sound file.
+  # @return [Audio] the receiver.
+  def resume; end
+
+  # Pauses the sound file.
+  # @return [Audio] the receiver.
+  def pause; end
+
+  # Stops the sound file.
+  # @return [Audio] the receiver.
+  def stop; end
+
+  # @return [Boolean] whether the sound file is being played.
+  def playing?; end
+
+  # @return [Boolean] whether the sound file is being paused.
+  def paused?; end
+
+end
+# Director is a shared object that takes care of the scene graph.
+class Director < Object
+
+  # @group Constructors
+
+  # @return [Director] the shared Director instance.
+  def self.shared; end
+
+
+  # @group Managing Scenes
+
+  # Runs the given scene object.
+  # @param scene [Scene] the scene to run.
+  # @return [Director] the receiver.
+  def run(scene); end
+
+  # Replaces the current scene with a new one. The running scene will be
+  # terminated.
+  # @param scene [Scene] the scene to replace the current one with.
+  # @return [Director] the receiver.
+  def replace(scene); end
+
+  # Suspends the execution of the running scene, and starts running the given
+  # scene instead.
+  # @param scene [Scene] the new scene to run.
+  # @return [Director] the receiver.
+  def push(scene); end
+
+  # Pops the running scene from the stack, and starts running the previous
+  # scene. If there are no more scenes to run, the execution will be stopped.
+  # @return [Director] the receiver.
+  def pop; end
+
+  # Ends the execution of the running scene.
+  # @return [Director] the receiver.
+  def end; end
+
+  # Pauses the execution of the running scene.
+  # @return [Director] the receiver.
+  def pause; end
+
+  # Resumes the execution of the current paused scene.
+  # @return [Director] the receiver.
+  def resume; end
+
+  # The main loop is triggered again.
+  # @return [Director] the receiver.
+  def start_animation; end
+
+  # Stops the animation.
+  # @return [Director] the receiver.
+  def stop_animation; end
+
+
+  # @group Properties
+
+  # @return [Point] the visible origin of the director view in points.
+  attr_reader :origin
+
+  # @return [Size] the visible size of the director view in points.
+  attr_reader :size
+
+  # Controls whether the FPS (frame-per-second) statistic label is displayed
+  # in the bottom-left corner of the director view. By default it is hidden.
+  # @return [Boolean] whether the FPS label is displayed.
+  attr_accessor :show_stats?
+
+end
+# This class represents an event received from the accelerometer sensor of
+# the device, usually from the {Scene#on_accelerate} method.
+class Events::Acceleration < Object
+
+  # @group Properties
+
+  # @return [Float] the x coordinate of the acceleration event.
+  attr_reader :x
+
+  # @return [Float] the y coordinate of the acceleration event.
+  attr_reader :y
+
+  # @return [Float] the z coordinate of the acceleration event.
+  attr_reader :z
+
+  # @return [Float] the timestamp of the acceleration event.
+  attr_reader :timestamp
+
+end
+# This class represents a touch event receive from the device, usually from
+# the {Scene#on_touch_begin} method.
+class Events::Touch < Object
+
+  # @group Properties
+
+  # @return [Point] the current location of the touch event.
+  attr_reader :location
+
+end
+
+class File
+  # Open a file and return its content
+  # @return [String] the content.
+  def self.read; end
+
+end
+# This class represents a scene, an independent screen or stage of the
+# application workflow. A scene is responsible for handling events from the
+# device, providing a physics world for the sprites, and also starting the
+# game loop.
+# An application must have at least one scene, and the +Scene+ class is
+# designed to be subclassed.
+class Scene < Node
+
+  # @group Constructors
+
+  # The default initializer. Subclasses can construct the scene interface in
+  # this method, as well as providing an implementation for {#update}, then
+  # run the update loop by calling {#start_update}.
+  # @return [Scene] the receiver.
+  def initialize; end
+
+
+  # @group Update Loop
+
+  # Starts the update loop. The +#update+ method will be called on this object
+  # for every frame.
+  # @return [Scene] the receiver.
+  def start_update; end
+
+  # Stops the update loop. The +#update+ method will no longer be called on
+  # this object.
+  # @return [Scene] the receiver.
+  def stop_update; end
+
+  # The update loop method. Subclasses can provide a custom implementation of
+  # this method. The default implementation is empty.
+  # @param delta [Float] a value representing the amount of time, in seconds,
+  #   since the last time this method was called.
+  # @return [Scene] the receiver.
+  def update(delta); end
+
+  # Schedules a given block for execution.
+  # @param delay [Float] the duration of the block, in seconds.
+  # @param repeat [Integer] the number of times the block should be repeated.
+  # @param interval [Float] the interval between repetitions, in seconds.
+  # @yield [Float] the given block will be yield with the delta value,
+  #   in seconds.
+  # @return [String] a token representing the task that can be passed to
+  #   {#unschedule} when needed.
+  def schedule(delay, repeat=0, interval=0); end
+
+  # Unschedules a task that's currently running.
+  # @param key [String] a token representing the task to unschedule,
+  #   returned by {#schedule}.
+  # @return [Scene] the receiver.
+  def unschedule(key); end
+
+
+  # @group Events
+
+  # Starts listening for touch begin events on the receiver.
+  # @yield [Events::Touch] the given block will be yield when a touch begin
+  #   event is received.
+  # @return [Scene] the receiver.
+  def on_touch_begin; end
+
+  # Starts listening for touch end events on the receiver.
+  # @yield [Events::Touch] the given block will be yield when a touch end
+  #   event is received.
+  # @return [Scene] the receiver.
+  def on_touch_end; end
+
+  # Starts listening for touch move events on the receiver.
+  # @yield [Events::Touch] the given block will be yield when a touch move
+  #   event is received.
+  # @return [Scene] the receiver.
+  def on_touch_move; end
+
+  # Starts listening for touch cancel events on the receiver.
+  # @yield [Events::Touch] the given block will be yield when a touch cancel
+  #   event is received.
+  # @return [Scene] the receiver.
+  def on_touch_cancel; end
+
+  # Starts listening for accelerometer events on the receiver.
+  # @yield [Events::Acceleration] the given block will be yield when an
+  #   accelerometer event is received from the device.
+  # @return [Scene] the receiver.
+  def on_accelerate; end
+
+  # Starts listening for contact begin events from the physics engine.
+  # @yield [Events::PhysicsContact] the given block will be yield when a
+  #   contact event is received from the physics engine.
+  # @return [Scene] the receiver.
+  def on_contact_begin; end
+
+
+  # @group Properties
+
+  # @return [Point] the gravity of the scene's physics world.
+  attr_accessor :gravity
+
+  # @return [Boolean] whether the physics engine should draw debug lines.
+  attr_accessor :debug_physics?
+
+end
+# A Menu is a way to navigate through game options.
+# Menus often contain options like Play, Quit, Settings and About.
+# This is usually in the form of buttons that are pressed.
+class Menu < Object
+
+  # @group Miscellaneous
+
+  # aligns menu items vertically with padding
+  # (call after adding items via image_item)
+  # @param padding [Float] the amount of padding between the items.
+  # @return [Menu] the receiver.
+  def align_items_vertically(padding=null); end
+
+  # aligns menu items horizontally with padding
+  # (call after adding items via image_item)
+  # @param padding [Float] the amount of padding between the items.
+  # @return [Menu] the receiver.
+  def align_items_horizontally(padding=null); end
+
+
+  # @group Properties
+
+  # Whether the menu is enabled. When enabled, a menu can be
+  # touched or clicked. By default, a menu is enabled.
+  # @return [Boolean] whether the menu is enabled.
+  attr_accessor :enabled?
+
+end
+# Node is the base class of objects in the scene graph. You should not
+# instantiate this class directly but use a subclass instead.
+class Node < Object
+
+  # @group Properties
+
+  # The anchor point of the node, as a set of percentage coordinates.
+  # The anchor point represents where the node will be attached to its parent,
+  # and is normalized as a percentage. +[0, 0]+ means the bottom-left corner,
+  # and +[1, 1]+ the top-right corner. You can also use values lower than +0+
+  # and higher than +1+. The default anchor point value is +[0.5, 0.5]+, which
+  # means the center of the parent.
+  # @return [Point] the anchor point of the node.
+  attr_accessor :anchor_point
+
+  # @return [Point] the +[x, y]+ position of the node in its parent's
+  #   coordinate system.
+  attr_accessor :position
+
+  # @return [Size] the content size of the node.
+  attr_accessor :size
+
+  # @return [Boolean] whether the node should be visible. The default value is
+  #   true.
+  attr_accessor :visible?
+
+  # @return [Float] the opacity (alpha) level of the node, as a Float from the
+  #   +0.0+ to +1.0+ range.
+  attr_accessor :alpha
+
+  # @return [Integer] the local z-order index of the receiver in the scene
+  #   graph, which will determine its priority when rendering the scene.
+  attr_accessor :z_index
+
+  # @return [Color] the color of the node.
+  attr_accessor :color
+
+  # Returns the rotation of the node in degrees. 0 is the default angle.
+  # Positive values rotate node clockwise, and negative values for
+  # anti-clockwise
+  # @return [Float] the rotation of the node in degrees.
+  attr_accessor :rotation
+
+  # Returns the scaling factor of the node, which multiplies its width, height
+  # and depth.
+  # @return [Float] the scaling factor.
+  attr_accessor :scale
+
+  # @return [String] a name to easily identify the node in the graph.
+  attr_accessor :name
+
+
+  # @group Miscellaneous
+
+  # Run the provided action on the receiver node.
+  # @return [Node] the receiver.
+  def run_action(action); end
+
+  # Stop all actions running on the node
+  # @return [Node] the receiver.
+  def stop_all_actions(); end
+
+  # Stop the provided action
+  # @param action [Action] the action to stop.
+  # @return [Node] the receiver.
+  def stop_action(action); end
+
+  # @param node [Node] a given Node object.
+  # @return [Boolean] whether the receiver's bounding box intersects with the
+  #   given node's bounding box.
+  def intersects?(node); end
+
+
+  # @group Container
+
+  # Adds a child node to the receiver with a local z-order.
+  # @param node [Node] the child to add.
+  # @param zpos [Integer] the local z-order.
+  # @return [Node] the receiver.
+  def add(node, zpos=0); end
+
+  # Removes all children nodes from the receiver.
+  # @param cleanup [Boolean] cleans all running actions on children before
+  #   removing them.
+  # @return [Node] the receiver.
+  def clear(cleanup=true); end
+
+  # Removes the given child node from the receiver.
+  # @param cleanup [Boolean] cleans all running actions on child before
+  #   removing it.
+  # @return [Node] the receiver.
+  def delete(node, cleanup=true); end
+
+  # @return [Node] the parent node, or +nil+ if there isn't one.
+  def parent; end
+
+  # @return [Array<Node>] an array of +Node+ objects that have been added to
+  #   the receiver.
+  def children; end
+
+  # Removes the receiver node from its parent.
+  # Same as:
+  #   node.parent.delete(node, cleanup)
+  # @param cleanup [Boolean] cleans all running actions on the receiver before
+  #   removing it from the parent.
+  # @return [Node] the receiver.
+  def delete_from_parent(cleanup=true); end
+
+end
+
+class Parallax < Node
+  # Adds the given Node object to the receiver and configure it in the
+  # parallax view.
+  # @param node [Node] the node to add to the receiver.
+  # @param zpos [Integer] the local z-order.
+  # @param parallax_ratio [Point]
+  # @param position_offset [Point]
+  # @return [Node] the child node.
+  def add(node, zpos, parallax_ratio, position_offset); end
+
+end
+
+class Draw < Node
+
+  # @group Draw Operations
+
+  # Clears drew shapes.
+  # @return [Draw] the receiver.
+  def clear; end
+
+  # Draws a filled circle at the given position with the given radius and color.
+  # @param pos [Point] the position where to draw.
+  # @param radius [Float] the radius of the circle to draw.
+  # @param color [Color] the color to use to fill the circle.
+  # @return [Draw] the receiver.
+  def dot(pos, radius, color); end
+
+  # Draws a rectangle at the given position with the given color.
+  # @param origin [Point] the position where to start drawing (lower-left).
+  # @param destination [Point] the position where to end drawing (higher-right).
+  # @param color [Color] the color to use to draw.
+  # @param fill [Boolean] whether the rectangle should be filled up.
+  # @return [Draw] the receiver.
+  def rect(origin, destination, color, fill=false); end
+
+  # Draws a line at the given position with the given color.
+  # @param origin [Point] the position where to start drawing (lower-left).
+  # @param destination [Point] the position where to end drawing (higher-right).
+  # @param thickness [Float] the line thickness.
+  # @param color [Color] the color to use to draw.
+  # @return [Draw] the receiver.
+  def line(origin, destination, thickness, color); end
+
+  # Draws a triangle at the given positions with the given color.
+  # @param position1 [Point] The triangle vertex point.
+  # @param position2 [Point] The triangle vertex point.
+  # @param position3 [Point] The triangle vertex point.
+  # @param color [Color] the color to use to draw.
+  # @return [Draw] the receiver.
+  def triangle(position1, position2, position3, color); end
+
+end
+
+class Particle < Node
+
+  # @group Constructors
+
+  # Creates a Particle object. If +file_name+ is given, it should be the name
+  # files can be created manually or with a visual editor such as Particle
+  # Designer. If +file_name+  is not given an empty Particle object will be
+  # created.
+  # @param file_name [String] the name of the property list particle file.
+  def initialize(file_name=nil); end
+
+
+  # @group Properties
+
+  # @return [String] the path of the texture file.
+  attr_writer :texture
+
+  # @return [Float] the speed of the particle emitter.
+  attr_accessor :speed
+
+  # @return [Float] the life of each particle.
+  attr_accessor :life
+
+  # @return [Float] the life variation of each particle.
+  attr_accessor :life_range
+
+  # @return [Float] the angle of each particle.
+  attr_accessor :angle
+
+  # @return [Float] the angle variation of each particle.
+  attr_accessor :angle_range
+
+  # @return [Float] the duration of the particle.
+  attr_accessor :duration
+
+  # @return [Point] the position variation of each particle.
+  attr_accessor :position_range
+
+  # @return [Integer] the number of particles to emit.
+  attr_accessor :particle_count
+
+  # @return [Color] the color that should be used when the particle starts.
+  attr_accessor :start_color
+
+  # @return [Color] the color that should be used when the particle ends.
+  attr_accessor :end_color
+
+end
+
+class Sprite < Node
+
+  # @group Spritesheets
+
+  # Loads all sprites from the content of +file_name+, which should be
+  # the name of a property list spritesheet file in the application's resource
+  # directory. Once a spritesheet file is loaded, individual sprites can be
+  # created using {Sprite#initialize} by providing the name of the frame.
+  # Sprite frames files can be created with a visual editor such as
+  # TexturePacker.
+  # @param file_name [String] the name of the sprite frames property list file.
+  # @return [nil]
+  def self.load(file_name); end
+
+
+  # @group Constructors
+
+  # Creates a new sprite object from +sprite_name+, which must be either the
+  # name of a standalone image file in the application's resource directory
+  # or the name of a sprite frame which was loaded from a spritesheet using
+  # {load}.
+  # @param sprite_name [String] the name of the sprite to create.
+  def initialize(sprite_name); end
+
+
+  # @group Actions
+
+  # Moves the position of the receiver to a new location determined by the
+  # sum of the current location and the given +delta_location+ object.
+  # @param delta_location [Point] a point that will be added to the receiver's
+  #   current location.
+  # @param interval [Float] the animation interval.
+  # @return [Sprite] the receiver.
+  def move_by(delta_location, interval); end
+
+  # Moves the position of the receiver to a new given location.
+  # @param location [Point] where the receiver should be moved to.
+  # @param interval [Float] the animation interval.
+  # @return [Sprite] the receiver.
+  def move_to(location, interval); end
+
+  # Rotates the position of the receiver to a new angle determined by the
+  # sum of the current rotation and the given +delta_angle+ object.
+  # @param delta_angle [Float] the angle to add to the current rotation
+  # @param interval [Float] the animation interval.
+  # @return [Sprite] the receiver.
+  def rotate_by(delta_angle, interval); end
+
+  # Rotates the angle of the receiver to a new angle certain angle
+  # by modifying it's rotation attribute.
+  # @param angle [Float] the receiver should be rotated to.
+  # @param interval [Float] the animation interval.
+  # @return [Sprite] the receiver.
+  def rotate_to(angle, interval); end
+
+  # Blinks the receiver.
+  # @param number_of_blinks [Integer] the number of times the receiver should
+  #   blink.
+  # @param interval [Float] the animation interval.
+  # @return [Sprite] the receiver.
+  def blink(number_of_blinks, interval); end
+
+  # Starts an animation where the sprite display frame will be changed to
+  # the given frames in +sprite_frames_names+ based on the given +delay+ and
+  # repeated +loops+ times.
+  # @param frame_names [Array<String>] an array of sprite frames to load and
+  #   use for the animation, which can be either the names of standalone image
+  #   files in the application's resource directory or the names of sprite
+  #   frames loaded from a spritesheet using {load}.
+  # @param delay [Float] the delay in seconds between each frame animation.
+  # @param loops [Integer, Symbol] the number of times the animation should
+  #   loop. If given the +:forever+ symbol, the animation will loop forever.
+  # @return [Sprite] the receiver.
+  def animate(frame_names, delay, loops=1); end
+
+  # Sets whether the sprite should be flipped horizontally or not. It only flips
+  # the texture of the sprite, and not the texture of the sprite's children.
+  # Also, flipping the texture doesn't alter the anchorPoint.
+  # @param value [Boolean] true if the sprite should be flipped horizontally, false otherwise.
+  def flipped_horizontally=(value); end
+
+  # This is alias method of "#flipped_horizontally=".
+  def flipped_x=(value); end
+
+  # Sets whether the sprite should be flipped vertically or not. It only flips
+  # the texture of the sprite, and not the texture of the sprite's children.
+  # Also, flipping the texture doesn't alter the anchorPoint.
+  # @param value [Boolean] true if the sprite should be flipped vertically, false otherwise.
+  def flipped_vertically=(value); end
+
+  # This is alias method of "#flipped_vertically=".
+  def flipped_y=(value); end
+
+
+  # @group Physics
+
+  # Attaches a physics body with a box shape to the sprite.
+  # @param size [Size] the size of the box. If +nil+ is given, the size of the
+  #   sprite, retrieved with {#size}, will be used instead.
+  # @return [Sprite] the receiver.
+  def attach_physics_box(size=nil); end
+
+  # Applies a continuous force to the sprite body.
+  # @param force [Point] the force to apply.
+  # @return [Sprite] the receiver.
+  def apply_impulse(force); end
+
+  # Applies an immediate force to the sprite body.
+  # @param force [Point] the force to apply.
+  # @return [Sprite] the receiver.
+  def apply_force(force); end
+
+
+  # @group Properties
+
+  # @return [Float] the body mass of the sprite.
+  attr_accessor :mass
+
+  # @return [Boolean] whether the sprite should be affected by the scene's
+  #   gravitational force. The default is +true+.
+  attr_accessor :gravitates?
+
+  # @return [Boolean] whether the sprite body should be dynamic or not in the
+  #   physics world. The default is +true+, and a dynamic body will affect
+  #   with gravity.
+  attr_accessor :dynamic?
+
+  # @return [Float] the linear damping / air friction force on the sprite body.
+  attr_accessor :friction
+
+  # @return [Point] the velocity force on the sprite body.
+  attr_accessor :velocity
+
+  # @return [Boolean] whether the body is at rest.
+  attr_accessor :resting?
+
+  # @return [Float] the moment of inertia of the body.
+  attr_accessor :inertia_moment
+
+  # @return [Integer] physics category mask.
+  attr_accessor :category_mask
+
+  # @return [Integer] physics contact test mask.
+  attr_accessor :contact_mask
+
+  # @return [Integer] physics collision mask.
+  attr_accessor :collision_mask
+
+end
+# A point represents a location in a two-dimensional coordinate system using
+# +x+ and +y+ variables.
+# When calling a method that expects a +Point+ object, a 2-element +Array+
+# can be passed instead, as a convenience shortcut. For example,
+#   node.location = [10, 20]
+# is the same as
+#   point = MG::Point.new
+#   point.x = 10
+#   point.y = 20
+#   node.location = point
+class Point < Object
+
+  # @group Properties
+
+  # @return [Float] the x coordinate of the point.
+  attr_accessor :x
+
+  # @return [Float] the y coordinate of the point.
+  attr_accessor :y
+
+
+  # @group Helpers
+
+  # Adds the coordinates of the receiver with the coordinates of the given
+  # point object.
+  # @param point [Point]
+  # @return [Point] A new Point object.
+  def +(point); end
+
+  # Substracts the coordinates of the receiver with the coordinates of the given
+  # point object.
+  # @param point [Point]
+  # @return [Point] A new Point object.
+  def -(point); end
+
+end
+# A size represents the dimensions of width and height of an object.
+# When calling a method that expects a +Size+ object, a 2-element +Array+
+# can be passed instead, as a convenience shortcut. For example,
+#   node.size = [200, 400]
+# is the same as
+#   size = MG::Size.new
+#   size.x = 200
+#   size.y = 400
+#   node.size = size
+class Size < Object
+
+  # @group Properties
+
+  # @return [Float] the size width.
+  attr_accessor :width
+
+  # @return [Float] the size height.
+  attr_accessor :height
+
+
+  # @group Helpers
+
+  # Adds the dimensions of the receiver with the dimensions of the given
+  # size object.
+  # @param size [Size]
+  # @return [Size] a new Size object.
+  def +(size); end
+
+  # Substracts the dimensions of the receiver with the dimensions of the given
+  # size object.
+  # @param size [Size]
+  # @return [Size] a new Size object.
+  def -(size); end
+
+  # Divides the dimensions of the receiver with the given number.
+  # @param delta [Float] the number to divide the receiver with.
+  # @return [Size] a new Size object.
+  def /(delta); end
+
+  # Multiplies the dimensions of the receiver with the given number.
+  # @param delta [Float] the number to multiply the receiver with.
+  # @return [Size] a new Size object.
+  def *(delta); end
+
+end
+# A color represents the color, and sometimes opacity (alpha) of an object.
+# When calling a method that expects a +Color+ object, a 3-element +Array+
+# (red-green-blue) or 4-element +Array+ (red-green-blue-alpha) can be passed
+# instead, as a convenience shortcut. For example,
+#   node.color = [0.2, 0.3, 0.4]
+# is the same as
+#   color = MG::Color.new
+#   color.red = 0.2
+#   color.green = 0.3
+#   color.blue = 0.4
+#   node.color = color
+# Alternatively, a +Symbol+ corresponding to a basic color name can be
+# provided. For example,
+#   node.color = :red
+# is the same as
+#   color = MG::Color.new
+#   color.red = 1.0
+#   color.green = color.blue = 0
+#   node.color = color
+# Currently, the following symbols are supported: +:white+, +:black+, +:red+,
+# +:green+ and +:blue+.
+# The +MG::Color.new+ constructor will return the black color.
+class Color < Object
+
+  # @group Properties
+
+  # @return [Float] the red portion of the color, from +0.0+ to +1.0+.
+  attr_accessor :red
+
+  # @return [Float] the green portion of the color, from +0.0+ to +1.0+.
+  attr_accessor :green
+
+  # @return [Float] the blue portion of the color, from +0.0+ to +1.0+.
+  attr_accessor :blue
+
+  # @return [Float] the alpha portion of the color, from +0.0+ to +1.0+.
+  attr_accessor :alpha
+
+end
+# The base class for all UI widgets. You should not instantiate this class
+# directly but use a subclass instead.
+class Widget < Node
+
+  # @group Properties
+
+  # Whether the widget is enabled. When enabled, a widget can be
+  # touched or clicked. By default, a widget is enabled.
+  # @return [Boolean] whether the widget is enabled.
+  attr_accessor :enabled?
+
+  # Whether the widget is touch enabled. When touch enabled, a widget supports
+  # on_touch. By default, a widget is not touch enabled.
+  # @return [Boolean] whether the widget is touch enabled.
+  attr_accessor :touch_enabled?
+
+  # Whether the widget is highlighted. By default, a widget is not highlighted.
+  # @return [Boolean] whether the widget is highlighted.
+  attr_accessor :highlighted?
+
+
+  # @group Events
+
+  # Configures a block to be called when a touch event is received on the
+  # widget.
+  # @yield [Symbol] the given block will be called when the event
+  #   is received with a +Symbol+ that describes the type of event, which can
+  #   be +:begin+, +:move+, +:end+ or +:cancel+.
+  # @return [Widget] the receiver.
+  def on_touch; end
+
+end
+
+class Text < Widget
+
+  # @group Constructors
+
+  # Creates a new Text widget with optional content, font name and size.
+  # @param text [String] content for the text widget.
+  # @param font [String] name of the font the text widget should use.
+  # @param font_size [Integer] size of the font the text widget should use.
+  def initialize(text='', font='', font_size=0); end
+
+
+  # @group Properties
+
+  # @return [String] content of the widget.
+  attr_accessor :text
+
+  # @return [Color] color of the text part of the widget.
+  attr_accessor :text_color
+
+  # @return [String] name of the font used by the widget.
+  attr_accessor :font
+
+  # @return [Integer] size of the font used by the widget.
+  attr_accessor :font_size
+
+  # @return [Size] the text rendering area size.
+  attr_accessor :area_size
+
+  # @return [:top, :center, :bottom] the vertical alignment of the text.
+  attr_accessor :vertical_align
+
+  # @return [:left, :center, :right] the horizontal alignment of the text.
+  attr_accessor :horizontal_align
+
+end
+# A button widget. The {#on_touch} method can be used to set a callback when
+# the button is activated. Example:
+#   button = Button.new("Touch me!")
+#   button.on_touch { |type| puts "touched!" if type == :end }
+class Button < Widget
+
+  # @group Constructors
+
+  # Creates a new Button widget with an optional title.
+  # @param title [String] title for the button.
+  def initialize(title=''); end
+
+
+  # @group Properties
+
+  # @return [String] title of the button.
+  attr_accessor :text
+
+  # @return [Color] color of the title.
+  attr_accessor :text_color
+
+  # @return [String] name of the font used for the button title.
+  attr_accessor :font
+
+  # @return [Integer] size of the font used by for button title.
+  attr_accessor :font_size
+
+  # @return [Float] the value with which the button will zoom when the user
+  #   presses it.
+  attr_accessor :zoom_scale
+
+end
+
+class Slider < Widget
+
+  # @group Constructors
+
+  # Creates a new Slider widget.
+  def initialize; end
+
+
+  # @group Properties
+
+  # @return [Integer] the progress direction of the slider, as a percentage
+  #   value from +1+ to +100+.
+  attr_accessor :progress
+
+end
+
+class Layout < Widget
+
+  # @group Constructors
+
+  # Creates a new List widget.
+  def initialize; end
+
+
+  # @group Properties
+
+  # @return [:absolute, :vertical, :horizontal, :relative] the layout type.
+  attr_accessor :type
+
+  # @return [Color] the background color of the widget.
+  attr_accessor :background_color
+
+  # @return [Boolean] whether the layout can clip its content and children
+  #   (default is false).
+  attr_accessor :clipping?
+
+end
+
+class Scroll < Layout
+
+  # @group Constructors
+
+  # Creates a new Scroll widget.
+  def initialize; end
+
+
+  # @group Properties
+
+  # @return [:none, :vertical, :horizontal, :both] the direction of the scroll
+  #   view.
+  attr_accessor :direction
+
+  # @return [Size] the inner container size of the scroll view, which must be
+  #    larger or equal than the size of the scroll view itself.
+  attr_accessor :inner_size
+
+  # @return [Layout] the inner container of the scroll view.
+  attr_reader :inner_container
+
+end
+
+class List < Scroll
+
+  # @group Constructors
+
+  # Creates a new List widget.
+  def initialize; end
+
+
+  # @group Managing Items
+
+  # Adds a new item to the end of the list.
+  # @param widget [Widget] the item to add.
+  # @return [List] the receiver.
+  def add_item(widget); end
+
+  # Inserts a new item at the given index in the list.
+  # @param index [Integer] the index where to add the item.
+  # @param widget [Widget] the item to add.
+  # @return [List] the receiver.
+  def insert_item(index, widget); end
+
+  # Retrieves the item at the given index.
+  # @param index [Integer] the index to look up.
+  # @return [Widget] the item at the given index, or +nil+ if there isn't any.
+  def item_at(index); end
+
+  # Deletes the item at the given index.
+  # @param index [Integer] the index to look up.
+  # @return [List] the receiver.
+  def delete_item(index); end
+
+  # Removes all items in the list.
+  # @return [List] the receiver.
+  def clear_items; end
+
+
+  # @group Selection
+
+  # Configures a block to be called when an item is selected in the list view.
+  # @yield [Integer] the given block will be called when an item is selected,
+  #   passing the index of the selection as the argument.
+  # @return [List] the receiver.
+  def on_selection; end
+
+  # @return [Integer] the index of the currently selected item.
+  def selected_item; end
+
+
+  # @group Properties
+
+  # @return [Float] the margin between items in the list.
+  attr_accessor :items_margin
+
+end
+
+class Web < Widget
+
+  # @group Constructors
+
+  # Creates a new Web widget.
+  def initialize; end
+
+
+  # @group Loading Data
+
+  # Loads a given HTML data into the widget.
+  # @param str [String] the HTML string to load.
+  # @param baseurl [String] the base URL for the content.
+  # @return [Web] the receiver.
+  def load_html(str, baseurl); end
+
+  # Loads a given URL into the widget.
+  # @param url [String] the URL to load.
+  # @return [Web] the receiver.
+  def load_url(url); end
+
+  # Loads a given file into the widget.
+  # @param path [String] the file to load.
+  # @return [Web] the receiver.
+  def load_file(path); end
+
+  # Stops the current loading.
+  # @return [Web] the receiver.
+  def stop; end
+
+  # Reloads the current context.
+  # @return [Web] the receiver.
+  def reload; end
+
+
+  # @group JavaScript Interface
+
+  # Evaluates the given JavaScript expression.
+  # @param expr [String] a JavaScript expression to evaluate.
+  # @return [Web] the receiver.
+  def evaluate(expr); end
+
+end
+end