diff --git a/config.go b/config.go
index 87fa68c..934f2e2 100644
--- a/config.go
+++ b/config.go
@@ -1,20 +1,20 @@
 package main
 
 import (
-    "log"
-    "flag"
-    "os"
-    "path/filepath"
+	"flag"
+	"log"
+	"os"
+	"path/filepath"
 
-    "github.com/BurntSushi/toml"
+	"github.com/BurntSushi/toml"
 )
 
 type Config struct {
-    Database DatabaseConfig
+	Database DatabaseConfig
 }
 
 type DatabaseConfig struct {
-    Type string
+	Type string
 }
 
 var ConfigFolder string
@@ -23,39 +23,39 @@ var ConfigFilename string
 var Configuration Config
 
 func init() {
-    const baseFolder string = "jdr"
-
-    dir, varSet := os.LookupEnv("XDG_CONFIG_HOME")
-    if varSet {
-        ConfigFolder = filepath.Join(dir, baseFolder)
-    } else {
-        dir, varSet = os.LookupEnv("HOME")
-        if !varSet {
-            log.Fatal("Cannot find a config folder")
-        }
-
-        ConfigFolder = filepath.Join(dir, "." + baseFolder)
-    }
+	const baseFolder string = "jdr"
+
+	dir, varSet := os.LookupEnv("XDG_CONFIG_HOME")
+	if varSet {
+		ConfigFolder = filepath.Join(dir, baseFolder)
+	} else {
+		dir, varSet = os.LookupEnv("HOME")
+		if !varSet {
+			log.Fatal("Cannot find a config folder")
+		}
+
+		ConfigFolder = filepath.Join(dir, "."+baseFolder)
+	}
 }
 
 func ParseArguments() {
-    log.Println("Parsing arguments")
+	log.Println("Parsing arguments")
 
-    flag.StringVar(&ConfigFilename, "config", filepath.Join(ConfigFolder, "config.toml"), "configuration file")
-    flag.Parse()
+	flag.StringVar(&ConfigFilename, "config", filepath.Join(ConfigFolder, "config.toml"), "configuration file")
+	flag.Parse()
 }
 
 func LoadConfig() {
-    configFilename, err := filepath.Abs(ConfigFilename)
-    if err != nil {
-        log.Fatal(err)
-    }
-
-    log.Println("Loading config from", configFilename)
-    _, err = toml.DecodeFile(configFilename, &Configuration)
-    if err != nil {
-        log.Fatal(err)
-    }
-
-    log.Println(Configuration.Database.Type)
+	configFilename, err := filepath.Abs(ConfigFilename)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Println("Loading config from", configFilename)
+	_, err = toml.DecodeFile(configFilename, &Configuration)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Println(Configuration.Database.Type)
 }
diff --git a/jdr/game.go b/jdr/game.go
index 52269ca..50dbb8b 100644
--- a/jdr/game.go
+++ b/jdr/game.go
@@ -1,5 +1,4 @@
 package jdr
 
 type Game struct {
-
 }
