Corona SDK provides methods of sending data to a server via Lua sockets. It can use GET and POST
just as well, leaving it up to the developer to make the final decision. In addition to sending data,
retrieving the server generated response is convenient when it’s encoded in JSON format.

An example of a GET and POST request looks like this:
local query = "id=1&game=3&score=100"
local query2 = "id=1&game=2&score=100"
local serverUrl = "http://mygame.com/index.php/savescore/"

If the server responds with a JSON format, just use json.decode()
on the response body:
local asJsonG = json.decode(body)

For the server side, we will use a simple PHP framework, accurately named Slim. Being a micro framework, it does just enough to get boilerplate code out of the way and allows us to define routes and handler functions as callables.
Example code presumes PHP >= 5.3 is used. We take advantage of anonymous functions and ‘use’ keyword for scope manipulation. In addition to the web framework, we use PHP Doctrine ORM as our database abstraction layer. It provides us with and object relation mapper and active record type system to access the database – MySQL in this instance.

Checklist:

Check that your hosts file has the domain defined

Check that Apache has the virtual host entry defined

Check that there is a .htaccess file in the same directory as index.php file

Check that the host name you chose and the host name inside the Corona application match

Check that the credentials for the database inside bootstrap.php match

Nice to have – use mod_rewrite to hide away the index.php from the URL

Request lifecycle
As soon as above Lua code is executed, an HTTP request is sent to the server. Slim PHP framework will parse the parameters and allow us to handle them according to application logic. First entry point in this example happens inside index.php, which simply loads the bootstrap.php file from the parent directory. The boostrap files and any other non publicly accessible files are hidden outside of the Apache document root for a reason. As soon as the application bootstrapping begins, we load the Slim framework, Doctrine, create a database connection and load our models.

Models and database:
We have three tables in this sample application: user, score, game. We will allow one score per game, where game is treated more like a level inside a game. Table relations allow for a user to have one high score per game. Score table will hold the user id, game id and the high score. Game table holds ids and names of our levels and User will contain the
user id and name. Three PHP files are created by hand, to match this structure on Doctrine side. This will allow us to manipulate the tables using Doctrine object or query model. These three files are located inside the models directory.

Saving and retrieving data from database:
To retrieve data from database, point your application to http://YOURDOMAIN/index.php/testdb/ inside the browser. Slim framework will dispatch the matching callable, in this case the GET handler on line 11 inside routes.php. On line 16, we get all users using this piece of code $users = Doctrine_Core::getTable('User')->findAll(); Iterating over the result is as simple as using a foreach loop. On line 19, we can check of the User object has any scores associated to it: if( count($user->Scores) ), if so – we can loop over these and retrieve them further. This can be streamlined by using a leftJoin method, left out on purpose to show the relation flow between the tables.

PHP handler for Lua request:
On line 31, we have a Slim handler that will be dispatched when /savescore/ URL path is requested. It will answer to GET and POST request in the same way, because we used a generic route mapper $app->map('/savescore/' and defined the HTTP methods inside the ->via('GET', 'POST') section. Parameters are extracted from either type of request and passed on to function that handles saving the score using Doctrine object notation. In case of an exception, we return the unfiltered message back to Corona application.

]]>https://arekzb.wordpress.com/2012/04/27/corona-sdk-saving-player-score-on-server-using-php/feed/0arekzbCorona SDK – build automationhttps://arekzb.wordpress.com/2011/10/03/corona-sdk-build-automation/
https://arekzb.wordpress.com/2011/10/03/corona-sdk-build-automation/#commentsMon, 03 Oct 2011 12:45:53 +0000http://arekzb.wordpress.com/?p=47In my experience, Corona SDK build process has been a source of pain. It feels like it has been an afterthought thrown in on top of the authorization and remote build system. For those that don’t know, building the code takes place on Ansca’s servers and the process follows something along the lines of:

Repeat builds do save some time by remembering typed in values, but it’s a far cry from a one click build I would like have. Ideally, the application should be launched on the device at the end of the sequence.

To achieve this, I had to resort to using SikuliGUI automation and little bit of Python scripting. Following gist contains the code: https://gist.github.com/1257755 . Variables in the beginning point to the location of your project, terminal application and so on. Application specific data like name and version should be set there as well. The script will use Android adb tool to install and run the application at the end.

Paths inside the script are OSX specific, but changing them to work on Windows should be very easy.

The initial news broke out on http://reddit.com with us making the script for overlaying The Squirrel on any website by the end of the day. What happened next was a rollercoaster of traffic and squirrel buzz. We had a 4,000 % traffic spike as a result of increased demand for Squirrel LOLs . Other websites have used our image crop, located here http://zenebo.com/images/squirrel.png or simply followed suit in joining this fun activity of Photo Bombing a website.

