init versionning

dice.js

@@ -0,0 +1,55 @@
+var roll = Array();
+roll[1] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[2] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[3] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[4] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[5] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[6] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[7] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[8] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[9] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+roll[1][1] = [5, 8, 9, 3, 11, 4, 7, 9, 1, 5, 3, 1, 3, 1, 6, 4, 3, 5, 9, 2, 1, 3, 5, 4];
+roll[2][1] = [9, 7, 12, 9, 8, 9, 8, 16, 2, 9, 4, 8, 6, 8, 9, 16, 16, 8, 7, 4, 11, 5, 8, 17];
+roll[3][1] = [17, 9, 12, 9, 7, 19, 9, 4, 12, 9, 8, 14, 7, 8, 7, 9, 7, 19, 9];
+roll[4][1] = [];
+roll[5][1] = [];
+roll[6][1] = [];
+roll[7][1] = [];
+roll[8][1] = [];
+roll[9][1] = [];
+roll[2][2] = [25, 15, 15, 13, 10, 19, 9, 7, 7, 12, 12, 11, 10, 25, 8, 12, 5, 14, 5, 6, 15];
+roll[3][2] = [];
+roll[4][2] = [25, 15, 27, 9, 23, 18, 9, 15, 18, 18, 12, 12, 44, 12, 22, 25, 10, 14, 8, 14, 27, 25] ;
+roll[5][2] = [];
+roll[6][2] = [];
+roll[7][2] = [];
+roll[8][2] = [];
+roll[9][2] = [];
+roll[3][3] = [];
+roll[4][3] = [];
+roll[5][3] = [];
+roll[6][3] = [25, 29, 29, 17, 26, 26, 19, 32, 52, 25, 18, 24, 34, 28, 47, 21, 16, 20, 49, 14, 21, 37];
+roll[7][3] = [26, 32, 29, 32, 31, 28, 25, 37, 23, 35, 20, 32, 24, 44, 40, 19, 14, 22, 43, 44];
+roll[8][3] = [];
+roll[9][3] = [];
+roll[4][4] = [];
+roll[5][4] = [];
+roll[6][4] = [];
+roll[7][4] = [];
+roll[8][4] = [21, 30, 37, 56, 29, 39, 28, 24, 40, 36];
+roll[9][4] = [];
+roll[5][5] = [];
+roll[6][5] = [];
+roll[7][5] = [];
+roll[8][5] = [];
+roll[9][5] = [];
+roll[6][6] = [];
+roll[7][6] = [];
+roll[8][6] = [];
+roll[9][6] = [];
+roll[7][7] = [];
+roll[8][6] = [];
+roll[9][6] = [];
+roll[8][8] = [];
+roll[9][8] = [];
+roll[9][9] = [];

display.js

@@ -0,0 +1,25 @@
+function capitalize( str ) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function toHeader(array){
+    let resultat = document.createElement("tr");
+
+    for(let i = 0; i < array.length ; i++ ){
+        let cell = document.createElement("th");
+        cell.innerText = array[i];
+        resultat.appendChild( cell );
+    }
+    return resultat;
+}
+
+function display(html_id, data){
+    let anchor = document.getElementById( html_id ) ;
+    let resultat = document.createElement( "table" );
+
+    let header = toHeader( Object.keys(data) );
+
+    for(let i = 0 ; i < data.length ; i++){
+    }
+    html_id.appendChild( resultat );
+}

l5r.js

