Monkey Game Development: Beginner's Guide


Monkey Game Development: Beginner's Guide
eBook: $29.99
Formats: PDF, PacktLib, ePub and Mobi formats
$25.49
save 15%!
Print + free eBook + free PacktLib access to the book: $79.98    Print cover: $49.99
$49.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Support
Sample Chapters
  • Create eight fun 2d games.
  • Understand how to structure your code, your data structures and how to set up the control flow of a modern 2D game
  • Learn how to deploy your games to iOS, Android, XNA (Xbox, Windows Phone 7) and desktop platforms (Windows, OSX)

Book Details

Language : English
Paperback : 402 pages [ 235mm x 191mm ]
Release Date : April 2012
ISBN : 1849692033
ISBN 13 : 9781849692038
Author(s) : Michael Hartlef
Topics and Technologies : All Books, Game Development, Mobile, Beginner's Guides, Games

Table of Contents

Preface
Chapter 1: Monkey—Huh?
Chapter 2: Getting to Know your Monkey—a Trip to the Zoo
Chapter 3: Game #2, Rocket Commander
Chapter 4: Game #3, CometCrusher
Chapter 5: Game #4, Chain Reaction
Chapter 6: Game #5, Balls Out!
Chapter 7: Game #6, At The Docks
Chapter 8: Game #7, Air Dogs 1942
Chapter 9: Game #8, Treasure Chest
Chapter 10: Make Some Money for Bananas
Index
  • Chapter 1: Monkey—Huh?
    • Game development for the rest of us
    • Cross-platform development
    • Compiler or translator?
    • The Monkey toolbox
    • Time for action – installing Monkey
      • Please welcome… Monk
      • MSERVER—Monkey's own web server
    • Let's have a little playtime
    • Time for action – playing Pirate TriPeaks
    • Time for action – playing Surviball
      • Playing to have fun, playing to study
    • So let's go for something big? No!
      • The alternative
    • Time for action – read the manual
      • The Trans tool and the supported target platforms
        • HTML5
        • FLASH
        • iOS
        • Android
        • XNA
        • GLFW
      • The Monkey standard modules
        • Lang
        • Lists
        • Map
        • Math
        • Random
        • Set
        • Stack
      • Mojo – The 2D framework/modules
        • App
        • Audio
        • Graphics
        • Input
      • Monkey is extendable
        • Your own modules
        • Native source code
        • Third-party modules
        • Your own targets
      • Your game is easily portable
    • Summary
    • Chapter 2: Getting to Know your Monkey—a Trip to the Zoo
      • Call the Monk and start praying—the Monkey IDE
        • Why learn about Monk?
        • Starting up Monk
        • Monk's user interface
          • The toolbar
        • The code editor area
        • The info box
      • Time for action – opening a sample script
      • Where is my navi?
      • Time for action – navigating to the Main() function
      • Save... save... save!
      • Time for action – saving a script
      • Projects—bringing in some organization
      • Time for action – creating a project
      • The Monkey programming language
      • Time for action – Monkey's Hello World
      • Running your first script in a browser
      • Our first little game... PONGO
      • Time for action – the basic structure of your game
      • Pongo's data structure
      • Time for action – adding some data fields
      • Time for action – rendering the game field
      • Time for action – drawing the ball and the paddles
      • Time for action – player paddle movement
      • Time for action – moving the enemy paddles
      • Time for action – moving the ball
      • Time for action – controlling the ball with the player's paddle
      • Time for action – letting the enemy paddles fight back
      • Time for action – acting on the different game modes
      • Exporting your game as an HTML5 website
      • One more thing... comment your code!
      • Summary
      • Chapter 3: Game #2, Rocket Commander
        • The game objects
        • The basic file structure
        • Time for action – building the basic file structure of the game
        • Hold that data—RocketCommander's data structure
        • Time for action – creating the general data structure of the game
        • Detailing the Update process
        • Time for action – detailing the Update process
        • Detailing the Render process
        • Time for action – detailing the Render event
        • Enhancing the OnCreate event
        • Time for action – detailing the OnCreate process
        • Let's build some cities
        • Time for action – building some cities
          • Implementing the city class into the game
        • Time for action – changing the gameClasses file
          • Modifying the RocketCommander class
        • Time for action – spawning some cities in the game
          • Rendering the ground and the cities
        • Time for action – rendering the cities
        • Get the launchers ready!
        • Time for action – implementing the rocket launchers
          • Implementing the launcher class into the game
        • Time for action – changing the gameClasses file again
          • Modifying the RocketCommander class
        • Time for action – creating some launchers in the game
          • Updating the rocket launchers
        • Time for action – updating the launchers
          • Enhancing the UpdateMenu method
        • Time for action – modifying the menu update process
          • Rendering our precious rocket launchers
        • Time for action – rendering the launchers
        • Fire! Blast them to pieces!
        • Time for action – implementing some rockets
          • Implementing the rocket class into the game
        • Time for action – modifying the gameClasses file
          • Modifying the launcher class
        • Time for action – modifying the launcher class
          • Updating the rockets
        • Time for action – updating the rockets
          • Rendering our furious rockets
        • Time for action – rendering the rockets
        • And it goes BOOM!... Explosions
        • Time for action – implementing explosions
          • Implementing the explosion class into the game
        • Time for action – modifying the gameClasses file
          • Modifying the rocket class
        • Time for action – modifying the rocket class
          • Updating the explosions
        • Time for action – updating the explosions
          • Rendering beautiful explosions
        • Time for action – rendering the explosions
        • Don't fear the enemy—bombs
        • Time for action – creating the bomb class
          • Implementing the bomb class into the game
        • Time for action – modifying the gameClasses file
          • Updating bombs
        • Time for action – updating the bombs
          • Rendering beautiful bombs
        • Time for action – rendering the bombs
          • Creating new bombs and checking for GameOver conditions, or new level conditions
        • Time for action – modifying the UpdateGame method
        • Displaying the game score
        • Time for action – displaying the game score
        • Summary
        • Chapter 4: Game #3, CometCrusher
          • Using a game framework—the fantomEngine
          • Game resources
            • Images
            • Sounds
            • Bitmap fonts
          • The game objects
            • Layers
            • Background stars
            • Comets
            • The player ship
            • The shield
            • Shots
            • Particles
            • Game info text
          • The basic file structure
          • Time for action – create the main source file and its folders
          • Open the storage please—the data structure of CometCrusher
          • Time for action – creating the data structure
          • First changes to the OnCreate method
          • Time for action – modifying the OnCreate method
          • Detailing the Render process
          • Time for action – detailing the OnRender method
          • This is a setup—creating the game objects
            • Group yourself—layers
          • Time for action – creating some layers
            • Let them shine—the background stars
          • Time for action – implementing some stars
            • The Hero—creating the player ship
          • Time for action – setting up the player ship
            • Did you hear that—loading sounds
          • Time for action – creating a method to load sounds
            • Did you see that score—the game UI
          • Time for action – creating some game info text objects
            • Headlines—adding a title screen
          • Time for action – adding a title screen
            • How good are you—the high score list
          • Time for action – setting up the high score list
            • Rocks rocks rocks—fill the space with some comets
          • Time for action – create a comet
          • Time for action – creating some comets
            • Mission complete... finalizing the OnCreate process
          • Time for action – finalizing the OnCreate method
          • We need help—more methods for the Update process
            • Loading and showing the high score list
          • Time for action – loading a high score list
          • Time for action – showing the high score list
            • Activating the shield of the player ship
          • Time for action – the ActivateShield method
            • Delta time related movement
          • Time for action – determine the time delta
            • Updating the game statistic info text objects
          • Time for action – updating the info text
            • Starting a new game
          • Time for action – creating a StartNewGame method
            • Let the engine glow
          • Time for action – spawning some engine particle FX
            • And it goes boom—creating an explosion
          • Time for action – creating some explosions
            • Give me that gun—spawning a shot
          • Time for action – spawning some shots
            • Save some high scores, will ya!
          • Time for action – saving the high score list
          • Finalizing the OnUpdate method
          • Time for action – finalizing the OnUpdate method
          • Bring in the action—shaping the engine class
            • Crack these objects—object collision handling
          • Time for action – detailing the collision detection
            • It's about time—acting on timer events
          • Time for action – detailing the OnObjectTimer method
            • Everything is under control—object update events
          • Time for action – detailing the OnObjectUpdate method
            • Did I win—checking the losing conditions with OnLayerUpdate
          • Time for action – detailing the OnLayerUpdate method
          • One last thing—creating a FLASH game
          • Summary
          • Chapter 5: Game #4, Chain Reaction
            • Modifying the HTML5 canvas size
            • Time for action – modifying canvas size
            • Some development basics
              • Frameworks/modules
              • Sprite sheets
              • Content scaling
              • Touch input
              • Suspend and Resume events
              • Animation
            • Game resources
            • Game objects
              • Layers
              • Title screen
              • Game background
              • Atom tiles
              • Game info text
            • The basic app structure
            • Time for action – creating the main source file and its folders
            • The data storage
            • Time for action – creating the data structure
            • First changes to the OnCreate event
            • Time for action – first changes to the OnCreate method
            • Detailing the OnRender event
            • Time for action – detailing the OnRender method
            • Setting up the game objects
              • Sound effects
            • Time for action – loading the game sound effects
              • Game layers
            • Time for action – creating layers for the game
            • Game screen
              • Click here – Adding buttons
            • Time for action – creating buttons
              • The info text objects
            • Time for action – creating info text objects
              • The actual game screen
            • Time for action – composing the game screen
              • Title screen
            • Time for action – creating the title screen
            • Finalizing the OnCreate event
            • Time for action – finalizing the OnCreate method
            • Helper functions for the update process
              • Creating the atom elements
                • Collision circle objects
            • Time for action – creating collision circles
              • Atom elements
            • Time for action – creating the atom elements
              • Starting a new game
            • Time for action – creating a StartNewGame method
              • Time-related movement
            • Time for action – implementing the GetDeltaTime method
              • Updating the info text objects
            • Time for action – creating a method to update the text information
            • Detailing the OnUpdate event
            • Time for action – finalizing the OnUpdate method
            • Introducing the OnSuspend event
            • Time for action – modifying the OnSuspend event
            • Introducing the OnResume event
            • Time for action – updating the OnResume method
            • The heart of the game - the engine class
              • What are transitions?
              • Touch me – acting on touch hits
            • Time for action – enhancing the OnObjectTouch method
              • The eagle has landed—a transition is finished
            • Time for action – detailing the OnObjectTransition method
              • It's about time—timer events
            • Time for action – acting on timer events
              • Captain! Collision ahead!—doing collision checks
            • Time for action – detailing the collision detection
            • Creating an Android app
              • Changing icons
              • Do a name change
              • Signing an application for the market
            • Summary
            • Chapter 6: Game #5, Balls Out!
              • Which frameworks and modules are used?
              • Game resources
              • Our lovely game objects
                • Layers
                • The title screen
                • Game background
                • The ball
                • Enemies
                • The ball tiles
              • The basic app structure
              • Time for action – creating the basic file structure
              • Modifying the HTML5 canvas size for testing
              • Time for action – modifying the HTML5 output
              • The data storage
              • Time for action – creating the data structure
              • First changes to the OnCreate event
              • Time for action – first changes to the OnCreate method
              • Detailing the OnRender event
              • Time for action – detailing the OnRender method
              • Setting up the game objects
                • Make some noise—sound effects
              • Time for action – loading the game sound effects
                • Lay your head on me—the game layers
              • Time for action – creating layers for the game
                • Our beloved play field—the background screen
                  • Buttons—I need more text buttons!
              • Time for action – creating text buttons
                • The background screen as usual
            • Time for action – composing the game screen
              • Give it a name—the title screen
            • Time for action – creating the title screen
            • Finalizing the OnCreate event
            • Time for action – finalizing the OnCreate method
            • Helper methods for the update process
              • Creating the tiles
            • Time for action – creating the tiles
              • The main actor—creating the ball
            • Time for action – creating the ball
            • The bad guys—our beloved enemies
            • Time for action – creating the enemy class
            • More helper functions
              • Spawning an enemy
            • Time for action – spawning an enemy
              • Starting a new game
            • Time for action – creating a StartNewGame method
            • Bring me up-to-date—detailing the OnUpdate event
            • Time for action – detailing the OnUpdate method
            • Eye candy—particle effects
              • The particle emitter class
            • Time for action – creating the particle emitter class
              • The last helper method
            • Time for action – spawning a particle emitter
            • The heart of the game—the engine class
              • Touch me—acting on touch hits
            • Time for action – enhancing the OnObjectTouch method
              • Controlling the ball—acting on object update events
            • Time for action – acting on object update events
              • What's the situation? Layer update events
            • Time for action – acting on layer update events
              • We reached our parking position—a transition is done
            • Time for action – detailing the OnObjectTransition method
              • Bump bump—checking for collisions
            • Time for action – detailing the collision detection
            • Creating an iOS app
            • Summary
              • Chapter 7: Game #6, At The Docks
                • Frameworks and modules used
                • Game resources
                • The game objects
                  • Layers
                  • The default layer
                  • The title screen
                  • Game screen
                  • Wall tiles
                  • Floor tiles
                  • Target tiles
                  • Crate tiles
                  • The player machine
                • The basic app structure
                • Time for action – creating the basic file structure
                • Modifying the HTML5 canvas size for testing
                • Time for action – modifying the HTML5 output
                • The storage for our data
                • Time for action – creating the data structure
                • Setting up the game objects
                  • Slice over slice—game layers
                • Time for action – creating layers for the game
                  • The second-most important part—a title screen
                • Time for action – creating the title screen
                • Detailing the OnCreate event
                • Time for action – finalizing the OnCreate method
                • Some flexible methods for the update process
                  • Lads and gents… the main actor
                • Time for action – creating the player
                  • The level maps—loading the tiles
                • Time for action – loading the level tiles
                  • On your marks—starting a new game
                • Time for action – creating a StartNewGame method
                • Bring me up-to-date—detailing the OnUpdate event
                • Time for action – detailing the OnUpdate method
                • And action!—the engine class
                  • Move it… object updates
                • Time for action – updating each object
                  • Push push—checking for collisions
                • Time for action – detailing collision detection
                  • I can't see it anymore—the transition is finished!
                • Time for action – detailing the OnLayerTransition method
                • Creating a XNA app
                • Summary
                • Chapter 8: Game #7, Air Dogs 1942
                  • Frameworks and modules used
                  • No silver, no gold, but… our game resources!
                  • The game objects
                    • Layers
                    • The title screen
                    • Game background
                    • The player plane
                    • The enemy plane
                    • Bullets
                    • Clouds
                    • Info text
                    • Smoke particles
                    • Explosions
                  • The basic app structure
                  • Time for action – setting up the basic file structure
                  • Storing data
                  • Time for action – creating the data structure
                  • First changes to the OnCreate event
                  • Time for action – first changes to the OnCreate method
                  • Setting up the game objects
                    • Making some noise… sound effects!
                  • Time for action – loading the game sound effects
                    • Lay your head on me… the game layers
                  • Time for action – creating layers for the game
                    • Over high ground—the background screen
                  • Time for action – composing the background screen
                    • Hope it won't rain—creating the clouds
                  • Time for action – creating the clouds
                    • What is going on?—creating info text objects
                  • Time for action – creating info text objects
                    • What are we playing here?—The title/menu screen
                  • Time for action – creating the title screen
                  • Finalizing the OnCreate event
                  • Time for action – finalizing the OnCreate method
                  • Methods for the update process
                    • The hero—spawning the player plane
                  • Time for action – spawning the player plane
                    • Spawning an enemy
                  • Time for action – spawning an enemy plane
                    • Starting a new game
                  • Time for action – creating a StartNewGame method
                  • Detailing the OnUpdate event
                  • Time for action – detailing the OnUpdate method
                  • Making it look nicer—some particle effects
                    • Emitting smoke
                  • Time for action – emitting the smoke
                    • Boom!—Emitting explosions
                  • Time for action – creating the explosion
                    • Pow!—spawning a shot
                  • Time for action – spawning a shot
                  • The brain—Computer AI (Artificial Intelligence)
                    • Follow him!—creating a brain for the enemy pilot
                  • Time for action – following the player
                  • The heart of the game—the engine class
                    • Time management—acting on object timer events
                  • Time for action – enhancing the OnObjectTimer method
                    • It is gone!—a transition is done
                  • Time for action – detailing the OnObjectTransition method
                    • Controlling the player plane—acting on object update events
                  • Time for action – acting on object update events
                    • Hit it!—handling collision response
                  • Time for action – detailing the collision response
                    • Did I win?—layer update events
                  • Time for action – acting of layer update events
                  • Creating a GLFW app
                  • Summary
                  • Chapter 9: Game #8, Treasure Chest
                    • Frameworks and modules used
                    • Reusing code
                    • The parts of the game... resources
                    • And here they are… the game objects!
                      • Layers
                      • Our precious title screen
                      • A menu screen
                      • The "high-score" screen
                      • A game background
                      • The worthy gems
                      • The gem selector
                      • Particle effects
                    • Preparation… the basic app and project structure
                    • Time for action – creating the basic file structure
                    • Creating 2D arrays
                    • Time for action – creating 2D arrays
                    • Storing information… the data storage
                    • Time for action – creating the data structure
                    • First changes to the OnCreate event
                    • Time for action – first changes to the OnCreate method
                    • About the OnRender event
                    • Setting up the game objects
                      • Klick, bang, swoosh… the sound effects!
                    • Time for action – loading the game sound effects
                      • Lay your head on me…. the game layers
                    • Time for action – creating layers for the game
                      • Our beloved play field—the background screen
                    • Time for action – composing the background screen
                      • Give it a name… the title screen
                    • Time for action – creating the title screen
                      • Game over… creating the "game over" screen
                    • Time for action – creating the "game over" screen
                    • The menu please… creating the menu screen
                      • Buttons … I need more text buttons!
                    • Time for action – creating text buttons
                      • The menu screen
                    • Time for action – creating the menu screen
                      • What is the score?… creating the high-score screen
                    • Time for action – creating the score screen
                      • Layer activation
                    • Time for action – creating the activate layer method
                    • Finalizing the OnCreate event
                    • Time for action – finalizing the OnCreate method
                    • Dealing with the high-score list
                      • Loading and saving the list
                    • Time for action – loading and saving the high-score list
                      • Showing the high-score screen
                    • Time for action – showing the high-score list
                    • Managing the tile map
                      • Getting tile map slot IDs
                    • Time for action – getting tile slot IDs
                      • Setting tile map slot IDs
                    • Time for action – setting a tile slot ID
                    • Check/mark the neighboring tiles
                    • Time for action – checking neighboring horizontal tiles
                    • Time for action – check neighboring vertical tiles
                      • Clearing tiles
                    • Time for action – clearing the tile map
                      • Counting matching tiles
                    • Time for action – counting matching tiles
                      • The precious one… creating a gem
                    • Time for action – creating a gem
                      • Refilling the tile map
                    • Time for action – refilling the tile map
                    • Methods for the update process
                      • Starting a new game
                    • Time for action – creating a StartNewGame method
                      • Give me some information… displaying info
                    • Time for action – updating the text info
                      • Showing the "game over" screen
                    • Time for action – showing the 'game over' screen
                      • Showing the menu screen
                    • Time for action – showing the menu
                    • Bring me up-to-date—detailing the OnUpdate event
                    • Time for action – detailing the OnUpdate method
                    • Vroom… vroom—the engine class
                    • Eye candy—particle effects
                    • Time for action – spawning an explosion
                      • Tick tock… acting on object timer events
                    • Time for action – acting on object timer events
                      • Touch me—acting on Touch checks
                    • Time for action – enhancing the OnObjectTouch method
                      • We've reached our parking position… a transition is done
                    • Time for action – detailing the OnObjectTransition method
                      • What's the situation?… layer update events
                    • Time for action – acting on layer update events
                    • Summary
                    • Chapter 10: Make Some Money for Bananas
                      • Which markets exist for your game?
                        • iOS
                        • OSX
                        • Android
                        • XNA
                        • HTML5/FLASH
                      • Existing methods of making money
                        • Selling your game at a fixed price
                        • Subscriptions
                        • Advertisement
                        • In-App purchases
                      • Implementing advertising in your app
                        • Which ad providers exist?
                        • Implementing AdMob
                          • iOS
                          • Android
                      • Implementing MobFox in iOS
                        • Signing up at MobFox
                        • Creating the ID for an iOS app in MobFox
                      • Time for action – creating a new MobFox app ID
                        • Implementing MobFox into your XCODE project
                      • Time for action – adding the MobFox framework to the XCODE project
                        • Displaying MobFox ads in the app
                      • Time for action – modifying the code to display ads
                        • Activating real ads
                    • Implementing MobFox in Android
                      • Creating the ID for an Android app in MobFox
                    • Time for action – creating a new MobFox app ID
                      • Implement MobFox into your Android project
                    • Time for action – modifying the project to display ads in Android
                      • Adding a backfill through InMobi
                        • Signing up at InMobi
                        • Create an Android app in InMobi
                    • Time for action – creating an app ID in InMobi
                      • Setting the backfill option in MobFox
                    • Time for action – add a backfill in MobFox
                    • Publishing in the Android market
                      • Create app icons
                      • Change the app label and the package name
                      • Setting the version code and name
                      • Rename the app package
                      • Remove the debug key from the package
                      • Create a private key to sign the app with
                      • Sign the package with your new private key
                      • Zipalign your app package
                    • Publishing in Apple's App Store
                      • Add the app icons
                    • Time for action – adding an icon to the Xcode project
                    • Time for action – setting the product name in the target settings
                      • Set the distribution code signing profile
                    • Time for action – setting the distribution code signing profile
                      • Create a package to submit
                    • Time for action – creating the app package
                    • Summary

                      Michael Hartlef

                      Being into game development for a long long time, Michael Hartlef started in 1984 at the early age of 18 with this great hobby called developing computer games on the Commodore C64. Following this machine, he worked on most well know computers like the Amiga 1000 and 500, the Atari 1024 STFm and of course various PC's. These days it is mostly his IMac that he uses. Over the years, he developed a great knowledge about general and specific concepts for developing games and worked with a various range of game development tools/programming languages like thinBasic, Delphi, 3D GameStudio, Blitz3D, BlitzMax, DarkBasic Pro, App Game Kit (AGK), Corona ® SDK and of course Monkey! Besides working on games, Michael has developed various add ons for these tools like command library extensions and programming editors. At day Michael works for an utility company where he maintains the billing system (SAP IS-U). Michael is also the founder of an independent game developer startup called Whitesky Games (http://www.whiteskygames.com). There he spends a lot of his spare time working on game development tools (IndeED), addons and games for friends, clients and his own projects.
                      Sorry, we don't have any reviews for this title yet.

                      Code Downloads

                      Download the code and support files for this book.


                      Submit Errata

                      Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


                      Errata

                      - 1 submitted: last submission 15 May 2014

                      Errata type: Code | Page number: 49

                      Numbered bullet 6 has code:

                      Method GameOver_Int()

                      It should be:

                      Method GameOver:Int()

                      Sample chapters

                      You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

                      Frequently bought together

                      Monkey Game Development: Beginner's Guide +    Getting Started with Oracle Data Integrator 11g: A Hands-On Tutorial =
                      50% Off
                      the second eBook
                      Price for both: £29.05

                      Buy both these recommended eBooks together and get 50% off the cheapest eBook.

                      What you will learn from this book

                      • Implement collision detection and optimize it for mobile devices
                      • Handle game controls via touch, keyboard, mouse and accelerometer input
                      • Load and playback sound effects and music
                      • Sign your applications and publish them to different markets
                      • Use 3rd party modules like the fantomEngine game framework to speed up your game development process
                      • Store the data of your different game objects effectively in lists, stacks and classes
                      • Structure your monkey script into separate objects and files so your code is better maintainable
                      • Save and load application states and load level data from text files

                       

                      In Detail

                      Monkey is a programming language and toolset that allows its user to develop modern 2D games easily for mobile and other platforms like iOS, Android, HTML5, FLASH, OSX, Windows and XNA. With Monkey you can create best selling games in a matter of weeks, instead of months.

                      Monkey Game Development Beginner's Guide provides easy-to-follow step by step instructions on how to create eight different 2D games and how to deploy them to various platforms and markets.

                      Learning about the structure of Monkey and how everything works together you will quickly create eight classical games and publish them to the modern app markets. Throughout the book you will learn important game development techniques like collision detection, handling player input with mouse, keyboard or touch events and creating challenging computer AI. The author explains how to emit particle effects, play sound and music files, use sprite sheets, load or save high-score tables and handle different device resolutions. Finally you will learn how to monetize your games so you can generate revenue.

                      Approach

                      The first two chapters will provide you with grounding in Monkey. In each subsequent chapter you will create a complete game deployable to either iOS, Android, HTML5, FLASH, OSX, Windows and XNA. The last chapter will show you how to monetize the games so you can be commercially successful in the app development world.

                      Who this book is for

                      Do you want to quickly create games deployable to all the major desktop and mobile platforms?, if so look no further. You will learn how to utilize the highly versatile Monkey compiler to create 2d games deployable almost anywhere.

                      Code Download and Errata
                      Packt Anytime, Anywhere
                      Register Books
                      Print Upgrades
                      eBook Downloads
                      Video Support
                      Contact Us
                      Awards Voting Nominations Previous Winners
                      Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
                      Resources
                      Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software