grueserve 0.0.1

data/bin/grueserve

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'grueserve'
+
+Grueserve::Application.new.go

data/bin/grueserve_path2lines

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+if ARGV.size < 1 || !File.exists?(ARGV.first)
+  puts "Usage: #{$0} GIMP_POLYGON_PATH_EXPORT_FILE"
+  exit 1
+end
+
+require 'rexml/document'
+require 'pp'
+
+lines = []
+current_points = []
+d = REXML::Document.new(open(ARGV.first).read)
+d.each_element("svg/path") do |element|
+  mode = :start
+  element.attributes["d"].split.each do |word|
+    pieces = [word]
+    if match = word.match(/([\d.,]+)M/)
+      pieces = [match[1], "M"]
+    end
+    for piece in pieces
+      if piece == "M"
+        unless current_points.empty?
+          lines << current_points
+          current_points = []
+        end
+        mode = :first_point
+      elsif mode == :first_point && (match = piece.match(/([\d.]+),([\d.]+)/))
+        current_points << [match[1].to_i, match[2].to_i]
+        mode = :first_point_control
+      elsif mode == :first_point_control && (match = piece.match(/([\d.]+),([\d.]+)/))
+        mode = :data
+      elsif mode == :data && (match = piece.match(/([\d.]+),([\d.]+)/))
+        current_points << [match[1].to_i, match[2].to_i]
+        mode = :control_1
+      elsif mode == :control_1 && piece =~ /([\d.]+),([\d.]+)/
+        mode = :control_2
+      elsif mode == :control_2 && (match = piece.match(/([\d.]+),([\d.]+)/))
+        mode = :data
+      elsif mode == :control_2 && piece == "Z"
+        current_points << :loop
+        mode = :start
+      end
+    end
+  end
+  unless current_points.empty?
+    lines << current_points
+  end
+end
+puts(lines.collect do |line|
+       line.collect do |point|
+         case point
+         when Symbol
+           point.to_s
+         when Array
+           "#{point.first},#{point.last}"
+         end
+       end.join(" ")
+end.join(":"))

data/example/attributes.yaml

@@ -0,0 +1,28 @@
+--- 
+map: map.gif
+teams: green black
+green_start_points: 144,396 72,80 280,64
+black_start_points: 48,568 156,768 432,780
+hearing_distance_cutoff: 100
+viewing_distance_limit: 1000
+
+movement_obstacles: 312,40 463,40 463,246 312,246 loop:691,60 955,60 955,514 691,514 loop:28,433 282,433 282,525 28,525 loop:685,703 925,703 925,855 685,855 loop:78,1111 319,1111 319,1263 78,1263 loop:181,1341 423,1341 423,1491 181,1491 loop:91,1636 333,1636 333,1786 91,1786 loop:690,1824 981,1824 981,1900 690,1900 loop:378,759 370,748 378,739 385,745 loop:201,736 190,723 202,714 210,723 loop:127,835 148,828 174,831 199,831 220,819 249,810 271,811 291,828 316,844 343,853 378,859 396,879 405,907 388,930 366,951 354,978 339,1006 313,1011 297,984 274,966 244,963 208,963 172,957 153,930 147,898 130,874 121,856 loop:846,964 862,978 879,999 880,1027 877,1065 870,1096 864,1132 859,1164 859,1189 856,1233 856,1297 864,1350 874,1408 885,1465 882,1537 867,1579 843,1623 822,1644 801,1650 784,1644 780,1624 778,1585 774,1528 762,1488 756,1428 754,1381 771,1333 787,1282 789,1252 780,1215 768,1164 772,1108 786,1059 792,1023 789,981 805,964 822,955 loop:0,0 1023,0 1023,2064 0,2064 loop
+
+visibility_obstacles: 312,40 463,40 463,246 312,246 loop:691,60 955,60 955,514 691,514 loop:28,433 282,433 282,525 28,525 loop:685,703 925,703 925,855 685,855 loop:78,1111 319,1111 319,1263 78,1263 loop:181,1341 423,1341 423,1491 181,1491 loop:91,1636 333,1636 333,1786 91,1786 loop:690,1824 981,1824 981,1900 690,1900 loop:378,759 370,748 378,739 385,745 loop:201,736 190,723 202,714 210,723 loop
+
+bullet_obstacles: 312,40 463,40 463,246 312,246 loop:691,60 955,60 955,514 691,514 loop:28,433 282,433 282,525 28,525 loop:685,703 925,703 925,855 685,855 loop:78,1111 319,1111 319,1263 78,1263 loop:181,1341 423,1341 423,1491 181,1491 loop:91,1636 333,1636 333,1786 91,1786 loop:690,1824 981,1824 981,1900 690,1900 loop:378,759 370,748 378,739 385,745 loop:201,736 190,723 202,714 210,723 loop
+
+hearing_obstacles_default_value: 800
+hearing_obstacles: 312,40 463,40 463,246 312,246 loop=500:691,60 955,60 955,514 691,514 loop:28,433 282,433 282,525 28,525 loop:685,703 925,703 925,855 685,855 loop:78,1111 319,1111 319,1263 78,1263 loop:181,1341 423,1341 423,1491 181,1491 loop:91,1636 333,1636 333,1786 91,1786 loop:690,1824 981,1824 981,1900 690,1900 loop:378,759 370,748 378,739 385,745 loop:201,736 190,723 202,714 210,723 loop=2000
+
+fortifications_default_value: 500
+fortifications: 383,488 502,489:391,649 511,649=800
+
+speed_areas_default_value: 1500
+speed_areas: 176,230 256,102 256,362 96,362 340,322 96,100 loop:340,322 258,350 256,300 370,300 370,574 314,574 576,604 314,348 loop:576,604 2,574 0,630 1018,630 574,554 1018,576 loop=1600:574,554 628,2 520,2 520,2054 628,2054 loop=1700
+
+protection_areas_default_value: 500
+protection_areas: 204,725 168,703 183,693 205,711 219,705 232,725 230,748 218,740 215,748 202,736 186,758 174,728 167,721 375,750 174,713 loop:375,750 343,747 358,731 374,736 402,721 421,730 408,739 424,756 414,757 398,786 379,761 362,773 357,767 340,776 347,753 loop=600
+
+hidden_areas_default_value: 50000
+hidden_areas: 204,725 168,703 183,693 205,711 219,705 232,725 230,748 218,740 215,748 202,736 186,758 174,728 167,721 375,750 174,713 loop:375,750 343,747 358,731 374,736 402,721 421,730 408,739 424,756 414,757 398,786 379,761 362,773 357,767 340,776 347,753 loop

data/ext/extconf.rb

@@ -0,0 +1,93 @@
+# grueserve - a game server in c and ruby for the gruesome game
+# Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'mkmf'
+require 'pathname'
+
+def crash(s)
+  puts "--------------------------------------------------"
+  puts " extconf failure: #{s}"
+  puts "--------------------------------------------------"
+  exit 1
+end
+
+crash("pkg-config needed") unless find_executable("pkg-config")
+
+crash "libglib-2.0 needed" unless have_library('glib-2.0')
+
+$CFLAGS += " -std=c99 -Wall " + `pkg-config --cflags glib-2.0`.strip
+
+gem = if find_executable("gem")
+        "gem"
+      elsif find_executable("gem1.8")
+        "gem1.8"
+      else
+        crash("gem needed")
+      end
+
+geo_path = Pathname.glob(Pathname.new(`#{gem} environment`.match(/- GEM PATH.?:\s*- ([^\n]+)/)[1]).join("gems").join("geo-*")).sort.last
+
+geo_include = geo_path.join("ext")
+found_includes = false
+Pathname.glob(geo_include.join("*.h")).each do |header|
+  crash("couldnt compile against #{header}") unless find_header(header.basename, geo_include)
+  found_includes = true
+end
+crash("couldnt find geo includes") unless found_includes
+
+found_libs = false
+Pathname.glob(geo_include.join("*.o")).each do |lib|
+  $LOCAL_LIBS += " #{lib}"
+  found_libs = true
+end
+Pathname.glob(geo_path.join("lib").join("*.so")).each do |lib|
+  $LOCAL_LIBS += " #{lib}"
+  found_libs = true
+end
+[
+ "rb_is_a", # common.c
+ "Init_geo", # geo.c
+ "geo_set_free", # geo_set.c
+ "free_intersection", # intersection.c
+ "line_free", # line.c
+ "line_set_mark", # line_set.c
+ "new_point", # point.c
+ "point_set_mark", # point_set.c
+ "triangle_inspect", # triangle.c
+ "triangle_set_mark" # triangle_set.c
+].each do |func|
+  puts "checking for #{func}"
+  crash("couldnt find #{func}") unless try_func(func, [])
+  puts "... yes"
+end
+crash("couldnt find geo libs") unless found_libs
+
+if ARGV.include?("-d")
+  $CFLAGS += " -D GEO_DEBUG" 
+end
+
+if ARGV.include?("-O0")
+  $CFLAGS.gsub!(/-O./, "-O0")
+else
+  $CFLAGS.gsub!(/-O./, "-O3")
+end
+
+if ARGV.include?("-gdb")
+  $CFLAGS += " -g -gdwarf-2 -g3"
+end
+
+create_makefile("grueserve_ext")

data/ext/grueserve_ext.c

