We may earn an affiliate commission when you visit our partners.
J. A. Whye

Aimed at beginners, this video tutorial course will guide you through the creation of your own game for iOS or Android.

The  Solar2D framework used for this course is one of the most powerful 2D game engines available, and it's completely free so get started making your own games.

You Can Get Started, Right Now.

The videos can be viewed online and the sample code can be downloaded to your computer so you can follow along. Since it’s all online and all digital, you don’t have to wait, you can start finding out how to make your own game right now.

Read more

Aimed at beginners, this video tutorial course will guide you through the creation of your own game for iOS or Android.

The  Solar2D framework used for this course is one of the most powerful 2D game engines available, and it's completely free so get started making your own games.

You Can Get Started, Right Now.

The videos can be viewed online and the sample code can be downloaded to your computer so you can follow along. Since it’s all online and all digital, you don’t have to wait, you can start finding out how to make your own game right now.

Play games other people make, or finally take control and make your own games.

"You got me up to speed in record time and my first game should be out in 4-6 weeks time. Congrats on an awesome course." - Tim Buchalka

Imagine how it will feel when people around the world download and play what you’ve created.

Enroll now

What's inside

Syllabus

Intro
Read Me First!
What You'll Discover
Getting Ready
Read more
Installing the Corona SDK Framework
Installing the Outlaw IDE
If you're using Outlaw to write the code for the course (or for your own projects), here's a video that should get you up and running fairly quickly.
Downloading the Sample Code
Lua Boot Camp

Corona SDK isn’t a programming language, it’s a framework. A bunch of “library routines” that take care of stuff under the hood (displaying graphics, playing sounds, etc.). But we still need a programming language to write our game code and call those framework routines.

Corona SDK uses the Lua language (lua means moon in Portuguese). I’ve been programming since the mid-80s but never even looked at Lua until I discovered Corona SDK. Now, after using it for about two years I don’t have any desire to use any other language.

This “Boot Camp” isn’t going to teach you everything you need to know about Lua, but it’s a great start. With these videos as a foundation you’ll be able to dive into the actual game dev videos much easier.

Note: No extra sample code for this section.

Variable can be thought of as containers for bits of information - numbers, letters and words, etc. This video shows you the basics of making and using variables in Lua.

Just a quick note — there are some reserved words in Lua that are NOT available for use as a variable name. Those are:

 and break do else elseif end
 false for function goto if in
 local nil not or repeat return
 then true until while

If you want to use one of those as a variable name, don’t. :)

Functions are chunks of code that can be "called" at any time during your program. Besides making it easier to code your game, functions are often reusable from one project to the next.
Tables are one of the most powerful parts of the Lua language. You can think of them as another type of variable - but a variable that can hold multiple pieces of data, not just one.
In this video you'll discover how to use if/then in order for the program to decide which code to run, and how to use loops in your code to run chunks of code multiple times in a row.
Discover how to create a function that allows you to pass all, some, or no parameters at all.
Not beginner info, but not rocket science, either -- and if you can wrap your mind around this concept it will really help your coding. Watch it now, or later after you've had more experience under your belt. 
Display and Animate Images
Putting images on the screen and moving them around — that’s the core of game development. In this first series of videos you’ll see how easy Corona SDK allows you to get that done.
Displaying an object on the screen is neat -- but when you make those things animate it's a whole new world!
If you want to display 50 lily pads, or 50 asteroids, or 50 jewels you can create 50 chunks of code. Or you can do what the pros do and create (and position, and use) multiple objects with just a few lines of code.
After watching this video you'll be able to trigger specific code after an animation has completed.
Touch and Tap Events
Taking a look at event-driven programming and how it can make our game easier to develop.
Let's attach a tap event listener to the Frog as well as give him a fancy spin.
Touch events have different phases - you can see when someone first touches an object, when they move their finger across the device, and even when they lift their finger up.
Besides just tapping and touching, a lot of times you want the player to be able to drag an object. This video shows how easily you can accomplish that.
Make Some Noise - Music and Sound FX

Whether it's pops, clicks, and whooshes, or a full orchestral score, audio is one big way to add polish to your game. While the whole area of audio can cover a lot of territory, to actually put a sound effect in your game requires two lines of code:

