Case in point: Terry Paton.

Terry has been tinkering around with Corona SDK for a few weeks now. And just the other day, he put up videos of three games that he built with Corona (the free trial version too, if I’m not mistaken). Terry told us it took him a little under two weeks to build the games, adding that it was “not full time either.”

Terry followed the videos with his full thoughts on Corona, so go check those out too…

…And if you have something cool to show us like Terry, tell us on Twitter or e-mail!

Our latest App of the Week is the dating guide Fire Cupid, an exceptionally crafted eBook for the iPad and Android tablets.

Below, Josh from the Miss Pivot dating coach service elaborates on how he brought his vision for a truly interactive eBook using Corona SDK. If you read carefully, you might even be able to catch a hint or two at what may be in the Ansca pipeline…

Joshua Andrew Mitchell, Miss Pivot

The story of Fire Cupid started when my business partner, Kevin Emmons, and I, Josh Mitchell, decided we wanted to write and release a book on body language. A text-filled manuscript wasn’t an option though. We are both visual people and get tired of reading thousands of words. We knew our story had to be told in a modern medium.

Our idea was to write a book where our readers were able to interact and have fun while learning the science behind people’s undercover signals. The vision included a book with pictures, videos, and infographics — anything other than standard copy. We really wanted the first interactive book on body language to be able to breathe and come alive for readers.

Enter problem number one: we aren’t coders. In fact, no one at Miss Pivot is a coder. Sigh.

So, we dug in and started looking for a platform that would allow us to build an interactive book on iPad and Android Tablets because both devices are perfect mediums for rich media. Solution: Corona SDK! This program won out because it looked fast, simple and focused on more visual content than others we found.

We immediately started writing and creating. Lucky for us, our experience with JavaScipt and ActionScript helped, and we were able to push a prototype out within a week! It went quickly because every bug or glitch we ran into seemed to be magically fixed through Daily Build releases from Ansca. It was weird — weird enough that we’re pretty sure they had our office bugged… (editor’s note: Ansca Mobile does not comment on alleged office buggings)

Miss Pivot team

Seriously, though, we’ve continued to be impressed by Corona and its ability to deliver just what we needed.  This platform is exactly what non-coders need to achieve visual apps with a lot less work than you might think. We’re already working on the last two chapters of the book, and Corona’s new native video element is once again helping tremendously with our interaction plans.

Looking into the future, we’re considering publishing Fire Cupid to Macs and PC’s, and we know Corona just might be the perfect setup to make it happen!

And that’s where you came in!

The contest ended over the weekend, and we received a whopping 40 submissions from the Corona Community! We’re gonna have a lot of work to do in going thru all of these and picking a winner — but we will pick one very soon.

Thanks to everyone who submitted, and be sure to check back here for the winners announcement!

Oh, and you can now pre-order the book on Amazon.

If you’ve been paying close attention to the daily build logs, you probably noticed there have been several updates to the TableView widget since then. So for this week’s “Tutorial Tuesday”, I’ll be walking you through the creation one of the most commonly seen user-interface elements across all mobile apps: lists.

No matter what kind of app you’re developing, chances are good that one of these days, you’re going to need to display information in some kind of list. Thankfully, Corona’s TableView widget is perfectly suited for just that purpose! Our goal was to create a powerful, flexible widget that allows you to create lists of data—all while keeping simplicity and the developer experience in mind.

And although there may be some “tough spots” in terms of getting a really solid grasp on how to use it, I think we struck a good balance between ease-of-implementation and flexibility with the TableView widget.

Before you continue with the tutorial, please download the latest Daily Build to ensure you have access to all the necessary TableView features that we’ll be using.

The TableView widget is probably one of the most complicated widgets that are available, so this tutorial will be broken down into several sections that show you how to take advantage of each of its features. Each section will build off of the previous example before it. To get a more complete understanding of how to use the TableView widget, be sure to read all sections carefully, and in order.

Creating the Widget

This is the easiest part. We create the tableView widget and assign it to a variable called list using widget.newTableView(). If you cannot see the code below, go here to view it.

As you can see from the example above, we are creating a TableView with specific dimensions (in this case, 320×366) and have specified a PNG to use a mask for the TableView. It’s important to note that TableView widgets will not be clipped properly unless you specify a compatible mask file. Fortunately, masks are easy to create, and we have a separate tutorial dedicated to showing you how to create bitmap masks specifically for use with TableViews and ScrollViews.

