diff --git a/.eslintrc.json b/.eslintrc.json
new file mode 100644
index 0000000..75c9eb4
--- /dev/null
+++ b/.eslintrc.json
@@ -0,0 +1,68 @@
+{
+    "root": true,
+    "extends": [
+        "eslint:recommended"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 6,
+        "sourceType": "module",
+        "ecmaFeatures": {
+            "globalReturn": true,
+            "impliedStrict": true
+        }
+    },
+    "env": {
+        "es6": true,
+        "node": true
+    },
+    "rules": {
+        "no-trailing-spaces": [2],
+        "no-multiple-empty-lines": [2, {"max": 2, "maxEOF": 0}],
+        "eol-last": [2],
+        "indent": [0],
+        "indent-legacy": [2, 4, {"SwitchCase": 1}],
+        "max-len": [0, 80],
+        "brace-style": [0, "stroustrup", {"allowSingleLine": true}],
+        "curly": [2, "multi-line"],
+        "camelcase": [0, {"properties": "never"}],
+        "comma-spacing": [2, {"before": false, "after": true}],
+        "comma-style": [2, "last"],
+        "semi": [2],
+        "semi-spacing": [2, {"before": false, "after": true}],
+        "key-spacing": [2, {"beforeColon": false, "afterColon": true}],
+        "keyword-spacing": [2, {"overrides": {
+            "if": {"after": true},
+            "for": {"after": true},
+            "while": {"after": true},
+            "switch": {"after": false},
+            "catch": {"after": false}
+        }}],
+        "no-spaced-func": [2],
+        "space-in-parens": [2, "never"],
+        "space-before-function-paren": [2, "never"],
+        "space-before-blocks": [2],
+        "spaced-comment": [2, "always"],
+        "no-tabs": [2],
+        "no-multi-spaces": [2, {"ignoreEOLComments": true}],
+        "no-whitespace-before-property": [2],
+        "no-unexpected-multiline": [2],
+        "no-floating-decimal": [2],
+        "space-infix-ops": [2, {"int32Hint": true}],
+        "quotes": [2, "single"],
+        "dot-notation": [2],
+        "dot-location": [2, "property"],
+        "operator-linebreak": [2, "after"],
+        "eqeqeq": [2],
+        "new-cap": [2, { "capIsNewExceptionPattern": "^MathJax\\.." }],
+        "no-redeclare": [2, {"builtinGlobals": true}],
+        "no-shadow": [0, {"builtinGlobals": true}],
+        "block-scoped-var": [2],
+        "no-unused-vars": [2],
+        "no-undef-init": [2],
+        "no-use-before-define": [2, "nofunc"],
+        "no-loop-func": [2],
+        "no-console": [0],
+        "no-unused-labels": [2],
+        "no-useless-escape": [0]
+    }
+}
diff --git a/.travis.yml b/.travis.yml
index b1aa99b..7ced4f9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,6 +4,7 @@ node_js:
   - 6
   - 7
   - 8
+  - 10
 
 before_install:
 # Get installer script.
@@ -12,7 +13,8 @@ before_install:
 
 install:
   - npm install --only=dev
-  - node nodegame-installer.js @dev --install-dir node_modules --no-spinner --branch v4 --yes
+    # --branch v4
+  - node nodegame-installer.js @dev --install-dir node_modules --no-spinner --yes
 
 script:
 # Add module tests here.
diff --git a/CHANGELOG b/CHANGELOG
index c95d645..dd7e645 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,9 +1,53 @@
 # CHANGELOG
 
-## 4.0.0 (current)
+## 7.0.1 ## current
+- Fixed bugs and typos for export.
+
+## 7.0.0
+- Export functions added for logs and data.
+
+## 6.0.2
+- Games directories are always set by update-conf.
+- Updated to newer version of commander.
+
+## 6.0.1
+- Minor text.
+
+## 6.0.0
+- Single-player game.
+
+## 5.1.0
+- The private directory is created.
+
+## 5.0.1
+- Game names cannot start with a dot.
+
+## 5.0.0
+- Relative links for games enabled.
+
+## 4.2.1
+- CSS file copied
+- .gitignore is correctly handled also in non-dev version.
+
+## 4.2.0
+- Auto generate secret and credentials files.
+- Eslinted nodegame.
+- Added README and LICENSE.
+- Description included.
+
+## 4.1.1
+- Improved parameter checking, display of help.
+- Fixed bug update-conf not loading the latest author and email parameters.
+- File .gitignore is added by default.
+
+## 4.1.0
+- Auto-detect nodeGame installation folder
+- Enable games created in games/.
+- Small fixes.
+
+## 4.0.0
 - show-conf command.
 - Replace default nodeGame copyright string.
-- TODO: multiple templates.
 
 ## 1.1.2
 - Minor fix for autoplay template.
diff --git a/LICENSE b/LICENSE
index 26c0955..054092c 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2015 Stefano Balietti
+Copyright (c) 2018 Stefano Balietti
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/README.md b/README.md
index 8af16ab..358522c 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ This generator can also be further configured with the following command line fl
 
 ## Kudos
 
-Based on a fork of [Express Generator](https://github.com/expressjs/generator).
+Originally based on a fork of [Express Generator](https://github.com/expressjs/generator).
 
 ## License
 
diff --git a/bin/nodegame b/bin/nodegame
index 3c6ce43..2e7101c 100755
--- a/bin/nodegame
+++ b/bin/nodegame
@@ -1,33 +1,108 @@
-#!/usr/bin/env node
+#!/usrng/bin/env node
 
-var program = require('commander');
-var mkdirp = require('mkdirp');
-var os = require('os');
-var fs = require('fs-extra');
-var path = require('path');
-var readline = require('readline');
-var sortedObject = require('sorted-object');
+const program = require('commander');
+const mkdirp = require('mkdirp');
+const fs = require('fs-extra');
+const path = require('path');
+const readline = require('readline');
 
-var J = require('JSUS').JSUS;
-var ngt = require('nodegame-game-template');
+const J = require('JSUS').JSUS;
+const ngt = require('nodegame-game-template');
 
-var _exit = process.exit;
-var eol = os.EOL;
-var pkg = require('../package.json');
+const pkg = require('../package.json');
+const version = pkg.version;
 
-var version = pkg.version;
+const isWin = /^win/.test(process.platform);
 
-var root = path.resolve(__dirname, '..');
-var confFile = root + '/conf/generator.conf.json';
+// This file is "copied" and not linked in Windows,
+// therefore we need to be agnostic while loading the root path.
+const root = J.resolveModuleDir('nodegame-generator');
+const confFile = path.resolve(root, 'conf', 'generator.conf.json');
 
-// Re-assign process.exit because of commander
-process.exit = exit
+const exp = require(path.resolve(root, 'lib', 'export.js'));
 
-// Mock configuration. Will be overwritten.
+const NODEGAME_MODULE = 'nodegame';
+// const NODEGAME_MODULE = 'nodegame-test';
+
+// Setup readline.
+let rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+});
+rl.on('SIGINT', function() {
+    rl.close();
+    console.log();
+    console.log();
+    console.log('canceled');
+});
+
+var stdoutConf = {
+    willBeMuted: false,
+    muted: false,
+    lastPrompt: '',
+    origPrompt: ''
+};
+unmute();
+
+function muteNext() {
+    if (stdoutConf.muted) unmute();
+    stdoutConf.willBeMuted = true;
+}
+
+function unmute() {
+    stdoutConf.willBeMuted = false;
+    stdoutConf.muted = false;
+    stdoutConf.lastPrompt = '';
+    stdoutConf.origPrompt = '';
+}
+
+function mute() {
+    stdoutConf.willBeMuted = false;
+    stdoutConf.muted = true;
+}
+
+rl._writeToOutput = function _writeToOutput(str) {
+    // console.log('INPUT ', str, str.length);
+    if (stdoutConf.muted) {
+        if (str.length > 2) {
+            // console.log('LEN : ', str.length);
+            // console.log('1');
+            let len = stdoutConf.lastPrompt.length;
+            let lenOrig = stdoutConf.origPrompt.length;
+            str = stdoutConf.lastPrompt.substr(0, Math.max(lenOrig, len - 1));
+            stdoutConf.lastPrompt = str;
+            rl.output.write(str);
+        }
+        else if (str.length === 2) {
+            rl.output.write(str);
+        }
+        else {
+            // console.log('2');
+            rl.output.write('*');
+            stdoutConf.lastPrompt += '*';
+        }
+    }
+    else {
+        // console.log('3');
+        rl.output.write(str);
+    }
+    if (stdoutConf.willBeMuted) {
+        stdoutConf.lastPrompt = stdoutConf.origPrompt = str;
+        mute();
+    }
+};
+
+// Game-creation configuration.
+
+// Will be overwritten.
 var conf = {
     author: 'author',
     email: 'email',
-    gamesFolder: undefined
+    ngDir: undefined,
+    ngVersion: undefined,
+    ngGamesAvailDir: undefined,
+    ngGamesEnabledDir: undefined,
 };
 
 // Available templates.
@@ -36,25 +111,11 @@ var templates = {
 };
 
 // TODO: make templates actually loading from games_available.
-var templatesDir = 'TO_BE_DEFINED';
+// var templatesDir = 'TO_BE_DEFINED';
 
 // Chosen template. Default dictator.
 const DEFAULT_TEMPLATE = 'dictator';
 
-
-// Full copyright string. Will be overwritten.
-var fullCopyright;
-
-// Flag if a command is passed at all.
-var cmdValue;
-
-// CLI
-
-before(program, 'outputHelp', function () {
-    this.allowUnknownOption();
-});
-
-
 // program
 //     .command('list-templates')
 //     .description('List all available game templates')
@@ -65,40 +126,61 @@ before(program, 'outputHelp', function () {
 //             if (templates.hasOwnProperty(t)) {
 //                 str = ' - ' + t;
 //                 if (t === DEFAULT_TEMPLATE) str += '  **default**';
-//                 console.log(str);                
+//                 console.log(str);
 //             }
 //         }
 //         console.log();
 //     });
 
+program.version(version);
 
 program
-    .version(version)
     .command('update-conf')
     .description('Updates stored configuration (author, games dir, etc.)')
-    .action(function(env, options){
-        createConfFile(options);
+    .allowUnknownOption()
+    .action(function(options) {
+
+        loadConfFile(function() {
+            // Nothing.
+            rl.close();
+        }, true);
     });
 
 program
-    .version(version)
     .command('show-conf')
     .description('Shows current configuration')
-    .action(function(env, options){
+    .allowUnknownOption()
+    .action(function(options) {
+
         loadConfFile(function() {
             showConf();
+            rl.close();
         });
     });
 
 program
     .command('create-game [game_name] [author] [author_email]')
     .description('Creates a new game in the games directory')
-    .option('    --git', 'add .gitignore')
-    // .option('-t, --template <template>', 'set the template for game')
+// .option('-t, --template <template>', 'set the template for game')
     .option('-f, --force', 'force on non-empty directory')
     .option('-v, --verbose', 'verbose output')
+    .allowUnknownOption()
     .action(function(gameName, author, email, options) {
 
+        if (!gameName) {
+            console.log('Error: game name is missing.');
+            rl.close();
+            return;
+        }
+
+        // Do not generate confusion with hidden folders, e.g. .git.
+        if (gameName.charAt(0) === '.') {
+            console.log('Error: game names cannot start with a dot. ' +
+                        'Please correct the name and try again.');
+            rl.close();
+            return;
+        }
+
         loadConfFile(function() {
             createGame({
                 game: gameName,
@@ -106,34 +188,271 @@ program
                 email: email,
                 options: options
             });
+            // rl.close in complete();
         });
 
     });
 
+program
+    .command('export-data <game>')
+    .description('Exports data from a game.')
+    // Input/Output
+   .option('    --games-dir <dir>', 'games directory (default games/)')
+   .option('    --export-dir <dir>', 'export directory (default export)')
+   .option('    --create-export-sub-dir', 'create sub-directory inside export directory')
+   .option('-r, --recursive', 'recursively search for files')
+   .option('    --files <files>', 'comma separated list of files/patterns')
+   .option('    --files-add <files>', 'comma separated list of ' +
+           'files/patterns to add to defaults')
+   .option('    --out-format <format>', 'the export format (json,ndjson,csv)')
+   .option('    --in-format <format>', 'the import format (json,ndjson,csv)')
+    // Handle errors.
+    .option('    --on-duplicated-names <action>', 'action to take if a file ' +
+           'with same name exists in export directory (rename|append|err)')
+    .option('-t, --throw', 'throws errors (default continues to next file)')
+    // Filters.
+    .option('    --rooms <rooms>', 'room/s to export')
+    .option('    --from-room <room>', 'export from room (included)')
+    .option('    --to-room <room>', 'export up to room (included)')
+    // Process.
+    .option('    --on-insert <file.js>', 'path to file exporting a function to modify items')
+    // CSV
+    .option('    --out-csv-flatten [group]', 'merges all items [by group] before export')
+    .option('    --out-csv-header <header>', 'header for export csv files (comma separeted values)')
+    .option('    --out-csv-no-header', 'no header in export csv files')
+    .option('    --out-csv-obj-level <level>', 'level of nested objects to expand before export')
+    .option('    --in-csv-header <header>', 'header for import csv files (comma separeted values)')
+    .option('    --in-csv-no-header', 'no header in import csv files')
+    // Verbose.
+    .option('-v, --verbose', 'verbose output')
+    .allowUnknownOption()
+    .action(function(game, opts) {
+        // console.log(arguments);
+        opts.game = game;
+        processExportOptions(opts);
+
+        loadConfFile(() => exp.data(conf, opts, terminateExport));
+
+    });
+
+program
+    .command('export-logs')
+    .description('Exports logs from nodeGame server')
+     // Input/Output
+    .option('    --log-dir <dir>', 'log directory (default log/)')
+    .option('    --export-dir <dir>', 'export directory (default export)')
+    .option('    --create-export-sub-dir', 'create sub-directory inside export directory')
+    .option('-r, --recursive', 'recursively search for files')
+    .option('    --files <files>', 'comma separated list of files/patterns')
+    .option('    --files-add <files>', 'comma separated list of ' +
+            'files/patterns to add to defaults')
+    .option('    --out-format <format>', 'the export format (json,ndjson,csv)')
+    .option('    --in-format <format>', 'the import format (json,ndjson,csv)')
+    // Handle errors.
+    .option('    --on-duplicated-names <action>', 'action to take if a file ' +
+            'with same name exists in export directory (rename|append|err)')
+    .option('-t, --throw', 'throws errors (default continues to next file)')
+    // Filters.
+    .option('    --game <game>', 'export logs only for this game')
+    .option('    --set-msg-only', 'exports only "set" messages (e.g., "done" msgs)')
+    .option('    --clean-up', 'cleanup logs before export')
+    .option('    --msg-type <type>', 'messages to export (incoming|outgoing|all)')
+     // CSV
+    .option('    --out-csv-flatten [group]', 'merges all items [by group] before export')
+    .option('    --out-csv-header <header>', 'header for export csv files (comma separeted values)')
+    .option('    --out-csv-no-header', 'no header in export csv files')
+    .option('    --out-csv-obj-level <level>', 'level of nested objects to expand before export')
+    .option('    --in-csv-header <header>', 'header for import csv files (comma separeted values)')
+    .option('    --in-csv-no-header', 'no header in import csv files')
+    // Verbose.
+    .option('-v, --verbose', 'verbose output')
+    .allowUnknownOption()
+    .action(function(opts) {
+
+        processExportOptions(opts);
+
+        loadConfFile(() => exp.logs(conf, opts, terminateExport));
+
+    });
+
+/**
+ * ## detectNodeGameInstallation
+ *
+ * Try to detect a nodeGame normal installation
+ *
+ * First looks 2 and then 1 directories above.
+ *
+ * @return {object|boolean} An object with paths, or FALSE if detection failed.
+ */
+function detectNodeGameInstallation() {
+    let ngDir = path.resolve(root, '..', '..');
+    let ngPkg = {};
+    try {
+        ngPkg = require(path.resolve(ngDir, 'package.json'));
+    }
+    catch(e) {
+        ngDir = path.resolve(root, '..');
+    }
+    if (!ngPkg) {
+        try {
+            ngPkg = require(path.resolve(ngDir, 'package.json'));
+        }
+        catch(e) {
+            // Nothing.
+        }
+    }
+    if (ngPkg.name === NODEGAME_MODULE) {
+
+        console.log('NodeGame v' + ngPkg.version +
+                    ' installation detected in: ');
+        console.log(ngDir);
+        console.log('');
+
+        let gameDirs = checkGameDirs(ngDir);
+        if (!gameDirs) {
+            console.log('However, folders games and/or games_available ' +
+                        'could not be found');
+        }
+        else {
+            return {
+                ngVersion: ngPkg.version,
+                ngDir: ngDir + path.sep,
+                ngGamesAvailDir: gameDirs.ngGamesAvailDir,
+                ngGamesEnabledDir: gameDirs.ngGamesEnabledDir
+            };
+        }
+    }
+    return false;
+}
+
+/**
+ * ## processExportOptions
+ *
+ * Calls process.exit otherwise the process hangs
+ */
+const processExportOptions = opts => {
+    if (opts.throw) {
+        opts.onError = 'throw';
+        delete opts.throw;
+    }
+
+    if (opts.logDir) {
+        opts.dataDir = opts.logDir;
+        delete opts.logDir;
+    }
+
+    if (opts.gamesDir) {
+        opts.dataDir = opts.gamesDir;
+        delete opts.gamesDir;
+    }
+
+    if (opts.msgType) {
+        let m = opts.msgType;
+        if (m === 'incoming' || m === 'all') opts.incoming = true;
+        if (m === 'outgoing' || m === 'all') opts.outgoing = true;
+        delete opts.msgType;
+    }
+
+    if ('string' === typeof opts.files) opts.files = opts.files.split(',');
+    if (opts.filesAdd) opts.filesAdd = opts.filesAdd.split(',');
+
+    if ('string' === typeof opts.outCsvHeader) {
+        opts.outCsvHeader = opts.outCsvHeader.split(',');
+    }
+    if (opts.outCsvNoHeader) opts.outCsvHeader = false;
+
+    if ('string' === typeof opts.inCsvHeader) {
+        opts.inCsvHeader = opts.inCsvHeader.split(',');
+    }
+    if (opts.inCsvNoHeader) opts.inCsvHeader = false;
+
+    if (opts.outCsvObjLevel) opts.outCsvObjLevel = J.isInt(opts.outCsvObjLevel);
+
+    if (opts.outCsvFlatten) {
+        if ('string' === typeof opts.outCsvFlatten) {
+            opts.outCsvFlattenByGroup = opts.outCsvFlatten;
+            opts.outCsvFlatten = true;
+        }
+    }
+
+    if (opts.onInsert) {
+        let p = opts.onInsert;
+        // console.log(p);
+        if (!path.isAbsolute(p) && !p.substring(0,2) === "./") {
+            p = "./" + p;
+        }
+
+        try {
+            p = require(p);
+            if ('function' !== typeof p) {
+                console.log('Error: on-insert did not return a function');
+                opts.onInsert = null;    
+            }
+            else {
+                opts.onInsert = p;
+            }
+        }
+        catch(e) {
+            if (opts.verbose) console.log(e);
+            console.log('Error: could not load on-insert function');
+            opts.onInsert = null;
+        }
+    }
+};
+
 /**
- * Install a before function; AOP.
+ * ## terminateExport
+ *
+ * Calls process.exit otherwise the process hangs
  */
-function before(obj, method, fn) {
-    var old = obj[method];
+const terminateExport = () => {
+    console.log();
+    console.log(' *** Export finished.');
+    console.log();
+    process.exit();
+};
 
-    obj[method] = function () {
-        fn.call(this);
-        old.apply(this, arguments);
-    };
+/**
+ * ## checkGameDirs
+ *
+ * Verifies that games and games_available exist in the given folder
+ *
+ * @param {string} ngDir The path to the nodegame installation
+ *
+ * @return {object|boolean} An object with paths, or FALSE if detection failed.
+ */
+function checkGameDirs(ngDir) {
+    let ngGamesAvail = path.resolve(ngDir, 'games_available');
+    if (fs.existsSync(ngGamesAvail)) {
+        let ngGames = path.resolve(ngDir, 'games');
+        if (fs.existsSync(ngGames)) {
+            return {
+                ngGamesEnabledDir: ngGames + path.sep,
+                ngGamesAvailDir: ngGamesAvail + path.sep
+            };
+        }
+    }
+    return false;
 }
 
 /**
  * Prompt for confirmation on STDOUT/STDIN
  */
-function confirm(msg, callback) {
-    var rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
+function confirm(msg, cb) {
+    rl.question(msg, function(input) {
+        cb(/^y|yes|ok|true$/i.test(input));
     });
+}
 
-    rl.question(msg, function (input) {
-        rl.close();
-        callback(/^y|yes|ok|true$/i.test(input));
+function questionNoBlank(msg, cb) {
+    rl.question(msg, function(answer) {
+        // console.log('ANSWER WAS: ' + answer);
+        if ('undefined' === typeof answer || answer.trim() === '') {
+            questionNoBlank(msg, cb);
+            // Needed return otherwise it continues.
+            return;
+        }
+        cb(answer);
     });
 }
 
@@ -146,15 +465,17 @@ function createGameDir(template, gameName, outDir,
                        author, authorEmail, options) {
 
     // Number of synchronous / asynchronous operations.
-    var wait = 9;
+    var wait = 10;
+
     var verbose = !!options.verbose;
-    var doGit = !!options.git;
     var d = new Date();
     var year = d.getFullYear();
     var nodegameCopyright;
-    var fileName;
+    var str, fullCopyright;
+
 
-    nodegameCopyright = 'Copyright(c) 2017 Stefano Balietti <ste@nodegame.org>';
+    nodegameCopyright = 'Copyright(c) ' + year +
+        ' Stefano Balietti <ste@nodegame.org>';
 
     // Make full copyright string.
     fullCopyright = 'Copyright(c) ' + year;
@@ -162,9 +483,15 @@ function createGameDir(template, gameName, outDir,
     if (authorEmail) fullCopyright += ' <' + authorEmail + '>';
 
     // Fix trailing slash.
-    if (outDir.charAt(outDir.length) !== '/') outDir = outDir += '/';
+    if (outDir.charAt(outDir.length) !== path.sep) outDir = outDir += path.sep;
 
     console.log();
+    colorWrite('Creating Game', true);
+
+    function write(filePath, str) {
+        fs.writeFileSync(filePath, str);
+        if (verbose) colorWrite('   create : ' + filePath);
+    }
 
     function substituteHeader(str) {
         // Backward compatible.
@@ -176,287 +503,500 @@ function createGameDir(template, gameName, outDir,
         return str;
     }
 
-
-    function write(filePath, str, mode) {
-        fs.writeFileSync(filePath, str, { mode: mode || 0666 });
-        if (verbose) console.log('   \x1b[36mcreate\x1b[0m : ' + filePath);
-    }
-
     function mkdir(dir, fn) {
-        mkdirp(dir, 0755, function(err){
+        mkdirp(dir, function(err) {
             if (err) throw err;
-            if (verbose) console.log('   \033[36mcreate\033[0m : ' + dir);
-            fn && fn();
+            if (verbose) colorWrite('   create : ' + dir);
+            if (fn) fn();
         });
     }
 
     function complete() {
-        var prompt, tmp;
         if (--wait) return;
-        prompt = launchedFromCmd() ? '>' : '$';
+        let tmp;
+
+        // Enable by making a link in games/, if not there already.
+        tmp = path.resolve(conf.ngGamesEnabledDir, gameName);
+        if (!fs.existsSync(tmp)) {
+            makeLink(path.join('..', 'games_available', gameName), tmp);
+        }
+
         if (verbose) console.log();
 
-        console.log('   \x1b[36mcopyright string\x1b[0m:');
-        console.log('        ' + fullCopyright);
+        colorWrite('Well done! Game created!', true);
+
+        colorWrite('Copyright string:');
+        console.log('   ' + fullCopyright);
         console.log();
 
-        console.log('   \x1b[36mtemplate\x1b[0m:');
-        console.log('        ' + template);
+        colorWrite('Template:');
+        console.log('   ' + template);
         console.log();
 
-        console.log('   \x1b[36mgame created\x1b[0m:');
-        console.log('        ' + outDir);
+        colorWrite('License:');
+        console.log('   MIT');
         console.log();
 
-        tmp = '        channel/channel.secret.js.sample      -> ' +
-            'channel/channel.secret.js';
-        console.log('   \x1b[36medit and rename\x1b[0m:');
-        tmp = '        channel/channel.credentials.js.sample -> ' +
-            'channel/channel.credentials.js';
-        console.log(tmp);
-        console.log(tmp);
+        colorWrite('Game directory:');
+        console.log('   ' + outDir.substr(0, outDir.length - 1));
         console.log();
 
+        colorWrite('Admin configuration stored in:');
+        tmp = '   ' + 'channel' + path.sep + 'channel.credentials.js';
+        console.log(tmp);
+
         console.log();
 
-//        console.log('   run the app:');
-//
-//        if (launchedFromCmd()) {
-//          console.log('     %s SET DEBUG=%s:* & npm start', prompt, gameName);
-//        } else {
-//            console.log('     %s DEBUG=%s:* npm start', prompt, gameName);
-//        }
-//
-//        console.log();
+        rl.close();
     }
 
+    str = ' - Is the game single-player? [y/N]\n' +
+          '   (Hint: single-player: labeling task, survey, etc. ' +
+          'Default: No) ';
 
-    // Loading Templates.
+    confirm(str, function(singlePlayer, oneRoom) {
 
-    // AUTH.
-    var auth = loadTemplate(template, 'auth/auth.js');
-    var authSettings = loadTemplate(template, 'auth/auth.settings.js');
-    var authCodes = loadTemplate(template, 'auth/auth.codes.js');
+        console.log();
+        console.log('   Choice: ' +
+                    (singlePlayer ? 'single' : 'multi') + '-player');
+        console.log();
 
-    // CHANNEL.
-    var channelSettings = loadTemplate(template, 'channel/channel.settings.js');
-    var channelSecret = loadTemplate(template, 'channel/channel.secret.js');
-    var channelCredentials = loadTemplate(template,
-                                          'channel/channel.credentials.js');
+        if (singlePlayer) {
+            template = 'guessing game';
+            // Setting always to true for now.
+            oneRoom = true;
+        }
 
-    // GAME.
-    var gameStages = loadTemplate(template, 'game/game.stages.js');
-    var gameSetup = loadTemplate(template, 'game/game.setup.js');
-    var gameSettings = loadTemplate(template, 'game/game.settings.js');
+        str = ' - Type a secret passphrase or leave blank to generate a ' +
+            'random one\n' +
+            '   (Hint: it is used to sign auth tokens, ' +
+            'it won\'t be asked again): ';
 
-    // GAME / client_types.
-    var typePlayer = loadTemplate(template, 'game/client_types/player.js');
-    var typeBot = loadTemplate(template, 'game/client_types/bot.js');
-    var typeLogic = loadTemplate(template, 'game/client_types/logic.js');
-    var typePhantom = loadTemplate(template, 'game/client_types/phantom.js');
-    var typeAutoplay = loadTemplate(template, 'game/client_types/autoplay.js');
+        rl.question(str, function(secret) {
 
-    // PUBLIC.
-    var indexPage = loadTemplate(template, 'public/index.htm');
-    var gamePage = loadTemplate(template, 'public/game.htm');
-    var instrPage = loadTemplate(template, 'public/instructions.htm');
-    var endPage = loadTemplate(template, 'public/end.htm');
-    var indexJS = loadTemplate(template, 'public/js/index.js');
+            if ('undefined' === typeof secret || secret.trim() === '') {
+                secret = J.randomString(15, 'aA_1');
+            }
 
-    // VIEWS.
+            console.log();
+            str = ' - Enter the ADMIN username: ';
+            questionNoBlank(str, function(admin) {
+                console.log();
+                str = ' - Enter the ADMIN password (hidden): ';
+                muteNext();
+                questionNoBlank(str, function(pwd) {
+                    muteNext();
+                    str = ' - Confirm the ADMIN password (hidden): ';
+                    console.log();
+                    rl.question(str, function(pwd2) {
+                        unmute();
+                        console.log();
+
+                        if (pwd !== pwd2) {
+                            console.log('Error: passwords do not match.');
+                            process.exit();
+                            return;
+                        }
+
+                        // Description.
+                        let descr = ' A ';
+                        if (singlePlayer) descr += 'single-player ';
+                        descr += 'nodeGame game based on a ' + template;
+                        str = ' - Enter a description (Default:' +
+                              descr + '): ';
+                        rl.question(str, function(descr) {
+                            descr = descr || 'A nodeGame game based on a ' +
+                            template;
+                            console.log();
+                            doIt(secret, admin, pwd, descr,
+                                 singlePlayer, oneRoom);
+                        });
+                    });
+                });
+            });
 
+        });
+    });
 
-    // WAITROOM.
-    var waitroomSettings = loadTemplate(template,
-                                        'waitroom/waitroom.settings.js');
-    var waitroom = loadTemplate(template, 'waitroom/waitroom.js');
+    function doIt(secret, admin, pwd, descr, singlePlayer, oneRoom) {
 
-    // REQUIREMENTS.
-    fileName = 'requirements/requirements.settings.js';
-    var requirementsSettings = loadTemplate(template, fileName);
-    fileName = 'requirements/requirements.room.js';
-    var requirementsRoom = loadTemplate(template, fileName);
-    var requirements = loadTemplate(template, 'requirements/requirements.js');
+        // Loading Templates.
+        let filePath;
+        let t = template;
 
-    // LEVELS.
-    var levelsREADME = loadTemplate(template, 'levels/README.md');
+        // AUTH.
+        filePath = path.join('auth', 'auth.js');
+        let auth = loadTemplate(t, filePath);
+        filePath = path.join('auth', 'auth.settings.js');
+        let authSettings = loadTemplate(t, filePath);
+        filePath = path.join('auth', 'auth.codes.js');
+        let authCodes = loadTemplate(t, filePath);
 
-    mkdir(outDir, function() {
+        // CHANNEL.
 
-        mkdir(outDir + 'data');
+        filePath = path.join('channel', 'channel.settings.js');
+        let channelSettings = loadTemplate(t, filePath);
+        filePath = path.join('channel', 'channel.secret.js');
+        let channelSecret = loadTemplate(t, filePath);
+        filePath = path.join('channel', 'channel.credentials.js');
+        let channelCredentials = loadTemplate(t, filePath);
 
-        // AUTH.
-        mkdir(outDir + 'auth', function() {
-            auth = substituteHeader(auth);
-            authSettings = substituteHeader(authSettings);
+        // GAME.
 
-            auth = auth.replace('{NAME}', gameName);
+        let gameStages, gameSettings;
+        if (singlePlayer) {
+            filePath = path.join('game', 'game.stages_single.js');
+            gameStages = loadTemplate(t, filePath);
+            filePath = path.join('game', 'game.settings_single.js');
+            gameSettings = loadTemplate(t, filePath);
+        }
+        else {
+            filePath = path.join('game', 'game.stages.js');
+            gameStages = loadTemplate(t, filePath);
+            filePath = path.join('game', 'game.settings.js');
+            gameSettings = loadTemplate(t, filePath);
+        }
+        filePath = path.join('game', 'game.setup.js');
+        let gameSetup = loadTemplate(t, filePath);
+
+        // GAME / client_types.
+
+        let typePlayer, typeBot, typeLogic, typeAutoplay;
+
+        if (singlePlayer) {
+            filePath = path.join('game', 'client_types', 'player_single.js');
+            typePlayer = loadTemplate(t, filePath);
+            filePath = path.join('game', 'client_types', 'bot_single.js');
+            typeBot = loadTemplate(t, filePath);
+            filePath = path.join('game', 'client_types', 'logic_single.js');
+            typeLogic = loadTemplate(t, filePath);
+            filePath = path.join('game', 'client_types', 'autoplay_single.js');
+            typeAutoplay = loadTemplate(t, filePath);
+        }
+        else {
+            filePath = path.join('game', 'client_types', 'player.js');
+            typePlayer = loadTemplate(t, filePath);
+            filePath = path.join('game', 'client_types', 'bot.js');
+            typeBot = loadTemplate(t, filePath);
+            filePath = path.join('game', 'client_types', 'logic.js');
+            typeLogic = loadTemplate(t, filePath);
+            filePath = path.join('game', 'client_types', 'autoplay.js');
+            typeAutoplay = loadTemplate(t, filePath);
+        }
 
-            write(outDir + 'auth/auth.js', auth);
-            write(outDir + 'auth/auth.settings.js', authSettings);
-            write(outDir + 'auth/auth.codes.js.sample', authCodes);
-            complete();
-        });
 
-        // CHANNEL.
-        mkdir(outDir + 'channel', function() {
+        filePath = path.join('game', 'client_types', 'phantom.js');
+        let typePhantom = loadTemplate(t, filePath);
 
-            // Settings.
-            channelSettings = substituteHeader(channelSettings);
-            channelSettings = channelSettings.replace(/{NAME}/g, gameName);
-            channelSettings = channelSettings.replace('{ADMIN}',
-                                                      gameName + '/admin');
-            write(outDir + 'channel/channel.settings.js', channelSettings);
+        // PUBLIC.
 
-            // Credentials.
-            channelCredentials = substituteHeader(channelCredentials);
-            write(outDir + 'channel/channel.credentials.js.sample',
-                  channelCredentials);
+        filePath = path.join('public', 'index.htm');
+        let indexPage = loadTemplate(t, filePath);
 
-            // Secret.
-            channelSecret = substituteHeader(channelSecret);
-            write(outDir + 'channel/channel.secret.js.sample', channelSecret);
+        let gamePage, instrPage;
 
-            complete();
-        });
+        if (singlePlayer) {
+            filePath = path.join('public', 'game_single.htm');
+            gamePage = loadTemplate(t, filePath);
 
-        // GAME.
-        mkdir(outDir + 'game', function() {
-
-            gameStages = substituteHeader(gameStages);
-            gameSetup = substituteHeader(gameSetup);
-            gameSettings = substituteHeader(gameSettings);
-
-            write(outDir + 'game/game.stages.js', gameStages);
-            write(outDir + 'game/game.setup.js', gameSetup);
-            write(outDir + 'game/game.settings.js', gameSettings);
-
-            mkdir(outDir + 'game/client_types', function() {
-                typePlayer = substituteHeader(typePlayer);
-                typeBot = substituteHeader(typeBot);
-                typeAutoplay = substituteHeader(typeAutoplay);
-                typeLogic = substituteHeader(typeLogic);
-                typePhantom = substituteHeader(typePhantom);
-
-                write(outDir + 'game/client_types/autoplay.js', typeAutoplay);
-                write(outDir + 'game/client_types/player.js', typePlayer);
-                write(outDir + 'game/client_types/bot.js', typeBot);
-                write(outDir + 'game/client_types/logic.js', typeLogic);
-                write(outDir + 'game/client_types/phantom.js', typePhantom);
-                complete();
-            });
-        });
+            filePath = path.join('public', 'instructions_single.htm');
+            instrPage = loadTemplate(t, filePath);
+        }
+        else {
+            filePath = path.join('public', 'game.htm');
+            gamePage = loadTemplate(t, filePath);
 
-        // PUBLIC.
-        mkdir(outDir + 'public', function() {
-            write(outDir + 'public/index.htm', indexPage);
-            indexJS = substituteHeader(indexJS);
-            // TODO: one command to replace all instances.
-            indexJS = indexJS.replace('{NAME}', gameName);
-            indexJS = indexJS.replace('{NAME}', gameName);
+            filePath = path.join('public', 'instructions.htm');
+            instrPage = loadTemplate(t, filePath);
+        }
+
+
+        // filePath = path.join('public', 'end.htm');
+        // let endPage = loadTemplate(t, filePath);
+        filePath = path.join('public', 'js', 'index.js');
+        let indexJS = loadTemplate(t, filePath);
+        filePath = path.join('public', 'css', 'style.css');
+        let styleCSS = loadTemplate(t, filePath);
+
+        // VIEWS.
+
+
+        // WAITROOM.
+        let waitroomSettings;
+        if (singlePlayer) {
+            filePath = path.join('waitroom', 'waitroom.settings_single.js');
+            waitroomSettings = loadTemplate(t, filePath);
+        }
+        else {
+            filePath = path.join('waitroom', 'waitroom.settings.js');
+            waitroomSettings = loadTemplate(t, filePath);
 
-            instrPage = instrPage.replace('{NAME}', gameName);
-            write(outDir + 'public/instructions.htm', instrPage);
+        }
+        filePath = path.join('waitroom', 'waitroom.js');
+        let waitroom = loadTemplate(t, 'waitroom/waitroom.js');
+
+        // REQUIREMENTS.
+
+        filePath = path.join('requirements', 'requirements.settings.js');
+        let requirementsSettings = loadTemplate(t, filePath);
+        filePath = path.join('requirements', 'requirements.room.js');
+        let requirementsRoom = loadTemplate(t, filePath);
+        filePath = path.join('requirements', 'requirements.js');
+        let requirements = loadTemplate(t, filePath);
+
+        // LEVELS.
+
+        filePath = path.join('levels', 'README.md');
+        let levelsREADME = loadTemplate(t, filePath);
+
+        // README.
+
+        let rootREADME = loadTemplate(t, 'README.template.md');
+
+        // LICENSE.
 
-            write(outDir + 'public/game.htm', gamePage);
-            write(outDir + 'public/end.htm', endPage);
+        let license = loadTemplate(t, 'LICENSE.template');
 
-            // Copying favicon over.
-            fs.copySync(ngt.resolve('public/favicon.ico'),
-                        outDir + 'public/favicon.ico');
+        mkdir(outDir, function() {
 
-            mkdir(outDir + 'public/js', function() {
-                write(outDir + 'public/js/index.js', indexJS);
+            mkdir(path.resolve(outDir, 'data'));
 
-                mkdir(outDir + 'public/css', function() {
+            // AUTH.
+            mkdir(path.resolve(outDir, 'auth'), function() {
+                auth = substituteHeader(auth);
+                authCodes = substituteHeader(authCodes);
+                authSettings = substituteHeader(authSettings);
+
+                auth = auth.replace('{NAME}', gameName);
+                let filePath = path.resolve(outDir, 'auth', 'auth.js');
+                write(filePath, auth);
+                filePath = path.resolve(outDir, 'auth', 'auth.settings.js');
+                write(filePath, authSettings);
+                filePath = path.resolve(outDir, 'auth', 'auth.codes.js.sample');
+                write(filePath, authCodes);
+                complete();
+            });
+
+            // CHANNEL.
+            mkdir(path.resolve(outDir, 'channel'), function() {
+
+                // Settings.
+                channelSettings = substituteHeader(channelSettings);
+                channelSettings = channelSettings.replace(/{NAME}/g, gameName);
+                channelSettings = channelSettings.replace('{ADMIN}',
+                                                          gameName + '/admin');
+                let filePath = path.resolve(outDir,
+                                            'channel', 'channel.settings.js');
+                write(filePath, channelSettings);
+
+                // Credentials.
+                channelCredentials = channelCredentials.replace(/{ADMIN}/, admin);
+                channelCredentials = channelCredentials.replace(/{PWD}/, pwd);
+                channelCredentials = substituteHeader(channelCredentials);
+                filePath = path.resolve(outDir,
+                                        'channel', 'channel.credentials.js');
+                write(filePath, channelCredentials);
+
+                // Secret.
+                channelSecret = substituteHeader(channelSecret);
+                channelSecret = channelSecret.replace(/{SECRET}/g, secret);
+                filePath = path.resolve(outDir, 'channel', 'channel.secret.js');
+                write(filePath, channelSecret);
+
+                complete();
+            });
+
+            // GAME.
+            mkdir(path.resolve(outDir, 'game'), function() {
+
+                gameStages = substituteHeader(gameStages);
+                gameSetup = substituteHeader(gameSetup);
+                gameSettings = substituteHeader(gameSettings);
+
+                let filePath = path.resolve(outDir, 'game', 'game.stages.js');
+                write(filePath, gameStages);
+                filePath = path.resolve(outDir, 'game', 'game.setup.js');
+                write(filePath, gameSetup);
+                filePath = path.resolve(outDir, 'game', 'game.settings.js');
+                write(filePath, gameSettings);
+
+                mkdir(path.resolve(outDir, 'game', 'client_types'), function() {
+                    typePlayer = substituteHeader(typePlayer);
+                    typeBot = substituteHeader(typeBot);
+                    typeAutoplay = substituteHeader(typeAutoplay);
+                    typeLogic = substituteHeader(typeLogic);
+                    typePhantom = substituteHeader(typePhantom);
+
+                    let ctPath = path.resolve(outDir, 'game', 'client_types');
+
+                    let filePath = path.join(ctPath, 'autoplay.js');
+                    write(filePath, typeAutoplay);
+                    filePath = path.join(ctPath, 'player.js');
+                    write(filePath, typePlayer);
+                    filePath = path.join(ctPath, 'bot.js');
+                    write(filePath, typeBot);
+                    filePath = path.join(ctPath, 'logic.js');
+                    write(filePath, typeLogic);
+                    filePath = path.join(ctPath, 'phantom.js');
+                    write(filePath, typePhantom);
                     complete();
                 });
             });
-        });
 
-        // VIEWS.
-        mkdir(outDir + 'views', function() {
-            mkdir(outDir + 'views/contexts', function() {
-                // Something.
-                mkdir(outDir + 'views/templates', function() {
+            // PUBLIC.
+            mkdir(path.resolve(outDir, 'public'), function() {
+                indexJS = substituteHeader(indexJS);
+                indexJS = indexJS.replace('{ENDPOINT}', ('/' + gameName));
+                // instrPage = instrPage.replace('{NAME}', gameName);
+
+                let filePath = path.resolve(outDir, 'public', 'index.htm');
+                write(filePath, indexPage);
+                filePath = path.resolve(outDir, 'public', 'instructions.htm');
+                write(filePath, instrPage);
+                filePath = path.resolve(outDir, 'public', 'game.htm');
+                write(filePath, gamePage);
+                // filePath = path.resolve(outDir, 'public', 'end.htm');
+                // write(filePath, endPage);
+
+                // Copying favicon over.
+                fs.copySync(ngt.resolve(path.join('public', 'favicon.ico')),
+                            path.resolve(outDir, 'public', 'favicon.ico'));
+
+                fs.copySync(ngt.resolve(path.join('public', '404.htm')),
+                            path.resolve(outDir, 'public', '404.htm'));
+
+                mkdir(path.resolve(outDir, 'public', 'js'), function() {
+                    write(path.resolve(outDir, 'public', 'js', 'index.js'),
+                          indexJS);
+
+                    mkdir(path.resolve(outDir, 'public', 'css'), function() {
+                        write(path.resolve(outDir,
+                                           'public', 'css', 'style.css'),
+                              styleCSS);
+                        complete();
+                    });
+                });
+            });
+
+            // VIEWS.
+            mkdir(path.resolve(outDir, 'views'), function() {
+                mkdir(path.resolve(outDir, 'views', 'contexts'), function() {
                     // Something.
-                    complete();
+                    mkdir(path.resolve(outDir, 'views', 'templates'),
+
+                          function() {
+                              // Something.
+                              complete();
+                          });
                 });
             });
-        });
 
-        // WAITROOM.
-        mkdir(outDir + 'waitroom', function() {
+            // WAITROOM.
+            mkdir(path.resolve(outDir, 'waitroom'), function() {
 
-            waitroom = substituteHeader(waitroom);
-            waitroomSettings = substituteHeader(waitroomSettings);
+                let value = oneRoom ? 'true' : 'false';
+                waitroomSettings = waitroomSettings
+                                       .replace(/{SAME_ROOM_VALUE}/g, value);
 
-            write(outDir + 'waitroom/waitroom.js.sample', waitroom);
-            write(outDir + 'waitroom/waitroom.settings.js', waitroomSettings);
+                waitroom = substituteHeader(waitroom);
+                waitroomSettings = substituteHeader(waitroomSettings);
 
-            complete();
-        });
+                let filePath = path.resolve(outDir, 'waitroom',
+                                            'waitroom.js.sample');
+                write(filePath, waitroom);
+                filePath = path.resolve(outDir, 'waitroom',
+                                        'waitroom.settings.js');
+                write(filePath, waitroomSettings);
 
-        // REQUIREMENTS.
-        mkdir(outDir + 'requirements', function() {
+                complete();
+            });
 
-            requirements = substituteHeader(requirements);
-            requirementsSettings = substituteHeader(requirementsSettings);
-            requirementsRoom = substituteHeader(requirementsRoom);
+            // REQUIREMENTS.
+            mkdir(path.resolve(outDir, 'requirements'), function() {
 
-            write(outDir + 'requirements/requirements.js.sample', requirements);
-            write(outDir + 'requirements/requirements.settings.js',
-                  requirementsSettings);
-            write(outDir + 'requirements/requirements.room.js.sample',
-                  requirementsRoom);
+                requirements = substituteHeader(requirements);
+                requirementsSettings = substituteHeader(requirementsSettings);
+                requirementsRoom = substituteHeader(requirementsRoom);
 
-            complete();
-        });
+                let filePath = path.resolve(outDir, 'requirements',
+                                            'requirements.js.sample');
+                write(filePath, requirements);
+                filePath = path.resolve(outDir, 'requirements',
+                                        'requirements.settings.js');
+                write(filePath, requirementsSettings);
+                filePath = path.resolve(outDir, 'requirements',
+                                        'requirements.room.js.sample');
+                write(filePath, requirementsRoom);
 
-        // LEVELS.
-        mkdir(outDir + 'levels', function() {
-            write(outDir + 'levels/README.md', levelsREADME);
-            complete();
-        });
+                complete();
+            });
 
-        // Package.json
-         var pkg = {
-             name: gameName
-             , version: '0.0.1'
-             , description: 'This is a nodeGame game based on ' + template
-             , author: author + ' ' + '<' + authorEmail + '>'
-             , license: "MIT/X11"
-             , homepage: 'http://nodegame.org'
-//             , private: true
-         }
+            // LEVELS.
+            mkdir(path.resolve(outDir, 'levels'), function() {
+                write(path.resolve(outDir, 'levels', 'README.md'),
+                                   levelsREADME);
+                complete();
+            });
 
+            // PRIVATE
+            mkdir(path.resolve(outDir, 'private'), () => {
 
-        // sort dependencies like npm(1)
-        // pkg.dependencies = sortedObject(pkg.dependencies);
+                fs.copySync(ngt.resolve(path.join('private', '.gitkeep')),
+                            path.resolve(outDir, 'private', '.gitkeep'));
 
-        // write files
-        write(outDir + 'package.json', JSON.stringify(pkg, null, 4));
+                fs.copySync(ngt.resolve(path.join('private', 'README.md')),
+                            path.resolve(outDir, 'private', 'README.md'));
 
-        if (doGit) {
-            write(outDir + '.gitignore',
-                  fs.readFileSync(root + '/.gitignore', 'utf-8'));
-        }
+                complete();
+            });
 
-        complete();
-    });
-}
+            // README.
 
-/**
- * Copies a file to a destination
- *
- *
- *
- */
-function copyTemplate(from, to) {
-    from = path.join(__dirname, '..', 'templates', from);
-    write(to, fs.readFileSync(from, 'utf-8'));
+            rootREADME = rootREADME.replace(/{NAME}/g, gameName);
+            rootREADME = rootREADME.replace(/{DESCR}/g, descr);
+            rootREADME = rootREADME.replace(/{AUTHOR}/g, author);
+            rootREADME = rootREADME.replace(/{EMAIL}/g, authorEmail);
+            write(path.resolve(outDir, 'README.md'), rootREADME);
+
+            // README.
+
+            license = license.replace(/{AUTHOR}/g, author);
+            license = license.replace(/{YEAR}/g, year);
+            write(path.resolve(outDir, 'LICENSE'), license);
+
+            // Package.json.
+            let pkg = {
+                name: gameName,
+                version: '0.0.1',
+                description: descr,
+                author: author + ' ' + '<' + authorEmail + '>',
+                license: 'MIT/X11',
+                homepage: 'http://nodegame.org'
+            };
+
+            // Write files.
+
+            write(path.resolve(outDir, 'package.json'),
+                JSON.stringify(pkg, null, 4));
+            write(path.resolve(outDir, '.gitignore'),
+                loadTemplate(t, '.gitignore'));
+            write(path.resolve(outDir, '.eslintrc.js'),
+                loadTemplate(t, '.eslintrc.js'));
+
+            complete();
+        });
+    }
 }
 
+// /**
+//  * Copies a file to a destination
+//  *
+//  */
+// function copyTemplate(from, to) {
+//     from = path.join(__dirname, '..', 'templates', from);
+//     write(to, fs.readFileSync(from, 'utf-8'));
+// }
+
 /**
  * Check if the given directory `path` is empty.
  *
@@ -464,43 +1004,17 @@ function copyTemplate(from, to) {
  * @param {Function} fn
  */
 function emptyDirectory(dir, fn) {
-    fs.readdir(dir, function(err, files){
-        if (err && 'ENOENT' != err.code) throw err;
+    fs.readdir(dir, function(err, files) {
+        if (err && 'ENOENT' !== err.code) throw err;
         fn(!files || !files.length);
     });
 }
 
-/**
- * Graceful exit for async STDIO
- */
-function exit(code) {
-    // flush output for Node.js Windows pipe bug
-    // https://github.com/joyent/node/issues/6247 is just one bug example
-    // https://github.com/visionmedia/mocha/issues/333 has a good discussion
-    function done() {
-        if (!(draining--)) _exit(code);
-    }
-
-    var draining = 0;
-    var streams = [process.stdout, process.stderr];
-
-    exit.exited = true;
-
-    streams.forEach(function(stream){
-        // submit empty write request and wait for completion
-        draining += 1;
-        stream.write('', done);
-    });
-
-    done();
-}
-
 /**
  * Determine if launched from cmd.exe
  */
 function launchedFromCmd() {
-    return process.platform === 'win32'
-        && process.env._ === undefined;
+    return process.platform === 'win32' && process.env._ === undefined;
 }
 
 /**
@@ -515,15 +1029,15 @@ function launchedFromCmd() {
  */
 function loadTemplate(template, file) {
     var templatePath;
-// Uncomment when loading templates from templatesDir works.
-//     templatePath = path.join(templatesDir, templates[template], file);
-//     if (!fs.existsSync(templatePath)) {
-//         // Try to use the default one.
-//         templatePath = ngt.resolve(file);
-//         if (!fs.existsSync(templatePath)) {
-//             throw new Error('Cannot find template file: ' + file);
-//         }
-//     }
+    // Uncomment when loading templates from templatesDir works.
+    //     templatePath = path.join(templatesDir, templates[template], file);
+    //     if (!fs.existsSync(templatePath)) {
+    //         // Try to use the default one.
+    //         templatePath = ngt.resolve(file);
+    //         if (!fs.existsSync(templatePath)) {
+    //             throw new Error('Cannot find template file: ' + file);
+    //         }
+    //     }
     templatePath = ngt.resolve(file);
     if (!fs.existsSync(templatePath)) {
         throw new Error('Cannot find template file: ' + file);
@@ -553,13 +1067,14 @@ function createGame(options) {
     }
     else {
         // Is there a default game folder?
-        if (!conf.gamesFolder) {
-            console.log('Error: no default game folder found. Please ' +
-                        'provide an absolute path for the game, or ' +
-                        'set the default game folder');
+        if (!conf.ngGamesAvailDir) {
+            console.log('Error: no default games folder found. Please ' +
+                        'provide an absolute path for the game, or set the ' +
+                        'default games folder with command "update-conf"');
+            rl.close();
             return;
         }
-        destinationPath = conf.gamesFolder + options.game;
+        destinationPath = path.resolve(conf.ngGamesAvailDir, options.game);
     }
     // App name.
     appName = path.basename(path.resolve(destinationPath));
@@ -596,13 +1111,12 @@ function createGame(options) {
                           opts);
         }
         else {
-            colorWrite('Warning!');
-            console.log('');
-            str = destinationPath + ' is not empty, do '
-                + 'you want to continue? [y/N] ';
+            colorWrite('Warning!', true);
+            str = destinationPath + ' is not empty, do you want to ' +
+                'continue? [y/N] ';
             confirm(str, function(ok) {
                 if (ok) {
-                    process.stdin.destroy();
+                    // process.stdin.destroy();
                     createGameDir(template,
                                   appName,
                                   destinationPath,
@@ -612,7 +1126,7 @@ function createGame(options) {
                 }
                 else {
                     console.error('aborting');
-                    exit(1);
+                    process.exit(1);
                 }
             });
         }
@@ -625,22 +1139,29 @@ function createGame(options) {
  */
 function createConfFile(cb) {
 
-    var rl, str;
-
-    rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
+    var str;
 
     console.log('');
-    str = 'Path to nodeGame games_available folder: ';
-    if (conf.gamesFolder) str += '[' + conf.gamesFolder + '] ';
+    str = 'Path to nodeGame installation folder: ';
+    if (!conf.ngDir || ! conf.ngGamesAvailDir || !conf.ngGamesEnabledDir) {
+        let ngInfo = detectNodeGameInstallation();
+        if (ngInfo) J.mixin(conf, ngInfo);
+    }
+    if (conf.ngDir) str += '[' + conf.ngDir + '] ';
+
+    colorWrite('Please add missing info or press enter to keep default');
 
     rl.question(str, function(answer) {
-        
-        if (!answer) answer = conf.gamesFolder;
+
+        answer = answer || conf.ngDir;
+
+        if (!answer) {
+            console.log('Error: no directory provided and no default found.');
+            process.exit();
+            return;
+        }
         if (!path.isAbsolute(answer)) answer = path.join(process.cwd(), answer);
-        
+
         if (!fs.existsSync(answer)) {
             console.log('Error: directory not existing: ' + answer);
             process.exit();
@@ -650,66 +1171,78 @@ function createConfFile(cb) {
 
         // Add trailing slashes.
         if (launchedFromCmd()) {
-            if (answer.substring(answer.length-2)!== '\\') answer += '\\';
+            if (answer.substring(answer.length - 2) !== '\\') {
+                answer += '\\';
+            }
         }
         else {
-            if (answer.charAt(answer.length-1) !== '/') answer += '/';
+            if (answer.charAt(answer.length - 1) !== path.sep) {
+                answer += path.sep;
+            }
         }
 
-        conf.gamesFolder = answer;
+        // Set nodeGame dir.
+        conf.ngDir = answer;
+
+        // Add game directories to conf.
+        let gameDirs = checkGameDirs(answer);
+        if (!gameDirs) {
+            console.log('Err: Folders games and/or games_available ' +
+                        'could not be found');
+            return;
+        }
+        conf.ngGamesAvailDir = gameDirs.ngGamesAvailDir;
+        conf.ngGamesEnabledDir = gameDirs.ngGamesEnabledDir;
 
         str = 'Default author name: ';
-        if (conf.author) str += '[' + conf.author +'] ';
+        if (conf.author) str += '[' + conf.author + '] ';
 
         rl.question(str, function(answer) {
 
             if (answer) conf.author = answer;
 
             str = 'Default author email: ';
-            if (conf.email) str += '[' + conf.email +'] ';
+            if (conf.email) str += '[' + conf.email + '] ';
             rl.question(str, function(answer) {
 
                 if (answer) conf.email = answer;
 
                 showConf(conf);
 
-                rl.close();
-
                 writeConfFile(conf, cb);
             });
         });
     });
 }
 
-function loadTemplates() {
-    let dir = conf.gamesFolder;
-    
-    fs.readdirSync(dir).forEach(function(file, index){
-        let curPath = path.join(dir, file);
-        //  Recurse.
-        if (fs.lstatSync(curPath).isDirectory()) {
-            var name;
-            try {
-                let packageJson = require(path.join(curPath, 'package.json'));
-                name = packageJson.name;
-                if (name) templates[name] = curPath;            
-            }
-            catch(e) {
-                // Ignore errors for now.
-            }
-        }
-
-    });
-}
+// function loadTemplates() {
+//     let dir = conf.ngGamesAvailDir;
+//
+//     fs.readdirSync(dir).forEach(function(file, index) {
+//         let curPath = path.join(dir, file);
+//         //  Recurse.
+//         if (fs.lstatSync(curPath).isDirectory()) {
+//             var name;
+//             try {
+//                let packageJson = require(path.join(curPath, 'package.json'));
+//                 name = packageJson.name;
+//                 if (name) templates[name] = curPath;
+//             }
+//             catch(e) {
+//                 // Ignore errors for now.
+//             }
+//         }
+//
+//     });
+// }
 
 function showConf(localConf) {
     localConf = localConf || conf;
     console.log('');
-    colorWrite('Configuration: ');
-    console.log('');
-    console.log("    Games folder path: ", conf.gamesFolder);
-    console.log("          Author name: ", conf.author);
-    console.log("         Author email: ", conf.email);
+    colorWrite('Configuration: ', true);
+    console.log('    Games folder path: ', localConf.ngGamesAvailDir);
+    console.log('          Author name: ', localConf.author);
+    console.log('         Author email: ', localConf.email);
     console.log('');
     console.log('To change run nodegame update-conf');
     console.log('');
@@ -729,40 +1262,92 @@ function writeConfFile(conf, cb) {
             console.log('');
         }
 
-        if (cb) cb();
+        if (cb) {
+            try {
+                cb();
+            }
+            catch(e) {
+                console.log(e);
+                colorWrite('An error occurred. Aborted.');
+                process.exit();
+            }
+        }
     });
 }
 
-function loadConfFile(cb) {
+function loadConfFile(cb, force) {
+    let res = true;
     // Try to load configuration. If not found start utility to create it.
     try {
         conf = require(confFile);
-        if (!conf.author || !conf.email || !conf.gamesFolder) {
-            createConfFile(cb);
-        }
-        else {
-            cb();
-        }
     }
     catch(e) {
+        console.log(e);
         console.log('');
         colorWrite('Warning!');
-        console.log('');
-        console.log('nodegame-generator conf file ' +
-                    'not found or not readable');
-        console.log('');
+        console.log('nodegame-generator conf file not found or not readable');
         createConfFile(cb);
+        res = false;
+    }
+
+    if (!res) return;
+
+    if (force || !conf.author || !conf.email || !conf.ngDir) {
+        if (!force) {
+            console.log('Missing or incomple conf. Trying to recover it.');
+        }
+        createConfFile(cb);
+    }
+    else {
+        try {
+            cb();
+        }
+        catch(e) {
+            console.log(e);
+            colorWrite('An error occurred. Aborted.')
+            process.exit();
+        }
     }
 }
 
-function colorWrite(str) {
+function colorWrite(str, br) {
     console.log('\x1b[36m' + str + '\x1b[0m');
+    if (br) console.log('');
 }
 
+function makeLink(from, to, type) {
+    if (isWin) {
+        // console.log(from);
+        // console.log(to);
+        if (type === 'file') fs.linkSync(from, to, 'file');
+        else fs.symlinkSync(from, to, 'junction');
+    }
+    else {
+        fs.symlinkSync(from, to);
+    }
+}
+
+
 // Parsing options.
 program.parse(process.argv);
 
-if (!program.args.length &&
-    program.rawArgs[2] !== '--help' && program.rawArgs[2] !== '-h') {
-    console.log('Error: no command provided.');
+let firstCommand = program.rawArgs[2];
+if (!program.args.length) {
+    if (firstCommand !== '--help' && firstCommand !== '-h' &&
+        firstCommand !== '--version' && firstCommand !== '-V'
+       ) {
+        console.log('Error: no command provided.');
+    }
+}
+else {
+
+    if (firstCommand !== 'create-game' &&
+        firstCommand !== 'show-conf' &&
+        firstCommand !== 'update-conf' &&
+        firstCommand !== 'export-data' &&
+        firstCommand !== 'export-logs'
+    ) {
+
+        console.log('Error: invalid command: ' + firstCommand);
+    }
 }
diff --git a/conf/generator.conf.json.template b/conf/generator.conf.json.template
index 0d172dd..c4b3055 100644
--- a/conf/generator.conf.json.template
+++ b/conf/generator.conf.json.template
@@ -1,5 +1,5 @@
 {
     "author": "author",
     "email": "author@me.com",
-    "gamesFolder": "/path/to/games/folder"
+    "ngDir": "/path/to/nodeGame"
 }
diff --git a/games/dictator/private/.gitkeep b/games/dictator/private/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/games/dictator/private/README.md b/games/dictator/private/README.md
new file mode 100644
index 0000000..3dc7c8c
--- /dev/null
+++ b/games/dictator/private/README.md
@@ -0,0 +1,3 @@
+## private folder
+Store here private files that need to be loaded, such as databases, but not shared.
+This folder is not accessible from outside and it is added to .gitignore.
diff --git a/lib/export.js b/lib/export.js
new file mode 100644
index 0000000..08b4989
--- /dev/null
+++ b/lib/export.js
@@ -0,0 +1,458 @@
+const path = require('path');
+const fs = require('fs');
+const NDDB = require('NDDB');
+const J = require('JSUS').JSUS;
+
+// Keeps track of open processing operations
+let processing = 0;
+
+const exportLogs = (serverConf, opts, cb) => {
+    _export('logs', serverConf, opts, cb);
+};
+
+const exportData = (serverConf, opts, cb) => {
+    _export('data', serverConf, opts, cb);
+};
+
+// Generic export for data or logs.
+const _export = (type, serverConf, opts, cb) => {
+
+    // console.log(type)
+    // console.log(serverConf)
+    // console.log(opts)
+    // console.log(cb);
+
+    const LOGS = type === 'logs';
+
+    setDefaults(LOGS, serverConf, opts);
+
+    // We will clone it later.
+    let optsOrig = opts;
+
+    // Data directory.
+    const DATADIR = opts.dataDir;
+    // Output directory.
+    const OUTDIR = opts.exportDir;
+    // Verbose.
+    const V = opts.verbose;
+
+    // Load all files.
+    let checkUnique = {};
+    opts.files.forEach((file) => {
+        if (checkUnique[file]) {
+            if (V) console.log(`- skipping duplicated file: ${file}`);
+            return;
+        }
+        // console.log(optsOrig)
+        let opts = optsOrig;
+        try {
+            opts = J.clone(optsOrig);
+        }
+        catch {};
+
+        if (V) console.log('- Pattern: ' + file);
+
+        checkUnique[file] = true;
+
+        let db = NDDB.db();
+        let db2;
+
+        if (opts.inCsvHeader) opts.header = opts.inCsvHeader;
+
+        // Logs.
+        if (LOGS) {
+            db2 = NDDB.db();
+            db.on('insert', (item) => {
+                if (item.type === 'out-ID') {
+                    if (!opts.outgoing) return false;
+                }
+                else if (item.type === 'in') {
+                    if (!opts.incoming) return false;
+                }
+
+                let  i = item;
+                // console.log(i);
+                // console.log(i.sid);
+                if (opts.game) {
+
+                    // messages logs
+                    if (i.channel) {
+                        if (i.channel !== opts.game) return false;
+                    }
+
+                    // channel logs
+                    else if (i.name) {
+                        if (i.name !== opts.game) return false;
+                    }
+                    // servernode logs.
+                    else if (i.message) {
+                        if (!~i.message.indexOf(opts.game)) return false;
+                    }
+                }
+
+                try {
+                    i = J.parse(item.message);
+                    i.type = item.type === 'in' ? 'in' : 'out';
+                    i.channel = item.channel || item.name || 'NA';
+                }
+                catch {};
+
+
+                if (opts.setMsgOnly) {
+                    if (!i.action || i.action !== "set") return false;
+                }
+
+                // Session is the server session (not the room number).
+                if (opts.session && i.session !== opts.session) return false;
+
+                if (opts.cleanUp) {
+                    // i.player = i.from;
+                    // delete i.from;
+                    delete i.id;
+                    delete i.sid;
+                }
+
+                if (opts.onInsert) {
+                    let res = opts.onInsert(item);
+                    if (res === false) return;
+                }
+
+                db2.insert(i);
+            });
+        }
+        // Data.
+        else {
+            if (file === 'bonus_prolific.csv') {
+
+                if ('undefined' === typeof opts.header) opts.header = false;
+                opts.quote =  '';
+            }
+
+            if (opts.onInsert) db.on('insert', opts.onInsert);
+        }
+
+        // Load files.
+        opts.filter = file;
+        opts.file = file;
+        if (opts.inFormat) opts.format = opts.inFormat;
+        else if (LOGS) opts.format = 'ndjson';
+
+        db.loadDirSync(DATADIR, opts);
+        processing++;
+
+        // Check size.
+        if (V) console.log('    items loaded: ' + db.size());
+
+        // No items exit here.
+        if (!db.size()) return checkProcessing(cb);
+        let outFile = getExportFilename(serverConf, opts, V);
+
+        // We set the in-format before, now we make sure out-format is correct.
+        if (opts.outFormat) opts.format = opts.outFormat;
+        else delete opts.format;
+
+        if (opts.outCsvHeader) opts.header = opts.outCsvHeader;
+        if (opts.outCsvFlatten) opts.flatten = opts.outCsvFlatten;
+        if (opts.outCsvFlattenByGroup) {
+            opts.flattenByGroup = opts.outCsvFlattenByGroup;
+        }
+
+        opts.objectLevel = opts.outCsvObjLevel;
+
+        // Save it.
+        if (LOGS) db2.save(outFile, opts, () => checkProcessing(cb));
+        else db.save(outFile, opts, () => checkProcessing(cb));
+    });
+};
+
+
+const setDefaults = (LOGS, serverConf, opts, game) => {
+
+    opts.exportDir = opts.exportDir ?? getDefaultExportDir(serverConf);
+
+    opts.recursive = opts.recursive ?? false;
+
+    // Converts non-csv formats to csv.
+    opts.toCsv = opts.toCsv ?? true;
+    // Create a sub-directory within export directory.
+    opts.createExportSubDir = opts.createExportSubDir ?? false;
+
+    // If a file with same name exists inside the export dir.
+    // Other values: 'err' | 'append' ;
+    opts.onDuplicatedNames = opts.onDuplicatedNames ?? 'rename';
+
+    // If an error occurs with one file, what to do.
+    opts.onError = opts.onError ?? 'continue'; // 'throw'
+
+    opts.verbose = opts.verbose ?? true;
+
+    opts.inCsvHeader = opts.inCsvHeader ?? true;
+    opts.inCsvFlatten = !!opts.inCsvFlatten;
+
+    opts.ouCsvtHeader = opts.outCsvHeader ?? 'all';
+    opts.outCsvFlatten = !!opts.outCsvFlatten;
+
+    if ('string' === typeof opts.outCsvFlatten) {
+        opts.outCsvFlattenByGroup = opts.outCsvFlatten;
+    }
+
+    opts.outCsvObjLevel = opts.outCsvObjLevel || 2;
+
+    // Filled-in below.
+    let defaultFiles;
+
+    // Type-specific settings.
+
+    if (LOGS) {
+        opts.minLog = opts.minLog ?? false;
+        opts.maxLog = opts.maxLog ?? false;
+        opts.dataDir = opts.dataDir || path.resolve(serverConf.ngDir, 'log');
+
+        defaultFiles = [ 'messages' ];
+
+        opts.incoming = opts.incoming ?? true;
+        opts.outgoing = opts.outgoing ?? false;
+
+        if (!opts.incoming && !opts.outgoing) {
+            throw new Error(' - err: exports-logs: either incoming or ' +
+                            'outgoing must be selected.')
+        }
+
+        // Filters.
+        opts.setMsgOnly = !!opts.setMsgOnly;
+        opts.cleanUp = !!opts.cleanUp;
+    }
+    else {
+        opts.dataDir = opts.dataDir ||
+                       path.resolve(serverConf.ngGamesEnabledDir,
+                                    opts.game, 'data');
+
+        opts.fromRoom = opts.fromRoom ?? false;
+        opts.toRoom = opts.toRoom ?? false;
+        opts.rooms = opts.rooms ?? [];
+
+        if (opts.fromRoom || opts.toRoom || opts.rooms.length) {
+
+            // console.log(opts.fromRoom, opts.toRoom, opts.rooms);
+
+            opts.dirFilter = (dir) => {
+                // Filter room number.
+                let roomNum = dir.split('room')[1];
+                roomNum = J.isInt(roomNum);
+                // Skip directories not like rooom0000X.
+                if (!roomNum) return false;
+                if (opts.fromRoom && (roomNum < opts.fromRoom)) return false;
+                if (opts.toRoom && (roomNum > opts.toRoom)) return false;
+                if (opts.rooms.length && !~opts.rooms.indexOf(roomNum)) {
+                    return false;
+                }
+                return true;
+            };
+        }
+
+        defaultFiles = [
+            'bonus_prolific.csv',
+            'bonus.csv',
+            'memory.json',
+            'memory.csv',
+            'data.json',
+            'data.csv',
+            'times.csv',
+            'times_json',
+            'player_data.csv',
+            'player_data.json'
+        ];
+
+        if ('string' === typeof opts.rooms) {
+            let tokens = opts.rooms.split(',')
+            let out = [];
+            tokens.forEach(token => {
+                let idx = token.indexOf('-');
+                if (!~idx) return out.push(token);
+                let l = token.substring(0, idx);
+                l = J.isInt(l);
+                if (false === l) {
+                    console.log('err: invalid room parameter: ' + opts.rooms);
+                    return;
+                }
+
+                let r = token.substring(idx+1);
+                r = J.isInt(r);
+                if (false === r) {
+                    console.log('err: invalid room parameter: ' + opts.rooms);
+                    return;
+                }
+
+                J.seq(l, r, 1, t => out.push(t));
+
+            });
+            opts.roomsOrig = J.clone(opts.rooms);
+            opts.rooms = out;
+        }
+
+        if (opts.fromRoom) {
+            let f = J.isInt(opts.fromRoom);
+            if (false === f) {
+                console.log('err: invalid from-room parameter: ' +
+                            opts.fromRoom);
+                return;
+            }
+            opts.fromRoom = f;
+        }
+
+        if (opts.toRoom) {
+            let t = J.isInt(opts.toRoom);
+            if (false === t) {
+                console.log('err: invalid to-room parameter: ' + opts.toRoom);
+                return;
+            }
+            opts.toRoom = t;
+        }
+    }
+
+
+    opts.files = opts.files || defaultFiles;
+    if (!Array.isArray(opts.files)) opts.files = [ opts.files ];
+    if (opts.filesAdd) opts.files = [ ...opts.files, ... opts.filesAdd ];
+};
+
+/**
+ * getExportFilename
+ *
+ * Returns a file name for the exports
+ *
+ * @param {object} opts Configuration options
+ *
+ * @return {string} outFile The full path including the filename for the export
+ */
+const getExportFilename = (serverConf, opts, V) => {
+
+    const OUTDIR_EXPORT = createExportDir(serverConf, opts, V);
+
+    let file = opts.file;
+
+    if (opts.outFormat) {
+        let ext = getExtension(file);
+        if (ext !== opts.outFormat) file = file += '.' + opts.outFormat;
+    }
+
+    let outFile = path.resolve(OUTDIR_EXPORT, file);
+
+    // If file with same name already exists in out directory take action.
+    if (fs.existsSync(outFile)) {
+        let d = opts.onDuplicatedNames;
+        if (d === 'err') {
+            throw new Error(`out file already existing: ${outFile}`);
+        }
+        else if (d === 'rename') {
+            let idx = -1;
+            for (; ++idx < 100;) {
+                outFile = incrementFileIdx(file, idx);
+                outFile = path.resolve(OUTDIR_EXPORT, outFile);
+                if (!fs.existsSync(outFile)) break;
+            }
+            if (idx === 100) {
+                throw new Error(
+                    `max number of files with same suffix in directory` +
+                    `reached: ${file}`
+                );
+            }
+        }
+        else {
+            opts.append = true;
+        }
+    }
+
+    return outFile;
+};
+
+const printOptions = (type, opts) => {
+    console.log();
+    if (type === 'data') {
+        console.log(' *** Exporting data from game: ' + opts.game);
+    }
+    else {
+        // console.log(' *** Exporting logs from : ' + opts.game);
+    }
+    console.log(' *** Export folder: ' + opts.exportDir);
+    if (opts.minRoom) console.log(' *** Min Room: ' + opts.minRoom);
+    if (opts.maxRoom) console.log(' *** Max Room: ' + opts.maxRoom);
+    if (opts.fromRoom) console.log(' *** From room: ' + opts.fromRoom);
+    if (opts.toRoom) console.log(' *** From room: ' + opts.toRoom);
+    if (opts.rooms) console.log(' *** Rooms: ' + opts.roomsOrig);
+
+    console.log();
+
+};
+
+const getDefaultExportDir = conf => {
+    return path.join(conf.ngDir, 'export');
+};
+
+const checkProcessing = cb => {
+    setTimeout(() => {
+        if (--processing <= 0 && cb) cb();
+    }, 1000);
+};
+
+const createExportDir = (serverConf, opts, V) => {
+
+    let outDir = opts.exportDir ?? getDefaultExportDir(serverConf);
+
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir);
+        if (V) console.log('- created ' + outDir);
+    }
+
+    if (opts.createExportSubDir) {
+        // Create dir name based on time.
+        let t = new Date().toISOString().replaceAll(':', '-').replace('T', '_');
+        t = t.substr(0, t.lastIndexOf('.'));
+
+        outDir = path.join(outDir, t);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir);
+            if (V) console.log('- created ' + outDir);
+        }
+    }
+
+    return outDir;
+};
+
+/**
+* ### getExtension
+*
+* Extracts the extension from a file name
+*
+*
+* @param {string} file The filename
+*
+* @return {string} The extension or NULL if not found
+*/
+const getExtension = (file) => {
+    let format = file.lastIndexOf('.');
+    return format < 0 ? null : file.substr(format + 1);
+};
+
+/**
+* ### incrementFileIdx
+*
+* Incrementaly adds a suffix to a file name before the extension
+*
+* @param {string} file The filename
+* @param {number} idx Optional. The initial number to increment. Default: 0.
+*
+* @return {string} The incremented file name.
+*/
+const incrementFileIdx = (file, idx = 0) => {
+    let format = file.lastIndexOf('.');
+    if (!~format) return `${file}_${++idx}`;
+    return `${file.substr(0, format)}_${++idx}${file.substr(format)}`;
+};
+
+module.exports = {
+    logs: exportLogs,
+    data: exportData,
+    getDefaultExportDir: getDefaultExportDir,
+    setDefaults: setDefaults
+};
diff --git a/package.json b/package.json
index 50c3989..4ee012d 100644
--- a/package.json
+++ b/package.json
@@ -1,12 +1,13 @@
 {
   "name": "nodegame-generator",
   "description": "NodeGame' game generator",
-  "version": "1.1.2",
+  "version": "7.0.0",
   "author": "Stefano Balietti <futur.dorko@gmail.com>",
   "keywords": [
     "nodegame",
-    "framework",
-    "web",
+    "boilerplate",
+    "template",
+    "cli",
     "game",
     "multiplayer",
     "realtime"
@@ -14,22 +15,24 @@
   "repository": "nodeGame/generator",
   "license": "MIT",
   "dependencies": {
-    "commander": "2.6.0",
-    "mkdirp": "0.5.0",
-    "sorted-object": "1.0.0",
     "JSUS": "*",
+    "ansi-escapes": "^3.1.0",
+    "commander": "2.6.0",
+    "dictator": "*",
     "fs-extra": "*",
+    "mkdirp": "0.5.0",
     "nodegame-game-template": "*",
-    "dictator": "*",
     "ultimatum-game": "*"
   },
   "main": "bin/nodegame",
   "preferGlobal": true,
   "devDependencies": {
+    "eslint": "^5.5.0",
+    "jshint": "^2.9.6",
     "mocha": "~2.1.0",
     "should": "4.4.1"
   },
   "engines": {
-    "node": ">= 4.0.0"
+    "node": ">= 6.0.0"
   }
 }