@@ -0,0 +1,2083 @@
+// grueserve - a game server in c and ruby for the gruesome game
+// Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+#define _POSIX_SOURCE
+
+#include "ruby.h"
+#include "rubyio.h"
+#include "intern.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+#include <glib.h>
+#include <common.h>
+#include <time.h>
+#include <stdio.h>
+
+static VALUE rb_client;
+static VALUE rb_command;
+static VALUE rb_command_set;
+static VALUE rb_body;
+static VALUE rb_map;
+static VALUE rb_e_terminated_connection;
+
+static VALUE rb_standing;
+static VALUE rb_dodging;
+static VALUE rb_dead;
+
+static char* standing = "standing";
+static char* dodging = "dodging";
+static char* dead = "dead";
+
+#define RB_CLIENT(client_pointer,klass) ((client_pointer)->rbClient = Data_Wrap_Struct(klass, client_mark, client_free, (client_pointer)))
+#define CLIENT(rb_client,client_pointer) Data_Get_Struct((rb_client), Client, (client_pointer))
+#define RB_BODY(body_pointer,klass) ((body_pointer)->rbBody = Data_Wrap_Struct(klass, body_mark, free, (body_pointer)))
+#define BODY(rb_body,body_pointer) Data_Get_Struct((rb_body), Body, (body_pointer))
+#define RB_COMMAND(command_pointer,klass) ((command_pointer)->rbCommand = Data_Wrap_Struct(klass, NULL, command_free, (command_pointer)))
+#define COMMAND(rb_command,command_pointer) Data_Get_Struct((rb_command), Command, (command_pointer))
+#define RB_MAP(map_pointer,klass) ((map_pointer)->rbMap = Data_Wrap_Struct(klass, map_mark, map_free, (map_pointer)))
+#define MAP(rb_map,map_pointer) Data_Get_Struct((rb_map), Map, (map_pointer))
+#define RB_COMMAND_SET(command_set_pointer,klass) ((command_set_pointer)->rbCommandSet = Data_Wrap_Struct(klass, command_set_mark, command_set_free, (command_set_pointer)))
+#define COMMAND_SET(rb_command_set,command_set_pointer) Data_Get_Struct((rb_command_set), CommandSet, (command_set_pointer))
+
+#define COMMAND_P(l) (!NIL_P((l)) && rb_is_a((l), rb_command))
+#define CHECK_COMMAND(l) if (!COMMAND_P((l))) rb_raise(rb_eTypeError, "Expected Grueserve::Client::Command!")
+#define COMMAND_SET_P(l) (!NIL_P((l)) && rb_is_a((l), rb_command_set))
+#define CHECK_COMMAND_SET(l) if (!COMMAND_SET_P((l))) rb_raise(rb_eTypeError, "Expected Grueserve::Client::CommandSet!")
+#define MAP_P(l) (!NIL_P((l)) && rb_is_a((l), rb_map))
+#define CHECK_MAP(l) if (!MAP_P((l))) rb_raise(rb_eTypeError, "Expected Grueserve::Map!")
+#define CLIENT_P(l) (!NIL_P((l)) && rb_is_a((l), rb_client))
+#define CHECK_CLIENT(l) if (!CLIENT_P((l))) rb_raise(rb_eTypeError, "Expected Grueserve::Client!")
+
+#define COMMAND_SET_INCLUDES(command_set,name) (g_hash_table_lookup((command_set)->commands, (name)) != NULL)
+
+#define SPRITE_WIDTH 16.0
+#define SPRITE_HEIGHT 24.0
+
+#define UP "UP"
+#define DOWN "DOWN"
+#define LEFT "LEFT"
+#define RIGHT "RIGHT"
+#define DODGE "DODGE"
+#define LBUTTON "LBUTTON"
+
+#define BUFFER_UNIT 1024
+
+typedef struct {
+  GeoSet *movement_obstacles;
+  GeoSet *visibility_obstacles;
+  GeoSet *bullet_obstacles;
+  GeoSet *hearing_obstacles;
+  GeoSet *fortifications;
+  GeoSet *speed_areas;
+  GeoSet *protection_areas;
+  GeoSet *hidden_areas;
+  GHashTable *config_by_whatever;
+
+  GeoSet *bodies;
+  GeoSet *eyes;
+  GeoSet *body_parts;
+  GHashTable *client_by_whatever;
+
+  gint timeout;
+  gdouble viewing_distance_limit;
+
+  VALUE rbMap;
+} Map;
+
+typedef struct {
+  GHashTable *attributes;
+  gchar *name;
+  VALUE rbCommand;
+} Command;
+
+typedef struct {
+  GHashTable *commands;
+  VALUE rbCommandSet;
+} CommandSet;
+
+struct ClientStruct;
+
+typedef struct {
+  Line *vertical_axis;
+  Line *horizontal_axis;
+  Point *origo;
+  VALUE rbBody;
+  struct ClientStruct *client;
+} Body;
+
+struct ClientStruct {
+  Body *body;
+  CommandSet *current_command;
+  GHashTable *last_command;
+  Map *map;
+  VALUE rbClient;
+  VALUE state;
+  time_t last_ping;
+  gdouble running_speed;
+  OpenFile *socket;
+  VALUE rbSocket;
+  gboolean socket_locked;
+  gchar *team;
+  gchar *behaviour;
+  gchar *nickname;
+  gboolean status_dirty;
+  gdouble score;
+  gdouble kills;
+  gdouble deaths;
+  gdouble hitpoints;
+  gchar *extra_status;
+  GHashTable *subscriptions;
+};
+
+typedef struct ClientStruct Client;
+
+typedef gpointer
+(*viewing_handler)(Client *viewer, Client *viewee, gpointer user_data);
+
+typedef gpointer
+(*client_handler)(Client *client, gpointer user_data);
+
+static void
+map_mark(Map *map) {
+  rb_gc_mark(map->movement_obstacles->rbGeoSet);
+  rb_gc_mark(map->visibility_obstacles->rbGeoSet);
+  rb_gc_mark(map->bullet_obstacles->rbGeoSet);
+  rb_gc_mark(map->hearing_obstacles->rbGeoSet);
+  rb_gc_mark(map->fortifications->rbGeoSet);
+  rb_gc_mark(map->speed_areas->rbGeoSet);
+  rb_gc_mark(map->protection_areas->rbGeoSet);
+  rb_gc_mark(map->hidden_areas->rbGeoSet);
+
+  rb_gc_mark(map->bodies->rbGeoSet);
+  rb_gc_mark(map->eyes->rbGeoSet);
+  rb_gc_mark(map->body_parts->rbGeoSet);
+}
+
+static void
+map_free(Map *map) {
+  g_hash_table_destroy(map->client_by_whatever);
+  g_hash_table_destroy(map->config_by_whatever);
+}
+
+static void
+client_free(Client *client) {
+  if (client->team != NULL)
+    free(client->team);
+  if (client->behaviour != NULL)
+    free(client->behaviour);
+  if (client->nickname != NULL)
+    free(client->nickname);
+  if (client->extra_status != NULL)
+    free(client->extra_status);
+  g_hash_table_destroy(client->subscriptions);
+  g_hash_table_destroy(client->last_command);
+}
+
+static void
+client_mark(Client *client) {
+  rb_gc_mark(client->body->rbBody);
+  rb_gc_mark(client->current_command->rbCommandSet);
+  rb_gc_mark(client->map->rbMap);
+  rb_gc_mark(client->rbSocket);
+}
+
+static void
+body_mark(Body *body) {
+  rb_gc_mark(body->vertical_axis->rbLine);
+  rb_gc_mark(body->horizontal_axis->rbLine);
+  rb_gc_mark(body->origo->rbPoint);
+  rb_gc_mark(body->client->rbClient);
+}
+
+static void
+command_free(Command *command) {
+  free(command->name);
+  g_hash_table_destroy(command->attributes);
+}
+
+static void
+g_hash_table_mark_command(gpointer name, gpointer command, gpointer null) {
+  rb_gc_mark(( (Command *) command )->rbCommand);
+}
+
+static void
+command_set_mark(CommandSet *command_set) {
+  g_hash_table_foreach(command_set->commands, g_hash_table_mark_command, NULL);
+}
+
+static void
+command_set_free(CommandSet *command_set) {
+  g_hash_table_destroy(command_set->commands);
+  free(command_set);
+}
+
+static CommandSet*
+new_command_set() {
+  CommandSet *command_set = ALLOC(CommandSet);
+  command_set->commands = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
+  return command_set;
+}
+
+static Body*
+new_body() {
+  Body *body = ALLOC(Body);
+  body->vertical_axis = new_line_with_coordinates(-SPRITE_WIDTH / 2, 0,
+						  SPRITE_WIDTH / 2, 0);
+  body->horizontal_axis = new_line_with_coordinates(0,-SPRITE_HEIGHT / 2,
+						    0,SPRITE_HEIGHT / 2);
+  body->origo = new_point(0,0);
+  RB_BODY(body, rb_body);
+  RB_LINE(body->vertical_axis, rb_line);
+  RB_POINT(body->vertical_axis->p1, rb_point);
+  RB_POINT(body->vertical_axis->p2, rb_point);
+  RB_LINE(body->horizontal_axis, rb_line);
+  RB_POINT(body->horizontal_axis->p1, rb_point);
+  RB_POINT(body->horizontal_axis->p2, rb_point);
+  RB_POINT(body->origo, rb_point);
+  return body;
+}
+
+static VALUE
+rb_client_alloc(VALUE class) {
+  Client *client = ALLOC(Client);
+  client->state = rb_standing;
+  client->last_ping = time(NULL);
+  client->running_speed = 1;
+  client->current_command = new_command_set();
+  RB_COMMAND_SET(client->current_command, rb_command_set);
+  client->last_command = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
+  client->map = NULL;
+  client->socket = NULL;
+  client->rbSocket = 0;
+  client->socket_locked = FALSE;
+  client->team = NULL;
+  client->behaviour = NULL;
+  client->nickname = NULL;
+  client->status_dirty = TRUE;
+  client->score = 0.0;
+  client->kills = 0.0;
+  client->deaths = 0.0;
+  client->hitpoints = 0.0;
+  client->extra_status = NULL;
+
+  client->body = new_body();
+  client->body->client = client;
+
+  client->subscriptions = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
+  return RB_CLIENT(client, class);
+}
+
+static void
+map_register_body(Map *map, Body *body) {
+  g_hash_table_insert(map->bodies->table, body->origo, body->origo);
+  g_hash_table_insert(map->client_by_whatever, body->origo, body->client);
+
+  g_hash_table_insert(map->body_parts->table, body->vertical_axis, body->vertical_axis);
+  g_hash_table_insert(map->client_by_whatever, body->vertical_axis, body->client);
+  g_hash_table_insert(map->eyes->table, body->vertical_axis->p1, body->vertical_axis->p1);
+  g_hash_table_insert(map->client_by_whatever, body->vertical_axis->p1, body->client);
+  g_hash_table_insert(map->eyes->table, body->vertical_axis->p2, body->vertical_axis->p2);
+  g_hash_table_insert(map->client_by_whatever, body->vertical_axis->p2, body->client);
+
+  g_hash_table_insert(map->body_parts->table, body->horizontal_axis, body->horizontal_axis);
+  g_hash_table_insert(map->client_by_whatever, body->horizontal_axis, body->client);
+  g_hash_table_insert(map->eyes->table, body->horizontal_axis->p1, body->horizontal_axis->p1);
+  g_hash_table_insert(map->client_by_whatever, body->horizontal_axis->p1, body->client);
+  g_hash_table_insert(map->eyes->table, body->horizontal_axis->p2, body->horizontal_axis->p2);
+  g_hash_table_insert(map->client_by_whatever, body->horizontal_axis->p2, body->client);
+}
+
+static void
+map_unregister_body(Map *map, Body *body) {
+  g_hash_table_remove(map->bodies->table, body->origo);
+  g_hash_table_remove(map->client_by_whatever, body->origo);
+
+  g_hash_table_remove(map->body_parts->table, body->vertical_axis);
+  g_hash_table_remove(map->client_by_whatever, body->vertical_axis);
+  g_hash_table_remove(map->eyes->table, body->vertical_axis->p1);
+  g_hash_table_remove(map->client_by_whatever, body->vertical_axis->p1);
+  g_hash_table_remove(map->eyes->table, body->vertical_axis->p2);
+  g_hash_table_remove(map->client_by_whatever, body->vertical_axis->p2);
+
+  g_hash_table_remove(map->body_parts->table, body->horizontal_axis);
+  g_hash_table_remove(map->client_by_whatever, body->horizontal_axis);
+  g_hash_table_remove(map->eyes->table, body->horizontal_axis->p1);
+  g_hash_table_remove(map->client_by_whatever, body->horizontal_axis->p1);
+  g_hash_table_remove(map->eyes->table, body->horizontal_axis->p2);
+  g_hash_table_remove(map->client_by_whatever, body->horizontal_axis->p2);
+}
+
+static VALUE
+rb_command_alloc(VALUE class) {
+  Command *command = ALLOC(Command);
+  command->name = g_strndup("", 0);
+  command->attributes = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
+  return RB_COMMAND(command, class);
+}
+
+static VALUE
+rb_command_set_alloc(VALUE class) {
+  CommandSet *command_set = new_command_set();
+  return RB_COMMAND_SET(command_set, class);
+}
+
+static VALUE
+rb_command_set_name(VALUE self, VALUE name) {
+  Command *command;
+  Check_Type(name, T_STRING);
+  COMMAND(self, command);
+  command->name = g_strndup(RSTRING(name)->ptr, RSTRING(name)->len);
+  return name;
+}
+
+static VALUE
+rb_command_get_name(VALUE self) {
+  Command *command;
+  COMMAND(self, command);
+  return rb_str_new2(command->name);
+}
+
+static VALUE
+rb_command_insert(VALUE self, VALUE key, VALUE value) {
+  Command *command;
+  Check_Type(key, T_STRING);
+  Check_Type(value, T_STRING);
+  COMMAND(self, command);
+  g_hash_table_insert(command->attributes, g_strndup(RSTRING(key)->ptr, RSTRING(key)->len), g_strndup(RSTRING(value)->ptr, RSTRING(value)->len));
+  return value;
+}
+
+static VALUE
+rb_command_get(VALUE self, VALUE key) {
+  Command *command;
+  gpointer value;
+  Check_Type(key, T_STRING);
+  COMMAND(self, command);
+  value = g_hash_table_lookup(command->attributes, RSTRING(key)->ptr);
+  if (value == NULL)
+    return Qnil;
+  else
+    return rb_str_new2((gchar *) value);
+}
+
+static VALUE
+rb_command_set_get(VALUE self, VALUE key) {
+  CommandSet *command_set;
+  gpointer value;
+  Check_Type(key, T_STRING);
+  COMMAND_SET(self, command_set);
+  value = g_hash_table_lookup(command_set->commands, RSTRING(key)->ptr);
+  if (value == NULL)
+    return Qnil;
+  else
+    return ( (Command *) value )->rbCommand;
+}
+
+static VALUE
+rb_command_set_push(VALUE self, VALUE command_value) {
+  CommandSet *command_set;
+  Command *command;
+  CHECK_COMMAND(command_value);
+  COMMAND_SET(self, command_set);
+  COMMAND(command_value, command);
+  g_hash_table_insert(command_set->commands, g_strdup(command->name), command);
+  return self;
+}
+
+static VALUE
+rb_command_set_include(VALUE self, VALUE key) {
+  CommandSet *command_set;
+  Check_Type(key, T_STRING);
+  COMMAND_SET(self, command_set);
+  if (g_hash_table_lookup(command_set->commands, RSTRING(key)->ptr) == NULL)
+    return Qfalse;
+  else
+    return Qtrue;
+}
+
+static VALUE
+rb_client_get_body(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return client->body->rbBody;
+}
+
+static VALUE
+rb_body_get_origo(VALUE self) {
+  Body *body;
+  BODY(self, body);
+  return body->origo->rbPoint;
+}
+
+static VALUE
+rb_body_get_vertical_axis(VALUE self) {
+  Body *body;
+  BODY(self, body);
+  return body->vertical_axis->rbLine;
+}
+
+static VALUE
+rb_body_get_horizontal_axis(VALUE self) {
+  Body *body;
+  BODY(self, body);
+  return body->horizontal_axis->rbLine;
+}
+
+static void
+body_relocate(Body *body, Point *point) {
+  gdouble width;
+  gdouble height;
+  if (body->client->state == rb_dodging && !DBL_EQL(point->x, body->origo->x)) {
+    width = SPRITE_HEIGHT;
+    height = SPRITE_WIDTH;
+  } else {
+    width = SPRITE_WIDTH;
+    height = SPRITE_HEIGHT;
+  }
+  body->origo->x = point->x;
+  body->origo->y = point->y;
+  body->vertical_axis->p1->x = point->x;
+  body->vertical_axis->p1->y = point->y - height / 2;
+  body->vertical_axis->p2->x = point->x;
+  body->vertical_axis->p2->y = point->y + height / 2;
+  body->horizontal_axis->p1->x = point->x - width / 2;
+  body->horizontal_axis->p1->y = point->y;
+  body->horizontal_axis->p2->x = point->x + width / 2;
+  body->horizontal_axis->p2->y = point->y;
+}
+
+static VALUE
+rb_body_relocate(VALUE self, VALUE new_origo) {
+  Body *body;
+  Point *point;
+  CHECK_POINT(new_origo);
+  POINT(new_origo, point);
+  BODY(self, body);
+  body_relocate(body, point);
+  return new_origo;
+}
+
+static void
+g_hash_table_insert_key_equals_value_into_string(gpointer key, gpointer value, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  gchar *str = (gchar *) args[0];
+  gboolean *first = (gboolean *) args[1];
+  gchar neue[BUFFER_UNIT];
+  gint len = strlen(str);
+  gint neuelen = 0;
+  if (*first)
+    snprintf(neue, BUFFER_UNIT, "%s=%s", (gchar *) key, (gchar *) value);
+  else
+    snprintf(neue, BUFFER_UNIT, ", %s=%s", (gchar *) key, (gchar *) value);
+  *first = FALSE;
+  neuelen = strlen(neue);
+  str = realloc(str, sizeof(gchar) * (len + neuelen + 1));
+  strncpy(str + len, neue, neuelen);
+}
+
+static gchar*
+command_inspect(Command *command) {
+  gchar *rval = calloc(BUFFER_UNIT, sizeof(gchar));
+  gboolean first = TRUE;
+  gpointer args[2] = { rval, &first };
+  gint new_len = 0;
+  snprintf(rval, BUFFER_UNIT, "<%s:%p name=%s attributes=[", rb_obj_classname(command->rbCommand), command, command->name);
+  g_hash_table_foreach(command->attributes, g_hash_table_insert_key_equals_value_into_string, args);
+  new_len = strlen(rval);
+  rval = realloc(rval, sizeof(gchar) * (new_len + 3));
+  snprintf(rval + new_len, 3, "]>");
+  return rval;
+}
+
+static VALUE
+rb_command_inspect(VALUE self) {
+  gchar *str;
+  Command *command;
+  VALUE rval;
+  COMMAND(self, command);
+  str = command_inspect(command);
+  rval = rb_str_new2(str);
+  free(str);
+  return rval;
+}
+
+static void
+g_hash_table_insert_command_into_string(gpointer key, gpointer value, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  gchar *str = (gchar *) args[0];
+  gboolean *first = (gboolean *) args[1];
+  gchar neue[(BUFFER_UNIT * 2)];
+  gint len = strlen(str);
+  gint neuelen = 0;
+  gchar *command_str = command_inspect((Command *) value);
+  if (*first)
+    snprintf(neue, (BUFFER_UNIT * 2), "%s", command_str);
+  else
+    snprintf(neue, (BUFFER_UNIT * 2), ", %s", command_str);
+  free(command_str);
+  *first = FALSE;
+  neuelen = strlen(neue);
+  str = realloc(str, sizeof(gchar) * (len + neuelen + 1));
+  strncpy(str + len, neue, neuelen);
+}
+
+static gchar*
+command_set_inspect(CommandSet *command_set) {
+  gchar *rval = calloc(BUFFER_UNIT, sizeof(gchar));
+  gboolean first = TRUE;
+  gpointer args[2] = { rval, &first };
+  gint new_len = 0;
+  snprintf(rval, BUFFER_UNIT, "<%s:%p commands=[", rb_obj_classname(command_set->rbCommandSet), command_set);
+  g_hash_table_foreach(command_set->commands, g_hash_table_insert_command_into_string, args);
+  new_len = strlen(rval);
+  rval = realloc(rval, sizeof(gchar) * (new_len + 3));
+  snprintf(rval + new_len, 3, "]>");
+  return rval;
+}
+
+static VALUE
+rb_command_set_inspect(VALUE self) {
+  gchar *str;
+  CommandSet *command_set;
+  VALUE rval;
+  COMMAND_SET(self, command_set);
+  str = command_set_inspect(command_set);
+  rval = rb_str_new2(str);
+  free(str);
+  return rval;
+}
+
+static VALUE
+rb_body_inspect(VALUE self) {
+  gchar rval[BUFFER_UNIT];
+  Body *b;
+  gchar *origo;
+  gchar *vert;
+  gchar *hori;
+  BODY(self, b);
+  origo = point_inspect(b->origo);
+  vert = line_inspect(b->vertical_axis);
+  hori = line_inspect(b->horizontal_axis);
+  snprintf(rval, BUFFER_UNIT, "<%s:%p origo=%s vertical_axis=%s horizontal_axis=%s>",
+	   rb_obj_classname(self), b,
+	   origo,
+	   vert,
+	   hori);
+  free(origo);
+  free(vert);
+  free(hori);
+  return rb_str_new2(rval);
+}
+
+static VALUE
+rb_client_get_state(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return client->state;
+}
+
+static VALUE
+rb_client_set_state(VALUE self, VALUE new_state) {
+  Client *client;
+  CLIENT(self, client);
+  if (client->state != new_state) {
+    client->status_dirty = TRUE;
+    client->state = new_state;
+  }
+  return new_state;
+}
+
+static VALUE
+rb_client_set_current_command(VALUE self, VALUE new_command) {
+  Client *client;
+  CommandSet *command_set;
+  CHECK_COMMAND_SET(new_command);
+  CLIENT(self, client);
+  COMMAND_SET(new_command, command_set);
+  client->current_command = command_set;
+  return new_command;
+}
+
+static VALUE
+rb_client_get_current_command(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return client->current_command->rbCommandSet;
+}
+
+static void
+init_grueserve_globals() {
+  rb_standing = ID2SYM(rb_intern(standing));
+  rb_dodging = ID2SYM(rb_intern(dodging));
+  rb_dead = ID2SYM(rb_intern(dead));
+}
+
+static VALUE
+rb_client_registered(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return GBOOL2RB(g_hash_table_lookup(client->map->bodies->table, client->body->origo) != NULL);
+}
+
+static VALUE
+rb_client_moving(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return GBOOL2RB(g_hash_table_lookup(client->current_command->commands, UP) != NULL ||
+		  g_hash_table_lookup(client->current_command->commands, DOWN) != NULL ||
+		  g_hash_table_lookup(client->current_command->commands, LEFT) != NULL ||
+		  g_hash_table_lookup(client->current_command->commands, RIGHT) != NULL);
+}
+
+static gpointer
+map_yield_client(Client *client, gpointer user_data) {
+  rb_yield(( (Client *) client)->rbClient);
+  return NULL;
+}
+
+static gboolean
+g_hash_table_call_handler_for_client_for_body_until(gpointer key, gpointer value, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  Map *map = (Map *) args[0];
+  client_handler handler = (client_handler) args[1];
+  gpointer handler_args = args[2];
+  gpointer *rval = (gpointer *) args[3];
+  Client *client = (Client *) g_hash_table_lookup(map->client_by_whatever, key);
+  if (client == NULL)
+    rb_raise(rb_eRuntimeError, "%s: Weird! The body doesnt have a Client!", __PRETTY_FUNCTION__);
+  if (((*rval) = handler(client, handler_args)) != NULL)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+static gpointer
+map_each_client_until(Map *map, client_handler handler, gpointer handler_args) {
+  gpointer rval;
+  gpointer args[4] = { map, handler, handler_args, &rval };
+  g_hash_table_find(map->bodies->table, g_hash_table_call_handler_for_client_for_body_until, args);
+  return rval;
+}
+
+static VALUE
+rb_map_each_client(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  map_each_client_until(map, map_yield_client, NULL);
+  return Qnil;
+}
+
+static VALUE
+rb_map_alloc(VALUE class) {
+  Map *map = ALLOC(Map);
+  map->movement_obstacles = new_geo_set();
+  RB_LINE_SET(map->movement_obstacles, rb_line_set);
+  map->visibility_obstacles = new_geo_set();
+  RB_LINE_SET(map->visibility_obstacles, rb_line_set);
+  map->bullet_obstacles = new_geo_set();
+  RB_LINE_SET(map->bullet_obstacles, rb_line_set);
+  map->hearing_obstacles = new_geo_set();
+  RB_LINE_SET(map->hearing_obstacles, rb_line_set);
+  map->fortifications = new_geo_set();
+  RB_LINE_SET(map->fortifications, rb_line_set);
+  map->speed_areas = new_geo_set();
+  RB_TRIANGLE_SET(map->speed_areas, rb_triangle_set);
+  map->protection_areas = new_geo_set();
+  RB_TRIANGLE_SET(map->protection_areas, rb_triangle_set);
+  map->hidden_areas = new_geo_set();
+  RB_TRIANGLE_SET(map->hidden_areas, rb_triangle_set);
+
+  map->config_by_whatever = g_hash_table_new(g_direct_hash, g_direct_equal);
+
+  map->bodies = new_geo_set();
+  map->bodies->indexed = FALSE;
+  RB_POINT_SET(map->bodies, rb_point_set);
+  map->eyes = new_geo_set();
+  map->eyes->indexed = FALSE;
+  RB_POINT_SET(map->eyes, rb_point_set);
+  map->body_parts = new_geo_set();
+  map->body_parts->indexed = FALSE;
+  RB_LINE_SET(map->body_parts, rb_line_set);
+  
+  map->client_by_whatever = g_hash_table_new(g_direct_hash, g_direct_equal);
+  
+  map->timeout = 10;
+  map->viewing_distance_limit = 1000.0;
+
+  return RB_MAP(map, class);
+}
+
+static VALUE
+rb_map_set(VALUE self, VALUE key, VALUE value) {
+  Map *map;
+  gpointer key_p;
+  if (LINE_P(key)) {
+    LINE(key, key_p);
+  } else if (TRIANGLE_P(key)) {
+    TRIANGLE(key, key_p);
+  } else if (POINT_P(key)) {
+    POINT(key, key_p);
+  } else {
+    rb_raise(rb_eTypeError, "%s#[]= requires a Geo::Line, a Geo::Point or a Geo::Triangle as first parameter.", rb_obj_classname(self));
+  }
+  MAP(self, map);
+  Check_Type(value, T_FIXNUM);
+  g_hash_table_insert(map->config_by_whatever, key_p, GINT_TO_POINTER(NUM2INT(value)));
+  return value;
+}
+
+static VALUE
+rb_map_get(VALUE self, VALUE key) {
+  gpointer key_p;
+  gpointer rval;
+  Map *map;
+  if (LINE_P(key)) {
+    LINE(key, key_p);
+  } else if (POINT_P(key)) {
+    POINT(key, key_p);
+  } else if (TRIANGLE_P(key)) {
+    TRIANGLE(key, key_p);
+  } else {
+    rb_raise(rb_eTypeError, "%s[] requires a Geo::Line, a Geo::Point or a Geo::Triangle as argument.", rb_obj_classname(self));
+  }
+  MAP(self, map);
+  if ((rval = g_hash_table_lookup(map->config_by_whatever, key_p)) != NULL) {
+    return INT2NUM(GPOINTER_TO_INT(rval));
+  } else if ((rval = g_hash_table_lookup(map->client_by_whatever, key_p)) != NULL) {
+    return ( (Client *) rval )->rbClient;
+  }
+  return Qnil;
+}
+
+static VALUE
+rb_map_movement_obstacles(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->movement_obstacles->rbGeoSet;
+}
+
+static VALUE
+rb_map_visibility_obstacles(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->visibility_obstacles->rbGeoSet;
+}
+
+static VALUE
+rb_map_bullet_obstacles(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->bullet_obstacles->rbGeoSet;
+}
+
+static VALUE
+rb_map_hearing_obstacles(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->hearing_obstacles->rbGeoSet;
+}
+
+static VALUE
+rb_map_fortifications(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->fortifications->rbGeoSet;
+}
+
+static VALUE
+rb_map_speed_areas(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->speed_areas->rbGeoSet;
+}
+
+static VALUE
+rb_map_protection_areas(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->protection_areas->rbGeoSet;
+}
+
+static VALUE
+rb_map_hidden_areas(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->hidden_areas->rbGeoSet;
+}
+
+static VALUE
+rb_client_set_map(VALUE self, VALUE new_map) {
+  Client *client;
+  Map *map;
+  CHECK_MAP(new_map);
+  CLIENT(self, client);
+  MAP(new_map, map);
+  client->map = map;
+  return new_map;
+}
+
+static VALUE
+rb_client_get_map(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  if (client->map == NULL)
+    return Qnil;
+  return client->map->rbMap;
+}
+
+static VALUE
+rb_client_client_id(VALUE self) {
+  Client *client;
+  gchar rval[BUFFER_UNIT];
+  CLIENT(self, client);
+  snprintf(rval, BUFFER_UNIT, "%p", client);
+  return rb_str_new2(rval);
+}
+
+static VALUE
+rb_client_get_last_ping(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return INT2NUM((gint) client->last_ping);
+}
+
+static VALUE
+rb_client_ping(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  client->last_ping = time(NULL);
+  return INT2NUM((gint) client->last_ping);
+}
+
+static void
+map_move(Map *map, Point *from, Point *to, Point *rval) {
+  Line *movement_line = new_line_with_coordinates(from->x, from->y,
+						  to->x, to->y);
+  line_set_slide_point(map->movement_obstacles, movement_line, 3);
+  rval->x = movement_line->p2->x;
+  rval->y = movement_line->p2->y;
+  line_free(movement_line);
+}
+
+static gpointer
+map_add_overlap_factor_to_virtual_length(GeoSet *set, gpointer triangle, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  Line *line = (Line *) args[0];
+  gdouble *virtual_length = (gdouble *) args[1];
+  Map *map = (Map *) args[2];
+  Line *overlap = triangle_overlap((Triangle *) triangle, line);
+  gint triangle_value = GPOINTER_TO_INT(g_hash_table_lookup(map->config_by_whatever, triangle));
+  (*virtual_length) += (DISTANCE(overlap->p1, overlap->p2) * (triangle_value / 1000.0));
+  line_free(overlap);
+  return NULL;
+}
+
+static gboolean
+map_line_hidden(Map *map, Line *line) {
+  gdouble virtual_length = DISTANCE(line->p1, line->p2);
+  gpointer args[3] = { line, &virtual_length, map };
+  triangle_set_each_intersector_until(map->hidden_areas, line, map_add_overlap_factor_to_virtual_length, args);
+  return virtual_length > map->viewing_distance_limit;
+}
+
+static gpointer
+map_call_client_handler_if_within_visible_range(GeoSet *set, gpointer line, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  client_handler handler = (client_handler) args[0];
+  gpointer handler_args = args[1];
+  Map *map = (Map *) args[2];
+  GHashTable *seen_clients = (GHashTable *) args[3];
+  Client *client = (Client *) g_hash_table_lookup(map->client_by_whatever, ( (Line *) line )->p2);
+  if (client == NULL) {
+    rb_raise(rb_eRuntimeError, "%s: Weird! The viewing Point doesnt seem to have a Client!", __PRETTY_FUNCTION__);
+  }
+  if (!map_line_hidden(map, (Line *) line)) {
+    if (g_hash_table_lookup(seen_clients, client) == NULL) {
+      handler(client, handler_args);
+      g_hash_table_insert(seen_clients, client, GINT_TO_POINTER(1));
+    }
+  }
+  return NULL;
+}
+
+static void
+map_each_viewer_of(Map *map, Point *what, client_handler handler, gpointer user_data) {
+  GeoSet *what_set = new_geo_set();
+  GHashTable *seen_clients = g_hash_table_new(g_direct_hash, g_direct_equal);
+  gpointer args[4] = { handler, user_data, map, seen_clients };
+
+  g_hash_table_insert(what_set->table, what, what);
+
+  line_set_each_intersection_free_endpoint(map->visibility_obstacles,
+					   what_set,
+					   map->eyes,
+					   map->viewing_distance_limit,
+					   map_call_client_handler_if_within_visible_range,
+					   args);
+  g_hash_table_destroy(seen_clients);
+  geo_set_free(what_set);
+}
+
+static gpointer
+client_add_client_to_rb_ary(Client *client, gpointer user_data) {
+  rb_ary_push(*( (VALUE *) user_data), client->rbClient);
+  return NULL;
+}
+
+static VALUE
+rb_map_viewers_of(VALUE self, VALUE p) {
+  Map *map;
+  Point *point;
+  VALUE rval;
+  CHECK_POINT(p);
+  MAP(self, map);
+  POINT(p, point);
+  rval = rb_ary_new();
+  map_each_viewer_of(map, point, client_add_client_to_rb_ary, &rval);
+  return rval;
+}
+
+static gpointer
+client_call_viewing_handler_if_clients_within_visible_range(GeoSet *set, gpointer line, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  viewing_handler handler = (viewing_handler) args[0];
+  gpointer handler_args = args[1];
+  Client *viewer = (Client *) args[2];
+  Client *viewee = (Client *) args[3];
+  GHashTable *seen_viewers = (GHashTable *) args[4];
+  GHashTable *seen_viewees = (GHashTable *) args[5];
+  Map *map = (Map *) args[6];
+  if (viewer != NULL) {
+    if (viewer->map == NULL)
+      rb_raise(rb_eRuntimeError, "%s: Weird! The viewer doesnt have a Map!", __PRETTY_FUNCTION__);
+    if ((viewee = (Client *) g_hash_table_lookup(viewer->map->client_by_whatever, ( (Line *) line )->p2)) != NULL) {
+      if (!map_line_hidden(map, (Line *) line)) {
+      	if (g_hash_table_lookup(seen_viewees, viewee) == NULL) {
+	  handler(viewer, viewee, handler_args);
+	  g_hash_table_insert(seen_viewees, viewee, GINT_TO_POINTER(1));
+	}
+      }
+    } else { 
+      rb_raise(rb_eRuntimeError, "%s: Weird! The viewed Point doesnt seem to have a Client!", __PRETTY_FUNCTION__);
+    }
+  } else if (viewee != NULL) {
+    if (viewee->map == NULL)
+      rb_raise(rb_eRuntimeError, "%s: Weird! The viewee doesnt have a Map!", __PRETTY_FUNCTION__);
+    if ((viewer = (Client *) g_hash_table_lookup(viewee->map->client_by_whatever, ( (Line *) line )->p2)) != NULL) {
+      if (!map_line_hidden(map, (Line *) line)) {
+      	if (g_hash_table_lookup(seen_viewers, viewer) == NULL) {
+	  handler(viewer, viewee, handler_args);
+	  g_hash_table_insert(seen_viewers, viewer, GINT_TO_POINTER(1));
+	}
+      }
+    } else {
+      rb_raise(rb_eRuntimeError, "%s: Weird! The viewing Point doesnt seem to have a Client!", __PRETTY_FUNCTION__);
+    }
+  } else {
+    rb_raise(rb_eRuntimeError, "%s: Weird! map_call_viewing_handler should always have either viewer or viewee set!", __PRETTY_FUNCTION__);
+  }
+  return NULL;
+}
+
+static void
+client_each_viewee(Client *viewer, viewing_handler handler, gpointer user_data) {
+  GeoSet *eyes = new_geo_set();
+  GHashTable *seen_viewees = g_hash_table_new(g_direct_hash, g_direct_equal);
+  gpointer args[7] = { handler, user_data, viewer, NULL, NULL, seen_viewees, viewer->map };
+
+  g_hash_table_insert(eyes->table, viewer->body->horizontal_axis->p1, viewer->body->horizontal_axis->p1);
+  g_hash_table_insert(eyes->table, viewer->body->horizontal_axis->p2, viewer->body->horizontal_axis->p2);
+  g_hash_table_insert(eyes->table, viewer->body->vertical_axis->p1, viewer->body->vertical_axis->p1);
+  g_hash_table_insert(eyes->table, viewer->body->vertical_axis->p2, viewer->body->vertical_axis->p2);
+
+  line_set_each_intersection_free_endpoint(viewer->map->visibility_obstacles, 
+					   eyes, 
+					   viewer->map->bodies, 
+					   viewer->map->viewing_distance_limit, 
+					   client_call_viewing_handler_if_clients_within_visible_range,
+					   args);
+
+  g_hash_table_destroy(seen_viewees);
+  geo_set_free(eyes);
+}
+
+static void
+client_each_viewer(Client *viewee, viewing_handler handler, gpointer user_data) {
+  GeoSet *body_set = new_geo_set();
+  GHashTable *seen_viewers = g_hash_table_new(g_direct_hash, g_direct_equal);
+  gpointer args[7] = { handler, user_data, NULL, viewee, seen_viewers, NULL, viewee->map };
+
+  g_hash_table_insert(body_set->table, viewee->body->origo, viewee->body->origo);
+
+  line_set_each_intersection_free_endpoint(viewee->map->visibility_obstacles,
+					   body_set,
+					   viewee->map->eyes,
+					   viewee->map->viewing_distance_limit,
+					   client_call_viewing_handler_if_clients_within_visible_range,
+					   args);
+  g_hash_table_destroy(seen_viewers);
+  geo_set_free(body_set);
+}
+
+static gpointer
+client_add_viewer_to_rb_ary(Client *viewer, Client *viewee, gpointer user_data) {
+  rb_ary_push(*( (VALUE *) user_data), viewer->rbClient);
+  return NULL;
+}
+
+static gpointer
+client_add_viewee_to_rb_ary(Client *viewer, Client *viewee, gpointer user_data) {
+  rb_ary_push(*( (VALUE *) user_data), viewee->rbClient);
+  return NULL;
+}
+
+static VALUE
+rb_client_viewers(VALUE self) {
+  Client *client;
+  VALUE rval = rb_ary_new();
+  CLIENT(self, client);
+  client_each_viewer(client, client_add_viewer_to_rb_ary, &rval);
+  return rval;
+}
+
+static VALUE
+rb_client_viewees(VALUE self) {
+  Client *client;
+  VALUE rval = rb_ary_new();
+  CLIENT(self, client);
+  client_each_viewee(client, client_add_viewee_to_rb_ary, &rval);
+  return rval;
+}
+
+static gpointer
+map_increase_gdouble_with_config(GeoSet *set, gpointer triangle, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  Map *map = (Map *) args[0];
+  gdouble *to_increase = (gdouble *) args[1];
+  gint config = GPOINTER_TO_INT(g_hash_table_lookup(map->config_by_whatever, triangle));
+  if (*to_increase < (config / 1000.0))
+    (*to_increase) = (config / 1000.0);
+  return NULL;
+}
+
+static gdouble
+map_speed_factor(Map *map, Point *point) {
+  gdouble rval = 1.0;
+  gpointer args[2] = { map, &rval };
+  triangle_set_each_container_until(map->speed_areas, point, map_increase_gdouble_with_config, args);
+  return rval;
+}
+
+static gdouble
+client_speed(Client *client) {
+  gdouble rval = client->running_speed;
+  if (client->state == rb_dodging)
+    rval /= 5.0;
+  rval *= map_speed_factor(client->map, client->body->origo);
+  return rval;
+}
+
+static gpointer
+client_add_viewer_to_hash(Client *viewer, Client *viewee, gpointer user_data) {
+  g_hash_table_insert((GHashTable *) user_data, viewer, viewer);
+  return NULL;
+}
+
+static gpointer
+client_add_viewee_to_hash(Client *viewer, Client *viewee, gpointer user_data) {
+  g_hash_table_insert((GHashTable *) user_data, viewee, viewee);
+  return NULL;
+}
+
+static gboolean
+socket_send(gint fn, gchar *to_send, gint to_send_len, struct timeval wait_time) {
+  gchar *position = to_send;
+  gint write_rval;
+  while (position < to_send + to_send_len) {
+    write_rval = write(fn, position, to_send_len + to_send - position);
+    if (write_rval != -1) {
+      gchar blaj[to_send_len];
+      snprintf(blaj, write_rval + 1, "%s", position);
+      position += write_rval;
+    } else if (errno == EAGAIN) {
+      rb_thread_wait_for(wait_time);
+    } else {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+
+static void
+client_send(Client *client, gchar *str, gint len) {
+  FILE *file;
+  gchar header[BUFFER_UNIT];
+  gint fn;
+  struct timeval wait_time = { 0, 1000 };
+
+  while (client->socket_locked)
+    rb_thread_wait_for(wait_time);
+
+  client->socket_locked = TRUE;
+
+  file = GetWriteFile(client->socket);
+  rb_io_set_nonblock(client->socket);
+  fn = fileno(file);
+
+  snprintf(header, BUFFER_UNIT, "%i:", len);
+  if (!socket_send(fn, header, strlen(header), wait_time)) {
+    client->socket_locked = FALSE;
+    rb_sys_fail(client->socket->path);
+  }
+
+  if (!socket_send(fn, str, len, wait_time)) {
+    client->socket_locked = FALSE;
+    rb_sys_fail(client->socket->path);
+  }
+
+  DEBUG("sent to %p: %s%s", client, header, str);
+
+  client->socket_locked = FALSE;
+}
+
+static gpointer
+client_send_unscore_for(Client *recipient, gpointer other) {
+  gchar msg[BUFFER_UNIT * 2];
+  Client *client = (Client *) other;
+  snprintf(msg, BUFFER_UNIT * 2, "xml:<MESSAGE><UNSCORE id=\"%p\"/></MESSAGE>",
+	   client);
+  client_send(recipient, msg, strlen(msg));
+  return NULL;
+}
+
+static void
+client_broadcast_unscore(Client *client) {
+  map_each_client_until(client->map, client_send_unscore_for, client);
+}
+
+static VALUE
+rb_client_unregister(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  map_unregister_body(client->map, client->body);
+  client_broadcast_unscore(client);
+  return self;
+}
+
+static gchar*
+client_model(Client *client) {
+  gchar *rval = calloc(BUFFER_UNIT, sizeof(gchar));
+  snprintf(rval, BUFFER_UNIT, "%s_%s", client->team, client->behaviour);
+  return rval;
+}
+
+static gpointer
+map_sum_score_for_team(Client *client, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  gchar *team = (gchar *) args[0];
+  gdouble *sum = (gdouble *) args[1];
+  if (strcmp(team, client->team) == 0)
+    (*sum) += client->score;
+  return NULL;
+}
+
+static gdouble
+map_team_score(Map *map, gchar *team) {
+  gdouble sum = 0;
+  gpointer args[2] = { team, &sum };
+  map_each_client_until(map, map_sum_score_for_team, args);
+  return sum;
+}
+
+static char*
+client_state(Client *client) {
+  return client->state == rb_standing ? standing : (client->state == rb_dodging ? dodging : dead);
+}
+
+static void
+client_send_score(Client *recipient, Client *subject) {
+  gchar msg[BUFFER_UNIT * 2];
+  snprintf(msg, BUFFER_UNIT * 2, "xml:<MESSAGE><SCORE id=\"%p\" nickname=\"%s\" team=\"%s\" state=\"%s\" score=\"%.1f\" kills=\"%.0f\" deaths=\"%.0f\"/></MESSAGE>",
+	   subject,
+	   subject->nickname,
+	   subject->team,
+	   client_state(subject),
+	   subject->score,
+	   subject->kills,
+	   subject->deaths);
+  client_send(recipient, msg, strlen(msg));
+}
+
+static gpointer
+client_send_score_for(Client *recipient, gpointer other) {
+  client_send_score(recipient, (Client *) other);
+  return NULL;
+}
+
+static void
+client_broadcast_score(Client *client) {
+  map_each_client_until(client->map, client_send_score_for, client);
+}
+
+static gpointer
+client_receive_score_for(Client *subject, gpointer recipient) {
+  client_send_score((Client *) recipient, subject);
+  return NULL;
+}
+
+static void
+client_receive_scores(Client *client) {
+  map_each_client_until(client->map, client_receive_score_for, client);
+}
+
+static VALUE
+rb_client_register(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  map_register_body(client->map, client->body);
+  client_receive_scores(client);
+  client->status_dirty = TRUE;
+  return self;
+}
+
+static void
+client_send_status(Client *client) {
+  if (client->status_dirty) {
+    gchar msg[BUFFER_UNIT * 2];
+    snprintf(msg, BUFFER_UNIT * 2, "xml:<MESSAGE><STATUS player_score=\"%.1f\" team_score=\"%.1f\" hitpoints=\"%.1f\" extra=\"%s\" id=\"%p\"/></MESSAGE>",
+	     client->score,
+	     map_team_score(client->map, client->team),
+	     client->hitpoints,
+	     client->extra_status != NULL ? client->extra_status : "",
+	     client);
+    client_send(client, msg, strlen(msg));
+
+    client_broadcast_score(client);
+
+    client->status_dirty = FALSE;
+  }
+}
+
+static void
+client_send_sighting(Client *viewer, Client *viewee) {
+  gchar msg[BUFFER_UNIT];
+  gchar *model = client_model(viewee);
+  snprintf(msg, BUFFER_UNIT, "xml:<MESSAGE><SIGHTING id=\"%p\" nickname=\"%s\" model=\"%s\" state=\"%s\" x=\"%i\" y=\"%i\"/></MESSAGE>",
+	   viewee,
+	   viewee->nickname,
+	   model,
+	   client_state(viewee),
+	   (gint) round(viewee->body->origo->x),
+	   (gint) round(viewee->body->origo->y));
+  free(model);
+  client_send(viewer, msg, strlen(msg));
+}
+
+static VALUE
+rb_client_send_sighting(VALUE self, VALUE o) {
+  Client *client;
+  Client *other;
+  CHECK_CLIENT(o);
+  CLIENT(self, client);
+  CLIENT(o, other);
+  client_send_sighting(client, other);
+  return o;
+}
+
+static void
+client_send_disappearance(Client *viewer, Client *viewee) {
+  gchar msg[BUFFER_UNIT];
+  snprintf(msg, BUFFER_UNIT, "xml:<MESSAGE><DISAPPEARANCE id=\"%p\"/></MESSAGE>",
+	   viewee);
+  client_send(viewer, msg, strlen(msg));
+}
+
+static VALUE
+rb_client_send_disappearance(VALUE self, VALUE o) {
+  Client *client;
+  Client *other;
+  CHECK_CLIENT(o);
+  CLIENT(self, client);
+  CLIENT(o, other);
+  client_send_disappearance(client, other);
+  return o;
+}
+
+static gpointer
+client_send_sighting_and_remove_viewer_from_hash(Client *viewer, Client *viewee, gpointer user_data) {
+  GHashTable *old_viewers = (GHashTable *) user_data;
+  client_send_sighting(viewer, viewee);
+  if (g_hash_table_lookup(old_viewers, viewer) != NULL)
+    g_hash_table_remove(old_viewers, viewer);
+  return NULL;
+}
+
+static gpointer
+client_send_sighting_and_remove_viewee_from_hash(Client *viewer, Client *viewee, gpointer user_data) {
+  gpointer *args = (gpointer *) user_data;
+  GHashTable *old_viewees = (GHashTable *) args[0];
+  Client *self = (Client *) args[1];
+  if (viewee != self) 
+    client_send_sighting(viewer, viewee);
+  if (g_hash_table_lookup(old_viewees, viewee) != NULL)
+    g_hash_table_remove(old_viewees, viewee);
+  return NULL;
+}
+
+static void
+g_hash_table_send_disappearance_to_key(gpointer key, gpointer value, gpointer user_data) {
+  client_send_disappearance((Client *) key, (Client *) user_data);
+}
+
+static void
+g_hash_table_send_disappearance_to_user_data(gpointer key, gpointer value, gpointer user_data) {
+  client_send_disappearance((Client *) user_data, (Client *) key);
+}
+
+static void
+client_update_viewers(Client *client, GHashTable *old_viewers) {
+  client_each_viewer(client, client_send_sighting_and_remove_viewer_from_hash, old_viewers);
+  g_hash_table_foreach(old_viewers, g_hash_table_send_disappearance_to_key, client);
+}
+
+static void
+client_update_viewees(Client *client, GHashTable *old_viewees) {
+  gpointer args[2] = { old_viewees, client };
+  client_each_viewee(client, client_send_sighting_and_remove_viewee_from_hash, args);
+  g_hash_table_foreach(old_viewees, g_hash_table_send_disappearance_to_user_data, client);
+}
+
+static void
+client_update_viewing(Client *client, GHashTable *old_viewers, GHashTable *old_viewees) {
+  client_update_viewers(client, old_viewers);
+  client_update_viewees(client, old_viewees);
+}
+
+static VALUE
+rb_client_update_viewing(VALUE self) {
+  Client *client;
+  GHashTable *old_viewers = g_hash_table_new(g_direct_hash, g_direct_equal);
+  GHashTable *old_viewees = g_hash_table_new(g_direct_hash, g_direct_equal);
+  CLIENT(self, client);
+  client_update_viewing(client, old_viewers, old_viewees);
+  g_hash_table_destroy(old_viewers);
+  g_hash_table_destroy(old_viewees);
+  return self;
+}
+
+static void
+client_set_position(Client *client, Point *new_location, VALUE new_state) {
+  if (round(new_location->x) != round(client->body->origo->x) ||
+      round(new_location->y) != round(client->body->origo->y) ||
+      new_state != client->state) {
+
+    GHashTable *old_viewers = g_hash_table_new(g_direct_hash, g_direct_equal);
+    GHashTable *old_viewees = g_hash_table_new(g_direct_hash, g_direct_equal);
+
+    client_each_viewer(client, client_add_viewer_to_hash, old_viewers);
+    client_each_viewee(client, client_add_viewee_to_hash, old_viewees);
+    
+    body_relocate(client->body, new_location);
+    if (client->state != new_state)
+      client->status_dirty = TRUE;
+    client->state = new_state;
+
+    client_update_viewing(client, old_viewers, old_viewees);
+
+    g_hash_table_destroy(old_viewers);
+    g_hash_table_destroy(old_viewees);
+  } else {
+    body_relocate(client->body, new_location);
+    client->state = new_state;
+  }
+}
+
+static VALUE
+rb_client_set_position(VALUE self, VALUE new_loc_val, VALUE new_state) {
+  Client *client;
+  Point *new_loc;
+  CHECK_POINT(new_loc_val);
+  CLIENT(self, client);
+  POINT(new_loc_val, new_loc);
+  client_set_position(client, new_loc, new_state);
+  return Qnil;
+}
+
+static gboolean
+command_not_includes_attribute(gpointer key, gpointer value, gpointer other_command_gp) {
+  Command *other_command = (Command *) other_command_gp;
+  gchar *other_value;
+  if ((other_value = (gchar *) g_hash_table_lookup(other_command->attributes, key)) == NULL)
+    return TRUE;
+  return strcmp(other_value, (gchar *) value) != 0;
+}
+
+static gboolean
+command_set_not_includes_command(gpointer name, gpointer command, gpointer other_set_gp) {
+  CommandSet *other_set = (CommandSet *) other_set_gp;
+  Command *other_command;
+  Command *this_command = (Command *) command;
+  if ((other_command = (Command *) g_hash_table_lookup(other_set->commands, name)) == NULL)
+    return TRUE;
+  return (g_hash_table_find(this_command->attributes, command_not_includes_attribute, other_command) != NULL &&
+	  g_hash_table_find(other_command->attributes, command_not_includes_attribute, this_command) != NULL);
+}
+
+static gboolean
+command_set_equal(CommandSet *set1, CommandSet *set2) {
+  return (g_hash_table_find(set1->commands, command_set_not_includes_command, set2) == NULL &&
+	  g_hash_table_find(set2->commands, command_set_not_includes_command, set1) == NULL);
+}
+
+static VALUE
+rb_command_set_equal(VALUE self, VALUE other) {
+  CommandSet *me;
+  CommandSet *o;
+  CHECK_COMMAND_SET(other);
+  COMMAND_SET(self, me);
+  COMMAND_SET(other, o);
+  return GBOOL2RB(command_set_equal(me, o));
+}
+
+static void
+client_insert_into_last_command(gpointer name, gpointer command, gpointer client) {
+  gchar *dup = g_strdup((gchar *) name);
+  g_hash_table_insert(( (Client *) client)->last_command, dup, dup);
+}
+
+static void
+client_save_current_command(Client *client) {
+  g_hash_table_remove_all(client->last_command);
+  g_hash_table_foreach(client->current_command->commands, client_insert_into_last_command, client);
+}
+
+static VALUE
+rb_client_save_current_command(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  client_save_current_command(client);
+  return self;
+}
+
+static void
+g_hash_table_insert_string_into_rb_ary(gpointer key, gpointer value, gpointer ary) {
+  rb_ary_push(*((VALUE *) ary), rb_str_new2((gchar *) key));
+}
+
+static VALUE
+rb_client_last_command(VALUE self) {
+  Client *client;
+  VALUE rval;
+  CLIENT(self, client);
+  rval = rb_ary_new();
+  g_hash_table_foreach(client->last_command, g_hash_table_insert_string_into_rb_ary, &rval);
+  return rval;
+}
+
+static void
+client_call_subscription_if_subscribed(gpointer key, gpointer value, gpointer client_gp) {
+  Client *client = (Client *) client_gp;
+  ID *meth;
+  if ((meth = g_hash_table_lookup(client->subscriptions, key)) != NULL) {
+    rb_funcall(client->rbClient, *meth, 1, ( (Command *) value )->rbCommand);
+  }
+}
+
+static void
+client_call_subscription_if_command_disappeared(gpointer key, gpointer value, gpointer client_gp) {
+  Client *client = (Client *) client_gp;
+  ID *meth;
+  if ((meth = g_hash_table_lookup(client->subscriptions, key)) != NULL &&
+      g_hash_table_lookup(client->current_command->commands, key) == NULL) {
+    rb_funcall(client->rbClient, *meth, 1, Qnil);
+  }
+}
+
+static void
+client_call_subscriptions(Client *client) {
+  g_hash_table_foreach(client->current_command->commands, client_call_subscription_if_subscribed, client);
+  g_hash_table_foreach(client->last_command, client_call_subscription_if_command_disappeared, client);
+}
+
+static void
+client_update(Client *client) {
+  if (client->state != rb_dead) {
+    Point new_location = { 0, 0, 0};
+    gdouble direction = -1.0;
+    VALUE new_state;
+
+    client_call_subscriptions(client);
+
+    new_location.x = client->body->origo->x;
+    new_location.y = client->body->origo->y;
+    new_state = client->state;
+
+    if (COMMAND_SET_INCLUDES(client->current_command, UP)) {
+      if (COMMAND_SET_INCLUDES(client->current_command, LEFT)) {
+	direction = 3.0 * M_PI_4;
+      } else if (COMMAND_SET_INCLUDES(client->current_command, RIGHT)) {
+	direction = 1.0 * M_PI_4;
+      } else {
+	direction = M_PI_2;
+      }
+    } else if (COMMAND_SET_INCLUDES(client->current_command, DOWN)) {
+      if (COMMAND_SET_INCLUDES(client->current_command, LEFT)) {
+	direction = 5.0 * M_PI_4;
+      } else if (COMMAND_SET_INCLUDES(client->current_command, RIGHT)) {
+	direction = 7.0 * M_PI_4;
+      } else {
+	direction = 3.0 * M_PI_2;
+      }
+    } else if (COMMAND_SET_INCLUDES(client->current_command, LEFT)) {
+      direction = M_PI;
+    } else if (COMMAND_SET_INCLUDES(client->current_command, RIGHT)) {
+      direction = 0.0;
+    }
+
+    if (COMMAND_SET_INCLUDES(client->current_command, DODGE)) {
+      new_state = rb_dodging;
+    } else {
+      new_state = rb_standing;
+    }
+
+    if (direction != -1) {
+      gdouble speed = client_speed(client);
+      Point wanted_new_destination = { client->body->origo->x + speed * cos(direction), client->body->origo->y - speed * sin(direction), 0 };
+      map_move(client->map, client->body->origo, &wanted_new_destination, &new_location);
+    }
+
+    client_set_position(client, &new_location, new_state);
+    client_send_status(client);
+
+    client_save_current_command(client);
+  }
+}
+
+static gpointer
+map_update_client_until(Client *client, gpointer null) {
+  client_update(client);
+  return NULL;
+}
+
+static VALUE
+rb_map_update(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  map_each_client_until(map, map_update_client_until, NULL);
+  return Qnil;
+}
+
+static VALUE
+rb_client_update(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+
+  client_update(client);
+
+  return Qnil;
+}
+
+static VALUE
+rb_map_get_timeout(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return INT2NUM(map->timeout);
+}
+
+static VALUE
+rb_map_set_timeout(VALUE self, VALUE timeout) {
+  Map *map;
+  MAP(self, map);
+  CHECK_NUMERICALITY(timeout);
+  map->timeout = NUM2INT(timeout);
+  return timeout;
+}
+
+static VALUE
+rb_map_get_viewing_distance_limit(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return INT2NUM(map->viewing_distance_limit);
+}
+
+static VALUE
+rb_map_set_viewing_distance_limit(VALUE self, VALUE viewing_distance_limit) {
+  Map *map;
+  MAP(self, map);
+  CHECK_NUMERICALITY(viewing_distance_limit);
+  map->viewing_distance_limit = NUM2INT(viewing_distance_limit);
+  return viewing_distance_limit;
+}
+
+static VALUE
+rb_client_get_running_speed(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return INT2NUM(client->running_speed);
+}
+
+static VALUE
+rb_client_set_running_speed(VALUE self, VALUE running_speed) {
+  Client *client;
+  CLIENT(self, client);
+  CHECK_NUMERICALITY(running_speed);
+  client->running_speed = NUM2INT(running_speed);
+  return running_speed;
+}
+
+static VALUE
+rb_client_model(VALUE self) {
+  Client *client;
+  VALUE rval;
+  gchar *str;
+  CLIENT(self, client);
+  str = client_model(client);
+  rval = rb_str_new2(str);
+  free(str);
+  return rval;
+}
+
+static VALUE
+rb_client_get_team(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  if (client->team == NULL)
+    return Qnil;
+  return rb_str_new2(client->team);
+}
+
+static VALUE
+rb_client_set_team(VALUE self, VALUE v) {
+  Client *client;
+  Check_Type(v, T_STRING);
+  CLIENT(self, client);
+  if (client->team != NULL) {
+    if (strcmp(client->extra_status, RSTRING(v)->ptr) != 0) {
+      free(client->team);
+      client->team = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+      client->status_dirty = TRUE;
+    }
+  } else {
+    client->team = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+    client->status_dirty = TRUE;
+  }
+  return v;
+}
+
+static VALUE
+rb_client_get_extra_status(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  if (client->extra_status == NULL)
+    return Qnil;
+  return rb_str_new2(client->extra_status);
+}
+
+static VALUE
+rb_client_set_extra_status(VALUE self, VALUE v) {
+  Client *client;
+  Check_Type(v, T_STRING);
+  CLIENT(self, client);
+  if (client->extra_status != NULL) {
+    if (strcmp(client->extra_status, RSTRING(v)->ptr) != 0) {
+      free(client->extra_status);
+      client->extra_status = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+      client->status_dirty = TRUE;
+    }
+  } else {
+    client->extra_status = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+    client->status_dirty = TRUE;
+  }
+  return v;
+}
+
+static VALUE
+rb_client_get_behaviour(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  if (client->behaviour == NULL)
+    return Qnil;
+  return rb_str_new2(client->behaviour);
+}
+
+static VALUE
+rb_client_set_behaviour(VALUE self, VALUE v) {
+  Client *client;
+  Check_Type(v, T_STRING);
+  CLIENT(self, client);
+  if (client->behaviour != NULL) {
+    if (strcmp(client->behaviour, RSTRING(v)->ptr) != 0) {
+      free(client->behaviour);
+      client->behaviour = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+      client->status_dirty = TRUE;
+    }
+  } else {
+    client->behaviour = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+    client->status_dirty = TRUE;
+  }
+  return v;
+}
+
+static VALUE
+rb_client_get_nickname(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  if (client->nickname == NULL)
+    return Qnil;
+  return rb_str_new2(client->nickname);
+}
+
+static VALUE
+rb_client_set_nickname(VALUE self, VALUE v) {
+  Client *client;
+  Check_Type(v, T_STRING);
+  CLIENT(self, client);
+  if (client->nickname != NULL) {
+    if (strcmp(client->nickname, RSTRING(v)->ptr) != 0) {
+      free(client->nickname);
+      client->nickname = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+      client->status_dirty = TRUE;
+    }
+  } else {
+    client->nickname = g_strndup(RSTRING(v)->ptr, RSTRING(v)->len);
+    client->status_dirty = TRUE;
+  }
+  return v;
+}
+
+static VALUE
+rb_client_get_socket(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return client->rbSocket;
+}
+
+static VALUE
+rb_client_set_socket(VALUE self, VALUE new_socket) {
+  Client *client;
+  OpenFile *fptr;
+
+  GetOpenFile(new_socket, fptr);
+  rb_io_check_writable(fptr);
+  CLIENT(self, client);
+
+  client->socket = fptr;
+  client->rbSocket = new_socket;
+
+  return new_socket;
+}
+
+static VALUE
+rb_client_send(VALUE self, VALUE str) {
+  Client *client;
+
+  Check_Type(str, T_STRING);
+  CLIENT(self, client);
+  if (client->socket == NULL) 
+    rb_raise(rb_eRuntimeError, "Client %p does not have a socket!", client);
+
+  client_send(client, RSTRING(str)->ptr, RSTRING(str)->len);
+
+  return str;
+}
+
+static VALUE
+rb_client_status_dirty(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return GBOOL2RB(client->status_dirty);
+}
+
+static VALUE
+rb_client_set_status_dirty(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  client->status_dirty = TRUE;
+  return Qtrue;
+}
+
+static VALUE
+rb_client_set_status_clean(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  client->status_dirty = FALSE;
+  return Qfalse;
+}
+
+static VALUE
+rb_map_body_parts(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->body_parts->rbGeoSet;
+}
+
+static VALUE
+rb_map_bodies(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->bodies->rbGeoSet;
+}
+
+static VALUE
+rb_map_eyes(VALUE self) {
+  Map *map;
+  MAP(self, map);
+  return map->eyes->rbGeoSet;
+}
+
+static VALUE
+rb_client_get_score(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return rb_float_new(client->score);
+}
+
+static VALUE
+rb_client_set_score(VALUE self, VALUE new_score) {
+  Client *client;
+  gdouble new_score_gdouble;
+  CHECK_NUMERICALITY(new_score);
+  CLIENT(self, client);
+  new_score_gdouble = NUM2DBL(new_score);
+  if (!DBL_EQL(new_score_gdouble, client->score)) {
+    client->status_dirty = TRUE;
+    client->score = new_score_gdouble;
+  }
+  return new_score;
+}
+
+static VALUE
+rb_client_get_kills(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return rb_float_new(client->kills);
+}
+
+static VALUE
+rb_client_set_kills(VALUE self, VALUE new_kills) {
+  Client *client;
+  gdouble new_kills_gdouble;
+  CHECK_NUMERICALITY(new_kills);
+  CLIENT(self, client);
+  new_kills_gdouble = NUM2DBL(new_kills);
+  if (!DBL_EQL(new_kills_gdouble, client->kills)) {
+    client->status_dirty = TRUE;
+    client->kills = new_kills_gdouble;
+  }
+  return new_kills;
+}
+
+static VALUE
+rb_client_get_deaths(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return rb_float_new(client->deaths);
+}
+
+static VALUE
+rb_client_set_deaths(VALUE self, VALUE new_deaths) {
+  Client *client;
+  gdouble new_deaths_gdouble;
+  CHECK_NUMERICALITY(new_deaths);
+  CLIENT(self, client);
+  new_deaths_gdouble = NUM2DBL(new_deaths);
+  if (!DBL_EQL(new_deaths_gdouble, client->deaths)) {
+    client->status_dirty = TRUE;
+    client->deaths = new_deaths_gdouble;
+  }
+  return new_deaths;
+}
+
+static VALUE
+rb_client_get_hitpoints(VALUE self) {
+  Client *client;
+  CLIENT(self, client);
+  return rb_float_new(client->hitpoints);
+}
+
+static VALUE
+rb_client_set_hitpoints(VALUE self, VALUE new_hitpoints) {
+  Client *client;
+  gdouble new_hitpoints_gdouble;
+  CHECK_NUMERICALITY(new_hitpoints);
+  CLIENT(self, client);
+  new_hitpoints_gdouble = NUM2DBL(new_hitpoints);
+  if (!DBL_EQL(new_hitpoints_gdouble, client->hitpoints)) {
+    client->status_dirty = TRUE;
+    client->hitpoints = new_hitpoints_gdouble;
+  }
+  return new_hitpoints;
+}
+
+static VALUE
+rb_client_subscribe(VALUE self, VALUE n, VALUE meth) {
+  Client *client;
+  ID *id;
+  gchar *name;
+  Check_Type(n, T_STRING);
+  Check_Type(meth, T_SYMBOL);
+  CLIENT(self, client);
+  id = ALLOC(ID);
+  *id = SYM2ID(meth);
+  name = g_strndup(RSTRING(n)->ptr, RSTRING(n)->len);
+  g_hash_table_insert(client->subscriptions, name, id);
+  return self;
+}
+
+static VALUE
+rb_client_unsubscribe(VALUE self, VALUE n) {
+  Client *client;
+  ID *id;
+  VALUE rval = 0;
+  Check_Type(n, T_STRING);
+  CLIENT(self, client);
+  id = g_hash_table_lookup(client->subscriptions, RSTRING(n)->ptr);
+  if (id != NULL)
+    rval = ID2SYM(*id);
+  g_hash_table_remove(client->subscriptions, RSTRING(n)->ptr);
+  if (rval != 0)
+    return rval;
+  else
+    return Qnil;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  void Init_grueserve_ext() {
+    init_grueserve_globals();
+
+    VALUE rb_grueserve = rb_define_module("Grueserve");
+    rb_map = rb_define_class_under(rb_grueserve,
+				   "Map",
+				   rb_cObject);
+    rb_client = rb_define_class_under(rb_grueserve,
+				      "Client",
+				      rb_cObject);
+    rb_command = rb_define_class_under(rb_client,
+				       "Command",
+				       rb_cObject);
+    rb_command_set = rb_define_class_under(rb_client,
+					   "CommandSet",
+					   rb_cObject);
+    rb_body = rb_define_class_under(rb_client,
+				    "Body",
+				    rb_cObject);
+    rb_e_terminated_connection = rb_define_class_under(rb_client,
+						       "TerminatedConnection",
+						       rb_eRuntimeError);
+
+    rb_define_alloc_func(rb_client, rb_client_alloc);
+    rb_define_method(rb_client, "register!", rb_client_register, 0);
+    rb_define_method(rb_client, "unregister!", rb_client_unregister, 0);
+    rb_define_method(rb_client, "registered?", rb_client_registered, 0);
+    rb_define_method(rb_client, "body", rb_client_get_body, 0);
+    rb_define_method(rb_client, "state", rb_client_get_state, 0);
+    rb_define_method(rb_client, "state=", rb_client_set_state, 1);
+    rb_define_method(rb_client, "moving?", rb_client_moving, 0);
+    rb_define_method(rb_client, "current_command", rb_client_get_current_command, 0);
+    rb_define_method(rb_client, "current_command=", rb_client_set_current_command, 1);
+    rb_define_method(rb_client, "last_command", rb_client_last_command, 0);
+    rb_define_method(rb_client, "save_current_command!", rb_client_save_current_command, 0);
+    rb_define_method(rb_client, "map", rb_client_get_map, 0);
+    rb_define_method(rb_client, "map=", rb_client_set_map, 1);
+    rb_define_method(rb_client, "client_id", rb_client_client_id, 0);
+    rb_define_method(rb_client, "last_ping", rb_client_get_last_ping, 0);
+    rb_define_method(rb_client, "ping!", rb_client_ping, 0);
+    rb_define_method(rb_client, "update!", rb_client_update, 0);
+    rb_define_method(rb_client, "running_speed", rb_client_get_running_speed, 0);
+    rb_define_method(rb_client, "running_speed=", rb_client_set_running_speed, 1);
+    rb_define_method(rb_client, "socket=", rb_client_set_socket, 1);
+    rb_define_method(rb_client, "socket", rb_client_get_socket, 0);
+    rb_define_method(rb_client, "send", rb_client_send, 1);
+    rb_define_method(rb_client, "team", rb_client_get_team, 0);
+    rb_define_method(rb_client, "team=", rb_client_set_team, 1);
+    rb_define_method(rb_client, "extra_status", rb_client_get_extra_status, 0);
+    rb_define_method(rb_client, "extra_status=", rb_client_set_extra_status, 1);
+    rb_define_method(rb_client, "behaviour", rb_client_get_behaviour, 0);
+    rb_define_method(rb_client, "behaviour=", rb_client_set_behaviour, 1);
+    rb_define_method(rb_client, "nickname", rb_client_get_nickname, 0);
+    rb_define_method(rb_client, "nickname=", rb_client_set_nickname, 1);
+    rb_define_method(rb_client, "model", rb_client_model, 0);
+    rb_define_method(rb_client, "send_sighting", rb_client_send_sighting, 1);
+    rb_define_method(rb_client, "send_disappearance", rb_client_send_disappearance, 1);
+    rb_define_method(rb_client, "viewers", rb_client_viewers, 0);
+    rb_define_method(rb_client, "viewees", rb_client_viewees, 0);
+    rb_define_method(rb_client, "update_viewing", rb_client_update_viewing, 0);
+    rb_define_method(rb_client, "status_dirty?", rb_client_status_dirty, 0);
+    rb_define_method(rb_client, "status_dirty!", rb_client_set_status_dirty, 0);
+    rb_define_method(rb_client, "status_clean!", rb_client_set_status_clean, 0);
+    rb_define_method(rb_client, "score", rb_client_get_score, 0);
+    rb_define_method(rb_client, "score=", rb_client_set_score, 1);
+    rb_define_method(rb_client, "kills", rb_client_get_kills, 0);
+    rb_define_method(rb_client, "kills=", rb_client_set_kills, 1);
+    rb_define_method(rb_client, "deaths", rb_client_get_deaths, 0);
+    rb_define_method(rb_client, "deaths=", rb_client_set_deaths, 1);
+    rb_define_method(rb_client, "hitpoints", rb_client_get_hitpoints, 0);
+    rb_define_method(rb_client, "hitpoints=", rb_client_set_hitpoints, 1);
+    rb_define_method(rb_client, "set_position", rb_client_set_position, 2);
+    rb_define_method(rb_client, "subscribe", rb_client_subscribe, 2);
+    rb_define_method(rb_client, "unsubscribe", rb_client_unsubscribe, 1);
+
+    rb_define_alloc_func(rb_map, rb_map_alloc);
+    rb_define_method(rb_map, "movement_obstacles", rb_map_movement_obstacles, 0);
+    rb_define_method(rb_map, "visibility_obstacles", rb_map_visibility_obstacles, 0);
+    rb_define_method(rb_map, "bullet_obstacles", rb_map_bullet_obstacles, 0);
+    rb_define_method(rb_map, "hearing_obstacles", rb_map_hearing_obstacles, 0);
+    rb_define_method(rb_map, "fortifications", rb_map_fortifications, 0);
+    rb_define_method(rb_map, "speed_areas", rb_map_speed_areas, 0);
+    rb_define_method(rb_map, "protection_areas", rb_map_protection_areas, 0);
+    rb_define_method(rb_map, "hidden_areas", rb_map_hidden_areas, 0);
+    rb_define_method(rb_map, "body_parts", rb_map_body_parts, 0);
+    rb_define_method(rb_map, "bodies", rb_map_bodies, 0);
+    rb_define_method(rb_map, "eyes", rb_map_eyes, 0);
+    rb_define_method(rb_map, "[]", rb_map_get, 1);
+    rb_define_method(rb_map, "[]=", rb_map_set, 2);
+    rb_define_method(rb_map, "timeout", rb_map_get_timeout, 0);
+    rb_define_method(rb_map, "timeout=", rb_map_set_timeout, 1);
+    rb_define_method(rb_map, "viewing_distance_limit", rb_map_get_viewing_distance_limit, 0);
+    rb_define_method(rb_map, "viewing_distance_limit=", rb_map_set_viewing_distance_limit, 1);
+    rb_define_method(rb_map, "each_client", rb_map_each_client, 0);
+    rb_define_method(rb_map, "viewers_of", rb_map_viewers_of, 1);
+    rb_define_method(rb_map, "update!", rb_map_update, 0);
+
+    rb_undef_method(rb_body, "initialize");
+    rb_define_method(rb_body, "origo", rb_body_get_origo, 0);
+    rb_define_method(rb_body, "vertical_axis", rb_body_get_vertical_axis, 0);
+    rb_define_method(rb_body, "horizontal_axis", rb_body_get_horizontal_axis, 0);
+    rb_define_method(rb_body, "relocate", rb_body_relocate, 1);
+    rb_define_method(rb_body, "inspect", rb_body_inspect, 0);
+
+    rb_define_alloc_func(rb_command, rb_command_alloc);
+    rb_define_method(rb_command, "[]", rb_command_get, 1);
+    rb_define_method(rb_command, "[]=", rb_command_insert, 2);
+    rb_define_method(rb_command, "name", rb_command_get_name, 0);
+    rb_define_method(rb_command, "name=", rb_command_set_name, 1);
+    rb_define_method(rb_command, "inspect", rb_command_inspect, 0);
+
+    rb_define_alloc_func(rb_command_set, rb_command_set_alloc);
+    rb_define_method(rb_command_set, "[]", rb_command_set_get, 1);
+    rb_define_method(rb_command_set, "<<", rb_command_set_push, 1);
+    rb_define_method(rb_command_set, "include?", rb_command_set_include, 1);
+    rb_define_method(rb_command_set, "inspect", rb_command_set_inspect, 0);
+    rb_define_method(rb_command_set, "==", rb_command_set_equal, 1);
+  }
+#ifdef __cplusplus
+}
+#endif
+