Moving on, the example shown above is fairly minimal. There are several other parameters you can pass when creating the TableView widget. Please refer to the TableView API Documentation for a complete listing of these parameters.

Inserting and Deleting Rows

An empty TableView widget isn’t much use to us, so let’s insert a single row. Of course, the real benefit of using the TableView widget is having several rows, but we’ll take baby steps so things are easier to understand. Once we successfully create the row, we’ll remove it (just so you can see how it’s done). Please visit this page if you cannot see the code example below.

Once again, there are several other parameters associated with the insertRow() method, so consult the API documentation for a full listing. However, we’ll be using this function more in the following steps so you might want to wait a moment before exploring this API further.

onRender Listener

The most important parameter when inserting a row is the onRender parameter, because this is the function that will be called to create the row display object. By default, a row consists of only a background rectangle (accessed within the onRender listener via event.background) and a line (used to visually separate the row from others—accessed within the onRender listener via event.line).

When writing your onRender listener function, you should create any and all display objects you want your row to display. Whenever you create a display object, you must insert it into the event.view display group or it will not be rendered properly (and can potentially cause severe memory leaks in your app).

You can access the actual row object via event.row and the TableView that the row belongs to via event.parent. You can also assign references to your display objects to the row object if you need to access the objects from other rows, or elsewhere in your app.

All row objects are stored in the tableView.content.rows table, so in the case of our example, it would be list.content.rows.

Performance Advice

Depending on the amount of rows you have and how “heavy” they are in terms of what’s included, list scrolling performance can be greatly degraded (especially on device) if you’re not careful about optimizing what goes into each row (e.g. what you put into your onRender listener function).

Here are some “best practices” when it comes to creating your onRender listener function:

• Make your rows as “light” as possible by doing away with as many unnecessary elements as possible. If your app can possibly live without something in a TableView row, it’s best to just leave it out.
   
• Use as little vector shapes and text as possible. When using text, if it is predictable (and especially if it will be repeated in other rows), consider rasterizing the text to an image and use the image instead. Images can be cached in OpenGL while vector shapes and text cannot, so whenever possible, choose images over shapes and text.
   
• Avoid using gradients (created using graphics.newGradient() in row rendering) — once again, stick to images or avoid gradients altogether if at all possible.
   
• Avoid creating a new background for row, and instead take advantage of the already-created event.background if you need to change the row’s background color.
   
• If possible, break up your content into several different lists (perhaps via the TabBar widget?) if your app requires very long lists.
   
• If performance issues seem to only occur during really fast

Depending on your app and the kind (and amount) of data you need to display in a single TableView widget, you might find that performance is still not where you want it to be. For these cases, you might consider setting your app’s FPS to 30 (in config.lua) and see if that helps with TableView scrolling performance. You might also try adjusting the TableView friction and maxVelocity (set via parameters when calling widget.newTableView).

Adding Several Rows

Chances are, you’ll want to add more than a single row, but there’s also a good chance that many of your rows will resemble one another and have just a few differences. A great way to reduce the amount of code needed to add multiple row items is to place all your row creation code (which includes your onRender listener) in a for-loop and take advantage of event.index and event.id to differentiate between the different rows.

Here’s a revised version of the previous example (minus the deletion at the end), but this time it’ll insert 25 rows instead of just one (go here if you cannot see the code below):

Handling Row Touches

Now that you know how to to display information in a list using the TableView widget, it’s time to make your tableView content interactive by allowing it to respond to touches.

Row touches are handled via a separate listener which is specified via the listener parameter when you call tableView:insertRow(). This listener has several phases, which include: tap, press, swipeLeft, swipeRight, and release.

If you cannot see the code below, visit this page to view it.

Once again, the above example is a modified version of the previous example but with a few notable differences:

• The onRowTouch function has been added to serve as the row’s listener for user touches.
   
• In the onRender function, we create a reference to the text object (row.textObj) so the object can be accessed outside of the function (in the example, it is used in the onRowTouch function)
   
• The listener parameter is assigned a reference to the onRowTouch when we call the TableView’s insertRow() method.
   

The phases within the row’s listener function (touch, tap, swipeLeft, swipeRight, and release) are all fairly self-explanatory (and even more-so if you ran the example in the Corona Simulator), but there is one property that is used in the “release” phase that should be explained further.

When you set the reRender property to true, this tells the TableView to destroy the row and re-render it (per its onRender listener) on the next TableView update (which is very frequently). By setting row.reRender to true in the “release” phase, we are telling the row to go back to it’s original state before it was touched.

Category Items