One to load it, and one to play it.

In this series of videos I'll show you how to do that -- and a whole lot more.

(Other videos for this section and sample code available Friday)

Playing longer audio files such as music is basically as easy as playing short audio files -- but there are some differences and tweaks you need to know about.

There is a short "sidebar" video after this one that *must* be viewed in order for the code shown in this video to work. Basically, it fixes changes that Corona Labs made to the framework since the original video was recorded.

This is a short "sidebar" video that *must* be viewed in order for the code shown in the previous video to work. Basically, it fixes changes that Corona Labs made to the framework since the original video was recorded.

You can specify certain sounds to be played on certain audio "channels" which gives you more control over the sounds in your game.
Here are a couple ways to reset an audio channel after you've faded the volume to zero.
Taking what we've learned so far in this section we add background music and a jumping sound effect to our sample game.
A bit of a "crash course" in how to tweak an audio file and make it fade out. This uses the Audacity software which is free for Windows, Mac, and Linux.

Not always necessary in game development, but it comes up more often than you might think.

Text as Display Objects

Once you create a text object you can manipulate it just as if it were a regular graphical object like a frog or lily pad.

Be sure to watch the “sidebar” video after this one to see how to handle the setReferencePoint() calls (as seen in this video) that are no longer valid in Corona SDK.

This video shows how to use anchorX and anchorY in the sample code instead of setReferencePoint(). This is a must view.

If the fonts on the device aren't good enough for you, see how to use a custom True Type Font in your game.
Now that we've seen how to create text objects, let's use that knowledge to add a scoring module to our game.
Saving and Loading Files

While it’s possible to create a mobile game without needing file I/O (input/output) it’s not likely. Whether you’re saving high scores or user preferences you’re probably going to need to write data to the “hard drive” and read it back.

In this section I’ll show you the guts of file I/O and then show you a “shortcut” you can use in the future. We’ll dive into using a 3rd-party library from Glitch Games to save and load data.

Here’s a link to a file guide on the Corona Labs site in case you want to dig into file I/O further: http://developer.coronalabs.com/content/files

The first 4 videos make use of the readingwriting.lua file in the sample code archive. Rename it as main.lua or give it an alias in Outlaw/Corona Project Manager.

Reading Data from a Text File - Pt 1
Reading Data from a Text File - Pt 2
Here's the Glitch Games github page: https://github.com/GlitchGames
Adding File I/O to the Froggy Game
Scene Management with Storyboard

Storyboard has now been sidelined in favor of a new scene management library called Composer. If you’re following this course from beginning-to-end, go ahead and do this Storyboard lesson — the concepts for both are the same, so switching from Storyboard to Composer at a later time will be very easy for you.

However, if you’re just kind of “cherry-picking” the course and doing the lessons that really interest you, skip this Storyboard lesson and do the Composer course instead. It’s included as part of this course.

Being able to switch from a main menu, to an options screen, to choosing a level, etc., are all part of scene management. Corona SDK gives us a way to handle that called Storyboard.

In a nutshell, you place your game code in scene templates and then tell storyboard which scene to go to next. And storyboard even gives you fancy transitions to use when moving from one scene to another.

If you want to see the official Storyboard docs, here's a link: http://docs.coronalabs.com/api/library/storyboard/index.html

The Storyboard library has now be deleted from Corona SDK. This section will still work, with just a little tweaking as I've now included the Storyboard library as an extra file. Read on...

In the videos I have some sample code called storyboard.lua, but the Storyboard library itself MUST be named storyboard.lua -- the file in the video is now called storyboard-sample.lua inside the project.

So if you remember that now you NEVER edit the storyboard.lua file, no matter what you see in the video, you should be able to go through the tutorial.

Understanding the Scene Template
Building a Storyboard App
Storyboarding Our Froggy Game
Sprite Animation

You've seen how to animate an object on the screen using transition.to() but that only moves the entire object. What if you have a man character and you want him to move his arms and legs while he walks across the screen? That's where sprite animation comes in.

In this series of videos you'll discover how to make a snake slither across the screen as well as give our frog a more realistic leap.

If you want to read up more, here's a link to a written tutorial on the Corona Labs site: Animated Sprites and Methods

