The haxe.unit package consists of only 4 classes:

• TestCase
• TestResult
• TestRunner
• TestStatus

Most of the time we need to use only 2 of them: TestCase and TestRunner. We subclass TestCase and put the test functions as class methods, and then create a TestRunner object to run one or multiple TestCase instances. I usually create one class for each class I want to test and create one test method for each of the methods.

For example we want to test the StringTools class in the top-level package of the Haxe std library. Here we wrote the test function for 2 methods, endsWith and hex:

class TestStringTools extends haxe.unit.TestCase {
	public function testEndsWith():Void {
		this.assertTrue(StringTools.endsWith("abcd", "cd"));
		this.assertFalse(StringTools.endsWith("abcde", "cd"));
	}
 
	public function testHex():Void {
		this.assertEquals("FFFFFF", StringTools.hex(0xFFFFFF, 6));
		this.assertEquals("000000", StringTools.hex(0, 6));
	}
 
	static function main():Void {
		var runner = new haxe.unit.TestRunner();
		runner.add(new TestStringTools());
		var success = runner.run();
 
		#if sys
		Sys.exit(success ? 0 : 1);
		#end
	}
}

As illustrated above, to check the return values of the function calls, there are 3 methods come from the TestCase class we can make use of:

• function assertTrue( b : Bool, ?c : PosInfos ) : Void;
• function assertFalse( b : Bool, ?c : PosInfos ) : Void;
• function assertEquals( expected : T, actual : T, ?c : PosInfos ) : Void;

They are self-explanatory. You may have noticed, they all accept an extra optional argument of type PosInfos, which is actually used for getting the method name, line number etc for printing the test result. We should simply ignore it and the compiler will automatically fill in the value.

Notice that the test methods have to be named with prefix “test”. We can create utility functions, without the “test” prefix, and they will be ignored by TestRunner.

To run the tests, we created a TestRunner in the main entry function. The main function can of course be put into another class, but since we’ve only one TestCase in this example, let’s just put it into our TestCase. When we call runner.run(), it will test all the TestCase objects that are added to the TestRunner, and immediately print the test result, which for our example, it would be:

Class: TestStringTools ..
OK 2 tests, 0 failed, 2 success

Lastly, based on the return value of runner.run(), which is “all tests success or not”, we exit the program properly as a best practice. It is used by many CI softwares, for example TravisCI, in order to get back the test result.

There exist more advanced unit testing frameworks, like munit and utest, but the structure and concept is somewhat similar. Anyway, writing unit test is easy and the benefit is huge: It will enables us to discover regression that may caused by refactoring, adding new features, changes in 3rd party library (or Haxe itself) as soon as possible. Let’s start doing it today if you haven’t!

The cool parts:

• Supports jQuery version 1.9.1/2.0.0! Note that 2.0.0 has the same API of 1.9.1, but removed support of IE 6,7,8.
• jQueryExtern is now generated from the official jQuery documentation in xml format. It means it will be updated faster, more accurate in the future!
• Fine grained configuration of the extern via… macros! e.g. Select specific jQuery support version, switching between the use of “$” or “jQuery” in generated code etc.
• Macro based Plugin extern system! Writing jQuery plugin extern is much easier.

You can find out the details at the github wiki page.

Processing is written in Java, and it plays very well with the Android platform. Every serious programmer knows that the Processing IDE is far from being a proper IDE, and the official Android IDE is Eclipse, so we better stick to Eclipse.

To setup a Processing Android project in Eclipse, follow these steps:

1. Setup a normal Eclipse Android project, such that we can run a simple hello world with a blank activity, targeting Android API 10+.
2. Download Processing 2.0+.
3. Copy android-core.zip to the libs folder as android-core.jar inside our Eclipse Android project.
   The location of android-core.zip is inside the Processing folder, modes/android/android-core.zip. For Mac, the Processing folder can be found by right-clicking Processing.app, show package contents, /Contents/Resources/Java.
