dave’s blog of art and programming

user generated content

Groworld is part of the preliminary program for Pixelache 2011 – we are planning an expanded version of our presence last year, more to follow.

This week has been about researching the next steps for the germination x design. Principally looking at how we can use the game to demonstrate and exploit some of the work on the Lirec project. I’ve had a speculative look at how we could use companions to fit the theme of a permaculture game, and ended up with some strange combination of bickering greek gods and plant spirits.

I’ve also been playing with the AgentMind code from our partners at Heriot Watt and got some of my own AI agents running and interacting with objects in a test world. At the other end, the client game code is now free from flash dependencies, so it should be possible to target HTML5 canvas and flash in the same code.

I’ve also switched from svn to git for everything and moved to gitorious. Germination X is here and all the rest of my mess is now located here.

A few days of summertime in the Finnish archipelago at the M.A.R.I.N. hacklab at the sea.

This experience included a lot of swimming in the sea, saunas, boat activity and simply exploring the environment, but the hacking seemed to fit in surprisingly well with this routine.

Having the privilege of being in such a place makes you aware of your footprints. With only renewable power resources available, I wanted to lower the power consumption of my computer to extend its battery life. I came across some useful instructions from the ubuntu wiki and from that discovered powertop which I can’t recommend highly enough.

This is the script I’m currently using to switch everything to low power mode, cobbled from the resources above.

# Set CPU scaling / max freq to battery mode

for x in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do
    echo "conservative" > $x
    X=${x%/*}
    # The second column is the second from the highest freq most power savings / least slowdown
    awk '{print $2}' $X/scaling_available_frequencies > $X/scaling_max_freq
done

# Tweak virtual memory to conserve power when running on batteries.

echo 10 > /proc/sys/vm/swappiness
echo 0 > /proc/sys/vm/dirty_expire_centisecs
echo 1500 > /proc/sys/vm/dirty_writeback_centisecs
echo 60 > /proc/sys/vm/dirty_background_ratio
echo 95 > /proc/sys/vm/dirty_ratio

# Enable SATA ALPM link power management via:
echo min_power > /sys/class/scsi_host/host0/link_power_management_policy

# Disable 'hal' from polling your cdrom with:
hal-disable-polling --device /dev/cdrom
# 'hal' is the component that auto-opens a
# window if you plug in a CD but disables SATA power saving from kicking in.

# Change the wireless power mode to Battery.

for x in $(/bin/ls -d /sys/class/net/*/wireless | /usr/bin/cut -d'/' -f5); do
    /sbin/iwconfig $x power on power period 2 power timeout 300u
    /sbin/iwpriv eth1 set_power 7
done

I worked a little more on plant sensing, trying a simple approach of testing the electrical resistance of parts of growing plants with a sensor boosted to extremely high sensitivity. This area is fairly rife with pseudoscience, but has some basis in reality. I was quite surprised to see some changes between the values from a real plant and a dead twig, or air, with distant electrodes – but this requires a scientific test in controlled conditions, and any variation is most likely due to changes in the temperature of the wood with sunlight changes.

Returning to power consumption, it was a good opportunity to build a solar engine, which is a device that collects low currents from small solar cells and periodically dumps them into a circuit which requires a higher current (usually a motor). It should be possible to use this approach to drive self powered microcontrollers for limited bursts of activity, making their state persistent and cleanly shutting down on the low power interrupt, waking up the program where it stopped when new power is available. This could be useful for a remote device running for months or years from a very small power source.

I could only attend the first couple of days, so I’m really looking forward to seeing the results from the other projects being worked on.

I’ve set up a sneak preview of a multiplayer permaculture game running here, at the moment it simply allows you to plant plants with your name attached. I’m pretty excited about it though – anxiously awaiting rude words and troublemaking!

The raw data is viewable here. I’m going to write a little bit more about the technical details of this and naked on pluto, but for the moment the code is here.

Doing some games designing:

A new month, and the start of various new things around here. One is a slub residency with sketchpatch, where we write processing sketches and bounce them between us in a game of “sketch tennis” that lasts a month. We already have a bunch of sketches and it’s only the first day.

I’m also taking part in a collaboration with Marloes de Valk and Aymeric Mansoux involving social games, text adventures and far distant planets. This is quite a new direction for me, and it’s exciting to be forging new alliances. A bit more explanation coming soon!

On the groworld front, we are also doing some design and further development surrounding permaculture, in what could become quite a big game project. Again – more on that as it happens.

Here is another experiment with html5 canvas, this time working with Lina Kusaite to try and bring some of the groworld illustrations to life. There is nothing particularly ground breaking happening at the moment, we are just testing some things. You might need to reload the page for it to work properly, I still have to figure out some caching issues:

In my last post I forgot to mention a very big reason why javascript is important – the fact that it’s very easy to access via the browser’s “view source” feature. It’s a pretty simple thing to take a site and modify it on your own machine with just a browser and a text editor. I wouldn’t be surprised if this is the most common entry point for new programmers at the moment.

My exploration of web programming continues, this is a rewrite of the wilderness game world from haxe/flash into javascript and html5 canvas. There are some plans to make this into something more resembling an actual game, but at the moment it’s serving as a good test as I get to grips with these new fangled bits and pieces.

Leaving out all the hot air about small companies beginning with “A”, here are my thoughts on canvas for making games compared with haxe/flash:

Pros:

Cons:

Update: While I hope HTML5 is the future, it seems on some counts my optimism was premature, it seems it’s still to reach a point where it’s available for the majority of people – and where it is available, the stability and performance is variable. With this in mind : On flash, software art and freedom

I’ve gathered most of the game prototypes I made for groworld and put them into a cross platform release. There will probably be a bit of tweaking still to be done, as the windows version of plant eyes seems a bit unstable.

OSX version (Just extract and run)
Linux version (needs fluxus-0.17 installed which you can get here)
Windows version (Copy the Fluxus directory to “C:\Program Files” and run the executable it contains)

You may recognise the “menu plant” from the Kansallisteatteri building projections, a bit of recycling.

My last update from pixelache is about the urban projection lab Miska Knapek, Ville Hyvönen and I were doing on Saturday night during Earth Hour. Despite not being allowed to turn the streetlights off and some heavy rain, our projector base station/van managed to beam images through the night onto the Finnish national theater building. My contribution was some specially adapted plants from the groworld code base:

Thanks to Ville for the last image. More images of the other projections are here and here.