@@ -0,0 +1,804 @@
+var stances = ["attack", "full attack", "defense", "full defense", "center"];
+
+class Characters {
+    constructor(){}
+
+    pool = [];
+    elements = ["Character", "Samourai"];
+
+    at( index ){
+        return this.pool[ index ];
+    }
+
+    elementsType = Character;
+
+    create( json ){
+        let charac = new Character();
+
+        if( typeof json === "Object" )
+            charac.fromJson( json ) ;
+
+        this.add( charac );
+    }
+    
+    createCharacter( aRole, gender, name, familly,experience, gempukku, skills ){
+        let character = new Character( aRole, gender, name, familly, school, experience, gempukku, skills );
+        this.add( character );
+    }
+
+    createSamourai( aRole, gender, name, familly, school, experience, gempukku, skills ){
+        let samourai = new Samourai( aRole, gender, name, familly, school, experience, gempukku, skills );
+        this.add( samourai );
+    }
+
+    fromJson( json ){
+
+        let data = JSON.parse(json);
+
+        for( prop in data){
+            this[ prop ] = data[ prop ];
+        }
+    }
+    
+    add(character){
+        if( this.elements.includes( character.constructor.name )){
+            this.pool.push( character );
+        }
+    }
+
+    indexOf( character ){
+        if(  this.elements.includes( character.constructor.name )){
+            for(let i = 0; i < this.pool.length ; i++){
+                if( character == this.pool[ i ] )
+                    return i;
+            }
+        }
+    }
+
+    getByName( name ){
+        for(let i = 0; i < this.pool.length ; i++){
+            if( this.pool[i].getName() == name)
+                return this.pool[i];
+        }
+    }
+
+    getIndexByName( name ){
+        for(let i = 0; i < this.pool.length ; i++){
+            if( this.pool[i].getName() == name)
+                return i;
+        }
+    }
+
+    size(){
+        return this.pool.length;
+    }
+}
+
+class Character {
+
+    constructor( aRole, skills, gender, name, experience, gempukku ){
+        if( aRole in roleSkills )
+            this.role = aRole;
+        else
+            this.role = randomFromAssociative(roleSkills);
+
+        this.gempukku = gempukku || 0;
+        this.stamina = (this.rank() < 1)? 1 : 2 ;
+        this.willpower = (this.rank() < 1)? 1 : 2 ;
+        this.perception = (this.rank() < 1)? 1 : 2 ;
+        this.strength = (this.rank() < 1)? 1 : 2 ;
+        this.reflexes = (this.rank() < 1)? 1 : 2 ;
+        this.awarness = (this.rank() < 1)? 1 : 2 ;
+        this.agility = (this.rank() < 1)? 1 : 2 ;
+        this.intelligence = (this.rank() < 1)? 1 : 2 ;
+        this.void = (this.rank() < 1)? 1 : 2 ;
+
+        this.skills = ( typeof skills === "object")? skills : {};
+        this.gender = (typeof gender !== "undefined")? gender : r_gender();
+        this.name = (name !== "undefined")? { "name" : name, "gender" : gender}: names.randomFromFilters([{ filter : "gender", value : this.gender },{ filter : "gender", value : "n" }]) ;
+        this.experience = (typeof experience === "undefined")? 25 : experience ;
+        this.expandedExperience = 0;
+        this.malus = 0 ;
+        this.actualizeWounds();
+        this.currentWounds = this.maxWounds;
+    }
+    
+    earth () { return ( this.stamina < this.willpower)? this.stamina : this.willpower ;}
+    water () { return ( this.strength < this.perception)? this.strength : this.perception ;}
+    air () { return ( this.reflexes < this.awarness)? this.reflexes : this.awarness ;}
+    fire () { return ( this.agility < this.intelligence)? this.agility : this.intelligence ;}
+
+    insight(){
+        let resultat = (this.earth() + this.water() + this.air() + this.fire() + this.void) * 10 ;
+
+        if(typeof this.skills == "object")
+        for(let i in this.skills)
+            resultat += parseInt(this.skills[i]);
+        return resultat;    
+    }
+
+    rank(){
+        let insight = this.insight();
+        switch( insight ){
+        case( !this.gempukku ):
+            return 0;
+            break;
+        case ( insight > 150 ):
+            return 1;
+        default :
+            return Math.round((insight - 125)/25);
+        }
+    }
+    
+    skills = {};
+    weapons = {
+        "wakizachi" : weapons["wakizachi"]
+    };
+
+    armors = [];
+    equippedArmor = "kimono";
+
+    equippedArrow = "willow leaf";
+
+    rollMade = {};
+
+    getTN(){
+        let armorTN = 0;
+        let modifier = 0;
+
+        switch(this.stance){
+        case "full attack":
+            modifier = -10;
+            break;
+        case "full defense":
+            modifier = this.rollMade["defense"];
+            break;
+        case "defense":
+            modifier = this.air() + this.getSkillRank( 'defense' );
+            break;
+        }
+        if ( typeof armors[ this.equippedArmor ].TN !== "undefined")
+            armorTN = armors[ this.equippedArmor ].TN;
+
+        return 5 + armorTN + (this.reflexes * 5) + modifier;
+    }
+
+    naturalDR = 0;
+
+    getName(){
+        return capitalize( this.name.familly ) + " " + capitalize( this.name.name );
+    }
+    
+    dr(){
+        let armorDR = 0;
+        for (var armor in this.equippedArmor)
+            if ( typeof armor.DR !== "undefined")
+                armorDR = armor.DR;
+
+        return this.naturalDR + armorDR;
+    }
+
+    addWeapon( weapon ){
+        if( typeof this.weapons[ weapon ] === "objects" )
+           return null;              
+        this.weapons[ weapon ] = weapons[ weapon ];
+    };
+
+    advantages = [];
+    addAdvantages ( newAdvantage ){
+        if( typeof this.advantages.find(element => element == newAdvantage ) === "undefined" ){
+            return null;
+        }
+        let cost;                            
+        for( advantage in  advantages[ newAdvantage ] )
+             if( this.name.familly in advantages[ newAdvantage ] ){
+                cost = advantages[ newAdvantage ][ this.name.familly ];
+             } else if ( this.clan in advantages[ newAdvantage ] ){
+                advantages[ newAdvantage ][ this.clan ];
+             } else if ( this.clan in advantages[ newAdvantage ] ){
+                advantages[ newAdvantage ][ this.role ];
+             } else {
+                cost = advantages[ newAdvantage ][ "default" ];
+             }
+    }
+
+    hasAdvantage( advantage){
+         if( typeof this.advantages.find(element => element == advantage ) === "undefined" ){
+            return 0;
+         }
+            return 1;
+    }
+
+    attack(){
+        let modifier_r = 0;
+        let modifier_k = 0;
+        if( this.stance = "full attack"){
+            modifier_r = 2;
+            modifier_k = 1;
+        }        
+        if( (typeof defaultAttacks === "undefined") ||
+            (typeof defaultAttacks.expandedExperience === "undefined") ||
+            (defaultAttacks.expandedExperience < this.expandedExperience)){
+
+                let attack =  Object.keys(this.updateAttacks())[0];
+                if( attack == "jiujutsu" ){
+                    return {"r" : this.strength + modifier_r, "k" : 1 + modifier_k};
+                }else{
+                    let skill =  0;
+                    if((skill = this.skills[ this.weapons[ attack ].skill ]) in this.skills){
+                        return {"r" : skill[0] + modifier_r, "k" : skill[1] + modifier_k};
+                    }
+
+                    return {"r" : this[skills[weapons[ attack ].skill].trait] + modifier_r, "k" : this[skills[weapons[ attack ].skill].trait] + modifier_k, "x" : 11};
+               }
+        }
+        return { "r" : this.defaultAttacks[ Object.keys(this.defaultAttacks)[0] ]['attack'].r + modifier_r,
+                 "k" : this.defaultAttacks[ Object.keys(this.defaultAttacks)[0] ]['attack'].k + modifier_k };
+   }
+
+    attackFromWeapon( weapon ){
+        let trait = parseInt( this[skills[ this.weapons[weapon].skill ].trait], 10);
+        let skill = parseInt( this.skills[ this.weapons[weapon].skill ], 10) || 0;
+        return({ "r" : trait + skill, "k" : trait, "x" : (skill)? 10: 11});
+    }
+
+    damageFromWeapon( weapon ){
+        if( weapons[ weapon ].type == "bow"){
+                let arrow = arrows[ this.equippedArrow ];
+                return {
+                    "r" : arrow.r + ( weapon.strength <= this.strength )? weapon.strength : this.strength,
+                    "k" : arrow.k}
+        }
+        return({ "r" : parseInt(this.strength, 10) +  parseInt(weapons[ weapon ].damage.split("G")[0], 10) ,
+                 "k" :  parseInt(weapons[ weapon ].damage.split("G")[1], 10) });
+    }
+
+    damage(){
+        if( (typeof defaultAttacks === "undefined") ||
+            (typeof defaultAttacks.expandedExperience === "undefined") ||
+            (defaultAttacks.expandedExperience < this.expandedExperience)){
+
+            let weapon = Object.keys(this.updateAttacks())[0]
+
+            if( weapon == "jiujutsu")
+                return {"r" : this.strength, "k" : 1};
+            else if( weapon.type == "bow"){
+                let arrow = arrows[ this.equippedArrow ];
+                return {
+                    "r" : arrow.r + ( bow_strength <= this.strength )? weapon.strength : this.strength,
+                    "k" : arrow.k
+                }
+            }else{
+                let damage = weapons[ weapon ]['damage'].split("G");
+                return {"r" :damage[0], "k" : damage[1]};
+            }
+        }
+
+        return  this.defaultAttacks[ (Object.keys( this.defaultAttacks)[0]) ];
+    }
+
+    initiative(){
+        return { "r" : this.rank() + this.reflexes , "k" : this.reflexes };
+    }
+    
+    getAttack(){
+        let roll = this.attack();
+        let modifier_r = 0;
+        let modifier_k = 0;
+        if( this.stance = "full attack"){
+            modifier_r = 2;
+            modifier_k = 1;
+        }
+        return RNG.rk10(roll.r, roll.k, this.malus);
+    }
+
+    getInitiative(){
+        let roll = this.initiative();
+        return RNG.rk10(roll.r, roll.k);
+    }
+
+    getDamage(){
+        let roll = this.damage();
+        return RNG.rk10(roll.r, roll.k);
+    }
+
+    getSkillRank( aSkill ){
+	return this.skills[ aSkill ] || 0; 
+    }
+    
+    allAttacks(){
+        let result = {};
+        if( "jiujutsu" in this.skills ){
+            result['jiujutsu'] = { "attack" : { "r" : parseInt(this.agility, 10) + parseInt(this.skills[ 'jiujutsu' ], 10), "k": this.agility }, "damage" : { "r" : this.strength, "k" : 1} };
+        }
+        for(let i in this.weapons){
+            result[ i ] = { "attack" : this.attackFromWeapon( i ), "damage" : this.damageFromWeapon( i ) };
+        }
+        /*(result)*/
+        return result;
+    }
+
+    attacking( charac ){
+        if( this.getAttack() > charac.getTN()){
+            charac.getWounded ( this.getDamage() );
+        }
+    }
+    
+    defaultAttacks = {};
+    attacks(){
+        if( (typeof defaultAttacks === "undefined") ||
+            (typeof defaultAttacks.expandedExperience === "undefined") ||
+            (defaultAttacks.expandedExperience < this.expandedExperience))
+            return this.updateAttacks();
+        return this.defaultAttacks[1]['attack'];
+    }
+    
+    updateAttacks(){
+        let bestAttack = 0;
+        let bestDamage = 0;
+        let attacks = this.allAttacks();
+
+        for(let i in attacks){
+            if( !bestAttack )
+                bestAttack = i ;
+            if( (attacks[i].k > attacks[ bestAttack ].k ) ||
+                ((attacks[i].k = attacks[ bestAttack ]) && (attacks[i].r < attacks[ bestAttack ].r )) ||
+                ( attacks[i].r < (attacks[ bestAttack ].r + 2 ))){
+                bestAttack = i ;
+            };
+            if( !bestDamage )
+                bestDamage = i ;
+            if( (attacks[i].k > attacks[ bestDamage ].k ) ||
+                ((attacks[i].k = attacks[ bestDamage ]) && (attacks[i].r < attacks[ bestDamage ]).r ) ||
+                ( attacks[i].r < (attacks[ bestDamage ].r + 2 ))){
+                bestDamage = i ;
+            };            
+            if( !bestDamage )
+                bestDamage = i ;
+        }
+        this.defaultAttacks[bestAttack] = attacks[ bestAttack ];
+        this.defaultAttacks[bestDamage] = attacks[ bestDamage ];
+        this.defaultAttacks['expandedExperience'] = this.expandedExperience;
+
+        return this.defaultAttacks;
+    }
+
+    expanseExperience( value ){
+        if(!this.experience){
+            this.experience = 0;
+            return 0;
+        }else if ( value > this.experience){
+            return 0;
+        }
+
+        if( typeof value == "undefined"){
+            this.experience = this.experience - 1;
+            this.expandedExperience = this.expandedExperience + 1;
+        }else{
+            this.experience = this.experience - value;
+            this.expandedExperience = this.expandedExperience + value;
+        }
+        return value || 1;
+    }
+
+    increaseSkill( skill ){
+        if(( typeof this.skills[ skill ] === "number" ) && ( this.skills[ skill ] < 10 )){
+            var cost = this.skills[ skill ] + 1;
+            if( (this.experience - cost) >= 0 ){
+                this.expanseExperience( cost );
+                return this.skills[ skill ]++;
+            }
+        } else {
+            if( this.experience > 0){
+                this.expanseExperience();
+                return this.skills[ skill ] = 1;
+            }
+        }
+        return 0;
+    }
+
+    increaseTrait( trait ){
+        let factor = ( trait == "void")? 12 : 6  ;
+        let cost = (this[ trait ] + 1) * factor;
+        this.actualizeWounds();
+
+        if(this.expanseExperience( cost ))
+            this[ trait ]++;
+    };
+                 
+    actualizeWounds(){
+        this.maxWounds = 17 * this.earth();
+        return this.fullHeal;
+    };
+
+    fullHeal(){
+        return this.currentWounds = this.maxWounds;
+    }
+    
+    actualizeMalus(){
+        switch(this.state){
+            case "healthy" :
+                 this.malus = 0;
+            break;
+            case "nicked" :
+                this.malus = ( this.hasAdvantage( "strength of the earth" )  )? 0 : 3 ;
+            break;
+            case "grazed" :
+                this.malus = ( this.hasAdvantage( "strength of the earth" )  )? 2 : 5 ;
+            break;
+            case "hurt" :
+                this.malus = ( this.hasAdvantage( "strength of the earth" )  )? 7 : 10 ;
+            break;
+            case "injured" :
+                this.malus = ( this.hasAdvantage( "strength of the earth" )  )? 12 : 15 ;
+            break;
+            case "crippled" :
+                this.malus = ( this.hasAdvantage( "strength of the earth" )  )? 17 : 20 ;
+            break;
+            case "down" :
+                this.malus = ( this.hasAdvantage( "strength of the earth" )  )? 37 : 40 ;
+            break;
+            case "out" :
+                this.malus = 100 ;
+            break;
+            case "dead" :
+                this.malus = 1000 ;
+            break;
+        }
+    };
+    
+    getWounded( wounds ){
+       let inflicted = wounds - this.dr();
+        this.currentWounds = this.currentWounds - inflicted;
+       if( this.currentWounds < 1 )
+            this.state = "dead";
+       else if( this.currentWounds < (5 * this.earth()) )
+            this.state = "out";
+       else if( this.currentWounds < (7 * this.earth()) )
+           this.state = "down";
+       else if( this.currentWounds < (9 * this.earth()) )
+           this.state = "crippled";
+       else if( this.currentWounds < (11 * this.earth()) )
+            this.state = "injured";
+       else if( this.currentWounds < (13 * this.earth()) )
+            this.state = "hurt";
+       else if( this.currentWounds < (15 * this.earth()) )
+            this.state = "grazed";
+       else if( this.currentWounds < (17 * this.earth()) )
+            this.state = "nicked";
+       else if( this.currentWounds < (7 * this.earth()) )
+            this.state = "healthy";                                                                                                                   
+       this.actualizeMalus();
+
+        return inflicted;
+    }
+
+    getHeal( value ){
+        this.currentWounds = ( value < this.maxWounds)? this.currentWounds + value : this.maxWounds;
+        this.actualizeMalus();
+    }
+
+    fullHeal(){
+        this.currentWounds = this.maxWounds;
+        this.actualizeMalus();
+    }
+
+    generate( level, role ){
+        this.role =( typeof role === "undefined" )? this.role : role ;
+        this.experience = 25 + Math.round(level * 30 + Math.pow(15, level/10));
+        this.randomTraits( level );
+        this.randomSkill( level );
+        this.armedFromSkills();
+    }
+    
+    getWeaponsKeyword( keyword ){
+       let result = [];
+       for(let i = 0; i < weapons.length ; i++){
+           if( keyword in weapons[i].keyword )
+               result.push( weapons[i] );
+       }
+       return result ;
+    }
+
+    getWeaponKeyword( keyword ){
+       let weapons = getWeaponsKeyword( keyword );
+       let hasIt = 1;
+       while( hasIt ){
+           let index = random( weapons.length );
+           hasIt = this.weapons[ weapons[ index ] ];
+           if( !hasIt )
+               this.weapons.push( weapons[ index ] );
+       }
+    }
+
+    getRandomWeaponFromSkill( skill ){
+        if( typeof skill == "unsigned") return null;
+        let results = {};
+        let atLeastOne = false;
+        for(let weapon in weapons){
+            if((typeof weapon != "undefined") && (typeof weapons[weapon].skill != "undefined")){
+                if(weapons[weapon].skill == skill){
+                    atLeastOne = true;
+                    results[weapon] = weapons[weapon];
+                }
+            }
+        }
+        return ( atLeastOne)? randomFromAssociative( results ) : null ;
+    }
+
+    getWeaponsFromSkills( skills ){
+        let result = {};
+        for(let skill in skills){
+            let weapon = this.getRandomWeaponFromSkill( skill );
+            if(weapon)
+                Object.assign( result, weapon );
+        }
+        return result;
+    }
+
+    armedFromSkills(){
+        Object.assign( this.weapons, this.getWeaponsFromSkills( this.skills )) ;
+    }
+
+    allSkills(){
+        let skillList = roleSkills[ this.role ];
+        for(let skill in skillList){
+            skillList[skill].occurrence *= 10;
+        }
+        return Object.assign({}, skillList, skills);
+    }
+    
+     randomSkill(){
+         let hasMain = 0;
+         let skill ;
+         let skillList = this.allSkills();
+         
+         while(  this.experience > 2 ){
+            skill = randomFromWeight( skillList );
+
+            if( hasMain ){
+                if( skill == hasMain ){
+                    if(!this.increaseSkill( Object.keys(skill)[0] )){
+                        skill = Object.keys( randomFromWeight( skillList ))[0];
+
+                        for(let i = 0 ; !this.increaseSkill( skill ) && (i < arrayLength( skillList)); i++ ){
+                            skill = Object.keys( randomFromWeight( skillList ))[0];
+                        };
+                    };
+                }
+            } else if( typeof skill.main !== "undefined"){
+                hasMain = skill;
+                this.increaseSkill( Object.keys(skill)[0] ) ;
+            } else {
+                this.increaseSkill( Object.keys(skill)[0] ) ;
+            }
+         }
+   }
+    
+    randomTraits( level ){
+        let pass = level * random(2) + random(2);
+        switch( this.role ){
+        case "bushi" :
+           while(pass){
+               let asset = random(3);
+               switch( asset ){
+               case 0 :
+                   if( this.experience >= ((6 * this.increaseTrait("stamina") + (6 * this.increaseTrait("willpower"))))){
+                       this.increaseTrait("willpower");
+                       this.increaseTrait("stamina");
+                   }else
+                       this.increaseTrait("void")
+               break;
+               case 1 :
+                   this.increaseTrait("strength") ;
+               break;
+               case 2 :
+                   this.increaseTrait("reflexes");
+               break;
+               case 3 :
+                   this.increaseTrait("agility");
+               break;
+              };
+          pass--;
+          }
+        break;
+        case "shugenja" :
+           switch( random(3) ){
+           case 0 :
+               while(pass){
+                   this.increaseTrait("stamina") ;
+                   this.increaseTrait("willpower");}
+            break;
+            case 1 :
+               while(pass){
+                   this.increaseTrait("perception");
+                   this.increaseTrait("strength") ;}
+            break;
+           case 2 :
+               while(pass){
+                   this.increaseTrait("reflexes") ;
+                   this.increaseTrait("awarness") ;}
+            break;
+            case 3 :
+               while(pass){
+                   this.increaseTrait("intelligence") ;
+                   this.increaseTrait("agility") ;}
+            break;
+            }
+       break;
+        case "monk" :
+            while(pass){
+               let asset = random(3);
+               switch( asset ){
+               case 0 :
+                   this.increaseTrait("void") ;
+               break;
+               case 1 :
+                   this.increaseTrait("strength") ;
+                   this.increaseTrait("agility");
+               break;
+               case 2 :
+                   this.increaseTrait("awarness");
+                   this.increaseTrait("reflexes");
+               break;
+               case 3 :
+                   this.increaseTrait("void");
+                   this.increaseTrait("strength");
+               break;
+              };
+          pass--;
+            }
+       break;
+       case "scout" :
+            while(pass){
+               let asset = random(2);
+               switch( asset ){
+               case 0 :
+                   this.increaseTrait("perception");
+                   this.increaseTrait("strength");
+               break;
+               case 1 :
+                   this.increaseTrait("agility");
+               break;
+               case 2 :
+                   this.increaseTrait("reflexes");
+               break;
+              };
+          pass--;
+          }
+           break;
+           case "ninja" :
+            while(pass){
+               let asset = random(2);
+               switch( asset ){
+               case 0 :
+                   this.increaseTrait("void")
+               break;
+               case 1 :
+                   this.increaseTrait("agility") ;
+               break;
+               case 2 :
+                   this.increaseTrait("reflexes");
+               break;
+              };
+          pass--;
+          }           
+       break;
+       }
+    this.actualizeWounds();
+    }
+
+    getWounds(){
+        return this.currentWounds ;
+    }
+
+    stance = "attack";
+    
+    switchStance( aStance ){
+        if( stances.includes( aStance ) ){
+            this.stance = aStance;
+	}else if( typeof aStance === "undefined" ){
+	    let nextStanceIndex = stances.indexOf( this.stance ) + 1;
+	    nextStanceIndex = (nextStanceIndex >= stances.length )? 0 : nextStanceIndex;
+	    this.stance = stances[ nextStanceIndex ];
+	}
+	if( this.stance == "full defense")
+	    this.rollMade["defense"] = this.skillRoll( "defense" ) ;
+    }
+    
+    skillRoll( skill ){
+        let skillRank = this.getSkillRank( "defense" );
+        let traitRank = this[ skills[skill].trait ];
+        return RNG.rk10( traitRank + skillRank, traitRank );
+    }
+}
+
+var RNG = new RandomGenerator(4);
+
+function characterFromJSON( json ){
+    let result = new Character();
+    let data = JSON.parse(json);
+
+    for( prop in data){
+        result[ prop ] = data[ prop ];
+    }
+
+    return result;
+}
+
+function fight(charac1, charac2){
+    let result = {
+        "attacker" : charac1.initiative(),
+        "defender" : charac2.initiative()
+    };
+    let first = (  charac1.initiative() + (charac1.water/10) > charac1.initiative() + (charac1.water()/10))? charac1 : charac2 ;
+    let second = ( charac1 == first)? charac2 : charac1 ;
+    let winner = 0
+    let round = 0;
+
+    while( !winner ){
+        round++;
+
+        result[round] = {
+            "attack" : {
+                "attacker" : first.attack(),
+                "defender" : second.attack()
+            },
+            "damage" : {
+                "attacker" : first.damage(),
+                "defender" : second.damage()
+            }
+        };
+        result[round]["wounds"] =  {
+                "attacker" : ( result[round]['attack']['attacker'] >= second.getTN() )? second.getWounded( result[round]['damage']['attacker'] ) : 0,
+                "defender" : (( result[round]['attack']['defender'] >= first.getTN() ) && second.malus < 100)? first.getWounded( result[round]['damage']['defender'] ) : 0,
+        }
+            
+        if( second.malus > 99 ){
+            winner = first;
+        } else if( first.malus > 99 )
+            winner = second;
+    }
+
+    result['winner'] = winner ;
+    result['winner_side'] = (winner == charac1)? "attacker": "defender";
+    return result;
+}
+
+class Samourai extends Character {
+    constructor( aRole, gender, name, familly, school, experience, gempukku, skills){
+        super( aRole, skills, gender, name, experience, gempukku );
+
+        this.setFamilly( familly );
+        this.setBasicSchool( school );
+        this.autoWearArmor();
+    }
+
+    setFamilly( familly_name ){
+        let familly = famillies[ familly_name ];
+        this[ familly.trait ]++;
+        this.name['familly'] = familly_name;
+    }
+
+    setBasicSchool( school_name ){
+        let school = basicSchool[ school_name ];
+        this[ school.trait ]++;
+        for(let i = 0 ; i < school.outfit.weapon.length ; i++){
+            let weapon = (school.outfit.weapon[ i ] == "any")? Object.keys( randomFromAssociative( weapons ) ) : school.outfit.weapon[ i ];
+
+            if( !(weapon in this.weapons) )
+                this.weapons[ weapon ] = weapons[ weapon ];
+        }
+        this.armors = school.outfit.armor || this.armors;
+    }
+
+    autoWearArmor(){
+        let maxArmor = "kimono";
+        for(let i = 0 ; i < this.armors.length ; i++){
+            if( armors[ this.armors[ i ] ].TN >  armors[ maxArmor ].TN ){
+                maxArmor = this.armors[i];
+            }
+        };
+        this.equippedArmor = maxArmor;
+    }
+}

