--- a/src/Application.cc	Tue Jan 20 23:30:18 2009 +0200
+++ b/src/Application.cc	Wed Jan 21 00:21:42 2009 +0200
@@ -2,6 +2,7 @@
 #include "Application.hh"
 
 #include <stdexcept>
+#include <sstream>
 #include <cstdio>
 #include <cassert>
 
@@ -14,10 +15,22 @@
     ARG_FULLSCREEN  = 'F',
     ARG_RESOLUTION  = 'R',
 
-    ARG_LIST_MODES  = 0xff01,
-    ARG_VERSION     = 0xff02,
+    ARG_LIST_MODES      = 0xff01,
+    ARG_VERSION         = 0xff02,
+    ARG_TERRAIN_SEED    = 0xff03,
+    ARG_TERRAIN_SIZE    = 0xff04,
+
 };
 
+        
+Main::Main (void) :
+    graphics_enabled(false),
+    net_port(NETWORK_PORT_STR),
+    net_server(false),
+    net_connect("")
+{
+
+}
 
 /**
  * Set the arg_* members
@@ -48,17 +61,15 @@
     args.add_option(ARG_LIST_MODES, "list-modes", "",
             "output a list of available display modes and exit");
 
+    args.add_option(ARG_TERRAIN_SEED, "terrain-seed", "SEED",
+            "set seed for terrain random generator");
+
+    args.add_option(ARG_TERRAIN_SIZE, "terrain-size", "WIDTHxHEIGHT",
+            "set terrain size for random generator");
+
     args.add_option(ARG_VERSION, "version", "",
             "output application version and exit");
 
-    // set defaults
-    arg_graphics = false;
-    arg_port = NETWORK_PORT_STR;
-    arg_server = false;
-    arg_connect = "";
-    graphics.fullscreen = GRAPHICS_FULLSCREEN;
-    graphics.resolution = PixelCoordinate(GRAPHICS_RESOLUTION_WIDTH, GRAPHICS_RESOLUTION_HEIGHT);
-
     // extra state
     bool resolution_default = true;
     
@@ -77,19 +88,19 @@
                 return false;
 
             case ARG_PORT:
-                arg_port = args.get_argument();
+                net_port = args.get_argument();
                 break;
 
             case ARG_SERVER:
-                arg_server = true;
+                net_server = true;
                 break;
 
             case ARG_CLIENT:
-                arg_connect = args.get_argument();
+                net_connect = args.get_argument();
                 break;
 
             case ARG_GRAPHICS:
-                arg_graphics = true;
+                graphics_enabled = true;
                 break;
 
             case ARG_FULLSCREEN:
@@ -106,7 +117,7 @@
                 break;
 
             case ARG_RESOLUTION:
-                parse_arg_resolution(args.get_argument());
+                graphics.resolution = parse_arg_dimensions(args.get_argument(), "--resolution");
                 resolution_default = false;
                 break;
 
@@ -118,36 +129,55 @@
                 dump_version();
                 return false;
 
+            case ARG_TERRAIN_SEED:
+                terrain.random_seed = parse_arg_int(args.get_argument(), "--terrain-seed");
+                break;
+
+            case ARG_TERRAIN_SIZE:
+                terrain.dimensions = parse_arg_dimensions(args.get_argument(), "--terrain-size");
+                break;
+
             case CL_CommandLine::REST_ARG:
-                throw ArgumentError(args.get_argument());
+                throw ArgumentError("Trailing arguments: " + args.get_argument());
 
             default:
-                throw ArgumentError(std::string(1, (char) args.get_key()));
+                throw ArgumentError(std::string() + "Unknown argument key: " + (char) args.get_key());
 
         }
     }
 
     // check for invalid combinations of arugments
-    if (arg_server and !arg_connect.empty())
+    if (net_server and !net_connect.empty())
         throw ArgumentError("cannot be both server and client");
 
     // enable graphics by default unless server
-    if (!arg_server)
-        arg_graphics = true;
+    if (!net_server)
+        graphics_enabled = true;
     
     // continue
     return true;
 }
         
-void Main::parse_arg_resolution (const std::string &val) {
+int Main::parse_arg_int (const std::string &arg_val, const char *arg_name) {
+    int int_val;
+    
+    // read using istringstream
+    std::istringstream ss(arg_val);
+    
+    if (!(ss >> int_val))
+        throw ArgumentError(std::string() + "invalid integer arugment for " + arg_name + ": " + arg_val);
+
+    return int_val;
+}
+
+PixelCoordinate Main::parse_arg_dimensions (const std::string &arg_val, const char *arg_name) {
     unsigned int w, h;
     
     // sccanf as unsigned
-    if (sscanf(val.c_str(), "%ux%u", &w, &h) != 2)
-        throw ArgumentError("invalid format for --resolution");
+    if (sscanf(arg_val.c_str(), "%ux%u", &w, &h) != 2)
+        throw ArgumentError(std::string() + "invalid format for " + arg_name + ": " + arg_val);
     
-    // store as PixelCoordinate
-    graphics.resolution = PixelCoordinate(w, h);
+    return PixelCoordinate(w, h);
 }
         
 void Main::dump_display_modes (void) {
@@ -180,17 +210,21 @@
 
         // our engine
         Engine engine;
+
+        // setup game unless client
+        if (net_connect.empty())
+            engine.setupGame(terrain);
         
         // setup graphics
-        if (arg_graphics)
+        if (graphics_enabled)
             engine.setupGraphics(graphics);
 
         // setup either network server, client or singleplayer
-        if (arg_server) {
-            engine.setupNetworkServer(arg_port);
+        if (net_server) {
+            engine.setupNetworkServer(net_port);
 
-        } else if (!arg_connect.empty()) {
-            engine.setupNetworkClient(arg_connect, arg_port);
+        } else if (!net_connect.empty()) {
+            engine.setupNetworkClient(net_connect, net_port);
         
         } else {
             engine.setupSinglePlayer();