diff --git a/jdr/sheet.go b/jdr/sheet.go
index 6f30789..489cfca 100644
--- a/jdr/sheet.go
+++ b/jdr/sheet.go
@@ -1,369 +1,369 @@
 package jdr
 
 import (
-    "html/template"
-    "encoding/xml"
+	"encoding/xml"
+	"html/template"
 
-    "errors"
-    "os"
-    "log"
+	"errors"
+	"log"
+	"os"
 )
 
 type Page struct {
-    Items []SheetItem
+	Items []SheetItem
 }
 
 func (self *Page) ToHTML() template.HTML {
-    ret := ""
+	ret := ""
 
-    for _, item := range(self.Items) {
-        ret += string(item.ToHTML())
-    }
+	for _, item := range self.Items {
+		ret += string(item.ToHTML())
+	}
 
-    return template.HTML(ret)
+	return template.HTML(ret)
 }
 
 type SheetItem interface {
-    Name() string
-    ToHTML() template.HTML
+	Name() string
+	ToHTML() template.HTML
 }
 
 type Block struct {
-    name  string
-    Items []SheetItem
+	name  string
+	Items []SheetItem
 }
 
 func (self *Block) Name() string {
-    return self.name
+	return self.name
 }
 
 func (self *Block) ToHTML() template.HTML {
-    begin  := `<fieldset>`
-    legend := `<legend>` + template.HTMLEscapeString(self.Name()) + `</legend>`
-    end    := `</fieldset>`
+	begin := `<fieldset>`
+	legend := `<legend>` + template.HTMLEscapeString(self.Name()) + `</legend>`
+	end := `</fieldset>`
 
-    ret := template.HTML(begin)
-    if self.Name() != "" {
-        ret += template.HTML(legend)
-    }
+	ret := template.HTML(begin)
+	if self.Name() != "" {
+		ret += template.HTML(legend)
+	}
 
-    for _, item := range(self.Items) {
-        ret += item.ToHTML()
-    }
-    ret += template.HTML(end)
+	for _, item := range self.Items {
+		ret += item.ToHTML()
+	}
+	ret += template.HTML(end)
 
-    return ret
+	return ret
 }
 
 type Variable struct {
-    Type VariableType
-    name string
+	Type VariableType
+	name string
 }
 
 func (self *Variable) Name() string {
-    return self.name
+	return self.name
 }
 
 func (self *Variable) ToHTML() template.HTML {
-    label := ""
-    if self.name != "" {
-        label = `<label>` + template.HTMLEscapeString(self.name) + `</label>`
-    }
+	label := ""
+	if self.name != "" {
+		label = `<label>` + template.HTMLEscapeString(self.name) + `</label>`
+	}
 
-    html, err := self.Type.ToHTML(self.Type.DefaultValue())
-    if err != nil {
-        log.Fatal(err)
-    }
+	html, err := self.Type.ToHTML(self.Type.DefaultValue())
+	if err != nil {
+		log.Fatal(err)
+	}
 
-    return template.HTML(label) + html + template.HTML(`<br/>`)
+	return template.HTML(label) + html + template.HTML(`<br/>`)
 }
 
 type CharacterSheet struct {
-    types map[string]VariableType
-    Pages []*Page
+	types map[string]VariableType
+	Pages []*Page
 }
 
 func (self *CharacterSheet) Script() template.JS {
-    return template.JS("")
+	return template.JS("")
 }
 
 func (self *CharacterSheet) Render() template.HTML {
-    ret := template.HTML("")
+	ret := template.HTML("")
 
-    for _, page := range(self.Pages) {
-        ret += page.ToHTML()
-    }
+	for _, page := range self.Pages {
+		ret += page.ToHTML()
+	}
 
-    return ret
+	return ret
 }
 
 func (self *CharacterSheet) AddType(t VariableType) {
-    if self.types == nil {
-        self.types = make(map[string]VariableType)
-    }
+	if self.types == nil {
+		self.types = make(map[string]VariableType)
+	}
 
-    name := t.Name()
-    self.types[name] = t
+	name := t.Name()
+	self.types[name] = t
 }
 
 func (self *CharacterSheet) AddDefaultTypes() {
-    self.AddType(&VariableType_bool{})
-    self.AddType(&VariableType_int{})
-    self.AddType(&VariableType_float{})
-    self.AddType(&VariableType_string{})
-    self.AddType(&VariableType_d{})
+	self.AddType(&VariableType_bool{})
+	self.AddType(&VariableType_int{})
+	self.AddType(&VariableType_float{})
+	self.AddType(&VariableType_string{})
+	self.AddType(&VariableType_d{})
 }
 
 func (self *CharacterSheet) getType(typename string) (VariableType, error) {
-    t, ok := self.types[typename]
-    if !ok {
-        return &VariableType_badType{}, errors.New("unknown type \"" + typename + "\"")
-    }
+	t, ok := self.types[typename]
+	if !ok {
+		return &VariableType_badType{}, errors.New("unknown type \"" + typename + "\"")
+	}
 
-    return t, nil
+	return t, nil
 }
 
 type xmlNode struct {
-    XMLName xml.Name
-    Attrs   []xml.Attr `xml:"-"`
-    Content []byte     `xml:",innerxml"`
-    Nodes   []xmlNode  `xml:",any"`
+	XMLName xml.Name
+	Attrs   []xml.Attr `xml:"-"`
+	Content []byte     `xml:",innerxml"`
+	Nodes   []xmlNode  `xml:",any"`
 }
 
 func (n *xmlNode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
-    n.Attrs = start.Attr
-    type node xmlNode
+	n.Attrs = start.Attr
+	type node xmlNode
 
-    return d.DecodeElement((*node)(n), &start)
+	return d.DecodeElement((*node)(n), &start)
 }
 
 func parseVariable(root xmlNode, sheet *CharacterSheet, defaults *Variable) (*Variable, error) {
-    ret := &Variable{}
-
-    typeOk := false
-    nameOk := false
-
-    if defaults != nil {
-        switch defaults.Type.(type) {
-        case *VariableType_badType:
-            typeOk = false
-        default:
-            typeOk = true
-            ret.Type = defaults.Type
-        }
-    }
-
-    for i := 0; i < len(root.Attrs); i++ {
-        attrName := root.Attrs[i].Name.Local
-        attrVal  := root.Attrs[i].Value
-
-        switch attrName {
-        case "type":
-            t, err := sheet.getType(attrVal)
-            if err != nil {
-                return nil, err
-            }
-            ret.Type = t
-            typeOk = true
-        case "name":
-            ret.name = attrVal
-            nameOk = true
-        }
-    }
-
-    if !nameOk {
-        return nil, errors.New("Unnamed variable")
-    }
-    if !typeOk {
-        return nil, errors.New("No type provided for variable \"" + ret.Name() + "\"")
-    }
-
-    return ret, nil
+	ret := &Variable{}
+
+	typeOk := false
+	nameOk := false
+
+	if defaults != nil {
+		switch defaults.Type.(type) {
+		case *VariableType_badType:
+			typeOk = false
+		default:
+			typeOk = true
+			ret.Type = defaults.Type
+		}
+	}
+
+	for i := 0; i < len(root.Attrs); i++ {
+		attrName := root.Attrs[i].Name.Local
+		attrVal := root.Attrs[i].Value
+
+		switch attrName {
+		case "type":
+			t, err := sheet.getType(attrVal)
+			if err != nil {
+				return nil, err
+			}
+			ret.Type = t
+			typeOk = true
+		case "name":
+			ret.name = attrVal
+			nameOk = true
+		}
+	}
+
+	if !nameOk {
+		return nil, errors.New("Unnamed variable")
+	}
+	if !typeOk {
+		return nil, errors.New("No type provided for variable \"" + ret.Name() + "\"")
+	}
+
+	return ret, nil
 }
 
 func parseBlock(root xmlNode, sheet *CharacterSheet) (*Block, error) {
-    ret := &Block{}
-
-    for i := 0; i < len(root.Attrs); i++ {
-        attrName := root.Attrs[i].Name.Local
-        attrVal  := root.Attrs[i].Value
-
-        switch attrName {
-        case "name":
-            ret.name = attrVal
-        }
-    }
-
-    for i := 0; i < len(root.Nodes); i++ {
-        items, err := parseItem(root.Nodes[i], sheet)
-        if err != nil {
-            return nil, err
-        }
-
-        for _, item := range(items) {
-            ret.Items = append(ret.Items, item)
-        }
-    }
-
-    return ret, nil
+	ret := &Block{}
+
+	for i := 0; i < len(root.Attrs); i++ {
+		attrName := root.Attrs[i].Name.Local
+		attrVal := root.Attrs[i].Value
+
+		switch attrName {
+		case "name":
+			ret.name = attrVal
+		}
+	}
+
+	for i := 0; i < len(root.Nodes); i++ {
+		items, err := parseItem(root.Nodes[i], sheet)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, item := range items {
+			ret.Items = append(ret.Items, item)
+		}
+	}
+
+	return ret, nil
 }
 
 func parseVariableGroup(root xmlNode, sheet *CharacterSheet, defaults *Variable) ([]*Variable, error) {
-    ret := []*Variable{}
-
-    typeOk := false
-    if defaults == nil {
-        defaults = &Variable{}
-    } else {
-        typeOk = true
-    }
-
-    for i := 0; i < len(root.Attrs); i++ {
-        attrName := root.Attrs[i].Name.Local
-        attrVal  := root.Attrs[i].Value
-
-        switch attrName {
-        case "default-type":
-            t, err := sheet.getType(attrVal)
-            if err != nil {
-                return nil, err
-            }
-            defaults.Type = t
-            typeOk = true
-        }
-    }
-
-    if !typeOk {
-        defaults.Type = &VariableType_badType{}
-    }
-
-    for i := 0; i < len(root.Nodes); i++ {
-        node := root.Nodes[i]
-
-        switch node.XMLName.Local {
-        case "variable":
-            item, err := parseVariable(node, sheet, defaults)
-            if err != nil {
-                return nil, err
-            }
-
-            ret = append(ret, item)
-        case "variable-group":
-            items, err := parseVariableGroup(node, sheet, defaults)
-            if err != nil {
-                return nil, err
-            }
-
-            for j := 0; j < len(items); j++ {
-                ret = append(ret, items[j])
-            }
-
-        default:
-            return nil, errors.New("Unknown variable-group item: \"" + node.XMLName.Local + "\"")
-        }
-    }
-
-    return ret, nil
+	ret := []*Variable{}
+
+	typeOk := false
+	if defaults == nil {
+		defaults = &Variable{}
+	} else {
+		typeOk = true
+	}
+
+	for i := 0; i < len(root.Attrs); i++ {
+		attrName := root.Attrs[i].Name.Local
+		attrVal := root.Attrs[i].Value
+
+		switch attrName {
+		case "default-type":
+			t, err := sheet.getType(attrVal)
+			if err != nil {
+				return nil, err
+			}
+			defaults.Type = t
+			typeOk = true
+		}
+	}
+
+	if !typeOk {
+		defaults.Type = &VariableType_badType{}
+	}
+
+	for i := 0; i < len(root.Nodes); i++ {
+		node := root.Nodes[i]
+
+		switch node.XMLName.Local {
+		case "variable":
+			item, err := parseVariable(node, sheet, defaults)
+			if err != nil {
+				return nil, err
+			}
+
+			ret = append(ret, item)
+		case "variable-group":
+			items, err := parseVariableGroup(node, sheet, defaults)
+			if err != nil {
+				return nil, err
+			}
+
+			for j := 0; j < len(items); j++ {
+				ret = append(ret, items[j])
+			}
+
+		default:
+			return nil, errors.New("Unknown variable-group item: \"" + node.XMLName.Local + "\"")
+		}
+	}
+
+	return ret, nil
 }
 
 func parseItem(root xmlNode, sheet *CharacterSheet) ([]SheetItem, error) {
-    switch root.XMLName.Local {
-    case "block":
-        block, err := parseBlock(root, sheet)
-        if err != nil {
-            return nil, err
-        }
-
-        return []SheetItem{block}, nil
-    case "variable":
-        variable, err := parseVariable(root, sheet, nil)
-        if err != nil {
-            return nil, err
-        }
-
-        return []SheetItem{variable}, err
-    case "variable-group":
-        variables, err := parseVariableGroup(root, sheet, nil)
-        if err != nil {
-            return nil, err
-        }
-
-        items := make([]SheetItem, len(variables))
-        for i, v := range variables {
-            items[i] = SheetItem(v)
-        }
-        return items, nil
-    default:
-        return nil, errors.New("Unknown item: " + root.XMLName.Local)
-    }
+	switch root.XMLName.Local {
+	case "block":
+		block, err := parseBlock(root, sheet)
+		if err != nil {
+			return nil, err
+		}
+
+		return []SheetItem{block}, nil
+	case "variable":
+		variable, err := parseVariable(root, sheet, nil)
+		if err != nil {
+			return nil, err
+		}
+
+		return []SheetItem{variable}, err
+	case "variable-group":
+		variables, err := parseVariableGroup(root, sheet, nil)
+		if err != nil {
+			return nil, err
+		}
+
+		items := make([]SheetItem, len(variables))
+		for i, v := range variables {
+			items[i] = SheetItem(v)
+		}
+		return items, nil
+	default:
+		return nil, errors.New("Unknown item: " + root.XMLName.Local)
+	}
 }
 
 func parsePage(root xmlNode, sheet *CharacterSheet) (*Page, error) {
-    ret := &Page{}
+	ret := &Page{}
 
-    for i := 0; i < len(root.Nodes); i++ {
-        items, err := parseItem(root.Nodes[i], sheet)
-        if err != nil {
-            return nil, err
-        }
+	for i := 0; i < len(root.Nodes); i++ {
+		items, err := parseItem(root.Nodes[i], sheet)
+		if err != nil {
+			return nil, err
+		}
 
-        for _, item := range(items) {
-            ret.Items = append(ret.Items, item)
-        }
-    }
+		for _, item := range items {
+			ret.Items = append(ret.Items, item)
+		}
+	}
 
-    return ret, nil
+	return ret, nil
 }
 
 func parseSheet(root xmlNode) (*CharacterSheet, error) {
-    if root.XMLName.Local != "jdr-desc" {
-        return nil, errors.New("Wrong root node")
-    }
-
-    sheet := &CharacterSheet{}
-    sheet.AddDefaultTypes()
-    for i := 0; i < len(root.Nodes); i++ {
-        node := root.Nodes[i]
-
-        switch node.XMLName.Local {
-        case "custom-types":
-            err := parseCustomTypes(node, sheet)
-            if err != nil {
-                return nil, err
-            }
-
-        case "page":
-            page, err := parsePage(node, sheet)
-            if err != nil {
-                return nil, err
-            }
-            sheet.Pages = append(sheet.Pages, page)
-
-        default:
-            return nil, errors.New("Wrong format")
-        }
-    }
-
-    return sheet, nil
+	if root.XMLName.Local != "jdr-desc" {
+		return nil, errors.New("Wrong root node")
+	}
+
+	sheet := &CharacterSheet{}
+	sheet.AddDefaultTypes()
+	for i := 0; i < len(root.Nodes); i++ {
+		node := root.Nodes[i]
+
+		switch node.XMLName.Local {
+		case "custom-types":
+			err := parseCustomTypes(node, sheet)
+			if err != nil {
+				return nil, err
+			}
+
+		case "page":
+			page, err := parsePage(node, sheet)
+			if err != nil {
+				return nil, err
+			}
+			sheet.Pages = append(sheet.Pages, page)
+
+		default:
+			return nil, errors.New("Wrong format")
+		}
+	}
+
+	return sheet, nil
 }
 
 func ReadCharacterSheet(filename string) (*CharacterSheet, error) {
-    file, err := os.Open(filename)
-    if err != nil {
-        return nil, err
-    }
-    defer file.Close()
-
-    decoder := xml.NewDecoder(file)
-    var n xmlNode
-    err = decoder.Decode(&n)
-    if err != nil {
-        return nil, err
-    }
-
-    sheet, err := parseSheet(n)
-    if err != nil {
-        return nil, err
-    }
-    return sheet, nil
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	decoder := xml.NewDecoder(file)
+	var n xmlNode
+	err = decoder.Decode(&n)
+	if err != nil {
+		return nil, err
+	}
+
+	sheet, err := parseSheet(n)
+	if err != nil {
+		return nil, err
+	}
+	return sheet, nil
 }