l5r_data.js

@@ -0,0 +1,273 @@
+var weapons = {
+    "wakizachi" : { "damage" : "2G2", "type" : "sword", "keywords" : ["samourai", "medium"], "skill" : "kenjutsu"},
+    "katana" : { "damage" : "3G2", "type" : "sword", "keywords" : ["samourai", "medium"], "skill" : "kenjutsu"},
+    "no-dachi" : { "damage" : "3G3", "type" : "sword", "keywords" : ["large"], "skill" : "kenjutsu"},
+    "scimitar" : { "damage" : "2G3", "type" : "sword", "keywords" : ["medium"], "skill" : "kenjutsu"},
+    "parangu" : { "damage" : "2G2", "type" : "sword", "special" : "If a parangu inflicts more than 30 Wounds in a single attack, its blade breaks.", "keywords" : ["medium", "peasant"], "skill" : "kenjutsu"},
+    "ninja-to" : { "damage" : "2G2", "type" : "sword", "special" : "The ninja-to is a medium weapon, but is considered a small weapon for the purposes of concealment. If a ninja-to infl icts more than 40 Wounds in a single attack, its blade breaks.",     "keywords" : ["ninja", "medium"], "skill" : "kenjutsu"},
+    "tetsubo" : { "damage" : "3G3", "type" : "heavy", "keywords":[], "skill" : "heavy weapon"},
+    "ono" : { "damage" : "0G4", "type" : "heavy", "keywords":[], "skill" : "heavy weapon"},
+    "masakari" : { "damage" : "2G3", "type" : "heavy", "keywords":[], "skill" : "heavy weapon"},
+    "dai tsuchi" : { "damage" : "5G2", "type" : "heavy", "keywords":[], "skill" : "heavy weapon"},
+    "kusarigama" : { "damage" : "0G2", "type" : "chain", "keywords":[], "skill" : "chain"},
+    "kyoketsu-shogi" : { "damage" : "0G1", "type" : "chain", "special" : "Double an opponent’s bonus to Armor TN from armor.", "keywords":[], "skill" : "chain"},
+    "manrikikusari" : { "damage" : "1G1", "type" : "chain", "keywords":[], "skill" : "chain"},
+    "yumi" : { "strength" : "3", "type" : "bow", "special" : "Increase the TN of all attack rolls by +10 if used from horseback.", "keywords":[], "skill" : "kyujutsu"},
+    "han-kyu" : { "strength" : "1", "type" : "bow", "special" : "Increase the TN of all attack rolls by +10 if used from horseback.", "keywords":[], "skill" : "kyujutsu"},
+    "dai-kyu" : { "strength" : "4", "type" : "bow", "special" : "Increase the TN of all attack rolls by +10 by foot. Only 3 strength needed", "keywords":[], "skill" : "kyujutsu"},
+    "nagamaki" : { "damage" : "2G3", "type" : "polearm", "keywords":[], "skill" : "polearm"},
+    "naginata" : { "damage" : "3G2", "type" : "polearm", "keywords" : ["samourai"], "skill" : "polearm"},
+    "sasumata" : { "damage" : "0G2", "type" : "polearm", "special" : "The sasumata may be used to initiate and maintain a grapple.", "keywords":[], "skill" : "polearm"},
+    "sodegarami" : { "damage" : "1G1", "type" : "polearm", "special" : "The sodegarami may be used to initiate and maintain a grapple.", "keywords":[], "skill" : "polearm"},
+    "bisento" : { "damage" : "3G3", "type" : "polearm", "keywords":[], "skill" : "polearm"},
+    "kumade" : { "damage" : "1G1", "type" : "spear", "special" : "If a kumade inflicts more than 25 Wounds in a single attack, it breaks.", "keywords" : [ "large", "peasant" ], "skill" : "spear"},
+    "lance" : { "damage" : "3G2", "type" : "spear", "special" : "The listed DR only applies if the lance is used from horseback and used to make an attack directly following a Move Action. Under any other circumstances, it possesses DR 1k2. Using the lance in melee combat without a Move Action increases the TN of all attack rolls by +5 on horseback and +10 on foot. A lance shatters if it infl icts more than 30 Wounds in one attack.", "keywords":[], "skill" : "spear"},
+    "nage-yari" : { "damage" : "1G2", "type" : "spear", "special" : "The nage-yari may be thrown accurately up to 50’", "keywords":[], "skill" : "spear"},
+    "yari" : { "damage" : "2G2", "type" : "spear", "special" : "The yari can be thrown a maximum range of 30’, and has DR 1k2 when thrown.", "keywords":[], "skill" : "spear"},
+    "bo" : { "damage" : "1G2", "type" : "stave", "keywords":[], "skill" : "stave"},
+    "nunchaku" : { "damage" : "1G2", "type" : "stave", "keywords" : ["peasant", "small"], "skill" : "stave"},
+    "tonfa" : { "damage" : "0G3", "type" : "stave", "keywords" : ["peasant", "large"], "skill" : "stave"},
+    "bo" : { "damage" : "1G2", "type" : "stave", "keywords":[], "skill" : "stave"},
+    "tanto" : { "damage" : "1G1", "type" : "knives", "keywords" : ["small"], "skill" : "knive"},
+    "sai" : { "damage" : "1G1", "type" : "knives", "keywords" : ["small"], "skill" : "knive"},
+    "kama" : { "damage" : "0G2", "type" : "knives", "keywords" : ["peasant", "small"], "skill" : "knive"},
+    "war fan" : { "damage" : "0G1", "type" : "small", "keywords":["small"], "skill" : "knive"},
+    "oyomi" : { "damage" : "4G2", "type" : "small", "keywords":["small"], "skill" : "crossbow"}    
+};
+
+var armors = {
+    "kimono" : { "DR" : 0, "TN": 0},
+    "ashigaru" : {"DR" : 1, "TN": 3},
+    "light" : {"DR" : 3, "TN": 5},
+    "heavy" : {"DR" : 5, "TN": 10},
+    "ridding" : {"DR" : 4, "TN": 4}
+};
+
+var advantages = {
+    "strength of the earth" : { "default" : 3, "bushi" : 2, "ninja" : 2, "scout" : 2 }
+};
+
+var roleSkills = {
+    "courtier" : { "courtier" : { "occurence" : 10, "trait" : "intelligence"},
+                   "etiquette" : { "occurence" : 10, "trait" : "awarness"},
+                   "sincerity" : { "occurence" : 10, "trait" : "awarness"},
+                   "lore : heraldy" : { "occurence" : 5, "trait" : "intelligence"},
+                   "tea ceremony" : { "occurence" : 5, "trait" : "void"},
+                   "lore : theology" : { "occurence" : 4, "trait" : "intelligence"},
+                   "lore : history" : { "occurence" : 4, "trait" : "intelligence"},
+                   "lore : bushido" : { "occurence" : 3, "trait" : "intelligence" }},
+    "bushi" : { "kenjutsu" : { "occurence" :10, "main" : true, "trait" : "agility"},
+                "iaijutsu" : { "occurence" : 8, "main" : true, "trait" : "reflexes"},
+                "heavy weapon" : { "occurence" : 8, "main" : true, "trait" : "agility"},
+                "polearm" : { "occurence" : 7, "main" : true, "trait" : "agility"},
+                "defense" : {  "occurence" : 7, "trait" : "reflexes"},
+                "kyujutsu": { "occurence" : 6, "main" : true, "trait" : "reflexes"},
+                "jiujutsu": { "occurence" : 5, "trait" : "agility"},
+                "battle" : { "occurence" : 5, "trait" : "perception"},
+                "athletics": {  "occurence" : 4, "trait" : "strength" }},
+    "monk" : { "jiujutsu": { "occurence" : 7, "main" : true, "trait" : "agility"},
+               "staves": { "occurence" : 6, "main" : true, "trait" : "agility"},
+               "lore : theology" : { "occurence" :6, "trait" : "intelligence"},
+               "meditation": { "occurence" : 6, "trait" : "void"},
+               "chain": { "occurence" : 3, "main" : true, "trait" : "agility"}},
+    "scout" : { "kenjutsu" : { "occurence" :8, "main" : true, "trait" : "agility"},
+                "kyujutsu": { "occurence" : 7, "main" : true,"trait" : "reflexes"},
+                "athletics": {  "occurence" : 6, "trait" : "strength" },
+                "heavy weapon" : { "occurence" : 6, "main" : true, "trait" : "agility"},
+                "polearm" : { "occurence" : 6, "main" : true, "trait" : "agility"},
+                "stealth" : {  "occurence" : 6 , "trait" : "agility"},
+                "battle" : { "occurence" : 6, "trait" : "perception"},
+                "defense" : {  "occurence" : 5 , "trait" : "reflexes"},
+                "iaijutsu" : { "occurence" : 4, "main" : true, "trait" : "reflexes"},
+                "jiujutsu": { "occurence" : 3, "trait" : "agility"}},
+    "ninja" : { "stealth" : {  "occurence" : 10 , "trait" : "agility"},
+                "knives": { "occurence" : 8, "main" : true,"trait" : "agility", "type" : "bugei"},
+                "kenjutsu" : {  "occurence" : 6 , "main" : true, "trait" : "agility"},
+                "sincerity" : {  "occurence" : 5 , "trait" : "awarness"},
+                "ninjutsu" : {  "occurence" : 3 , "main" : true,"trait" : "agility"},
+                "jiujutsu" : {  "occurence" : 3 , "trait" : "agility"},
+                "staves" : {  "occurence" : 3 , "trait" : "agility"}
+              }
+};
+
+var skills = {
+    "perform" : { "occurence" : 1, "trait" : "awarness", "type" : "high"},
+    "courtier" : { "occurence" : 2, "trait" : "intelligence",  "type" : "high"},
+    "etiquette" : { "occurence" : 2, "trait" : "awarness",  "type" : "high"},
+    "sincerity" : { "occurence" : 2, "trait" : "awarness",  "type" : "high"},
+    "acting" : { "occurence" : 1, "trait" : "awarness",  "type" : "high"},
+    "artisan" : { "occurence" : 1, "trait" : "awarness",  "type" : "high"},
+    "calligraphy" : { "occurence" : 1, "trait" : "intelligence",  "type" : "high"},
+    "investigation" : { "occurence" : 1, "trait" : "perception",  "type" : "high"},
+    "medicine" : { "occurence" : 1, "trait" : "awarness",  "type" : "high"},
+    "spellcraft" : { "occurence" : 1, "trait" : "awarness",  "type" : "high"},
+    "lore : heraldy" : { "occurence" : 1, "trait" : "intelligence",  "type" : "high"},
+    "tea ceremony" : { "occurence" : 2, "trait" : "void", "type" : "high"},
+    "lore : theology" : { "occurence" : 1, "trait" : "intelligence",  "type" : "high"},
+    "lore : history" : { "occurence" : 1, "trait" : "intelligence",  "type" : "high"},
+    "lore : bushido" : { "occurence" : 2, "trait" : "intelligence" ,  "type" : "high"},
+    "battle" : { "occurence" : 2, "trait" : "perception", "type" : "bugei"},
+    "heavy weapon" : { "occurence" : 1, "main" : true, "trait" : "agility"},    
+    "defense" : {  "occurence" : 2 , "trait" : "reflexes", "type" : "bugei"},
+    "iaijutsu" : { "occurence" : 2, "main" : true, "trait" : "reflexes", "type" : "bugei"},
+    "jiujutsu": { "occurence" : 2, "trait" : "agility", "type" : "bugei"},
+    "kenjutsu" : { "occurence" : 2, "main" : true, "trait" : "agility", "type" : "bugei"},
+    "polearm" : { "occurence" : 1, "main" : true, "trait" : "agility", "type" : "bugei"},
+    "kyujutsu": { "occurence" : 1, "main" : true,"trait" : "reflexes", "type" : "bugei"},
+    "chain": { "occurence" : 1, "main" : true,"trait" : "agility", "type" : "bugei"},
+    "stave": { "occurence" : 1, "main" : true,"trait" : "agility", "type" : "bugei"},
+    "spear": { "occurence" : 1, "main" : true,"trait" : "agility", "type" : "bugei"},    
+    "knive": { "occurence" : 1, "main" : true,"trait" : "agility", "type" : "bugei"},    
+    "crossbow": { "occurence" : 1, "main" : true,"trait" : "agility", "type" : "gaijin"},    
+    "swordmanship": { "occurence" : 1, "main" : true,"trait" : "agility", "type" : "gaijin"},
+    "athletics": {  "occurence" : 1, "trait" : "strength", "type" : "bugei"},
+    "horsemanship": {  "occurence" : 1, "trait" : "strength", "type" : "bugei"},
+    "hunting": {  "occurence" : 1, "trait" : "strength", "type" : "bugei"},
+    "animal handling": {  "occurence" : 1, "trait" : "awarness", "type" : "merchant"},
+    "commerce": {  "occurence" : 1, "trait" : "intelligence", "type" : "merchant"},
+    "engineering": {  "occurence" : 1, "trait" : "intelligence", "type" : "merchant"},
+    "craft": {  "occurence" : 1, "trait" : "", "type" : "merchant"},
+    "intimidation" : {  "occurence" : 1 , "trait" : "awarness", "type" : "low"},
+    "temptation" : {  "occurence" : 1 , "trait" : "awarness", "type" : "low"},
+    "sleight of hand" : {  "occurence" : 1 , "trait" : "agility", "type" : "low"},
+    "stealth" : {  "occurence" : 1 , "trait" : "agility", "type" : "low"}
+};
+
+var famillies = {
+    "daidodji" : { "clan" : "crane", "trait" : "willpower"} ,
+    "tamori" : { "clan" : "dragon", "trait" : "willpower" },
+    "hida" : { "clan" : "crab", "trait" : "strength"},
+    "matsu" : { "clan" : "lion", "trait" : "strength"},
+    "hiruma" : { "clan" : "crab", "trait" : "agility"},
+    "kakita" : { "clan" : "crane", "trait" : "agility"},
+    "mirumoto" : { "clan" : "dragon", "trait" : "agility"},
+    "kuni" : { "clan" : "crab", "trait" : "intelligence"},
+    "kaiu" : { "clan" : "crab", "trait" : "intelligence"},
+    "asahina" : { "clan" : "crane", "trait" : "intelligence"},
+    "kitsu" : { "clan" : "lion", "trait" : "intelligence"},
+    "yasuki" : { "clan" : "crab", "trait" : "awarness"},
+    "doji" : { "clan" : "crane", "trait" : "awarness"},
+    "kitsuki" : { "clan" : "dragon", "trait" : "awarness"},
+    "ikoma" : { "clan" : "lion", "trait" : "awarness"},
+    "kitsune" : { "clan" : "mantis", "trait" : "awarness"},
+    "moshi" : { "clan" : "mantis", "trait" : "intelligence"},
+    "tsuruchi" : { "clan" : "mantis", "trait" : "perception"},
+    "yoritomo" : { "clan" : "mantis", "trait" : "stamina"},    
+    "togashi order" : { "clan" : "dragon", "trait" : "void"},
+    "agasha" : { "clan" : "phœnix", "trait" : "agility"},
+    "asako" : { "clan" : "phœnix", "trait" : "awarness"},
+    "isawa" : { "clan" : "phœnix", "trait" : "willpower"},
+    "shiba" : { "clan" : "phœnix", "trait" : "perception"},
+    "bayushi" : { "clan" : "scorpion", "trait" : "agility"},
+    "shosuro" : { "clan" : "scorpion", "trait" : "awareness"},
+    "soshi" : { "clan" : "scorpion", "trait" : "intelligence"},
+    "yogo" : { "clan" : "scorpion", "trait" : "willpower"},
+    "horiuchi" : { "clan" : "unicorn", "trait" : "willpower"},
+    "ide" : { "clan" : "unicorn", "trait" : "perception"},
+    "iuchi" : { "clan" : "unicorn", "trait" : "intelligence"},
+    "moto" : { "clan" : "unicorn", "trait" : "agility"},
+    "shinjo" : { "clan" : "unicorn", "trait" : "reflexes"},
+    "utaku" : { "clan" : "unicorn", "trait" : "stamina"},
+    "chuda" : { "clan" : "spider", "trait" : "intelligence"},
+    "daigotsu" : { "clan" : "spider", "trait" : "stamina"},
+    "goju" : { "clan" : "spider", "trait" : "agility"},
+    "spider monks" : { "clan" : "spider", "trait" : "reflexes"},
+    "ichiro" : { "clan" : "badger", "trait" : "strength"},
+    "komori" : { "clan" : "bat", "trait" : "intelligence"},
+    "heichi" : { "clan" : "boar", "trait" : "willpower"},
+    "tonbo" : { "clan" : "dragonfly", "trait" : "awareness"},
+    "toritaka" : { "clan" : "falcon", "trait" : "perception"},
+    "kitsune" : { "clan" : "fox", "trait" : "willpower"},
+    "usagi" : { "clan" : "hare", "trait" : "awareness"},
+    "ujina" : { "clan" : "hare", "trait" : "agility"},
+    "toku" : { "clan" : "monkey", "trait" : "stamina"},
+    "fuzake" : { "clan" : "monkey", "trait" : "perception"},
+    "tsi" : { "clan" : "oriole", "trait" : "strength"},
+    "morito" : { "clan" : "ox", "trait" : "stamina"},
+    "chuda" : { "clan" : "snake", "trait" : "willpower"},
+    "suzume" : { "clan" : "sparrow", "trait" : "awareness"},
+    "kasuga" : { "clan" : "tortoise", "trait" : "perception"},
+    "miya" : { "clan" : "imperial", "trait" : "reflexes"},
+    "otomo" : { "clan" : "imperial", "trait" : "intelligence"},
+    "seppun" : { "clan" : "imperial", "trait" : "agility"},
+    "sons of the mountain tribe" : { "clan" : "geijin", "trait" : "agility"},
+    "daughters of the flame" : { "clan" : "geijin", "trait" : "agility"}
+};
+
+var basicSchool = {
+    "hida bushi" : { "clan" : "crabe", "trait" : "stamina", "outfit" : {"armor" : ["light", "heavy"], "weapon" : ["heavy", "polearm", "katana", "wakizachi"]}},
+    "mirumoto bushi" : { "clan" : "dragon", "trait" : "stamina", "outfit" : {"armor" : [ "ashigaru", "light" ], "weapon" : ["any", "wakizachi", "katana"]}},
+    "tamori shugenja" : { "clan" : "lion", "trait" : "stamina"},
+    "kuni shugenja" : { "clan" : "crab", "trait" : "willpower"},
+    "hiruma bushi" : { "clan" : "crab", "trait" : "willpower", "outfit" : {"armor" : [ "ashigaru", "light" ], "weapon" : ["bow", "wakizachi", "katana", "tanto"]}},
+    "yasuki courtier" : { "clan" : "crab", "trait" : "perception"},
+    "kitsuki" : { "clan" : "dragon", "trait" : "perception", "outfit" : {"weapon" : ["wakizachi"]}},
+    "akodo bushi" : { "clan" : "lion", "trait" : "perception", "outfit" : {"armor" : [ "ashigaru", "light" ], "weapon" : ["bow", "wakizachi", "katana", "tanto"]}},
+    "kitsu shugenja" : { "clan" : "lion", "trait" : "perception"},
+    "matsu berserker" : { "clan" : "lion", "trait" : "strength", "outfit" : {"armor" : [ "heavy", "light" ], "weapon" : ["heavy", "wakizachi", "katana", "polearm"]}},
+    "kakita bushi" : { "clan" : "crane", "trait" : "reflexes"},
+    "asahina shugenja" : { "clan" : "crane", "trait" : "awarness"},
+    "doji courtier" : { "clan" : "crane", "trait" : "awarness"},
+    "daidodji iron warrior" : { "clan" : "crane", "trait" : "agility"},
+    "ikoma bard" : { "clan" : "lion", "trait" : "intelligence"},
+    "togashi tattooed order" : { "clan" : "dragon", "trait" : "void"},
+    "yoritomo bushi" : { "clan" : "mantis", "trait" : "strength", "outfit" : {"armor" : [ "ashigaru", "light" ], "weapon" : ["wakizachi", "katana", "any"]}},
+    "moshi shugenja" : { "clan" : "mantis", "trait" : "awarness"},
+    "yoritomo courtier" : { "clan" : "mantis", "trait" : "willpower"},
+    "tsuruchi archer" : { "clan" : "mantis", "trait" : "reflexes", "outfit" : {"armor" : [ "ashigaru", "light" ], "weapon" : ["bow", "wakizachi"]}},
+    "shiba" : { "clan" : "phœnix", "trait" : "agility", "outfit" : {"armor" : [ "light" ], "weapon" : ["any", "wakizachi", "katana", "tanto"]}},
+    "isawa shugenja" : { "clan" : "phœnix", "trait" : "intelligence"},
+    "asako loremaster" : { "clan" : "phœnix", "trait" : "intelligence"},
+    "agasha shugenja" : { "clan" : "phœnix", "trait" : "intelligence"},
+    "asako henshin" : { "clan" : "phœnix", "trait" : "willpower", "outfit" : { "weapon": ["wakizachi"]}},
+    "bayushi bushi" : { "clan" : "scorpion", "trait" : "intelligence", "outfit" : {"armor" : [ "light" ], "weapon" : ["any", "wakizachi", "katana"]}},
+    "soshi shugenja" : { "clan" : "scorpion", "trait" : "awareness"},
+    "bayushi courtier" : { "clan" : "scorpion", "trait" : "awarenes"},
+    "shosuro infiltrator" : { "clan" : "scorpion", "trait" : "reflexes"},
+    "moto" : { "clan" : "unicorn", "trait" : "strength", "outfit" : {"armor" : [ "riding", "heavy" ], "weapon" : ["wakizachi", "katana", "polearm", "heavy", "any"]}},
+    "iuchi shugenja" : { "clan" : "unicorn", "trait" : "perception"},
+    "ide emissary" : { "clan" : "unicorn", "trait" : "awareness"},
+    "utaku" : { "clan" : "unicorn", "trait" : "reflexes", "outfit" : {"armor" : ["riding", "light" ], "weapon" : ["any", "wakizachi", "katana"]}},
+    "meishodo shugenja" : { "clan" : "unicorn", "trait" : "stamina", "outfit" : { "weapon" : ["wakizachi", "tanto"], "koku" : 4}},
+    "daigotsu bushi" : { "clan" : "spider", "trait" : "strength"},
+    "chuda shugenja" : { "clan" : "spider", "trait" : "willpower"},
+    "daigotsu courtier" : { "clan" : "spider", "trait" : "perception"},
+    "order of the spider monk" : { "clan" : "spider", "trait" : "agility"},
+    "ichiro bushi" : { "clan" : "badger", "trait" : "strength"},
+    "komori shugenja" : { "clan" : "bat", "trait" : "awareness"},
+    "heichi bushi" : { "clan" : "boar", "trait" : "strength"},
+    "tonbo" : { "clan" : "dragonfly", "trait" : "perception"},
+    "toritaka" : { "clan" : "falcon", "trait" : "strength"},
+    "kitsune shugenja" : { "clan" : "fox", "trait" : "stamina"},
+    "usagi bushi" : { "clan" : "hare", "trait" : "reflexes"},
+    "toku bushi" : { "clan" : "monkey", "trait" : "willpower"},
+    "tsi smith" : { "clan" : "oriole", "trait" : "intelligence"},
+    "morito bushi" : { "clan" : "ox", "trait" : "agility"},
+    "chuda shugenja" : { "clan" : "snake", "trait" : "willpower"},
+    "suzume bushi" : { "clan" : "sparrow", "trait" : "willpower"},
+    "kasuga smuggler" : { "clan" : "tortoise", "trait" : "awareness"},
+    "seppun guardman" : { "clan" : "imperial", "trait" : "perception"},
+    "seppun shugenja" : { "clan" : "imperial", "trait" : "intelligence"},
+    "otomo courtier" : { "clan" : "imperial", "trait" : "awareness"},
+    "miya herald" : { "clan" : "imperial", "trait" : "awareness"},
+    "the four temple" : { "clan" : "monk", "trait" : "awareness"},
+    "the order of heroes" : { "clan" : "monk", "trait" : "perception"},
+    "the shrine of the seven thunder" : { "clan" : "monk", "trait" : "stamina"},
+    "the temple of kaimetsu-uo" : { "clan" : "monk", "trait" : "willpower"},
+    "the temple of osano-wo" : { "clan" : "monk", "trait" : "strength"},
+    "the temple of thousand fortunes" : { "clan" : "monk", "trait" : "agility"},
+    "disciples of sun tao" : { "clan" : "ronin", "trait" : "reflexes"},
+    "forest killers" : { "clan" : "ronin", "trait" : "agility"},
+    "tawagoto's army" : { "clan" : "ronin", "trait" : "agility"},
+    "tengoku's justice" : { "clan" : "ronin", "trait" : "strength"},
+    "tessen" : { "clan" : "ronin", "trait" : "stamina"},
+    "void mystic" : { "clan" : "ronin", "trait" : "willpower", "outfit" : { "weapon" : ["any", "wakizachi"], "koku" : 1}}
+};
+
+var arrows = {
+    "willow leaf" : { "r" : 2, "k" : 2, "range" : 1, "armorTN_m" : 1, "price" : 0.2},
+    "rope cutter" : { "r" : 1, "k" : 1, "range" : 0.50, "armorTN_m" : 1, "price" : 0.75},
+    "humming bulb" : { "r" : 0, "k" : 1, "range" : 1, "armorTN_m" : 1, "price" : 1},
+    "flesh cutter" : { "r" : 2, "k" : 3, "range" : 0.50, "armorTN_m" : 2, "price" : 1},
+    "armor piercing" : {"r" : 1, "k" : 1, "range" : 1, "armorTN_m" : 0, "price" : 0.2}
+};