Another great feature of the TableView widget is the ability to specify “category” rows, which are rendered (and behave) identically to other rows, with one exception: category items will “stick” to the top of the TableView widget when they are scrolled to the top, and will push other category items up (if there are any currently stuck).

To specify a row as a “category”, you simply set the isCategory parameter to true when you call the insertRow() method. Category rows have an additional property, isCategory, which is useful in differentiating category items from normal row items within your listener functions.

Additional Resources

And that concludes our tutorial! If you didn’t follow along during the tutorial, I recommend going through it at least one more time while typing the code in so you get a better understanding of how to use the widget.

Also, don’t forget to consult the (just updated) TableView API Reference for more information on all the different parameters, properties, and methods associated with the TableView widget and rows.

For a working example, please see the WidgetDemo located in: /SampleCode/Interface/WidgetDemo in the Corona SDK download.

As a reminder, the conventions used by this tutorial require the most recent TableView changes, so be sure to download the latest build for best results. If you’re a trial user, subscribe today so you can take advantage of the best of the TableView widget and other cutting-edge features being pushed in on a regular basis.

Since we’re all nerds here, Fire Cupid is an immeasurably useful app for us all. Creators Miss Pivot are a dating coach service out of Indianapolis, and have created Fire Cupid as a guide to, in their words, stop awkward dating. In Fire Cupid, you explore real-life examples and advice on getting over the initial hurdle of meeting that special someone. Oh, and the eBook is for both men and women — no objectifying Pick Up Artist stuff here!

Specifically, this inaugural volume of Fire Cupid is focused on body language and how to properly read it in your dating endeavors. Now, that sounds like it’d be really hard to explain in just words, right? Well, Fire Cupid features a motherlode of interactive quizzes and over an hour of original video content to make the learning  process that much easier. If you can’t attend one of Miss Pivot’s workshops all the way in Indy, this eBook is an awesome substitute to get the same kind of advisory awesomeness.

If you take away its relatively niche-based subject matter, Fire Cupid is an exemplary eBook in its construction. With interactive elements, checkpoint quizzes, and HD video, it’s a virtually perfect demonstration of how a textbook should be built for the iPad. Imagine if instructional books on dance, or martial arts, or even app-building included elements like those? It would make for a much more effective learning tool and, consequently, a much more learned reader.

Check out Fire Cupid on iPad and Android tablets now.
Oh, and be sure to let us know if you end up finding your soul mate!

Since then, we’ve added support for more Game Center features to the gameNetwork.request() API, so today I’ll give you an overview of what those are. Before you continue, don’t forget to grab the latest Daily Build to ensure your implementation is up-to-date. At the moment, standalone Game Center support is available to subscribers only.

NOTE: This blog will go over some of the APIs that haven’t previously been discussed (outside of the API documentation)—this is not a Game Center integration tutorial. For a walk-through on how to get Game Center working in your Corona app, please see the previously published Game Center integration tutorial.

The following gameNetwork “request” types have been made available as of Daily Build 2012.730.

loadPlayerPhoto

This request will load the specified user’s Game Center avatar and create a Corona display object for it.

Request example:

Going by the example shown above, the display object for the player’s avatar can be accessed from the requestCallback function via event.data (via the “photo” property). There are other important properties associated with this request, so before you implement this into your own app, be sure to take a look at the updated gameNetwork.request() documentation (scroll down to the “loadPlayerPhoto” section).

loadAchievementImage

This is similar to the loadPlayerPhoto request, but instead loads the image for a specified achievement. This is the same image you uploaded to iTunes Connect for the achievement, so be sure that the image you submitted is compatible with Corona (24-bit PNG files are your safest bet).

Request example:

As with loadPlayerPhoto, this request also creates a Corona display object, but instead it is accessed via the “image” property in the event.data table. Once again, see the gameNetwork.request() API documentation to see the full event table data.

Placeholder Images

The last two provide you with a Corona display object for Apple’s placeholder complete/incomplete achievement images:

• loadPlaceholderCompletedAchievementImage
• loadIncompleteAchievementImage

Returns the Apple-provided achievement images (complete/incomplete) in the form of a Corona display object (if you did not upload a custom one). The API for this is the same as loadAchievementImage but you do not specify specific achievement data (just a listener). The display object can be accessed from the “image” property of the event.data table in the callback listener you specified.

Other Requests