diff --git a/jdr/type.go b/jdr/type.go
index 7f66c1c..a03934f 100644
--- a/jdr/type.go
+++ b/jdr/type.go
@@ -1,14 +1,14 @@
 package jdr
 
-import(
-    "html/template"
-
-    "fmt"
-    "log"
-    "errors"
-    "strings"
-    "strconv"
-    "regexp"
+import (
+	"html/template"
+
+	"errors"
+	"fmt"
+	"log"
+	"regexp"
+	"strconv"
+	"strings"
 )
 
 var regexp_d = regexp.MustCompile(`^[1-9][0-9]*d([468]|1[02]|20|100)$`)
@@ -16,443 +16,443 @@ var regexp_d = regexp.MustCompile(`^[1-9][0-9]*d([468]|1[02]|20|100)$`)
 type JsonValue interface{}
 
 type VariableType interface {
-    Name() string
-    Validate(value JsonValue) bool
-    ToHTML(value JsonValue) (template.HTML, error)
-    DefaultValue() JsonValue
+	Name() string
+	Validate(value JsonValue) bool
+	ToHTML(value JsonValue) (template.HTML, error)
+	DefaultValue() JsonValue
 }
 
 func validateCast(err error) bool {
-    if err != nil {
-        log.Println(err)
-        return false
-    }
-    return true
+	if err != nil {
+		log.Println(err)
+		return false
+	}
+	return true
 }
 
-type VariableType_badType struct {}
+type VariableType_badType struct{}
 
 func (*VariableType_badType) Name() string {
-    return "unknown type"
+	return "unknown type"
 }
 
 func (*VariableType_badType) Validate(s JsonValue) bool {
-    return false
+	return false
 }
 
 func (*VariableType_badType) ToHTML(value JsonValue) (template.HTML, error) {
-    return template.HTML(""), errors.New("unknown type")
+	return template.HTML(""), errors.New("unknown type")
 }
 
 func (*VariableType_badType) DefaultValue() JsonValue {
-    return ""
+	return ""
 }
 
-type VariableType_bool struct {}
+type VariableType_bool struct{}
 
 func (*VariableType_bool) Name() string {
-    return "bool"
+	return "bool"
 }
 
 func (*VariableType_bool) ToBool(value JsonValue) (bool, error) {
-    val, isBool := value.(bool)
-    if !isBool {
-        return false, errors.New("Non boolean value")
-    }
+	val, isBool := value.(bool)
+	if !isBool {
+		return false, errors.New("Non boolean value")
+	}
 
-    return val, nil
+	return val, nil
 }
 
 func (self *VariableType_bool) Validate(value JsonValue) bool {
-    _, err := self.ToBool(value)
-    return validateCast(err)
+	_, err := self.ToBool(value)
+	return validateCast(err)
 }
 
 func (self *VariableType_bool) ToHTML(value JsonValue) (template.HTML, error) {
-    val, err := self.ToBool(value)
-    if err != nil {
-        return template.HTML(""), err
-    }
+	val, err := self.ToBool(value)
+	if err != nil {
+		return template.HTML(""), err
+	}
 
-    ret := `<input type="checkbox"`
-    if(val) {
-        ret += ` checked`
-    }
-    ret += `/>`
+	ret := `<input type="checkbox"`
+	if val {
+		ret += ` checked`
+	}
+	ret += `/>`
 
-    return template.HTML(ret), nil
+	return template.HTML(ret), nil
 }
 
 func (self *VariableType_bool) DefaultValue() JsonValue {
-    return false
+	return false
 }
 
-type VariableType_int struct {}
+type VariableType_int struct{}
 
 func (*VariableType_int) Name() string {
-    return "int"
+	return "int"
 }
 
 func (self *VariableType_int) ToInt(value JsonValue) (int64, error) {
-    val, isInt := value.(int64)
-    if !isInt {
-        val2, isInt := value.(int)
-        if isInt {
-            val = int64(val2)
-        } else {
-            return 0, errors.New("Bad int type: " + fmt.Sprintf("%T", value))
-        }
-    }
+	val, isInt := value.(int64)
+	if !isInt {
+		val2, isInt := value.(int)
+		if isInt {
+			val = int64(val2)
+		} else {
+			return 0, errors.New("Bad int type: " + fmt.Sprintf("%T", value))
+		}
+	}
 
-    return val, nil
+	return val, nil
 }
 
 func (self *VariableType_int) Validate(value JsonValue) bool {
-    _, err := self.ToInt(value)
-    return validateCast(err)
+	_, err := self.ToInt(value)
+	return validateCast(err)
 }
 
 func (self *VariableType_int) ToHTML(value JsonValue) (template.HTML, error) {
-    val, err := self.ToInt(value)
-    if err != nil {
-        return template.HTML(""), err
-    }
+	val, err := self.ToInt(value)
+	if err != nil {
+		return template.HTML(""), err
+	}
 
-    ret := `<input type="number" step="1" value="` + strconv.FormatInt(val, 10) + `"/>`
-    return template.HTML(ret), nil
+	ret := `<input type="number" step="1" value="` + strconv.FormatInt(val, 10) + `"/>`
+	return template.HTML(ret), nil
 }
 
 func (self *VariableType_int) DefaultValue() JsonValue {
-    return 0
+	return 0
 }
 
-type VariableType_float struct {}
+type VariableType_float struct{}
 
 func (*VariableType_float) Name() string {
-    return "float"
+	return "float"
 }
 
 func (*VariableType_float) ToFloat(value JsonValue) (float64, error) {
-    val, isFloat := value.(float64)
-    if !isFloat {
-        return 0.0, errors.New("Not a float")
-    }
+	val, isFloat := value.(float64)
+	if !isFloat {
+		return 0.0, errors.New("Not a float")
+	}
 
-    return val, nil
+	return val, nil
 }
 
 func (self *VariableType_float) Validate(value JsonValue) bool {
-    _, err := self.ToFloat(value)
-    return validateCast(err)
+	_, err := self.ToFloat(value)
+	return validateCast(err)
 }
 
 func (self *VariableType_float) ToHTML(value JsonValue) (template.HTML, error) {
-    val, err := self.ToFloat(value)
-    if err != nil {
-        return template.HTML(""), err
-    }
+	val, err := self.ToFloat(value)
+	if err != nil {
+		return template.HTML(""), err
+	}
 
-    ret := `<input type="number" value="` + strconv.FormatFloat(val, 'g', -1, 64) + `"/>`
+	ret := `<input type="number" value="` + strconv.FormatFloat(val, 'g', -1, 64) + `"/>`
 
-    return template.HTML(ret), nil
+	return template.HTML(ret), nil
 }
 
 func (self *VariableType_float) DefaultValue() JsonValue {
-    return 0.0
+	return 0.0
 }
 
-type VariableType_string struct {}
+type VariableType_string struct{}
 
 func (*VariableType_string) Name() string {
-    return "string"
+	return "string"
 }
 
 func (self *VariableType_string) ToString(value JsonValue) (string, error) {
-    val, isString := value.(string)
-    if !isString {
-        return "", errors.New("Not a string")
-    }
+	val, isString := value.(string)
+	if !isString {
+		return "", errors.New("Not a string")
+	}
 
-    return val, nil
+	return val, nil
 }
 
 func (self *VariableType_string) Validate(value JsonValue) bool {
-    _, err := self.ToString(value)
-    return validateCast(err)
+	_, err := self.ToString(value)
+	return validateCast(err)
 }
 
 func (self *VariableType_string) ToHTML(value JsonValue) (template.HTML, error) {
-    str, err := self.ToString(value)
-    if err != nil {
-        return template.HTML(""), err
-    }
+	str, err := self.ToString(value)
+	if err != nil {
+		return template.HTML(""), err
+	}
 
-    ret := `<input type="text" value="` + template.HTMLEscapeString(str) + `"/>`
-    return template.HTML(ret), nil
+	ret := `<input type="text" value="` + template.HTMLEscapeString(str) + `"/>`
+	return template.HTML(ret), nil
 }
 
 func (self *VariableType_string) DefaultValue() JsonValue {
-    return ""
+	return ""
 }
 
-type VariableType_d struct {}
+type VariableType_d struct{}
 
 func (*VariableType_d) Name() string {
-    return "d"
+	return "d"
 }
 
 func (*VariableType_d) Validate(value JsonValue) bool {
-    //FIXME
-    return false
+	//FIXME
+	return false
 }
 
 func (self *VariableType_d) ToHTML(value JsonValue) (template.HTML, error) {
-    //FIXME: non-generic version
-    ret := `<input type="text" value="` /*+ template.HTMLEscapeString(value)*/ +`"/>`
+	//FIXME: non-generic version
+	ret := `<input type="text" value="` /*+ template.HTMLEscapeString(value)*/ + `"/>`
 
-    return template.HTML(ret), nil
+	return template.HTML(ret), nil
 }
 
 func (self *VariableType_d) DefaultValue() JsonValue {
-    //FIXME: non-generic version
-    return ""
+	//FIXME: non-generic version
+	return ""
 }
 
 func makeVariableType(s string) VariableType {
-    switch(strings.ToLower(s)) {
-    case "bool":
-        return &VariableType_bool{}
-    case "int":
-        return &VariableType_int{}
-    case "float":
-        return &VariableType_float{}
-    case "string":
-        return &VariableType_string{}
-    case "d":
-        return &VariableType_d{}
-    default:
-        log.Println("Unknown type:", s)
-        return &VariableType_badType{}
-    }
+	switch strings.ToLower(s) {
+	case "bool":
+		return &VariableType_bool{}
+	case "int":
+		return &VariableType_int{}
+	case "float":
+		return &VariableType_float{}
+	case "string":
+		return &VariableType_string{}
+	case "d":
+		return &VariableType_d{}
+	default:
+		log.Println("Unknown type:", s)
+		return &VariableType_badType{}
+	}
 }
 
 type CustomEnum struct {
-    name        string
-    Values      []string
+	name   string
+	Values []string
 }
 
 func (self *CustomEnum) Name() string {
-    return self.name
+	return self.name
 }
 
 func (self *CustomEnum) ToId(value JsonValue) (int, error) {
-    val, isString := value.(string)
-    if !isString {
-        return 0, errors.New("Enum value not a string")
-    }
+	val, isString := value.(string)
+	if !isString {
+		return 0, errors.New("Enum value not a string")
+	}
 
-    for i := 0; i < len(self.Values); i++ {
-        if self.Values[i] == val {
-            return i, nil
-        }
-    }
+	for i := 0; i < len(self.Values); i++ {
+		if self.Values[i] == val {
+			return i, nil
+		}
+	}
 
-    return 0, errors.New("No such element")
+	return 0, errors.New("No such element")
 }
 
 func (self *CustomEnum) Validate(value JsonValue) bool {
-    _, err := self.ToId(value)
-    return validateCast(err)
+	_, err := self.ToId(value)
+	return validateCast(err)
 }
 
 func (self *CustomEnum) ToHTML(value JsonValue) (template.HTML, error) {
-    val, isString := value.(string)
-    if !isString {
-        return template.HTML(""), errors.New("Bad enum value")
-    }
-    selectItem := val != ""
-
-    value_id := 0
-    if selectItem {
-        var err error
-        value_id, err = self.ToId(value)
-        if err != nil {
-            return template.HTML(""), err
-        }
-    }
-
-    ret := `<select>`
-    for i, v := range(self.Values) {
-        ret += `<option`
-        if selectItem && i == value_id {
-            ret += ` selected`
-        }
-        ret += `>`
-        ret += template.HTMLEscapeString(v)
-        ret += `</option>`
-    }
-    ret += `</select>`
-
-    return template.HTML(ret), nil
+	val, isString := value.(string)
+	if !isString {
+		return template.HTML(""), errors.New("Bad enum value")
+	}
+	selectItem := val != ""
+
+	value_id := 0
+	if selectItem {
+		var err error
+		value_id, err = self.ToId(value)
+		if err != nil {
+			return template.HTML(""), err
+		}
+	}
+
+	ret := `<select>`
+	for i, v := range self.Values {
+		ret += `<option`
+		if selectItem && i == value_id {
+			ret += ` selected`
+		}
+		ret += `>`
+		ret += template.HTMLEscapeString(v)
+		ret += `</option>`
+	}
+	ret += `</select>`
+
+	return template.HTML(ret), nil
 }
 
 func (self *CustomEnum) DefaultValue() JsonValue {
-    return ""
+	return ""
 }
 
 type JsonObject map[string]interface{}
 
 type CustomStruct struct {
-    name        string
-    Variables   []*Variable
+	name      string
+	Variables []*Variable
 }
 
 func (self *CustomStruct) Name() string {
-    return self.name
+	return self.name
 }
 
 func (self *CustomStruct) Validate(value JsonValue) bool {
-    obj, isObj := value.(JsonObject)
-    if !isObj {
-        log.Println("Struct \"" + self.Name() + "\": value is not a JSON object")
-        return false
-    }
+	obj, isObj := value.(JsonObject)
+	if !isObj {
+		log.Println("Struct \"" + self.Name() + "\": value is not a JSON object")
+		return false
+	}
 
-    for _, v := range self.Variables {
-        if !v.Type.Validate(obj[v.Name()]) {
-            log.Println("Struct \"" + self.Name() + "\": value \"" + v.Name() + "\" was not validated")
-            return false
-        }
-    }
+	for _, v := range self.Variables {
+		if !v.Type.Validate(obj[v.Name()]) {
+			log.Println("Struct \"" + self.Name() + "\": value \"" + v.Name() + "\" was not validated")
+			return false
+		}
+	}
 
-    return true
+	return true
 }
 
 func (self *CustomStruct) ToHTML(value JsonValue) (template.HTML, error) {
-    if !self.Validate(value) {
-        return template.HTML(""), errors.New("Cannot validate struct")
-    }
+	if !self.Validate(value) {
+		return template.HTML(""), errors.New("Cannot validate struct")
+	}
 
-    obj, _ := value.(JsonObject)
+	obj, _ := value.(JsonObject)
 
-    ret := template.HTML("")
-    ret += `<div>` //FIXME: better tag
-    for _, v := range self.Variables {
-        if v.Name() != "" {
-            label := `<label>` + template.HTMLEscapeString(v.Name()) + `</label>`
-            ret += template.HTML(label)
-        }
+	ret := template.HTML("")
+	ret += `<div>` //FIXME: better tag
+	for _, v := range self.Variables {
+		if v.Name() != "" {
+			label := `<label>` + template.HTMLEscapeString(v.Name()) + `</label>`
+			ret += template.HTML(label)
+		}
 
-        html, err := v.Type.ToHTML(obj[v.Name()])
-        if err != nil {
-            return template.HTML(""), err
-        }
+		html, err := v.Type.ToHTML(obj[v.Name()])
+		if err != nil {
+			return template.HTML(""), err
+		}
 
-        ret += html
-    }
-    ret += `</div>`
+		ret += html
+	}
+	ret += `</div>`
 
-    return ret, nil
+	return ret, nil
 }
 
 func (self *CustomStruct) DefaultValue() JsonValue {
-    ret := make(JsonObject)
-    for _, v := range self.Variables {
-        ret[v.Name()] = v.Type.DefaultValue()
-    }
-    return ret
+	ret := make(JsonObject)
+	for _, v := range self.Variables {
+		ret[v.Name()] = v.Type.DefaultValue()
+	}
+	return ret
 }
 
 func parseCustomEnum(root xmlNode) (*CustomEnum, error) {
-    customEnum := CustomEnum {}
+	customEnum := CustomEnum{}
 
-    nameOk := false;
-    for i := 0; i < len(root.Attrs); i++ {
-        attrName := root.Attrs[i].Name.Local
-        attrVal  := root.Attrs[i].Value
+	nameOk := false
+	for i := 0; i < len(root.Attrs); i++ {
+		attrName := root.Attrs[i].Name.Local
+		attrVal := root.Attrs[i].Value
 
-        switch attrName {
-        case "name":
-            nameOk = true
-            customEnum.name = attrVal
-        }
-    }
+		switch attrName {
+		case "name":
+			nameOk = true
+			customEnum.name = attrVal
+		}
+	}
 
-    if !nameOk {
-        return nil, errors.New("Unnamed custom enum")
-    }
+	if !nameOk {
+		return nil, errors.New("Unnamed custom enum")
+	}
 
-    for i := 0; i < len(root.Nodes); i++ {
-        node := root.Nodes[i]
+	for i := 0; i < len(root.Nodes); i++ {
+		node := root.Nodes[i]
 
-        switch node.XMLName.Local {
-        case "value":
-            customEnum.Values = append(customEnum.Values, string(node.Content))
-        }
-    }
+		switch node.XMLName.Local {
+		case "value":
+			customEnum.Values = append(customEnum.Values, string(node.Content))
+		}
+	}
 
-    return &customEnum, nil
+	return &customEnum, nil
 }
 
 func parseCustomStruct(root xmlNode, sheet *CharacterSheet) (*CustomStruct, error) {
-    customType := CustomStruct{}
-
-    nameOk := false
-    for i := 0; i < len(root.Attrs); i++ {
-        attrName := root.Attrs[i].Name.Local
-        attrVal  := root.Attrs[i].Value
-
-        switch attrName {
-        case "name":
-            nameOk = true
-            customType.name = attrVal
-        }
-    }
-
-    if !nameOk {
-        return nil, errors.New("Unnamed custom type")
-    }
-
-    for i := 0; i < len(root.Nodes); i++ {
-        node := root.Nodes[i]
-
-        switch node.XMLName.Local {
-        case "variable":
-            variable, err := parseVariable(node, sheet, nil)
-            if err != nil {
-                return nil, err
-            }
-
-            customType.Variables = append(customType.Variables, variable)
-        default:
-            return nil, errors.New("Unknown tag in custom type: " + node.XMLName.Local)
-        }
-    }
-
-    return &customType, nil
-}
-
-func parseCustomTypes(root xmlNode, sheet *CharacterSheet) (error) {
-    for i := 0; i < len(root.Nodes); i++ {
-        node := root.Nodes[i]
-
-        switch node.XMLName.Local {
-        case "enum":
-            customEnum, err := parseCustomEnum(node)
-            if err != nil {
-                return err
-            }
-            sheet.AddType(customEnum)
-        case "type":
-            customType, err := parseCustomStruct(node, sheet)
-            if err != nil {
-                return err
-            }
-            sheet.AddType(customType)
-        default:
-            return errors.New("Unknown CustomType: " + root.Nodes[i].XMLName.Local)
-        }
-    }
-
-    return nil
+	customType := CustomStruct{}
+
+	nameOk := false
+	for i := 0; i < len(root.Attrs); i++ {
+		attrName := root.Attrs[i].Name.Local
+		attrVal := root.Attrs[i].Value
+
+		switch attrName {
+		case "name":
+			nameOk = true
+			customType.name = attrVal
+		}
+	}
+
+	if !nameOk {
+		return nil, errors.New("Unnamed custom type")
+	}
+
+	for i := 0; i < len(root.Nodes); i++ {
+		node := root.Nodes[i]
+
+		switch node.XMLName.Local {
+		case "variable":
+			variable, err := parseVariable(node, sheet, nil)
+			if err != nil {
+				return nil, err
+			}
+
+			customType.Variables = append(customType.Variables, variable)
+		default:
+			return nil, errors.New("Unknown tag in custom type: " + node.XMLName.Local)
+		}
+	}
+
+	return &customType, nil
+}
+
+func parseCustomTypes(root xmlNode, sheet *CharacterSheet) error {
+	for i := 0; i < len(root.Nodes); i++ {
+		node := root.Nodes[i]
+
+		switch node.XMLName.Local {
+		case "enum":
+			customEnum, err := parseCustomEnum(node)
+			if err != nil {
+				return err
+			}
+			sheet.AddType(customEnum)
+		case "type":
+			customType, err := parseCustomStruct(node, sheet)
+			if err != nil {
+				return err
+			}
+			sheet.AddType(customType)
+		default:
+			return errors.New("Unknown CustomType: " + root.Nodes[i].XMLName.Local)
+		}
+	}
+
+	return nil
 }
diff --git a/main.go b/main.go
index 08850a7..b135212 100644
--- a/main.go
+++ b/main.go
@@ -1,44 +1,44 @@
 package main
 
 import (
-    //"fmt"
-    "log"
-    "net/http"
-    "html/template"
-    "github.com/gorilla/mux"
-    "homnomnom.fr/jdr-server/jdr"
+	//"fmt"
+	"github.com/gorilla/mux"
+	"homnomnom.fr/jdr-server/jdr"
+	"html/template"
+	"log"
+	"net/http"
 )
 
 var templates = template.Must(template.ParseGlob("templates/*.html"))
 
 func mainPageHandler(w http.ResponseWriter, r *http.Request) {
-    err := templates.ExecuteTemplate(w, "login.html", nil)
-    if err != nil {
-        log.Println(err)
-    }
+	err := templates.ExecuteTemplate(w, "login.html", nil)
+	if err != nil {
+		log.Println(err)
+	}
 }
 
 func playerPageHandler(w http.ResponseWriter, r *http.Request) {
-    sheet, err := jdr.ReadCharacterSheet("jdr-desc/wasteland.xml")
-    if err != nil {
-        log.Fatal("error: ", err)
-    }
+	sheet, err := jdr.ReadCharacterSheet("jdr-desc/wasteland.xml")
+	if err != nil {
+		log.Fatal("error: ", err)
+	}
 
-    err = templates.ExecuteTemplate(w, "player.html", map[string]interface{}{
-        "Script": sheet.Script(),
-        "Sheet": sheet.Render(),
-    })
-    if err != nil {
-        log.Println(err)
-    }
+	err = templates.ExecuteTemplate(w, "player.html", map[string]interface{}{
+		"Script": sheet.Script(),
+		"Sheet":  sheet.Render(),
+	})
+	if err != nil {
+		log.Println(err)
+	}
 }
 
 func main() {
-    ParseArguments()
-    LoadConfig()
+	ParseArguments()
+	LoadConfig()
 
-    r := mux.NewRouter()
-    r.HandleFunc("/", mainPageHandler)
-    r.HandleFunc("/player", playerPageHandler)
-    log.Fatal(http.ListenAndServe(":8080", r))
+	r := mux.NewRouter()
+	r.HandleFunc("/", mainPageHandler)
+	r.HandleFunc("/player", playerPageHandler)
+	log.Fatal(http.ListenAndServe(":8080", r))
 }