players.js

@@ -0,0 +1,51 @@
+var characters = new Characters();
+
+characters.createSamourai( "courtier", "m", "takahashi", "kitsuki", "kitsuki", 0, 0);
+characters.createSamourai( "bushi", "m", "kaji", "mirumoto", "mirumoto bushi", 0, 0);
+characters.createSamourai( "monk", "m", "kiyoshi", "asako", "asako henshin", 0, 0, { "calligraphy" : 1, "jiujutsu" : 1, "lore: theology": 1, "sincerity" : 1, "meditation" : 1, "medecine" : 1});
+characters.createSamourai( "shugenja",  "f", "", "tamori", "void mystic", 0, 0, { "calligraphy" : 1, "defense" : 1, "medecine" : 1, "spellcraft" : 1 });
+characters.createSamourai( "shugenja",  "f", "honami", "utaku", "meishodo shugenja", 0, 0, { "calligraphy" : 1, "craft: meishodo" : 1, "spellcast (research)" : 1, "kenjutsu" : 1 }) ;
+
+for(let j = 0 ; j < characters.size() ; j++){
+    characters.at(j).experience = 39;
+
+    switch( characters.at(j).name.familly ){
+    case "utaku":
+        characters.at(j).increaseTrait("willpower");
+        characters.at(j).increaseTrait("willpower");
+        break;
+    case "tamori" :
+        characters.at(j).increaseTrait("void");
+        characters.at(j).increaseTrait("void");
+        characters.at(j).increaseSkill("calligraphy");
+        characters.at(j).increaseSkill("defense");
+        characters.at(j).increaseSkill("medecine");
+        characters.at(j).increaseSkill("spellcraft");
+        break;
+    case "asako" :
+        characters.at(j).increaseSkill("willpower");
+        characters.at(j).increaseSkill("agility");
+        characters.at(j).increaseSkill("intelligence");
+        characters.at(j).increaseSkill("jiujutsu");
+        characters.at(j).increaseSkill("lore: theology");
+        characters.at(j).increaseSkill("meditation");
+        break;
+    case "mirumoto":
+        characters.at(j).increaseTrait("agility");
+        characters.at(j).increaseTrait("agility");
+        characters.at(j).increaseTrait("void");
+        break;
+    case "kitsuki":
+        characters.at(j).increaseTrait("reflexe");
+        characters.at(j).increaseTrait("intelligence");
+        characters.at(j).increaseSkill("investigation");
+        break;
+    }
+        
+}
+
+characters.createSamourai( "bushi",  "f", "", "sons of the mountain tribe", "mirumoto bushi", 0, 0, { "knives" : 2 }) ;
+characters.createSamourai( "bushi",  "f", "", "sons of the mountain tribe", "mirumoto bushi", 0, 0, { "swordwanship" : 2 }) ;
+characters.createSamourai( "bushi",  "f", "", "sons of the mountain tribe", "mirumoto bushi", 0, 0, { "crossbow" : 2 }) ;
+characters.createSamourai( "bushi",  "f", "", "daughters of the flame", "mirumoto bushi", 0, 0, { "crossbow" : 2 }) ;
+    