There are other requests, such as loadFriends, that are not shown in the sample code and were not covered in the previously published Game Center tutorial. These remaining requests are used in the same manner as the requests in the sample code and the tutorial, but return different properties in the event.data table. Please see the API documentation to see the exact properties that belong to event.data for the specific request you intend to make.

Once again, Game Center support in Corona is a subscribers-only feature for the time being, available through our exclusive Daily Builds program that each and every Corona subscriber has access to. If you’re ready to take your apps to the next level using the latest Corona features, to download the most recent build today.

Like it or not, an app’s ability to succeed and get people talking often relies on its looks. Unfortunately, not everyone is an awesome graphic artist, and a lot of indie developers out there can’t quite afford to hire one.

And that’s a problem!

But now, we have teamed up with Tapptics to bring you some excellent design lessons and graphics templates for your Corona apps. With Tapptics, you can now get a ‘Design Kit for Corona’ full of the following goodies to equip your app with aesthetic awesomeness:

Now (after nearly a year in the making) Fire Maple are ready to release their next puzzle/adventure epic, The Lost City, which FireChief Joe Kauffman told me is waaay more awesome and longer than Grisly Manor.

The Lost City is currently under review in the App Store — and I’m pretty sure you’ll see  it up here sometime in the near future.

Rares and Anamaria head up the Romanian-based New Mindflow studio. Much like your friendly neighborhood Carlos, they started out in the film-making world before heading over to app-making.

Below, they elaborate on their story of being film makers-turn-coders using Corona and our sidekick Kwik to make one of the best eBooks we’ve ever seen — Where’s Paradise?.

Rares Kovesdi + Anamaria Chioveanu, New Mindflow

After graduating from film school in 2008, we discovered mobile apps as a potentially great medium to distribute our work — especially to explore new possibilities for storytelling and new audiences. The two of us also met that year and it was clear to us from the beginning that we wanted to work together and be as independent as possible while doing so.

I had seen Steve Jobs’ keynote in which he introduced the iPhone SDK and App Store earlier that year, and I recognized it as a good opportunity to create and distribute our work outside the conventions of the established system. An opportunity that, most importantly, lets us be independent and focus on the creative part rather than the bureaucracy of getting a project funded — something which young film-makers often face.

After securing some funding from a friend, we started New Mindflow in 2009 with the idea of exploring games as a new medium to tell our stories and engage our audience in a way that isn’t yet possible with films. We had a couple of great projects and we were set on hiring graphic artists and developers to get them done. But after almost two-and-half years in which we had numerous setbacks and our high standards conflicted with our limited budget and the high costs of producing a great game, we re-founded the company in October 2011 to give commercial life to some of our artistic projects.

For now, New Mindflow is just the two of us, Rares Kovesdi and Anamaria Chioveanu. All of the content in our first app, Where’s Paradise? (film, photos, and text) is made by us, and we also designed the UI and did all the coding for development. By using Corona and Kwik, that last part was by far the shortest. Preparing the content and app design took almost a year, building the app with Corona and Kwik took less than two weeks!

Given our artistic background, we have no experience or training as coders. However, with Corona and Kwik we not only managed to produce an app that we are happy with and proud of, but more importantly the app is very stable and responsive — something that isn’t the case with a lot of interactive eBooks we’ve seen in the App Store.

Even though the app has yet to see any real success, the experience of making it was a great one for us. We got to make a film and put a “digital photo exhibition” together; I (Rares) got to realize my techie side and Anamaria got to rekindle her passion for drawing while making the map and app icon. But, most importantly, we have proven to ourselves that we can still continue to make the apps we want, even without outside funding.

For now, New Mindflow will be focusing on bringing to market some of our artistic projects, including an illustrated interactive storybook in the near-future. Nevertheless, we still have some game projects in development about which you can find out more by going to the Projects section of our website.

Getting back to the app, the Where’s Paradise? series puts side-by-side the western idea of paradise (small tropical islands with white sandy beaches and coconut groves) with the actual lives of the people that live in these often remote places. The first episode focuses on the island of Nusa Lembongan, 20km southeast of Bali.

We like to think of the app as a new kind of book; a new medium for presenting a film and exhibiting photos. A new way of seeing an artistic vision come to life!

To find out more about Where’s Paradise? (the apps and the overall long-term project) head over to our website.

Below is a presentation given by coding extraordinaire Seb Lee-Delisle at the Update 2011 conference in the UK late last year. We were humbled when we saw that Seb chose Corona SDK as his weapon of choice for his demo.

Be sure to let Seb know what you think on Twitter at @seb_ly.
Thanks for the awesome demo, Seb!