4. Right-click the Eclipse Android project, properties. Choose Java Build Path, under the Libraries tab, click Add JARs… button. Choose the android-core.jar we’ve copied in previous step.
5. Modify the MainActivity class such that it extends processing.core.PApplet instead of android.app.Activity:

   package net.onthewings.android; //the package of MainActivity   import processing.core.*;   public class MainActivity extends PApplet { //PApplet in fact extends android.app.Activity public void setup() { /*...*/ }   public void draw() { /*...*/ } }

6. Run the project and you should see a blank full screen app

Notice that it is not even necessary to use additional Eclipse plug-in like proclipsing. By coding in plain Java, we can mix the Processing drawing API with the Android API easily. Additional Processing Android details can be found at http://wiki.processing.org/w/Android.

Vicker Leung

簡介幾個近期的新 products

- Apache Flex 4.9.1 (http://flex.apache.org)

- Adobe AIR SDK 3.6 (http://www.adobe.com/devnet/air/air-sdk-download.html)

另外分享左 FXG o係 Adobe Flex mobile app 開發的經驗

- Presentation Slide (http://www.slideshare.net/vickerleung/fxg-and-flex-mobile-development)

Travis-CI is “a hosted continuous integration service for the open source community”. It is tightly integrated with github, once we enabled its commit hook, whenever there is a new commit, or a pull request, on any branch, it will automatically build and run the unit test and notify us any problem respecting to certain commits.

Why use it?

It gives us an extra level of safety, which safety is what we Haxe users love, after all that’s one of the reasons to use a strictly typed language over a dynamic one. Travis-CI’s unit test on pull request is particularly useful, which we can instantly identify on the github pull request page any incoming changes that breaks our specification.

And did I mention this great hosted service is in fact free for open source projects?

How to use it?

All we have to do is to toggle the repo on in the Travis-CI accounts control panel, and then commit a .travis.yml in the root directory.

Here is an example .travis.yml that test C++, Neko and PHP targets:

# The first thing is to tell which VM environment we want the test to be run on.
# It dosen't quite matter for Haxe, just choose one of the targets our project support (e.g. PHP),
# and than apt-get install the others (e.g. Neko, C++).
# For more info, see http://about.travis-ci.org/docs/user/ci-environment/
language: php
 
# Install Haxe before running the test.
before_script:
  - sudo apt-get install python-software-properties -y # for the next command
  - sudo add-apt-repository ppa:eyecreate/haxe -y      # add the ubuntu ppa that contains haxe
  - sudo apt-get update                                # pull info from ppa
  - sudo apt-get install haxe -y                       # install haxe (and neko)
  - sudo apt-get install gcc-multilib g++-multilib -y  # VM is 64bit but hxcpp builds 32bit
  - mkdir ~/haxelib                                    # create a folder for installing haxelib
  - haxelib setup ~/haxelib
  - haxelib install hxcpp                              # install hxcpp to test C++ target
  - mkdir bin                                          # create an output folder if needed
 
# Run the test!
script:
  - haxe travis.hxml

Note that at the time of writing, Travis-CI is running 64bit Ubuntu 12.4 VMs, and the ppa we used above will install Haxe 3.0RC and Neko 2.0.

Every command specified in the “script” section is actual test and should exit with code 0 if it pass or non-0 if fail. The above example simply try to compile the project. We can specify subsequent command to run a Haxe written test case, which we can use Sys.exit(allPass ? 0 : 1) to properly inform the test result.

Finally, we can check the repo page on Travis-CI for the test result. By default, if the test failed, an email will be sent to the commit author and the committer.

Existing Haxe project using Travis-CI

Some Haxe projects have been using the Travis-CI service for some time, for example flambe, HaxePunk and Ash-HaXe. We will soon re-enabled the TravisCI test of NME too! Hope it will help Haxe to become more solid every day, every commit

1. Run project right after compilation

Being able to do so is critical to rapid development. The simple trick to use -cmd, which run the a command after successful compilation. For different target, you have to use different command:

• Neko

  -neko Test.n
  -main Test
  -cmd neko Test.n
  Or there is actually a shortcut that performs exactly the same as above:
  -x Test

• C++

  -cpp bin
  -main Test
  -cmd ./bin/Test
  Notice the resulting file will be Test-debug if you compile with -debug.

• JavaScript

  -js Test.js
  -main Test
  -cmd phantomjs Test.js
  Here we use phantomjs to run the JS file, the trace will output to the terminal. In case it is something graphical, you have to launch a browser with a HTML file that loads the script.

• PHP

  -php bin
  -main Test
  -cmd php bin/index.php
  I guess you have already know you can execute a php script this way?

• Flash

  -swf Test.swf
  -main Test
  -cmd path/to/FlashDebugger Test.swf
  Or if you're on Mac, you can actually use -cmd open Test.swf, it will do the same as you double clicked on a swf file (or any other file!).

• Java

  -java bin
  -main Test
  -cmd java -jar bin/bin.jar

• C#

  -cs bin
  -main Test
  -cmd mono bin/bin/bin.exe
  Mac/Linux has to use Mono to execute it. Windows should able to run it with -cmd bin/bin/bin.exe (not tested though).

2. Commenting a hxml file

Use a hash (i.e. #) to comment out the rest of the line. Despite of being useful to put documentation, it can let us switch between different compilation configurations:

-js Main.js
-main Main
### comment out one of the following logging levels
#-D my-log-error
#-D my-log-warning
-D my-log-info

And in the source file:

public function attack(target:Monster, power:Int):Void {
    if (target == null) {
        #if (my_log_error || my_log_warning || my_log_info)
        trace("target is null");
        #end
        return;
    }
    if (power <= 0) {
        #if (my_log_warning || my_log_info)
        trace("attack power should be positive");
        #end
        return;
    }
    mp -= power;
    target.hp -= power;
    #if my_log_info
    trace("attacked " + target + " by " + power);
    #end
}

3. Append extra compiler argument when using the command line

Another useful trick to switch between compilation configurations, is to simple supply more arguments after the hxml file. For example temporarily switch to debug mode:

haxe project.hxml -debug

4. Multiple compilations at once

The majority knows the existence of  --next, used for separating different builds:

all.hxml
-js script/MainPage.js
-main MainPage
-lib jQueryExtern
--next
-js script/ContactPage.js
-main ContactPage
-lib jQueryExtern
--next
-js script/AlbumPage.js
-main AlbumPage
-lib jQueryExtern

There is an --each option, which reduce the repeating params. It is used in the haxe compiler unit test hxml. Rewriting the above, we will get:

all.hxml
-lib jQueryExtern
--each
-js script/MainPage.js
-main MainPage
--next
-js script/ContactPage.js
-main ContactPage
--next
-js script/AlbumPage.js
-main AlbumPage

But really, separating each of them in different hxml is easier to maintain and has better compatibility with code completion (because many editors don't read hxml with --next very well). So we may use the following instead:

MainPage.hxml
-js script/MainPage.js
-main MainPage
-lib jQueryExtern

ContactPage.hxml
-js script/ContactPage.js
-main ContactPage
-lib jQueryExtern

AlbumPage.hxml
-js script/AlbumPage.js
-main AlbumPage
-lib jQueryExtern

all.hxml
MainPage.hxml
--next
ContactPage.hxml
--next
AlbumPage.hxml

Switch the hxml for code completion when working in different pages, and use the "all.hxml" to compile at once.

Surely it is less than optimal, so I fixed it as the following:

Looks nice? I also took the chance to include 100% Haxe 3 support (and still backward compatible for highlighting Haxe2 code), which includes Array/Map comprehension, import wildcard, macro-reification and even string interpolation! In fact I’ve tested ALL 1589 Haxe source files appeared in the source of Haxe, including the core std library of Haxe and its unit test files. So it is guaranteed to be as complete as possible, supporting all tiny Haxe features you may have never noticed (and I myself indeed learned a few tricks and even detected some typos in the Haxe std lib when running the test!).

I’ve made a pull request to Pygments, which hopefully they will merge it soon. But even when they’ve merged it, it will still take some time to let the Github guys updates their internal Pygments. But don’t be sad, the future is here: I created a Chrome extension, Pygmentx, that replace the Haxe codes on Github (and Gist) with the improved one. It only supports the normal file view at the moment, not diff view nor the previews on Gist user page at the moment. Btw, thanks Tong (a.k.a disktree) again for his chrome.extension Haxe externs

“Katamari” means clump; “Damacy” means soul. It is a game of collecting objects, creating a large clump of things. Player acts as the Prince, son of the King of All Cosmos, rolls a katamari that can pick up anything smaller than its size, forming a large sticky sphere. As more things get stuck onto the katamari, it grows larger and larger and eventually able to hold people, houses, islands or even planets.

The story in the Katamari Damacy game series is not an important part of it, but a “pretext for inspired weirdness” (Colgan). Basically it was the King of All Cosmos done something accidentally that destroyed part of universe, and the Prince was sent to roll up large clumps of things, in order to for example rebuild the moon, or to fill up a black hole. However its focus on interaction, the underlying logic or algorithm, can be seen as the narrative part of the work (Manovich, Database and Narrative).

There is a wide range of objects exist in the game scene, be composed as a fresh, relaxed, joyful hyperreality. Despite of the destructive act of rolling katamari around, the atmosphere remains fun and cheerful. It is made possible by the careful selection of background music (mostly in Jazz style), cute sound effects and graphics. The game levels are nice montages of playfulness and positive child memory, for instance playground, candy shop, theme park, sunny country park with rainbow etc. The game scenes start cluttered with objects. They are clearly more packed than their real world counterparts. For example in a bedroom there are a lot of snakes, books, toys that makes the game world a celebration of wealth and materials.

Rolling katamari to collect different objects is yet another form of art, a process of creating the player’s own montage. At the time of destroying or cleaning up the world, player is creating a piece of work that can be a new planet in the game world. Its seemly contradictive destruction and creation is the same as the practice of pastiche and quotation, “to select elements and styles from the ‘database of culture’” and “to put them together into new objects” (Manovich, The Logic of Selection).

Mentioned by its Japanese creator, Keita Takahashi, at Game Developers Conference, Katamari Damacy was a comment on consumerism (Welsh). On one hand, the ultra packed scene suggested the ideals of capitalism. Cleaning the scene up by rolling the katamari over can be seen as an act of subvert to “the culture of consumption and even the value of other video games” (Sino). It is because most of the video games nowadays, as a culture interface, reflected the real world’s favor of capitalism and/or consumerism. Classical examples are SimCity, Age of Empires, and their inspired variants, where player starts with a small plain area, develops into a large place that contains a large amount of artifacts. The “more to less” direction of Katamari Damacy is the opposite of the mainstream “less to more” progress. On the other hand, picking up objects by the katamari is also a metaphor of consuming the materials around us. Although there is a target size as the goal of each stage, player is encouraged in the game to roll as much and as large as they can. It is very similar to the concept of consumerism, that people are encouraged to purchase goods or service in great amount, often in excess of their basic needs. Having the theme of consumerism in mind, the delightfulness made up by the media elements in game seems to be compensation to the emptiness feeling after mindless consumption. Even Keita Takahashi “felt empty when the objects were gone” (Welsh).

Katamari Damacy is a good example of a video game being successful in the consumer market, also being an art piece that contains message and thoughts from the creator. It was recently acquired as one of the video games in the permanent design collection of The Museum of Modern Art (Antonelli).

Bibliography

Antonelli, Paola. Video Games: 14 in the Collection, for Starters. 29 Novermber 2012. 4 December 2012 <http://www.moma.org/explore/inside_out/2012/11/29/video-games-14-in-the-collection-for-starters/>.

Colgan, Mike. Review – Me and My Katamari. 18 April 2006. 3 December 2012 <http://www.gamechronicles.com/reviews/psp/meandmy/katamari.htm>.

Manovich, Lev. “Database and Narrative.” Manovich, Lev. The Language of New Media. Cambridge: The MIT Press, 2001. 199-201.

Manovich, Lev. “The Logic of Selection.” Manovich, Lev. The Language of New Media. Cambridge: The MIT Press, 2001. 120-124.

Sino, Cando. Metaphor: Katamari Damacy and Capitalism and Overconsumption. 8 May 2009. 4 December 2012 <http://lasttoblame.blogspot.hk/2009/05/metaphor-katamari-damacy-and-capitalism.html>.

Welsh, Oli. Katamari was comment on consumerism. 30 March 2009. 3 December 2012 <http://www.eurogamer.net/articles/katamari-was-comment-on-consumerism>.

** 請留意下一次聚會為 2013 年 2 月 23 日 **

Vicker Leung

簡介幾個近期的新 products

- Adobe Flash Builder 4.7 (http://www.adobe.com/products/flash-builder.html)

- Adobe AIR SDK 3.5 (http://www.adobe.com/devnet/air/air-sdk-download.html)

- Apache Flex > FalconJS (https://svn.apache.org/repos/asf/incubator/flex/falcon/trunk/compiler.js/)

- Adobe Game Developer Tools (http://gaming.adobe.com/getstarted/)

- Adobe Scout (http://gaming.adobe.com/technologies/scout/)

另外展示左幾隻 Flash Game

- Adobe Flash C++ Compiler Epic Citadel demo (http://www.unrealengine.com/flash/)

- Zynga FarmVille 2 (https://apps.facebook.com/farmville-two/)

- Zynga CityVille 2 (https://apps.facebook.com/cityville-two/)

之後簡介左 Blackberry 10 及幾個重要活動

- BlackBerry SDK for Adobe AIR (https://developer.blackberry.com/air/)

- BlackBerry App World (http://appworld.blackberry.com/)

- BlackBerry APAC Get Featured (BlackBerryAppWorldMarketingAPAC@rim.com)

- The 10k Developer Commitment (http://developer.blackberry.com/BuiltForBlackBerry)

- BlackBerry 10 App Development Contest (http://www.hkaim.org/BlackBerry10/)

- BlackBerry 10 GameJam (http://www.blackberryjamhack.com/gotgame/)

- BlackBerry Developer Group Hong Kong (https://www.facebook.com/groups/bbdevhk/)

Nelson Lee

講解了如何使用 Adobe Flash CS5 作手機遊戲開發

Judy Wong

Adobe Edge Tools and Services (http://html.adobe.com/edge/)

Pixlr (http://pixlr.com/)

Pierre

HTML5 game engine – Construct 2 (http://www.scirra.com/construct2)

Colin Leung

Typescript (http://www.typescriptlang.org/)

App Annie (http://www.appannie.com/)

TypeScript Sublime2 package (https://github.com/digi3colin/sublime-text-2-typescript)

其他活動相片
http://www.flickr.com/photos/vicker/sets/72157632239565802/

Epic Win is a game that runs in the Apple iOS platform (iPhone/iPad). It is a fusion of role-playing game, referred as RPG, and To-Do list application. Players define and input their own personal objectives in real life as game objectives. Once players mark an objective as complete, they will be moved forward in a quest map and may discover loot of game item. Experience points, referred as XP in the game, will also be given which will level up the player.

The game is set in a strongly naturalistic virtual world in an extreme case that, in fact, the virtual game world is built on top of the real world. The game objectives are objective in real life. To complete the objective, players have to perform real life action using their own physical body. However, the game world is not exactly the real world. Epic Win’s game world is virtual in the sense that there are virtual game elements like XP, treasure loots that do not exist in real world.

The simulation approach of Epic Win is different from typical simulation games like The Sims. Because the game world of Epic Win is built on top of the real world with added virtual elements, instead of started as a virtual world and added real world characteristic, the simulation direction is the opposite of typical simulation games. Epic Win uses the real world and simulates a typical RPG world; typical simulation games use a virtual world and simulate the real world. As Manovich suggested, “we do not necessarily have to think of immersion in the virtual and augmentation of the physical as opposites” (Manovich, The poetics of augmented space). Although the approaches are different to each other, both outcome of Epic Win and typical simulation games is a mixed reality.

Simulation requires modeling the logic or behavior of the simulation target (Manovich, The Illusions). Epic Win modeled a typical medieval themed RPG world in several ways. Firstly, it modeled the game logic, which is to complete missions (objectives) to gain points and collect game items in order to level up. In RPG, when the player level up, the ability of the player will be increased. Since a game cannot directly increase the player’s abilities in real life, Epic Win modeled this with virtual abilities of a RPG character, eg. “strength”, “intelligent” etc. Secondly, a typically RPG game has a story line. Epic Win simulated it by taking the seemly non-related real life objectives, map onto a logical narrative experience. Lastly, typical RPG uses a fantasy world. Epic Win simulated the fantasy world by extensive use of heavily stylized media, including wordings, graphics, and sounds, in medieval theme. The game items contained in the loots which players collect, are also typical object in a fantasy world.

Epic Win presents to players a hyperreality that solving real life problems will be rewarded with XP and treasures that can enhance the virtual character of the player. Since such world presented by Epic Win does not really exist, it matches the definition of hyperreality, “A real without origin or reality” (Baudrillard). This character development, i.e. level up, is one of the basic fulfillments of playing RPG. The progress of player is simulated as an exploration in a virtual world. It corresponds to the story-telling part of a RPG, which can also encourage player to move forward, in terms of completing tasks, and immerse into the virtual world, the enhanced real world.

The process of adding playful game elements in real life activity, which is increasing popular nowadays, is referred as gamification. It is “the application of digital game design techniques to non-game problems, such as business and social impact challenges” (Werbach). I consider it as a form of mixed reality as well as a hyperreality. It is because its aim is clearly to trick users to enjoy non-game activity as they enjoy games, making the boundary of entertainment and work blurry. Al Gore summed up, “Games are the new normal.” (Tsai). People will increasingly treat real life as game, and work as entertainment. Even the military is using the same technologies and employing the same visual forms (Manovich, Kino-Eye and Simulators). Virtual awards, game media and game concepts are natural additions to daily life activity.

Gamification as demonstrated by Epic Win is an interesting example of “simulation” and “hyperreality”. There were players of Epic Win observed an uptick in their productivity (Rattray). Further scientific measurement of the relation between productivity improvement and game immersiveness would be useful.

Bibliography

Baudrillard, Jean. Simulacra and Simulation. Michigan: University of Michigan Press, 1995.

Manovich, Lev. “Kino-Eye and Simulators.” Manovich, Lev. The Language of New Media. Cambridge: The MIT Press, 2001. 234-240.

Manovich, Lev. “The Illusions.” Manovich, Lev. The Language of New Media. Cambridge: The MIT Press, 2001. 162-167.

Manovich, Lev. “The poetics of augmented space.” Visual Communication (2006): 219-240.

Rattray, Tim. EpicWin Gives You Loot For Doing Your Chores. 18 Augest 2010. 30 Oct 2012 <http://www.slidetoplay.com/story/epicwin-gives-you-loot-for-doing-your-chores>.

Tsai, Charles. Al Gore: ‘Games Are the New Normal’. 22 June 2011. 30 Oct 2012 <http://www.huffingtonpost.com/charles-tsai/al-gore-games-social-good_b_881017.html>.

Werbach, Kevin. Gamification. 2012. 29 Oct 2012 <https://www.coursera.org/course/gamification>.