random_utils.js

@@ -0,0 +1,149 @@
+
+class RandomGenerator{
+
+    constructor( cache ){
+        this.rng = new Uint8Array( cache  );
+        this.index = cache-- ;
+        this.generate();
+    }
+
+    generate(){
+        window.crypto.getRandomValues(this.rng);
+        this.index = this.rng.length - 2;
+        return  this.rng.length - 1;
+    }
+
+    next(){
+        return (this.index < 0)? this.generate() : this.index--;
+    }
+
+    rand(){
+        return this.rng[ this.next() ]/256 ;
+    }
+    
+    get( max, min ){
+        min = ( typeof min === "number")? min : 0 ;
+        return Math.round(this.rand() * (max - min) + min);
+    }
+
+    roll10( explode ){
+        explode = ( typeof explode === "number")? explode : 10;
+        let dice = this.get( 10, 1 );
+        return  (dice >= explode)? 10 + this.roll10( explode ) : dice ;
+    }
+
+    rk10( r, k, malus, explode ){
+        let rolls = [];
+        if((typeof r === "unigned") || (typeof k === "unigned"))
+            return 0;
+        malus = ( typeof malus === "unsigned")? 0 : malus ;
+        for(let i = 0 ; i < r ; i++)
+            rolls[i] = this.roll10( explode);
+        sort( rolls );
+        return rolls.slice( 0, k ).reduce((a, b) => a + b) - (malus || 0);
+    }
+}
+
+function sort( array ){
+    let temp = 0;
+    var unsorted = true ;
+    while(unsorted){
+        unsorted = false;
+        for(let i = 0; i < array.length -1 ; i++){
+            if(array[ i ] < array[ i + 1 ]){
+               temp = array[ i ];
+               array[ i ] = array[ i + 1 ];
+               array[ i + 1 ] = temp;
+               unsorted =  true;
+           }
+       }
+    }
+}
+
+function sortAssociative( array_arg ){
+    let result = {};
+    let array = array_arg;
+    let higher = 1;
+    while( !higher ){
+        higher = 0;
+        for(let i in array){
+            higher = (higher)?
+                (array[higher] < array[i])? i : higher : i ;
+            if(array[ i ] < array[ i + 1 ]){
+                temp = array[ i ];
+                array[ i ] = array[ i + 1 ];
+                array[ i + 1 ] = temp;
+                unsorted =  true;
+            }
+        }
+        if(higher){
+            result.push(higher);
+            delete array[ higher ];
+            higher = 0;
+        }
+    }
+    return result;
+}
+
+
+function random( max, min ){
+    min = (typeof min == "undefined")? 0 : min;
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+
+function r_gender(){
+    return (random(1))? "f": "m";
+}
+
+function arrayAt( index, array ){
+    let i = 0;
+    let result = {};
+    for(let obj in array){
+        if( index == ++i ){
+            result[obj] = array[obj];
+            return result;
+        }
+    }
+}
+
+function arrayAtWeight( index, array ){
+    let i = 0;
+    for(let obj in array){
+        if(( i <= index ) && ( index <= (i + array[obj].occurence))){
+            let rs = {};
+            rs[ obj ] = array[obj];
+            return rs;
+        }
+        i += array[obj].occurence ;
+    }
+    return null;
+}
+
+function arrayLength( array ){
+    let i = 0;
+    for(let obj in array){
+        i++;
+    };
+    return i;
+}
+
+function arrayWeight( array ){
+    let i = 0;
+    for(let obj in array){
+        i += array[obj].occurence;
+    };
+    return i;
+}
+
+function randomFromAssociative( array ){
+    return arrayAt( random( arrayLength( array ), 1), array) ;
+}
+
+function randomFromArray( array ){
+    return array[ random( arrayLength( array )) ] ;
+}
+
+function randomFromWeight( array ){
+    return arrayAtWeight( random( arrayWeight( array )), array) ;
+}
+

roll.html

@@ -0,0 +1,417 @@
+<html>
+  <head>
+    <meta charset="utf8">
+    <script src="dice.js"></script>
+    <script src="names.js"></script>    
+    <script src="l5r_data.js"></script>
+    <script src="random_utils.js"></script>
+    <script src="display.js"></script>        
+    <script src="l5r.js"></script>
+    <script src="players.js"></script>
+    <script>
+
+    var npcs = [];
+    var result = [];
+    var result1 = [];
+    var result2 = [];
+    var current_target= 0;
+
+    function target(){
+        return characters.at(current_target) ;
+    }
+    
+    var npc_summary = document.getElementById("npc.summary");           
+    function characterToLine(){
+        let line = document.CreateElement('td');
+        let cell = document.CreateElement('tr');
+    }
+    
+    function generateNPC(){
+        var newNPC = new Character();
+        newNPC.generate( document.getElementById("npc-level").value );
+        return newNPC;
+    }
+
+    function generateNPCs( size ){
+        let result = [];
+    
+        for(let i = 0; i < size ; i++){
+            result[i] = generateNPC( i );
+        }
+
+        return result;
+    }
+    
+    function skirmish( size ){
+        let npcs = generateNPCs( size );
+
+        for(let i = 0; i < size ; i+=2){
+            if( (npcs[i]) && (npcs[i + 1]))
+                result[i] = fight(npcs[i], npcs[i + 1]);
+        }
+
+        for( let i = 0; i < size ; i++ ){
+            ;
+        }    
+    }
+
+    function swissContest( size ){
+        let result = [];
+        let npcs = generateNPCs( size );
+
+        for(let i = 0; i < npcs.length; i++){
+             result[i] = [];
+                           
+            for(let j = 0; j < npcs.length; j++){
+                result[i][j] = ( fight( npcs[i], npcs[j] ) );
+                npcs[i].fullHeal();
+                npcs[j].fullHeal();
+            }
+        }
+        return result;
+    }
+
+    function winRateSwissContest( array, stat){
+        let result = [];
+
+        for(let i = 0; i < array.length; i++){
+            let winrate = 0;
+            let total = 0;
+            for(let j = 0; j < array[i].length; j++){
+                winrate += ( array[i][j].winner_side == "attacker" )? 1: 0;
+                total++;
+            }
+
+            result[i] = winrate/total;
+        }
+        return result; 
+    }
+
+    function hasClass( elem, className){
+
+        for( let i = 0 ; i < elem.classList.length ; i++ )
+            if( elem.classList[ i ] === className )
+                return elem;
+
+        return 0;
+    };
+                               
+    function getClassFromList( list, className ){
+        let result = [];
+
+        for( let i = 0 ; i < list.childNodes.length   ; i++ )
+            if( hasClass( list.childNodes[ i ], className ))
+                 result.push( list.childNodes[ i ] );
+
+        return result;
+    }
+
+    function inputFromElementList( list, input_type ){
+        let result = [];
+
+        for( let i = 0 ; i ; i++ )
+            if( list[ i ].getAttributeNames().includes( input_type ))
+                result.push( list[i] );
+
+        return result;
+    }
+
+    function display_data( data, anchor ){
+        let html_display = document.getElementById( anchor );
+        let headers = [ "name", "initiative", "TN", "attack", "damage", "wounds" ];
+        let hs = document.createElement("tr");
+
+                               
+        for(let i = 0; i < headers.length ; i++){
+            let h = document.createElement("th");
+            h.innerText = headers[ i ];
+            hs.appendChild( h );
+        }
+
+        html_display.appendChild( hs ) ;
+
+        for(let i = 0;  i < data.length ; i++){
+            let line = document.createElement( "tr" );
+            line.setAttribute("id", i + "-" + anchor );
+            let name = document.createElement("td");
+            name.innerText = data[i]["get"+capitalize( headers[0] )]();
+            line.appendChild( name );
+
+            for(let j = 1; j <  headers.length ; j++){
+                let cell = document.createElement("td");
+                let button = document.createElement("button");
+                button.setAttribute("class", headers[j]);
+                let id = i + "-"+j+"-" + anchor;
+
+                button.innerText = headers[j];
+
+                button.addEventListener('click', function(event) {
+                   document.getElementById( id ).value = data[i]["get"+capitalize( headers[j] )]();
+                });
+                cell.appendChild( button );
+
+                let result = document.createElement("input");
+                result.setAttribute("id", id);
+                result.setAttribute("type", "text");
+                result.setAttribute("class", "result");
+                cell.appendChild( result );
+                line.appendChild( cell );
+            }
+            let cell1 = document.createElement("td");
+            let targeted = document.createElement("input");
+            targeted.setAttribute("type", "checkbox");
+            targeted.setAttribute("class", "targeted");
+            targeted.checked = false;
+            targeted.addEventListener('click', function(event) {
+               let targeteds = document.getElementsByClassName( "targeted" );
+               for(let targeted in targeteds){
+                   if(targeteds[targeted] != this)
+                                targeteds[targeted].checked = false;
+
+                   current_target = this.parentNode.parentNode.id.split("-")[0];
+               }
+            });
+            cell1.appendChild( targeted );
+            line.appendChild( cell1 );
+
+            cell2 = document.createElement("td");
+            let attacking = document.createElement("input");
+            attacking.setAttribute("type", "button");
+            attacking.setAttribute("class", "attacking");
+            attacking.value = "Attack";
+            attacking.checked = false;
+            attacking.addEventListener('click', function(event) {
+                characters.at( this.parentNode.parentNode.id.split("-")[0] ).attacking( target() );
+                triggerField( "Wounds" );
+                triggerField( "TN" );
+            });
+            cell2.appendChild( attacking );
+            line.appendChild( cell2 );
+	    
+	    let cell_switchStance = document.createElement("td");
+	    let switchStance = document.createElement("input");
+            switchStance.setAttribute("type", "button");
+	    switchStance.value = "Attack Stance";
+	    cell_switchStance.appendChild( switchStance );
+	    cell_switchStance.addEventListener('click', function(event) {
+                let charac = characters.at( this.parentNode.id.split("-")[0] );
+		charac.switchStance();
+		event.target.value = charac.stance;
+		triggerField( "TN" );
+            });	    
+            line.appendChild( cell_switchStance );
+
+            html_display.appendChild( line );
+        }
+    }
+
+    function popAssociativeMaker( associative, anchor ){
+    
+        let result = document.createElement( "div" );
+        result.setAttribute( "class", "popup" );
+        let exit = document.createElement("input");
+        exit.setAttribute("type", "button");
+        exit.setAttribute("class", "exit");  
+        exit.value = "×";
+        exit.addEventListener('click', function(event) {
+            anchor.value = JSON.stringify( formToData( result ) );
+            result.parentNode.removeChild( result );
+         });
+
+        result.appendChild( exit );
+
+        for( let i in associative ){
+            switch( typeof varType ){
+            case "function":
+            break;
+            case "object":
+                result.appendChild( inputField( i, associative[ i ] || "", true, null, function(event) {
+                    this.value =  popObjectMaker( associative[ i ], line );
+                } ));
+            break;
+            default:
+                result.appendChild( inputField( i, associative[ i ] || "") );
+            }
+        }
+
+        let add = document.createElement("input");
+        add.setAttribute("type", "button");
+        add.setAttribute("class", "add");  
+        add.value = "+";
+        add.addEventListener('click', function(event) {
+            result.appendChild( inputField( "", "", true) );
+        });
+        result.appendChild( add );
+                                
+        document.getElementsByTagName('body')[0].appendChild( result );
+
+        return result;
+    }
+
+    function inputField( field, value, modifiable, label_onclick, input_onclick ){
+         field = (( typeof field === "unsigned" ) || !field )? "" : field;
+         value = (( typeof value === "unsigned" ) || !value )? "" : value;
+         modifiable = (( typeof modifiable === "unsigned" ) || !modifiable )? false : true ;
+
+         let  line= document.createElement("div");
+         let input = document.createElement("input");
+         let label ;
+
+         if( modifiable ){
+             label = document.createElement("input");
+             label.setAttribute("type", "text");                                
+         }else{
+             label = document.createElement("label");
+         }
+       
+         line.setAttribute("class", "line");
+         label.setAttribute("class", "label");
+         label.innerText = field;
+
+         if( label_onclick instanceof Function )
+             label.addEventListener('click', label_onclick );
+                                
+         line.appendChild( label );
+
+         input.setAttribute("type", "text");
+         input.setAttribute("class", "maker");
+         input.value = value;
+
+         if( input_onclick instanceof Function )
+             input.addEventListener('click', label_onclick );
+
+         input.checked = false;
+         line.appendChild( input );
+
+         return line;
+    }
+                                
+    function popObjectMaker( object, anchor, dictionnary ){
+        let prototype = new object;
+        let result = document.createElement( "div" );
+        result.setAttribute( "class", "popup" );
+
+        let exit = document.createElement("input");
+        exit.setAttribute("type", "button");
+        exit.setAttribute("class", "exit");  
+        exit.value = "×";
+
+        if( typeof dictionnary === "object" )
+            exit.addEventListener('click', function(event) {
+                 formToDictonnary( result, dictionnary);});
+        else
+            exit.addEventListener('click', function(event) {
+                 saveAndExitForm( result);});
+        result.appendChild( exit );
+                                  
+        for( let i in prototype ){
+            let varType = prototype[i];
+            let  line= document.createElement("div");
+            let input = document.createElement("input");
+            let label = document.createElement("label");
+
+            switch( typeof varType ){
+            case "function":
+            break;
+            case "object":
+                line= document.createElement("div");
+                line.setAttribute("class", "line");
+                label.setAttribute("type", "button");
+                label.classList.add("label");
+                label.innerText = i;
+                line.appendChild( label );
+
+                input.setAttribute("type", "text");
+                input.classList.add("json");
+                input.classList.add("maker");
+                input.value = prototype[ i ] || "";
+                input.checked = false;
+                input.addEventListener('click', function(event) {
+                    this.value = popAssociativeMaker( prototype[ i ], input );
+                });
+                line.appendChild( input );
+
+                result.appendChild( line );
+            break;
+            default:
+                line.setAttribute("class", "line");
+                label.setAttribute("type", "button");
+                label.classList.add("label");
+                label.innerText = i;
+                line.appendChild( label );
+
+                input.setAttribute("type", "text");
+                input.classList.add("maker");
+                input.value = prototype[ i ] || "";
+                input.checked = false;
+                line.appendChild( input );
+
+                result.appendChild( line );
+            }
+        }
+
+        if( anchor instanceof Element )
+            anchor.appendChild( result );
+        else
+            document.getElementsByTagName('body')[0].appendChild( result );
+
+       return result;
+    }
+                                  
+    function formToData( form ){
+        let lines = form.getElementsByClassName( "line" ) ;
+        let data = {} ;
+
+        for ( let i = 0 ; i < lines.length ; i++ ){
+            let labels = getClassFromList( lines[ i ], "label");
+            let makers = getClassFromList( lines[ i ], "maker");
+
+            if(( lines[ i ] instanceof Element ) && ( labels[0] || makers[0] )){
+                 let index = labels[0].value || labels[0].innerText;
+                 let value = makers[0].value || makers[0].innerText ;
+                 value = (hasClass( makers[0], "json" ))? JSON.parse( value ) : value ;
+                              
+                 data[ index ] = value ;
+            }
+        }
+        return data ;
+    }                                  
+                                  
+    function saveAndExitForm( form ){
+        form.value = JSON.stringify( formToData( form ) );
+        form.parentNode.removeChild( form );
+    }
+
+    function formToDictonnary( form, dictionnary){
+        return dictionnary.create( formToData( form ) );
+    }
+                              
+    function triggerField( field ){
+        let fields = document.getElementsByClassName( field ) ;
+                                
+        for (let i = 0 ; i < fields.length ; i++ ){
+            fields[i].click();
+        }
+    }
+
+    function main(){
+        display_data( characters.pool, "players_summary");
+        triggerField( "wounds" );
+        triggerField( "TN" );        
+    }
+    </script>
+    <style>
+      .result{
+          width : 3em;
+      }
+    </style>
+  </head>
+  <body onload="main()">
+    <button onclick="popObjectMaker( Character )">Créer un Personnage</button>
+    <table id="players_summary"></div>
+    <div id="npc_summary"></div>
+    </table>
+    <button onclick="generateNPC()">Générer NPC</button><input id="npc-level" type="number" value="1"/><select id="npc-role"></select>
+    <button onclick="popObjectMaker( Character, null, characters )">Générer Personnage</button>
+  </body>
+</html>