Creating Image Sheets
Creating and Playing Sprite Sequences - Pt 1
Creating and Playing Sprite Sequences - Pt 2
Using Animated Sprites in the Frog Project
The Basics of Box2D Physics in Games
The physics engine behind such hits as Angry Birds, Tiny Wings, and Fantastic Contraptions is Box2D -- and that's the same physics engine that's inside Corona SDK. Yes, there's more to Angry Birds than just the physics, but you have the same engine available to you and your games.

Our Froggy sample game isn't really a physics-based game, so I took a little detour to show you how easy physics games can be. The sample code for raining frogs could be turned into a fun game.

We do add some physics to our main game as a way to use "collision-detection" -- or being able to see when one object hits another.

Creating Bounding Boxes for Physics Objects
Raining Frogs Game
Froggy's Collision Detection Pt 1
Froggy's Collision Detection Pt 2
Using Native Widgets
Widget Changes! (Important)

While most people think of widgets as only being useful for business-type apps, in this series of videos I’ll show you how they can be awesome additions to games, too.

Here’s a link to more info about widgets on the Corona Labs site: http://docs.coronalabs.com/api/library/widget/index.html

Checkboxes with Widgets
Level Selection with ScrollView
Adding Options to Froggy
Polishing Up the Frog Project

Have you reached this far? Cool! Because it means you’ve been exposed to enough coding info that you should be able to start writing your own (simple) games.

Notice I didn’t say you’ve learned, but you’ve at least been exposed. Sometimes we blank out while watching a video, or it’s on in the background and we hope it’s seeping in anyway. ;) Watching the videos more than once isn’t just a good idea, it’s almost a necessity (depending on whether you’re a complete newbie or not).

This section of the course is going to be a little different — the first video is a step-by-step look at creating different kind of levels for the Froggy game.

But after that I’m going to shake things up. I’m going to show you several different techniques I’ve used in the “real” Froggy game — the one submitted to the App Store. And most of those techniques are at least intermediate level.

I’m including them for two reasons. Number 1, to give you something to stretch for. These are techniques you’ll end up using (in one way or another) throughout your game development career/hobby. And number 2, you’ll be able to download the code for the real Froggy game and go through the actual source and grab those chunks of code for your own game. Some will be relevant, some won’t, but you’ll be able to start a “toolbox” of routines you can use over and over again.

Maybe your game needs to lock some levels and unlock them only after the player has finished the first levels. This video shows how that's handled in the Froggy game.
Instead of allowing the frog to jump across the screen, let's take a look at one method of keeping him to jumping just one lily pad away. (Note: this is an overview video, not line-by-line.)
Cool utility function you can use in lots of games. Scores, messages, etc., can slowly drift up (or down) and slowly fade from view. Complete walk-through with separate code download for this lesson.
Drifting Text Objects - Part 2
Discover how to create a "popup" type window using the Storyboard showOverlay() command.
Tracking how often your game is played, whether different areas of the app are even viewed, etc., are all ways you can know whether to add new features, how best to monetize your game, etc. Using the Analytics library in Corona SDK and the free Flurry service, this video will show you how easy tracking your game can be.
Bonus Goodies
Complete Froggy Game Source Code
Bonus Lecture: Free Courses For You

Save this course

Save Beginning Mobile Game Development with Solar2D to your list so you can find it easily later:
Save

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Beginning Mobile Game Development with Solar2D with these activities:
Review Lua Basics
Solidify your understanding of Lua syntax and programming concepts before diving into game development with Solar2D. This will make learning the framework much easier.
Show steps
  • Review Lua tutorials and documentation.
  • Practice writing simple Lua scripts.
  • Experiment with variables, functions, and tables.
Programming in Lua
Deepen your understanding of Lua with a comprehensive guide. This will enhance your ability to leverage Solar2D effectively.
Show steps
  • Read the chapters on tables and functions.
  • Work through the examples in the book.
  • Apply the concepts to your Solar2D projects.
Create a Simple Game Prototype
Apply your knowledge by building a basic game prototype using Solar2D. This hands-on experience will solidify your understanding of the framework.
Show steps
  • Design a simple game concept.
  • Implement basic game mechanics using Solar2D.
  • Add simple graphics and sound effects.
  • Test and refine your prototype.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Document Your Game Development Journey
