init : affiche la liste des personnages définit avec des actions leurs permettans de combattre

game/character.js

@@ -0,0 +1,768 @@
+class baseCharacter{
+
+    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;
+
+        this.actions[ 'attack' ] = { actionType : "complex" };
+        this.actions[ 'unarmed attack' ] = { actionType : "complex" };
+        this.actions[ 'move' ] = { actionType : "simple" };
+        this.actions[ 'draw small' ] = { actionType : "free" };
+        this.actions[ 'draw medium' ] = { actionType : "simple" };
+        this.actions[ 'draw large' ] = { actionType : "simple" };
+    }
+
+    actions = new Array();
+    tatoos = new Array();
+    
+    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 = {};
+    skillsFromAction(){
+
+    }
+    
+    actionPoints = 2 ;
+    freeAction = false;
+
+    complexAction(){
+	if (this.actionPoints >= 2){
+	    this.actionPoints -= 2 ;
+	    return true;
+	}
+	return false;
+    }
+
+    simpleAction(){
+	if(this.actionPoints > 1){
+	    this.actionPoints -= 1;
+	    return true
+	}
+    }
+
+    freeAction(){
+	if( this.freeAction ){
+	    return false;
+	}else{
+	    return this.freeAction = true ;
+	}	
+    }
+
+    chooseTatoo(){
+
+    };
+    
+    weapons = {
+        "wakizachi" : weapons["wakizachi"]
+    };
+
+    armors = [];
+    equippedArmor = "kimono";
+
+    equippedArrow = "willow leaf";
+
+    rollMade = {};
+
+    baseGetTN(){
+        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;
+    }
+
+    act( action ){
+	if( this.actions.indexOf( action ) == -1){
+	    return this.complexAction();
+	}else{
+	    return this[ actions[ action ].actionType + 'Action' ]();
+	}
+    }
+    
+    baseAttack( attackType ){
+        let modifier_r = 0;
+        let modifier_k = 0;
+        if( this.stance = "full attack"){
+            modifier_r = 2;
+            modifier_k = 1;
+        };
+
+	if( typeof attackType !== "undefined" ){
+	    
+        }else 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 !== "undefined" ) && ( skill !== null )){
+	        if( typeof skill.main !== "undefined"){
+		    hasMain = skill;
+		    this.increaseSkill( Object.keys(skill)[0] ) ;
+		}
+            } else {
+                this.increaseSkill( Object.keys(skill)[0] ) ;
+            }
+         }
+    }
+
+    randomFromWeight( skills ){
+	let weight = [];
+
+	for(skill in skills)
+	    if(typeof skill.occurence !== "undefined")
+		/*size +=*/;
+    }
+    
+   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 );
+    }
+}
+
+class Character extends baseCharacter{
+
+    constructor( aRole, skills, gender, name, experience, gempukku ){
+	super( aRole, skills, gender, name, experience, gempukku );
+    }
+
+    getTN(){
+	return this.baseGetTN();
+    }
+
+    attack(){
+        return this.baseAttack();
+    }
+}
+
+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;
+
+	for( let i = 0; i < school.skills.length ; i++ ){
+	    if( !(school.skills[i] in this.skills) )
+		this.skills[ school.skills[i] ] = 1;
+	}
+    }
+
+    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;
+    }
+}
+
+class People extends Samourai {
+    constructor( gender, name, familly, school, experience, skills){
+	super( "people", gender, name, familly, school, experience, 0, skills );
+    }
+    
+}

game/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] = [];

game/display.js

@@ -0,0 +1,42 @@
+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 characterToLine(){
+    let line = document.CreateElement('td');
+    let cell = document.CreateElement('tr');
+}
+
+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 );
+}
+
+function setElementValue( elem, value ){
+    elem.style.transitionDuration = "0s";
+    elem.style.backgroundColor = "red";
+    elem.style.color = "white";
+    elem.value = value ;
+    window.setTimeout(() => {
+	elem.style.transitionDuration = "7s";
+	elem.style.backgroundColor = "inherit";
+	elem.style.color = "inherit";
+    }, 1000);
+}

game/l5r.js

@@ -0,0 +1,165 @@
+var stances = ["attack", "full attack", "defense", "full defense", "center"];
+
+const mechanics = new Array();
+// [ school name ][ mechanic name ][ action ][ function ]
+mechanics[ "œil de l'aigle" ] = { name : "kiho",
+			action : ()=> {
+			    console.log("En restant immobile et concentré, læ moine peut peut voir à un nombre de milles égal à son rang d'école, avec assez de précision pour reconnaître des individus, mais pas assez pour lire.");
+			          }
+				};
+mechanics[ "moine hitomi" ] = { name : "don de la dame",
+				mutator : ( charac ) => {
+				    charac['getTN'] = () => { return charac.defaultGetTN() + charac.reflexes;}
+				    addTatoo( charac );
+				}
+			      };
+mechanics[ "moine hitomi" ] = { name : "frapper la base",
+				mutator : ( charac ) => {
+				    charac['getTN'] = () => { return charac.defaultGetTN() + charac.reflexes;}
+				}
+			      };
+mechanics[ "moine hitomi" ] = { name : "déplacer le vent",
+				mutator : ( charac ) => {
+                                    charac[ 'actions' ][ 'unarmed attack' ].actionType = 'simple';
+				    charac.chooseTatoo();
+				}
+			      };
+
+class Characters {
+    constructor(){};
+
+    pool = [];
+    elements = ["Character", "Samourai", "People"];
+
+    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 );
+    }
+
+    createPeople( gender, name, familly, school, experience, skills ){
+        let people = new People( gender, name, familly, school, experience, skills );
+        this.add( people );
+    }
+
+    fromJson( json ){
+
+        let data = JSON.parse(json);
+
+        for( prop in data){
+            this[ prop ] = data[ prop ];
+        }
+    }
+
+    /** add
+   * character, parameter, must be declare in the characters.elemets.list
+   * return boolean
+   **/
+    add(character){
+        if( this.elements.includes( character.constructor.name )){
+            this.pool.push( character );
+	    return true;
+        }else{
+	    return false;
+	}
+    }
+
+    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;
+    }
+}
+
+
+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;
+}

helper/random.js

@@ -0,0 +1,156 @@
+
+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")? differenceToArray( explode, 10 ) : [10];
+        let dice = this.get( 10, 1 );
+        return  ( explode.indexOf( dice ) >= 0 )? 10 + this.roll10( explode ) : dice ;
+    }
+
+    rk10( r, k, malus, explode ){
+        let rolls = [];
+        if((typeof r === "unsigned") || (typeof k === "unsigned"))
+            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 differenceToArray( min, max ) {
+    let result = []
+    for( let i = min; i <= max; i++)
+        result.push(i) ; 
+    return result;
+}
+
+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) ;
+}
+

index.html

@@ -0,0 +1,416 @@
+<html>
+  <head>
+    <meta charset="utf8">
+    <link rel="stylesheet" type="text/css" href="style/anim.css">
+    <script src="game/dice.js"></script>
+    <script src="data/names.js"></script>    
+    <script src="data/l5r_data.js"></script>
+    <script src="helper/random.js"></script>
+    <script src="game/display.js"></script>        
+    <script src="game/character.js"></script>        
+    <script src="game/l5r.js"></script>
+    <script src="data/players.js"></script>
+    <script src="data/npc.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 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>

style/anim.css

@@ -0,0 +1,3 @@
+input {
+    transition-property : color, background-color;
+}