Overall, we are happy to provide a few laughs and please remember to watch out for squirrels when you set that photo camera on a timer and strike a pose.

]]>https://arekzb.wordpress.com/2009/08/14/return-of-the-banff-squirrel/feed/0arekzbEsenthel Enginehttps://arekzb.wordpress.com/2009/07/13/esenthel-engine/
https://arekzb.wordpress.com/2009/07/13/esenthel-engine/#commentsTue, 14 Jul 2009 03:37:42 +0000http://www.zenebo.com/word/?p=19Esenthel is an overachieving project that delivers a punch with minor developer effort. After trying out many game engines and rendering engines, I have learned to approach each with a certain grain of skepticism. Not because of the lackluster quality of most cheap, err. free engines. It’s a defense mechanism we engage in when learning principles of 3D, game development and overall story boarding is paramount to propping up a limping or incomplete development environment.

I have to say , with utmost respect , that it is by far one of my favorite pieces of software I have tried this year.

It delivers on most promises, encourages code centric, instead of drag-and-drop development and does it with ease.

I am getting ready to deliver a small demonstration game and post the code live.

One of the benchmarks at the computer languages game requires that a program parse a ‘stdin’ redirected input of these FASTA formated sequences and print the content of the sequence in reverse order. Each character in the sequence should also be complemented according to this translation table:

code meaning complement
A A T
C C G
G G C
T/U T A
M A or C K
R A or G Y
W A or T W
S C or G S
Y C or T R
K G or T M
V A or C or G B
H A or C or T D
D A or G or T H
B C or G or T V
N G or A or T or C N

Headers

Each sequence contains a header with an id and description. These lines are printed ‘as is’ .

Challenges

String reversal

Translation table substitution

Input handling and memory allocation

String Reversal

Sequences are reversed using a bitwise XOR and without using a temporary character or string buffers.

Operations are performed in a loop where forward is the first index and end is the last index in the sequence.

A small character array of complement values is created and accessed with the integer value of the source character matching to arrays index. For example:

buffer[end]=FtoCOMP[buffer[end]];

Buffer at index end will receive a character at index ‘buffer[end]‘ from translation table array FtoCOMP. Index ‘buffer[end]’ translated to an integer , will point to a desired complement . This speeds up the process of substitution and allows for very fast array index notation.

Input handling

The requirement to handle input one line at a time corresponds quite well to the translation procedure. In pseudo-code,

process one line at a time

for each sequence , print header line, reverse the sequence, translate it into its complement and print it out

Only one buffer is used as a destination for reading input. Beginning pointer where each line is placed is dictated by moving a pointer through a character array. Once a line is read in, we check if it is the last line in a sequence by peeking into the input stream. If it is , it is processed according to above instructions and beginning pointer where the next line is placed is reset to 0.

These functions are called for each line N in the input stream:

fgets_unlocked, fgetc_unlocked.

These functions are called for each line that’s not a header line:

ungetc, strlen.

Other functions are called only at the end of a sequence and do not approach N runtime. This version written in C language has been compiled and tested using kernel 2.6.24 with GCC 4.2.3 .

]]>https://arekzb.wordpress.com/2008/05/08/reverse-complement-of-fasta-bechmark/feed/0arekzbAtoi() or not to Atoi()https://arekzb.wordpress.com/2008/05/04/atoi-or-not-to-atoi/
https://arekzb.wordpress.com/2008/05/04/atoi-or-not-to-atoi/#commentsMon, 05 May 2008 03:14:06 +0000http://www.zenebo.com/word/?p=14Update: May 13th, 2008

My solution has been accepted and placed in the interesting alternative category. A bitter-sweet victory considering my program as tested by their standards is the fastest C language entry . It is still a small honor to be recognized and to know that my entry shaved off almost 30% off the next fastest C program.

Let’s see how the FASTA benchmark program stacks up in the next few days.

The computer language benchmarks game at http://shootout.alioth.debian.org/gp4/index.php matches up a fundamental processing task or algorithm in a variety of programming languages. One benchmark called ‘sumfile’ has the following requirements:

read integers from stdin, one line at a time

print the sum of those integers

It is based on this icon program:

procedure main(argv)

sum:=0

while(sum+:=read())

write (sum)

end

The C language entry topped at 6th and 7th place. Surprising as it was, a Java 6 version came in second with more than a second shaved off the total CPU running time.

The task for all of these is to read a flat file containing one integer per line, add the integer to the total and print out the sum at the end. Three versions of test files containing 1,000, 11,000 and 21,000 lines are used. While there could be more interesting ways to tackle this task, it’s trivial and simple demands warranted a quick look.

The fastest C program used these function calls per each line in the file:

fgets_unlocked() , atoi() and a += operator to sum up the total. It seems that either one of these functions could be improved on, but since line-by-line reading is a strict requirement thus leaving the atoi function open to critique.

This following function will return an integer given a string. It handles positive and negative number strings.

int matoi(char *c) {

int res = 0,n=1;

if(*c=='-'){n=-1;*c++;}

while (*c >= '0' && *c <= '9')

res = res * 10 + *c++ - '0';

return res*n;

}

When compared to the standard atoi() function and parsing 500,000 lines of integers, this version on a 2.4 GHz Core2Duo performed 60% better . It’s simplicity is also it’s weakness as the matoi() function is designed to handle proper input. Perfect for a situation where input is controlled.

Original benchmark entry was modified with timing capture and the addition of matoi() function. Header contains any previous entry owners and information.

]]>https://arekzb.wordpress.com/2008/05/04/atoi-or-not-to-atoi/feed/2arekzbLighttz – a simple and fast web serverhttps://arekzb.wordpress.com/2008/04/27/lighttz-a-simple-and-fast-web-server/
https://arekzb.wordpress.com/2008/04/27/lighttz-a-simple-and-fast-web-server/#commentsSun, 27 Apr 2008 23:59:15 +0000http://www.zenebo.com/word/?p=10Update : A naive implementation of using Lua 5.1 to generate a dynamic response has been added. This loads Lua, loads a Lua script and executes it. Retrieves the string response and returns it to the browser. Take a look below for a new additional download link.

Cheers

There are many well written , fast web servers around with full features for CGI , FastCGI , proxying and dynamic language support such as Ruby, PHP and Python. So what is Lighttz ? It’s a small HTTP server written in C , benchmarked against the big guns. It is by no means a replacement for the big four, and is mainly a testing showcase. For the sake of brevity, the comparison of the first benchmarks will compare the following web servers:

Apache/2.2.8-mpm-prefork

lighttpd/1.4.19

nginx/0.5.33

userver-0.6.0 – compiled and run with epoll support

lighttz/0.1 – libev epoll event model

Short summary and the configuration as tested is below. Please note that other event models such as select and poll are available under each server , but these were picked for the performance or wide use ( in case of Apache ) .

A small, microwebserver that’s mostly used for tests and benchmarks. Project is maintained at University of Waterloo.

Lighttz –

A short C program that simulates an HTTP server and handles the requests using Libev and epoll.

Test platform

Ubuntu 8.04 , Kernel 2.6.24-16 SMP , 2GB RAM, Core2Duo 2.4GHz

Benchmarking Client Program

ApacheBench . Command used:

ab -c1000 -n1000000 <host:port> . The test document index.html is a 357 byte static file. Lighttz did not use the static file, it sent out the exact same contents as index.html contained in a char array.

The above simulated 1000 concurrent clients making 1000000 requests .

Results

Each result is an average of three runs with one pre-warming run to let each server utilize the cache.

Hardware used, other running servers and operating systems will reflect different results. The tests were not run to define maximum performance for all solutions. Each application will apply a different level of stress on the server.

Who doesn’t like Pong ? A breakout hit of epic proportions, Pong has traversed a long and arduous path into our hearts.

The program is written in C++.Net and utilizes basic Windows GDI features to simulate a game of Pong.

Login

Once the program runs, it requires the user to login. Login process creates a flat binary file in the same directory as the executable.

The archive below has one pre-registered user:

Login:demo

Password:demo1!

Implementation

Core of the program is based around learning graphical user interface programming using C++.Net , expanding concepts of threading and communicating a managed application with an unmanaged dynamic link library file. The program loads a previously created unmanaged Win32 .dll file from the ReleaseDll directory.

The program does not attempt to adhere to actual rules of Pong nor does it try to play with intelligence. I like to win , what can I say

One of the interesting features of MSN Messenger is that you can see if a person is online and be able to look up their personal status . Some fields can be used to indicate a status such as : at work or at home

The task in this assignment is to write a server and a client that allows user to register with the server and see which other registered users are on .

Specification

A user will run the heythere client and connect to a heythere-server . Every N seconds, the server will send to the client a list of users that are currently registered and their status.

Client

The client first sends the user name to the server. The second message the client sends to the server is the location of the client . Other messages can be sent to the server. User can change their user name, the location and it may add a message tag .

Every time interval in seconds, the server will send a complete list of the currently logged on users. The client will print these out to stdout .

Each message has a strict format described as following:

First 3 characters describe the type of message the client is sending followed by a space and then the content of the message .

Location: usr

Hostname: loc

Message: tag

Server

Server is written to support up to 30 clients at a time. It uses select to multiplex between different clients. If the command-line arguments -t <time interval> are not given, the default value for the number of seconds between printing to the clients is 10 seconds . Information will be written on line per client in the following format:

<user name> <location> <message tag>

To handle client data, the server collects the information from all connected clients.