Reinforce your learning by creating a blog or video series documenting your game development progress. This will help you articulate your understanding and share your knowledge with others.
Show steps
  • Choose a platform for your documentation.
  • Document your learning process and challenges.
  • Share your insights and code snippets.
  • Solicit feedback from other developers.
Explore Advanced Solar2D Features
Expand your skillset by following tutorials on advanced Solar2D features such as physics engines, networking, and monetization. This will prepare you for more complex game development projects.
Show steps
  • Identify advanced features you want to learn.
  • Find relevant tutorials and documentation.
  • Implement the features in your own projects.
  • Experiment with different configurations and settings.
Game Design Workshop
Improve your game design skills with a comprehensive workshop. This will help you create more engaging and enjoyable games using Solar2D.
Show steps
  • Read the chapters on game mechanics and level design.
  • Analyze successful games and identify their design principles.
  • Apply the concepts to your Solar2D projects.
Contribute to Solar2D Community Projects
Deepen your understanding of Solar2D by contributing to open-source projects. This will expose you to real-world development practices and allow you to collaborate with other developers.
Show steps
  • Find an open-source Solar2D project on GitHub.
  • Identify a bug or feature you can contribute.
  • Submit a pull request with your changes.
  • Respond to feedback from project maintainers.

Career center

Learners who complete Beginning Mobile Game Development with Solar2D will develop knowledge and skills that may be useful to these careers:
Mobile Game Developer
A mobile game developer is responsible for designing, developing, and testing games for mobile devices such as smartphones and tablets. This Beginning Mobile Game Development with Solar2D course is suitable for aspiring mobile game developers because it guides you through the creation of your own game for iOS or Android using the Solar2D framework. The course covers core concepts like displaying and animating images, handling touch events, incorporating music and sound effects, managing text, and saving/loading files. Learning to create a game from scratch with this course will provide valuable experience for a mobile game developer.
Independent Game Developer
An independent game developer works independently or as part of a small team to create and publish their own games. This Beginning Mobile Game Development with Solar2D course suits those interested in becoming independent game developers, as it focuses on teaching the fundamentals of game development using the free and powerful Solar2D framework. The course teaches how to display and animate images, handle user input, add sound effects and music, manage text, and save game data. The course also covers scene management, sprite animation, and physics, and can help independent developers manage the entire game development process from start to finish.
2D Game Developer
A 2D game developer specializes in creating games with two-dimensional graphics and gameplay. This Beginning Mobile Game Development with Solar2D course is a great starting point for aspiring 2D game developers, since the Solar2D framework is designed for 2D game development. The course provides hands-on experience with creating a game, so it is a practical learning experience. The course covers essential topics such as displaying and animating images, handling touch events, adding music and sound effects, working with text, and saving and loading files. A 2D game developer can learn the basics with this course.
Game Programmer
A game programmer writes the code that brings a game to life, implementing game mechanics, artificial intelligence, and user interfaces. The Beginning Mobile Game Development with Solar2D course is a great starting point for aspiring game programmers, as it introduces the fundamentals of game development using the Solar2D framework and the Lua programming language. The course covers displaying and animating images, handling touch events, incorporating music and sound effects, and managing game data. The practical experience gained in this course directly translates to the skills needed to be a game programmer.
Gameplay Programmer
A gameplay programmer focuses on implementing the interactive elements of a game, such as player controls, character movement, and game rules. This Beginning Mobile Game Development with Solar2D course is relevant to a gameplay programmer, as it provides a foundation in game development using the Solar2D framework. The course teaches how to handle touch events, implement physics, manage scenes, and create sprite animations, all of which are essential for creating engaging gameplay experiences. By taking this course, a gameplay programmer can learn the fundamentals of game development.
Game Designer
A game designer conceptualizes and designs the gameplay, rules, and structure of a game. The Beginning Mobile Game Development with Solar2D course can prove especially helpful because it provides a practical introduction to game development. While a game designer may not directly code, understanding the technical aspects of game creation, such as those taught in this course, is helpful in communicating designs effectively to developers. The course uses the Solar2D framework, which is a powerful 2D game engine, and covers topics like animating images, handling events, and incorporating sound. By learning the basics of game development with this course, a game designer can better appreciate the possibilities and limitations of mobile game development.
Indie Game Studio Founder
An indie game studio founder establishes and leads an independent game development company. This Beginning Mobile Game Development with Solar2D course is valuable for someone looking to found an indie game studio, as it provides a practical introduction to game development using the Solar2D framework. The course covers essential topics such as displaying and animating images, handling touch events, and incorporating sound effects. Developing and releasing a game enables the founder to navigate the game development lifecycle.
Mobile Application Developer
A mobile application developer creates software applications for mobile devices. This Beginning Mobile Game Development with Solar2D course may be useful, as it provides experience with the Solar2D framework and Lua. The course covers concepts such as event-driven programming, handling user input, and managing application assets. While the course focuses on game development, the skills acquired can be transferable to mobile application development as a mobile application developer. This course may serve as a foundation.
Unity Developer
A Unity developer uses the Unity game engine to create 2D and 3D games. A Unity developer may appreciate the Beginning Mobile Game Development with Solar2D course to learn additional skills. The course uses Solar2D, which is a 2D game engine, and covers concepts such as displaying images, handling user input, and managing game assets. By learning about a different game engine, a Unity developer can broaden their skills as a Unity developer and gain a new perspective on game development. The course provides a hands-on approach.
Software Engineer
A software engineer designs, develops, and tests software systems. A software engineer may find the Beginning Mobile Game Development with Solar2D course useful in understanding game development principles and practices. Learning a new framework, such as Solar2D, and a new language, such as Lua, provides a software engineer with experience. Even though the course is specific to game development, the problem-solving and coding skills gained are applicable to software engineering in general as a software engineer.
Technical Artist
A technical artist bridges the gap between artists and programmers in game development. This Beginning Mobile Game Development with Solar2D course may be useful, because it provides a technical understanding of game development. The course covers topics such as displaying and animating images, handling events, and implementing physics. By learning about these technical aspects of game development, a technical artist can communicate more effectively with programmers and artists as a technical artist. This course provides you with experience.
Game Development Instructor
A game development instructor teaches game development concepts and techniques to students or aspiring developers. This Beginning Mobile Game Development with Solar2D course may be useful for an instructor to learn alternative game development techniques. The course uses the Solar2D framework and covers topics such as displaying and animating images, handling user input, and managing game assets. By learning about a different game engine, a game development instructor can broaden their knowledge and enhance teaching abilities as a game development instructor.
Augmented Reality Developer
An augmented reality developer creates applications that overlay digital content onto the real world, often using mobile devices. This Beginning Mobile Game Development with Solar2D course may be helpful for aspiring augmented reality developers, as it provides a foundation in mobile development and game design principles. While the course focuses on 2D game development, the skills learned, such as handling user input, managing assets, and creating interactive experiences, are transferable to augmented reality development as an augmented reality developer. This course may prove insightful.
Virtual Reality Developer
A virtual reality developer creates immersive experiences for virtual reality platforms. This Beginning Mobile Game Development with Solar2D course may be helpful for virtual reality developers because it provides a foundation in game development and interactive design. The course covers topics such as displaying and animating images, handling user input, and creating interactive experiences. While virtual reality development involves additional considerations such as 3D graphics and spatial audio, the fundamental principles taught in this course are relevant to a virtual reality developer.
Simulation Developer
A simulation developer creates software that simulates real-world systems or processes for training, research, or entertainment purposes. The Beginning Mobile Game Development with Solar2D course may be useful for exploring different simulation concepts. The course uses the Solar2D framework and covers topics such as displaying and animating images, handling user input, and implementing physics. While simulation usually involves more complex algorithms, the skills gained in this course are transferable to simulation development.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Beginning Mobile Game Development with Solar2D.
Is the definitive guide to the Lua programming language. It provides a comprehensive overview of Lua's syntax, semantics, and features. It is particularly useful for understanding the underlying language used in Solar2D. This book valuable reference for both beginners and experienced programmers.
Provides a comprehensive guide to game design principles and practices. It covers topics such as game mechanics, level design, and player experience. While not specific to Solar2D, it offers valuable insights into creating engaging and fun games. This book is more valuable as additional reading to improve the overall quality of your games.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser