Even thought they say it was for a better gaming experience (which I do not argue, bigger screen is usually better for videogames), there’s something we have to consider: What is the imapct of this new resolution in indie games development?

Many games technologies let you to compile the game into different platforms including iOS  6. However when we talk about games, a difference in pixels makes a huge difference in the gameplay. This issue turns even more complicated when we talk about pixelart.

In our case, we have our game almost ready to be launched. However we cannot silence the several questions that come to our minds:

• How fast will development platform add the compatibility for this new device?
• Will X-Code be modified in order to compile with the new specs?
• Will Apple approve our apps if they’re not compatible with last iPhone resolution?
• Should we wait launch until the platform we are using add the support to this new device?
• Should we re-build the game in order to be fully compatible with all devices prior launch?

I think many developers are asking themselves the same thing. I just hope this is not turning into a lot of development hours just to keep our products in the Apple Store.

Edit: I’ve been looking through different forums and it seems there is a popular uncertainty across different platforms (Cocos 2d, Unity, Bennu GD). And even thought there are some patches to try in the iphone emulator, the response is generalized: we have to wait to see what happen.

This time we’re going to review the Singleton dessign pattern, and the different ways it can implemented in PHP.

The  objetive of the Singleton pattern is to ensure a class has only one instance, and provide a global point of access to it. This is useful when exactly one object is needed to coordinate actions across the system.

Note the distinction between a simple static instance of a class and a singleton: although a singleton can be implemented as a static instance, it can also be lazily constructed, requiring no memory or resources until needed.

Implementation

The most common implementation of this pattern is as follows:

class MyClass { 

  // singleton instance 
  private static $instance; 

  // private constructor function 
  // to prevent external instantiation 
  private __construct() { } 

  // getInstance method 
  public static function getInstance() { 

    if(!self::$instance) { 
      self::$instance = new self(); 
    } 

    return self::$instance; 

  } 

  //... 

}

The usage is pretty simple:

<?php
$instance = MyClass::getInstance();
?>

 PHP 5.3 get_called_class() implementation

Prior to PHP 5.3, inheriting Singleton classes had the problem that it always instantiated the super class. But now it is possible to write a completely self-contained Singleton base class in PHP 5.3 using the function get_called_class.

<?php 

abstract class Singleton { 

    protected function __construct() { 
    } 

    final public static function getInstance() { 
        static $aoInstance = array(); 

        $calledClassName = get_called_class(); 

        if (! isset ($aoInstance[$calledClassName])) { 
            $aoInstance[$calledClassName] = new $calledClassName(); 
        } 

        return $aoInstance[$calledClassName]; 
    } 

    final private function __clone() { 
    } 
} 

class DatabaseConnection extends Singleton { 

    protected $connection; 

    protected function __construct() { 
        // @todo Connect to the database 
    } 

    public function __destruct() { 
        // @todo Drop the connection to the database 
    } 
} 

$oDbConn = new DatabaseConnection();  // Fatal error 

$oDbConn = DatabaseConnection::getInstance();  // Returns single instance 
?>

 PHP 5.4 Traits Implementation

PHP 5.4 introduced Traits as a solution to the limitations of single inheritance. With Traits we can also implement Singletons as the following way:

<?php

trait singleton {    
    /**
     * private construct, generally defined by using class
     */
    //private function __construct() {}

    public static function getInstance() {
        static $_instance = NULL;
        $class = __CLASS__;
        return $_instance ?: $_instance = new $class;
    }

    public function __clone() {
        trigger_error('Cloning '.__CLASS__.' is not allowed.',E_USER_ERROR);
    }

    public function __wakeup() {
        trigger_error('Unserializing '.__CLASS__.' is not allowed.',E_USER_ERROR);
    }
}

/**
 * Example Usage
 */

class foo {
    use singleton;

    private function __construct() {
        $this->name = 'foo';
    }
}

class bar {
    use singleton;

    private function __construct() {
        $this->name = 'bar';
    }
}

$foo = foo::getInstance();
echo $foo->name;

$bar = bar::getInstance();
echo $bar->name;

Ta-Dah! we reviewed 3 different ways to implement the Singleton design pattern in PHP. Each one have it’s pros and cons, but it’s very interesting to see we have many alternatives supported in PHP to solve our problems in a standard way. Next time we’ll see how to implement other design patterns. Till then!

Related posts:

1. PHP Performance – Tip #2: Reduce the size of your PHP objects and be careful with static functions
2. PHP 5.4 Traits
3. The road to linxPHP 2: Namespaces

So lets get down to business and start taking of cache and how linxphp (the framework we are developing) implement this tool through SimpleCache.

I don’t think I should start taking about what is cache because I think it’s petty much obvious, instead let’s talk something more practical, how does it work:

Cache is basically a pool of processed information that you know you will re-use. So instead of re-processing that information, you just pick it up from cache and use it. In programming there are a lot of situations that may require different considerations but in essence that is how cache is usually implemented.

In PHP development we have several ways of caching things, but the most used are: file system, database and the server memory. Other dirty solutions may include cookies or session variables but that’s not something I wish to talk about.

Lets consider cache using memory. Implementing a memory cache system usually involves some of third party tools like memcache, memcached, APC, etc. At least, these are the most used ones. But again, we should consider different cases because each engine has different capabilities.

APC (Alternative PHP cache): Is widely used because it’s present in most of LAMP environments. It lets you cache compiled php code in memory shared by all php requests of the same server

Memcache or Memcached (checkout the difference): Is, maybe, the most used cache system worldwide. Implements a distributed memory cache system across a set of one or more servers. It does not cache compiled code but it’s extremely useful for caching data structures and PHP objects in a memcache server cluster.

File System: Is also largely used due to many shared hosting do not have memory caching features. So the principle is the same but using file system instead.  Is slower, of course, but is quite much cheaper regarding storage and yet quite effective. However you should take some considerations when using this type of cache because you have to control the TTL (Time to live) of each record cached, also you have to consider the way the structure is cached (serialized, json, etc).

If you are looking for a good library to implement different cache controls we recommend to use the one we develop for linxphp called simplecache, it has a main class that implements different cache engines which makes it quite versatile, you could take a look at github linxphp site

Lets see an example using LinxPHP simplecache:

//simple cache set up
$cache_config = array('engine'=>'memcache');
simplecache::config($cache_config);
$starttime = microtime(true);
echo 'Memory usage before: ' .  number_format(memory_get_usage()). ' bytes <br>';
//cache key creation
$key = md5('SELECT * FROM table limit 1000');
//look for the cached content using the key
$result = simplecache::fetch($key);
//if no cache is stored make the query. If cache exists it will not execute the query.
if(empty($result))
{
    $pdo = new PDO ("mysql:host=$host;dbname=$db","$usr","$pw");
    $statement = $pdo->query('SELECT * FROM table limit 1000');
    $result = $statement->fetchAll();
    //once having results from db, save cache using the key
    simplecache::store($key,$result,3600);
}
echo 'Process time: ' . (microtime(true)-$starttime) . ' ms <br>';
echo 'Memory usage after: ' .  number_format(memory_get_usage()). ' bytes <br>';
echo '<hr>';

Not Using Memcached

Memory usage before: 719,168 bytes

Process time: 0.067841053009033 seconds
Memory usage after: 27,326,432 bytes

Using Memcached

Memory usage before: 719,168 bytes

Process time: 0.24466109275818 seconds 
Memory usage after: 27,393,272 bytes

As we can see, it is stupidly faster since you don’t have to make the query. Imaging having queries much bigger and heavier than this and then multiply that for thousands page requests of your site and you will understand how the high traffic pages can manage such demand (besides infrastructure).

However, it’s easy to over-use cache. Since it’s a great tool, many times it’s used for caching things it shouldn’t be cached. I’ve seen many bad implementations of cache and let me tell you it can give you quite a lot of headaches.

Just use common sense and do not stick with the only technology you know, keep learning. Then you even can have more than one working together. That is the case, for example, of having memcache for caching processed information and having file system cache to store generated HTML. That way you not only avoid hitting database but also generating HTML.

Ok, there are much more about performance but having in mind these tips, you will be waking the right path in terms of performance.

Of course, any feedback you may have about any of these posts it will very welcome.

Related posts:

1. PHP Performance – Tip #3: Be careful with your loops
2. PHP Performance – Tip #2: Reduce the size of your PHP objects and be careful with static functions
3. PHP Performance – Tip #1: Control the memory usage of your scripts

So, continuing with the previous series of performance tips, today I’m going to talk about  the excessive use of loops. That means, before using a loop, just ask yourself 2 questions:

1) Do I really need it? 

Even though the question sounds stupid for a senior developer, you may get surprised about how much programmers use unnecessary loops.

2) Can I use a better way?

In programming there’s always a different way of doing something. Just consider the best of the options.

Not convinced enough? Take a look at these examples that correspond to the previous questions.

1) Try to avoid SQL queries within loops

Have you ever tried to make a SELECT  mysql query within a while? I sure more than one of us did or saw something like this before. Well, let me tell you that’s an example of how not to do things.

$qry = mysql_query('SELECT * FROM one_table');
while ($result = mysql_fetch_all($query)){
    $qry2 = mysql_query('SELECT * FROM other_table WHERE id = '.$result['id']);
}

This may work, yes. Could solve your problem?, yes. But you’re wasting resources. If you have some hundreds of visitors per day in your site, may be you never realized this is not optimized. But what if you make a paid ads campaign to your site and that number rises up to 2000 in a few hours?  Just pray the server goes fine.

So instead, use MySQL to work for you instead of PHP. Just use an INNER JON in something like this:

$qry = mysql_query('SELECT other_table.* FROM one_table INNER JOIN other_table ON one_table.id = other_table.id;');

The difference using these example in my localhost with two tables of about 100 records used the following:

First Example

Memory usage before: 630,632 bytes
Process time: 0.088531017303467 ms
Memory usage after: 631,840 bytes

Second Example

Memory usage before: 631,840 bytes
Process time: 0.022024869918823 ms
Memory usage after: 631,840 bytes

Conclusion

As we can see, the second example work about 4 times faster than the single query. Even considering it was executed using example data is extremely important when you are right to the edge in high demand traffic sites.

2) Consider using variables as reference

Other things to have in mind, is that if you’re modifying an array within the loop, you should use reference. That way you don’t have to duplicate the data structure while pocessing the loop. I mean:

Do this:

foreach($array1 as $key=>&$value){
    $value = $value . '_ modified';
}

Instead of:

foreach($array as $key=>$value){
    $array[$key] = $value . '_ modified';
}

Look at the “&” right before the variable $value. That means $value is the reference to the same position within the array and any change the variable suffers it will impact right into the array without duplicating the variable.

First Example:

Memory usage before: 6,489,680 bytes
Process time: 0.0018508434295654 ms
Memory usage after: 6,578,224 bytes

Second Example

Memory usage before: 6,578,224 bytes
Process time: 0.0066568851470947 ms
Memory usage after: 6,665,976 bytes

Conclusion:

The result is remarkable. The first example is like 6 times faster. So seriously consider using references when using foreachs

My Experience

Premature optimization IS NOT the root of all evil. Of course extremes are not good, but why not understanding the language you’re working on as deep as you can?. Consider the cost of having your business down because of not doing a good optimization. Just pay a little attention about how doing things and everything will go smoother.

Ok, that’s everything for This week, I hope you enjoyed the article. For the next one I will talk about the most needed tool when talking of web performance: Caching. Stay tuned

Related posts:

1. PHP Performance – Tip #2: Reduce the size of your PHP objects and be careful with static functions
2. PHP Performance – Tip #1: Control the memory usage of your scripts

Nothing much happened between 2005 and 2009, when Pixelatom was born. Basically it was the first two guys plus Lucas Zallio, a guy who loved video games too! It was time to start again with the adventure. We began with our developing routine (on our free time, as grown ups we had bills to pay now), but now Fenix was dead. But wait, a fenix (Spanish word for Phoenix) can not die, it is always reborn from its ashes: it was the turn for BennuGD.

Bennu is the Egyptian name for fire bird, still a phoenix. As such, the language remained mostly untouched in syntax, but got several changes in the architecture. So the adventure continued with Bennu.

Global Game Jam and HTML5

But it wasn’t our only game developing tool this time! With the growth of the internet, Flash became the most popular platform for web games, and then HTML5. One of us got a copy of Impact JS, a library to easily make Canvas and JavaScript games. At this point we were full time web developers, so the syntax was pretty familiar to us, and after several years without a finished game, we participated in the Global Game Jam 2011 with our SECOND finished game, this time made in 48 hours: Poor little T-Rex.

Poor little T-Rex, our first HTML5 game.

The premise for the 2011 Game Jam was “extinction”, and we got into 3rd place in our city! Poor little T-Rex is a very simple game, where you have to run and jump avoiding the meteor shower and the pits. Also, you have to collect coins. We tried to use as much pixelart as we could, but since several artist did the elements separately the result was not as uniform as we wished. However, we were very happy with the result, the game was fun!

Global Game Jam 2012

The next year (I mean, this year, 2012) we participated again in the Global Game Jam. We finished our game within the 48 hours and, despite not having finished between the first places, we liked the final result. We felt like we were using well known elements in our previous game (a simple side-scroll platform), and we thought that we should experiment a little with new stuff; after all, this is the main objective of the Global Game Jam! So our entry for the 2012 edition was Hydro Jumper.

Our second HTML5 game, Hydro Jumper.

The premise this year was a little more strange, since it was only a drawing of a snake eating itself called Ouroboros. The game is a little bit complicated at first, but it gets challenging once you start understanding it. Basically you are in a spaceship and you have an energy bar. While not orbiting a planet, you drain energy from there. Once you get into orbit, a second bar appears, this is the “planet resources” bar. While orbiting the planet you drain its resources, but your energy bar gets filled slowly. Once you spot another planet, you must click on the screen when you feel like you can make a jump into the other planet orbit. This jump must be precise, otherwise you’ll crash into the planet, or you’ll not catch the gravity pull and then you’ll be sent into the emptiness of space.

Another point is that you can not stay too long in a planet. Once its resources are empty, the planet will explode and the game will end.

Well, that’s it for today. Remember that comments of any kind are welcome (except Viagra pills, I really don’t need that). In the next post I’ll get into our very first iOS game, made with BennuGD. Also, I’ll make a simple introduction about this multi-platform language, so you can make your own games with it.

Cheers!

Related posts:

1. Pixelatom video games I

One of the objectives of the version 2  is to adopt a series of recommendations proposed by The Framework Interop Group  (formerly known as the ‘PHP Standards Group’), in an effort to adhere to a common code style to make it easy for developers to use linxPHP with various other libraries for their projects, or even individual modules or linxPHP classes without needing to include the whole framework.

The first step is to adhere to the first recommendation, known as PSR-0, which aims to provide a standard file, class and namespace convention to allow plug-and-play code.

So one of the big changes in the next version is the inclusion of PHP Namespaces, all classes will have as top-level namespace  ”linxphp”, and all of our modules will have a separate namespace, for example, the class FileCache will be under the namespace linxphp\Cache, the class Model would be under linxphp\Models and so on.

The requirements of the PSR-0 also  defines a set of rules for class autoloading:

• Each namespace separator is converted to a DIRECTORY_SEPARATOR when loading from the file system.
• Each “_” character in the CLASS NAME is converted to a DIRECTORY_SEPARATOR. The “_” character has no special meaning in the namespace.
• The fully-qualified namespace and class is suffixed with “.php” when loading from the file system.

Below is an example function to demonstrate how the proposed standards would work with the PHP Autoload functionality:

<?php

function autoload($className)
{
    $className = ltrim($className, '\\');
    $fileName  = '';
    $namespace = '';
    if ($lastNsPos = strripos($className, '\\')) {
        $namespace = substr($className, 0, $lastNsPos);
        $className = substr($className, $lastNsPos + 1);
        $fileName  = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
    }
    $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';

    require $fileName;
}

We’ll, actually, make use of this implementation to follow the autoloader interoperability standards, in the recommended way to load PHP 5.1 classes:

• http://gist.github.com/221634

Which is a much better solution, because it uses the spl_autoload_register function (available since PHP 5.1), which allows to define different set of rules for autoloading depending on the implementation.

Below, an example of how to use the recommended implementation:

$classLoader = new SplClassLoader('Doctrine\Common', '/path/to/doctrine');
$classLoader->register();

This way 2 or more frameworks that follows these interoperability recommendations  can coexists in the same project, andwe want linxPHP to be one of them.

Until the next chapter of the road!

Related posts:

1. PHP 5.4 Traits
2. Linxphp and why I wrote another PHP framework

When using frameworks we usually see how easy and practical is adding useful functions and attributes to the controllers and/or to the models classes. However this is costly, specially setting attributes since these variables will make the object instance to be significantly bigger (in terms of memory consumption).

However, even though the functions you add to the PHP classes do not increase directly the memory usage of the instance, processor needs to compile every byte of that class and that cost memory.

So, consider to split the classes instead of having the mother of the controller and the grandfather of the models with every function related to the data processing. this way you can create separate clases that only be instantiated when needed instead of every time you want to execute a query.

Also, If you are dealing with huge arrays or huge objects and you have to pass them to a function, send the reference to the variable instead. This way the function won’t duplicate the variable in memory during execution.

One fun fact about working with objects is that static functions are less efficient than instantiating the class and calling the same method. Not sure why, but this is something to have in mind. Lets take this example:

class TestClass
{
   static function statictest($var){return $var;}
   function test($var) {return $var;}
}

echo '<strong>Static execution</strong><br>';
echo 'Memory usage before: ' .  number_format(memory_get_usage()). ' bytes <br>';
$starttime = microtime(true);

for ($i = 0; $i< 100000000; $i++)
   TestClass::statictest($i);

echo 'Process time: ' . (microtime(true)-$starttime) . ' ms <br>';
echo 'Memory usage after: ' .  number_format(memory_get_usage()). ' bytes <br>';
echo '<hr>';

echo '<strong>Instanced execution</strong><br>';
echo 'Memory usage before: ' .  number_format(memory_get_usage()). ' bytes <br>';
$starttime = microtime(true);

$obj = new TestClass();
for ($i = 0; $i< 100000000; $i++)
   $obj->test($i);

echo 'Process time: ' . (microtime(true)-$starttime) . ' ms <br>';
echo 'Memory usage after: ' .  number_format(memory_get_usage()). ' bytes <br>';
?>

This script outputs:

Static execution
Memory usage before: 634,256 bytes
Process time: 21.16055893898 ms
Memory usage after: 634,680 bytes

Instanced execution
Memory usage before: 634,680 bytes
Process time: 16.148050069809 ms
Memory usage after: 635,192 bytes

Instanced function was about 5 seconds faster using almost the same amount of memory! Funny huh?

Well that’s quite everything for this week. Stand by for the next tip, next week. As always, comments and feedback are welcome. Cheers!

Related posts:

1. PHP Performance – Tip #1: Control the memory usage of your scripts

Once one starts to work with Memcached in PHP quickly realises that there are two very similar, but yet different, names around the subject, and it takes time and a lot of reading to realize what are the differences between Memcache and Memcached, and what these words means.

Origins

Let’s start from our origins, initially we weren’t Pixelatom, but a small group of enthusiasts called AFSoft. This is, Arias and Fernandez, two of the current Pixelatom members. Under this name we started experimenting with an earlier DOS game programming environment called DIV Studio. We got a copy of DIV from a magazine and we really liked it. The year was 2001 if I remember correctly, and Javier Arias already made some progress writing a few small games (mainly shooters and a beat’em up). I’ll add a screenshot of one of those games later if I found one.

The problem with DIV Studio was that we needed a commercial license in order to publish games. As young students we didn’t had any money, let alone credit cards to buy a license from a Spanish company. Even worse, years later the company behind DIV disappeared! So what happened? Some guys started a similar project, with a free license to publish games: Project Fenix.

Battle City Remake

Under Fenix, we were able to continue our experiments, and decided to participate in a contest. As retro enthusiasts, we found about a Remakes community that organized yearly remakes contest: Retro Remakes. We got into the 2004 edition, and our entry, Battle City Remake got the 21th place!

A screenshot of our first finished game, Battle City Remake

Battle City Remake was, as you might guessed, a remake of the classic Namco game for the NES and Nintendo Vs. System, Battle City. Basically a one or two player coop game where you have to kill all 20 enemy tanks for every stage, taking care of not harming the base (marked with a quasi-eagle) trough 32 stages.

Graphics weren’t great, and we did mixed several techniques, but we were happy with the final result.

After that, our paths split for a few years, but we always kept our love for video game development. A few failed attempts here and there (that weren’t in vain, every small project gave us a lot of new knowledge!).

On the next post we will continue with our story as Pixelatom and our HTML5 games.

Until the next post!

When PHP finally implemented OOP in a decent way (PHP 5.1) I found that Multiple inheritance wasn’t allowed (I never fully understood why it’s said it’s a bad practice, I’ll let that to the Java boys) and I saw myself stuck in many situations where I needed it to do my classes the way I wanted to (interfaces are not actually the same, so can’t help some times).

So, that’s why I got very happy when I knew PHP 5.4 implemented Traits.

Traits is a mechanism for code reuse in single inheritance languages such as PHP. A Trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies.

In fact, Traits allows to recover the missing functionality of multiple inheritance in a simplified way. It’s basically a group of methods and properties that can be appended to any class.

Reading the php docs I found some good examples of traits, one of them is a really nice implementation of singleton, and the second one is a perfect example of when Traits are helpful in a case difficult to resolve with inheritance.

I’m really looking forward to implement them in the next version of our framework linxphp, as I know they will be really helpful on our Controllers and ORM classes design.