.gitignore

@@ -1,10 +0,0 @@
-.vscode/settings.json
-.idea
-.history
-todo.md
-/.vscode
-/ignored/
-/node_modules/
-/jsconfig.json
-/package.json
-/package-lock.json

lang/en.json

@@ -1,20 +1,3 @@
 {
-  "TYPES": {
+  
-    "Actor": {
-      "character": "Character"
-    },
-    "Item": {
-      "armor": "Armor",
-      "weapon": "Weapon",
-      "equipment": "Equipment",
-      "skill": "Skill",
-      "perk": "Perk",
-      "ability": "Ability",
-      "cumulativetask": "Cumulative Task",
-      "genetic": "Genetic",
-      "money": "Money",
-      "cyber": "Cyber",
-      "ammo": "Ammo"  
-    }
-  }
 }

modules/dark-stars-actor-sheet.js

@@ -11,12 +11,12 @@ export class DarkStarsActorSheet extends ActorSheet {
   /** @override */
   static get defaultOptions() {
 
-    return foundry.utils.mergeObject(super.defaultOptions, {
+    return mergeObject(super.defaultOptions, {
       classes: ["fvtt-dark-stars", "sheet", "actor"],
-      template: "systems/fvtt-dark-stars/templates/actors/actor-sheet.hbs",
+      template: "systems/fvtt-dark-stars/templates/actor-sheet.hbs",
       width: 960,
       height: 720,
-      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "main" }],
+      tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "skills" }],
       dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
       editScore: true
     });
@@ -25,7 +25,7 @@ export class DarkStarsActorSheet extends ActorSheet {
   /* -------------------------------------------- */
   async getData() {
     const objectData = this.object.system
-    let actorData = foundry.utils.duplicate(objectData)
+    let actorData = duplicate(objectData)
 
     let formData = {
       title: this.title,
@@ -35,27 +35,24 @@ export class DarkStarsActorSheet extends ActorSheet {
       name: this.actor.name,
       editable: this.isEditable,
       cssClass: this.isEditable ? "editable" : "locked",
-      system: actorData,
+      data: actorData,
       limited: this.object.limited,
       skills: this.actor.getSkills( ),
-      perks: this.actor.getPerks( ),
+      weapons: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getWeapons()) ),
-      weapons: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getWeapons()) ),
+      armors: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getArmors())),
-      ammos: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getAmmos()) ),
+      shields: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getShields())),
-      spells: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getSpells()) ),
+      spells: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getLore())),
-      powers: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getPowers()) ),
+      equipments: this.actor.checkAndPrepareEquipments(duplicate(this.actor.getEquipmentsOnly()) ),
-      armors: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getArmors())),
+      equippedWeapons: this.actor.checkAndPrepareEquipments(duplicate(this.actor.getEquippedWeapons()) ),
-      shields: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getShields())),
-      equipments: this.actor.checkAndPrepareEquipments(foundry.utils.duplicate(this.actor.getEquipmentsOnly()) ),
-      equippedWeapons: this.actor.checkAndPrepareEquipments(foundry.utils.duplicate(this.actor.getEquippedWeapons()) ),
-      cybers: this.actor.checkAndPrepareEquipments(foundry.utils.duplicate(this.actor.getCybers()) ),
-      genetics: this.actor.checkAndPrepareEquipments(foundry.utils.duplicate(this.actor.getGenetics()) ),
       equippedArmor: this.actor.getEquippedArmor(),
       equippedShield: this.actor.getEquippedShield(),
-      subActors: foundry.utils.duplicate(this.actor.getSubActors()),
+      feats: duplicate(this.actor.getFeats()),
+      subActors: duplicate(this.actor.getSubActors()),
+      race: duplicate(this.actor.getRace()),
+      moneys: duplicate(this.actor.getMoneys()),
       encCapacity: this.actor.getEncumbranceCapacity(),
+      saveRolls: this.actor.getSaveRoll(),
       conditions: this.actor.getConditions(),
-      extendedTests: this.actor.getExtendedTests(),
-      config: game.system.darkstars.config,
       description: await TextEditor.enrichHTML(this.object.system.biodata.description, {async: true}),
       notes: await TextEditor.enrichHTML(this.object.system.biodata.notes, {async: true}),
       containersTree: this.actor.containersTree,
@@ -101,6 +98,17 @@ export class DarkStarsActorSheet extends ActorSheet {
       this.actor.createEmbeddedDocuments('Item', [{ name: "NewItem", type: dataType }], { renderSheet: true })
     })
         
+    html.find('.equip-activate').click(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      this.actor.equipActivate( itemId)
+    });      
+    html.find('.equip-deactivate').click(ev => {
+      const li = $(ev.currentTarget).parents(".item")
+      let itemId = li.data("item-id")
+      this.actor.equipDeactivate( itemId)
+    });      
+
     html.find('.subactor-edit').click(ev => {
       const li = $(ev.currentTarget).parents(".item");
       let actorId = li.data("actor-id");
@@ -113,17 +121,6 @@ export class DarkStarsActorSheet extends ActorSheet {
       let actorId = li.data("actor-id");
       this.actor.delSubActor(actorId);
     });
-
-    html.find('.edit-weapon-ammo').change(ev => {
-      const li = $(ev.currentTarget).parents(".item")
-      let weaponId = li.data("item-id")
-      this.actor.setWeaponAmmo( weaponId, ev.currentTarget.value )
-    })
-    html.find('.skill-used-id').change(event => {
-      const li = $(event.currentTarget).parents(".item");
-      this.actor.setSkillUsed( li.data("item-id"), event.currentTarget.checked );
-    } );
-
     html.find('.quantity-minus').click(event => {
       const li = $(event.currentTarget).parents(".item");
       this.actor.incDecQuantity( li.data("item-id"), -1 );
@@ -142,31 +139,35 @@ export class DarkStarsActorSheet extends ActorSheet {
       this.actor.incDecAmmo( li.data("item-id"), +1 )
     } );
             
+    html.find('.roll-ability').click((event) => {
+      const abilityKey = $(event.currentTarget).data("ability-key");
+      this.actor.rollAbility(abilityKey);
+    });
     html.find('.roll-skill').click((event) => {
       const li = $(event.currentTarget).parents(".item")
       const skillId = li.data("item-id")
       this.actor.rollSkill(skillId)
     });    
-    html.find('.roll-attribute').click((event) => {
-      const attrKey = $(event.currentTarget).data("attr-key")
-      this.actor.rollAttribute(attrKey)
-    })
-    html.find('.start-extended-test').click((event) => {
-      const li = $(event.currentTarget).parents(".item")
-      const skillId = li.data("item-id")
-      this.actor.rollSkill(skillId, true)
-    })
-    html.find('.roll-extended-test').click((event) => {
-      const li = $(event.currentTarget).parents(".item")
-      const testId = li.data("item-id")
-      this.actor.continueExtendedTest(testId)
-    })
 
     html.find('.roll-weapon').click((event) => {
       const li = $(event.currentTarget).parents(".item");
       const skillId = li.data("item-id")
       this.actor.rollWeapon(skillId)
     });
+    html.find('.roll-armor-die').click((event) => {
+      this.actor.rollArmorDie()
+    });
+    html.find('.roll-shield-die').click((event) => {
+      this.actor.rollShieldDie()
+    });
+    html.find('.roll-target-die').click((event) => {
+      this.actor.rollDefenseRanged()
+    });
+    
+    html.find('.roll-save').click((event) => {
+      const saveKey = $(event.currentTarget).data("save-key")
+      this.actor.rollSave(saveKey)
+    });
     
     
     html.find('.lock-unlock-sheet').click((event) => {

modules/dark-stars-actor.js

@@ -43,6 +43,8 @@ export class DarkStarsActor extends Actor {
     }
 
     if (data.type == 'character') {
+      const skills = await DarkStarsUtility.loadCompendium("fvtt-dark-stars.skills");
+      data.items = skills.map(i => i.toObject())
     }
     if (data.type == 'npc') {
     }
@@ -62,35 +64,26 @@ export class DarkStarsActor extends Actor {
   /* -------------------------------------------- */
   computeHitPoints() {
     if (this.type == "character") {
+      let hp = duplicate(this.system.secondary.hp)
+      let max = (this.system.abilities.str.value + this.system.abilities.con.value) * 6
+      if (max != hp.max || hp.value > max) {
+        hp.max = max
+        hp.value = max // Init case
+        this.update({ 'system.secondary.hp': hp })
+      }
     }
   }
-
   /* -------------------------------------------- */
-  computeDerivated() {
+  computeEffortPoints() {
-    let attr = this.system.attributes
+    if (this.type == "character") {
-    let deriv = this.system.derivated
+      let effort = duplicate(this.system.secondary.effort)
-    let secondary = this.system.secondary 
+      let max = (this.system.abilities.con.value + this.system.abilities.int.value) * 6
-    
+      if (max != effort.max || effort.value > max) {
-    deriv.csb.value = Math.round((attr.dex.value + attr.sel.value) / 2) + deriv.csb.bonus
+        effort.max = max
-    deriv.asb.value = Math.round((attr.int.value + attr.edu.value) / 2) + deriv.asb.bonus
+        effort.value = max // Init case
-    deriv.ssb.value = Math.round((attr.cha.value + attr.emp.value + attr.att.value) / 3) + deriv.ssb.bonus
+        this.update({ 'system.secondary.effort': effort })
-    deriv.msb.value = Math.round((attr.con.value + attr.str.value ) / 2) + deriv.msb.bonus
+      }
-    deriv.psb.value = Math.round((attr.str.value + attr.dex.value + attr.con.value) / 3) + deriv.psb.bonus 
-
-    deriv.ego.value = attr.str.value + attr.cha.value + attr.sel.value + attr.emp.value + deriv.ego.bonus
-    deriv.hup.value = (attr.emp.value * 10) + deriv.hup.bonus 
-    deriv.ss.value = (attr.edu.value * 10) + (attr.int.value * 10) + 250 + deriv.ss.bonus 
-
-    deriv.mcdb.value = Math.round( (attr.str.value  + attr.siz.value) / 4) + deriv.mcdb.bonus 
-    deriv.si.value = Math.round( ((attr.dex.value  + attr.sel.value) / 5) + 0.5) + deriv.si.bonus
-    
-    secondary.hp.max = ((attr.con.value + attr.siz.value ) * 2) + secondary.hp.bonus
-    for(let key in this.system.hitlocations) {
-      let loc = this.system.hitlocations[key]
-      loc.max = Math.floor(secondary.hp.max * loc.ratio)
     }
-
-    secondary.fp.max =  10  + attr.str.value + attr.con.value + secondary.fp.bonus
   }
 
   /* -------------------------------------------- */
@@ -98,9 +91,9 @@ export class DarkStarsActor extends Actor {
 
     if (this.type == 'character' || game.user.isGM) {
       this.system.encCapacity = this.getEncumbranceCapacity()
-      this.computeDerivated()
       this.buildContainerTree()
       this.computeHitPoints()
+      this.computeEffortPoints()
     }
 
     super.prepareDerivedData();
@@ -117,72 +110,73 @@ export class DarkStarsActor extends Actor {
     return 1;
   }
 
+  /* -------------------------------------------- */
+  getMoneys() {
+    let comp = this.items.filter(item => item.type == 'money');
+    DarkStarsUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  /* -------------------------------------------- */
+  getFeats() {
+    let comp = duplicate(this.items.filter(item => item.type == 'feat') || []);
+    DarkStarsUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  /* -------------------------------------------- */
+  getFeatsWithDie() {
+    let comp = duplicate(this.items.filter(item => item.type == 'feat' && item.system.isfeatdie) || []);
+    DarkStarsUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  getFeatsWithSL() {
+    let comp = duplicate(this.items.filter(item => item.type == 'feat' && item.system.issl) || []);
+    DarkStarsUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
+  /* -------------------------------------------- */
+  getLore() {
+    let comp = duplicate(this.items.filter(item => item.type == 'spell') || []);
+    DarkStarsUtility.sortArrayObjectsByName(comp)
+    return comp;
+  }
   getEquippedWeapons() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'weapon' && item.system.equipped) || []);
+    let comp = duplicate(this.items.filter(item => item.type == 'weapon' && item.system.equipped) || []);
     DarkStarsUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   /* -------------------------------------------- */
   getArmors() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'armor') || []);
+    let comp = duplicate(this.items.filter(item => item.type == 'armor') || []);
-    DarkStarsUtility.sortArrayObjectsByName(comp)
-    return comp;
-  }
-  getSpells() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'spell') || []);
-    DarkStarsUtility.sortArrayObjectsByName(comp)
-    return comp;
-  }
-  getPowers() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'psychic') || []);
-    DarkStarsUtility.sortArrayObjectsByName(comp)
-    return comp;
-  }  
-  getExtendedTests() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'extendedtest') || []);
     DarkStarsUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   getEquippedArmor() {
     let comp = this.items.find(item => item.type == 'armor' && item.system.equipped)
     if (comp) {
-      return foundry.utils.duplicate(comp)
+      return duplicate(comp)
     }
     return undefined
   }
   /* -------------------------------------------- */
-  getCybers() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'cyber') || []);
-    DarkStarsUtility.sortArrayObjectsByName(comp)
-    return comp;
-  }
-  getGenetics() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'genetic') || []);
-    DarkStarsUtility.sortArrayObjectsByName(comp)
-    return comp;
-  }
-  /* -------------------------------------------- */
   getShields() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'shield') || []);
+    let comp = duplicate(this.items.filter(item => item.type == 'shield') || []);
     DarkStarsUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   getEquippedShield() {
     let comp = this.items.find(item => item.type == 'shield' && item.system.equipped)
     if (comp) {
-      return foundry.utils.duplicate(comp)
+      return duplicate(comp)
     }
     return undefined
   }
   /* -------------------------------------------- */
+  getRace() {
+    let race = this.items.filter(item => item.type == 'race')
+    return race[0] ?? [];
+  }
+  /* -------------------------------------------- */
   checkAndPrepareEquipment(item) {
-    // Dynamic assign ammo for the weapon
-    if (item.type == "weapon" && item.system.needammo) {      
-      let ammo = this.items.find(ammo => ammo.type == "ammo" && item.system.ammoid == ammo.id)
-      if (ammo) {
-        item.ammo = foundry.utils.duplicate(ammo)
-      }
-    }
   }
 
   /* -------------------------------------------- */
@@ -195,78 +189,46 @@ export class DarkStarsActor extends Actor {
 
   /* -------------------------------------------- */
   getConditions() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'condition') || []);
+    let comp = duplicate(this.items.filter(item => item.type == 'condition') || []);
     DarkStarsUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   /* -------------------------------------------- */
   getWeapons() {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'weapon') || []);
+    let comp = duplicate(this.items.filter(item => item.type == 'weapon') || []);
     DarkStarsUtility.sortArrayObjectsByName(comp)
     return comp;
   }
   /* -------------------------------------------- */
-  getAmmos() {
+  getItemById(id) {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'ammo') || []);
+    let item = this.items.find(item => item.id == id);
-    DarkStarsUtility.sortArrayObjectsByName(comp)
+    if (item) {
-    return comp;
+      item = duplicate(item)
-  }
-  /* -------------------------------------------- */
-  getItemById(id, duplicate = true) {
-    let item = this.items.find(it => it.id == id)
-    if (item && duplicate) {
-      item = foundry.utils.duplicate(item)
     }
-    return item
+    return item;
-  }
-  /* -------------------------------------------- */
-  getItem(id) {
-    let item = this.items.get(id)
-    return item
-  }
-  /* -------------------------------------------- */
-  setWeaponAmmo(weaponId, ammoId) {
-    let weapon = this.items.get(weaponId)
-    if(weapon) {
-      this.updateEmbeddedDocuments('Item', [ {_id: weapon.id, 'system.ammoid': ammoId} ])
-    }
-  }  
-  /* -------------------------------------------- */
-  setSkillUsed( skillId, checked) {
-    let skill = this.items.get(skillId)
-    if(skill) {
-      this.updateEmbeddedDocuments('Item', [ {_id: skill.id, 'system.used': checked} ])
-    }
-  }
-
-  /* -------------------------------------------- */
-  updateSkill(skill) {
-    skill.derivated = foundry.utils.duplicate(this.system.derivated[skill.system.base])
-    skill.total = skill.system.value + skill.derivated.value + skill.system.bonus    
   }
 
   /* -------------------------------------------- */
   getSkills() {
-    this.computeDerivated()
+    let comp = duplicate(this.items.filter(item => item.type == 'skill') || [])
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'skill') || [])
     for (let skill of comp) {
-      this.updateSkill(skill)
+      DarkStarsUtility.updateSkill(skill)
     }
     DarkStarsUtility.sortArrayObjectsByName(comp)
     return comp
   }
 
   /* -------------------------------------------- */
-  getPerks() {
+  getRelevantAbility(statKey) {
-    let comp = foundry.utils.duplicate(this.items.filter(item => item.type == 'perk') || [])
+    let comp = duplicate(this.items.filter(item => item.type == 'skill' && item.system.ability == ability) || []);
-    DarkStarsUtility.sortArrayObjectsByName(comp)
+    return comp;
-    return comp
   }
 
+
   /* -------------------------------------------- */
   async equipItem(itemId) {
     let item = this.items.find(item => item.id == itemId)
-    if (item?.system) {
+    if (item && item.system) {
       if (item.type == "armor") {
         let armor = this.items.find(item => item.id != itemId && item.type == "armor" && item.system.equipped)
         if (armor) {
@@ -303,7 +265,7 @@ export class DarkStarsActor extends Actor {
   }
   /* ------------------------------------------- */
   getEquipmentsOnly() {
-    return foundry.utils.duplicate(this.items.filter(item => item.type == "equipment") || [])
+    return duplicate(this.items.filter(item => item.type == "equipment") || [])
   }
 
   /* ------------------------------------------- */
@@ -329,7 +291,7 @@ export class DarkStarsActor extends Actor {
 
   /* ------------------------------------------- */
   async buildContainerTree() {
-    let equipments = foundry.utils.duplicate(this.items.filter(item => item.type == "equipment") || [])
+    let equipments = duplicate(this.items.filter(item => item.type == "equipment") || [])
     for (let equip1 of equipments) {
       if (equip1.system.iscontainer) {
         equip1.system.contents = []
@@ -381,9 +343,9 @@ export class DarkStarsActor extends Actor {
 
   /* -------------------------------------------- */
   async incDecHP(formula) {
-    let dmgRoll = new Roll(formula + "[dark-starsorange]").roll({ async: false })
+    let dmgRoll = new Roll(formula+"[dark-starsorange]").roll({ async: false })
     await DarkStarsUtility.showDiceSoNice(dmgRoll, game.settings.get("core", "rollMode"))
-    let hp = foundry.utils.duplicate(this.system.secondary.hp)
+    let hp = duplicate(this.system.secondary.hp)
     hp.value = Number(hp.value) + Number(dmgRoll.total)
     this.update({ 'system.secondary.hp': hp })
     return Number(dmgRoll.total)
@@ -410,7 +372,7 @@ export class DarkStarsActor extends Actor {
       } else {
         await this.updateEmbeddedDocuments("Item", [{ _id: object.id, 'system.containerid': containerId }])
       }
-    } else if (object?.system.containerid) { // remove from container
+    } else if (object && object.system.containerid) { // remove from container
       console.log("Removeing: ", object)
       await this.updateEmbeddedDocuments("Item", [{ _id: object.id, 'system.containerid': "" }]);
     }
@@ -427,34 +389,31 @@ export class DarkStarsActor extends Actor {
   /* -------------------------------------------- */
   async equipGear(equipmentId) {
     let item = this.items.find(item => item.id == equipmentId);
-    if (item?.system) {
+    if (item && item.system) {
       let update = { _id: item.id, "system.equipped": !item.system.equipped };
       await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
     }
   }
   /* -------------------------------------------- */
-  hasLastWord() {
+  getInitiativeScore(combatId, combatantId) {
-    return this.items.find(i => i.type == "perk" && i.name.toLowerCase() === "last word")
+    if (this.type == 'character') {
-  }
+      this.rollMR(true, combatId, combatantId)
-  /* -------------------------------------------- */
+    }
-  async getInitiativeScore() {
+    console.log("Init required !!!!")
-    let initFormula = (this.system.derivated.si.value + this.system.derivated.si.bonus) + "d6"
+    return -1;
-    let initRoll = await new Roll(initFormula).roll()
-    await DarkStarsUtility.showDiceSoNice(initRoll, game.settings.get("core", "rollMode"))
-    return initRoll.total
   }
 
   /* -------------------------------------------- */
   getSubActors() {
     let subActors = [];
     for (let id of this.system.subactors) {
-      subActors.push(foundry.utils.duplicate(game.actors.get(id)))
+      subActors.push(duplicate(game.actors.get(id)))
     }
     return subActors;
   }
   /* -------------------------------------------- */
   async addSubActor(subActorId) {
-    let subActors = foundry.utils.duplicate(this.system.subactors);
+    let subActors = duplicate(this.system.subactors);
     subActors.push(subActorId);
     await this.update({ 'system.subactors': subActors });
   }
@@ -469,11 +428,17 @@ export class DarkStarsActor extends Actor {
     await this.update({ 'system.subactors': newArray });
   }
 
+  /* -------------------------------------------- */
+  syncRoll(rollData) {
+    this.lastRollId = rollData.rollId;
+    DarkStarsUtility.saveRollData(rollData);
+  }
+
   /* -------------------------------------------- */
   getOneSkill(skillId) {
     let skill = this.items.find(item => item.type == 'skill' && item.id == skillId)
     if (skill) {
-      skill = foundry.utils.duplicate(skill);
+      skill = duplicate(skill);
     }
     return skill;
   }
@@ -523,7 +488,7 @@ export class DarkStarsActor extends Actor {
     if (objetQ) {
       let newQ = objetQ.system.quantity + incDec
       if (newQ >= 0) {
-        await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantity': newQ }]) // pdates one EmbeddedEntity
+        const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantity': newQ }]) // pdates one EmbeddedEntity
       }
     }
   }
@@ -533,7 +498,7 @@ export class DarkStarsActor extends Actor {
     if (objetQ) {
       let newQ = objetQ.system.ammocurrent + incDec;
       if (newQ >= 0 && newQ <= objetQ.system.ammomax) {
-        await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.ammocurrent': newQ }]); // pdates one EmbeddedEntity
+        const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.ammocurrent': newQ }]); // pdates one EmbeddedEntity
       }
     }
   }
@@ -567,13 +532,6 @@ export class DarkStarsActor extends Actor {
     return this.items.find(cond => cond.type == "condition" && cond.system.targetadvantage)
   }
 
-  /* -------------------------------------------- */
-  modifyRerolls( value) {
-    let rerolls = foundry.utils.duplicate(this.system.various.rerolls)
-    rerolls.value += value
-    this.update({ 'system.various.rerolls': rerolls })
-  }
-
   /* -------------------------------------------- */
   getCommonRollData(abilityKey = undefined) {
     let noAction = this.isNoAction()
@@ -585,14 +543,22 @@ export class DarkStarsActor extends Actor {
     let rollData = DarkStarsUtility.getBasicRollData()
     rollData.alias = this.name
     rollData.actorImg = this.img
-    console.log("Prepare common roll data for actor", this) 
+    rollData.actorId = this.id
-    rollData.tokenId = this.token?.id
-    rollData.actorId =  this.id
     rollData.img = this.img
+    rollData.featsDie = this.getFeatsWithDie()
+    rollData.featsSL = this.getFeatsWithSL()
     rollData.armors = this.getArmors()
     rollData.conditions = this.getConditions()
-    rollData.rerolls = this.system.various.rerolls.value
+    rollData.featDieName = "none"
-
+    rollData.featSLName = "none"
+    rollData.rollAdvantage = "none"
+    rollData.advantage = "none"
+    rollData.disadvantage = "none"
+    rollData.forceAdvantage = this.isForcedAdvantage()
+    rollData.forceDisadvantage = this.isForcedDisadvantage()
+    rollData.forceRollAdvantage = this.isForcedRollAdvantage()
+    rollData.forceRollDisadvantage = this.isForcedRollDisadvantage()
+    rollData.noAdvantage = this.isNoAdvantage()
     if (rollData.defenderTokenId) {
       let defenderToken = game.canvas.tokens.get(rollData.defenderTokenId)
       let defender = defenderToken.actor
@@ -627,69 +593,35 @@ export class DarkStarsActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  rollAttribute(attrKey) {
+  rollAbility(abilityKey) {
-    let rollData = this.getCommonRollData()
+    let rollData = this.getCommonRollData(abilityKey)
-    rollData.attr = foundry.utils.duplicate(this.system.attributes[attrKey])
+    rollData.mode = "ability"
-    rollData.mode = "attribute"
+    if (rollData.target) {
-    rollData.title = "Attribute " + rollData.attr.label
+      ui.notifications.warn("You are targetting a token with a skill : please use a Weapon instead.")
-    this.startRoll(rollData)
+      return
-  }
-  /* -------------------------------------------- */
-  continueExtendedTest(testId) {
-    let test = this.items.get(testId)
-    if (test) {
-      let skill = this.items.find(it => it.type == "skill" && it.name.toLowerCase() == test.system.skill.toLowerCase())
-      if (skill) {
-        skill = foundry.utils.duplicate(skill)
-        this.updateSkill(skill)
-        let rollData = this.getCommonRollData()
-        rollData.mode = "extendedtest"
-        rollData.isExtended = true
-        rollData.extendedTest = test
-        rollData.title = "Extended test " + skill.name
-        rollData.skill = skill
-        rollData.img = skill.img
-        rollData.taskId = test.id
-        if (rollData.target) {
-          ui.notifications.warn("You are targetting a token with a skill : please use a Weapon instead.")
-          return
-        }
-        this.startRoll(rollData)          
-      } else {
-        console.log("Unable to find the relevant skill for extended test " + test.system.skill)
-      } 
-    } else {
-      console.log("Unable to find the extended test")
     }
+    DarkStarsUtility.rollDarkStars(rollData)
   }
 
   /* -------------------------------------------- */
-  async rollSkill(skillId, isExtended = false, taskId = undefined) {
+  rollSkill(skillId) {
     let skill = this.items.get(skillId)
     if (skill) {
-      skill = foundry.utils.duplicate(skill)
+      if (skill.system.islore && skill.system.level == 0) {
-      this.updateSkill(skill)
+        ui.notifications.warn("You can't use Lore Skills with a SL of 0.")
-      let rollData = this.getCommonRollData()
+        return
+      }
+      skill = duplicate(skill)
+      DarkStarsUtility.updateSkill(skill)
+      let abilityKey = skill.system.ability
+      let rollData = this.getCommonRollData(abilityKey)
       rollData.mode = "skill"
-      rollData.isExtended = isExtended
-      rollData.title = "Skill " + skill.name
       rollData.skill = skill
       rollData.img = skill.img
       if (rollData.target) {
         ui.notifications.warn("You are targetting a token with a skill : please use a Weapon instead.")
         return
       }
-      if (isExtended) {
-        rollData.title = "Extended Test " + skill.name
-        if (!taskId) {
-          let extendedTest = await this.createEmbeddedDocuments("Item", [{name: "Extended test " + skill.name, type: "extendedtest", 
-            'system.skill': skill.name}])
-          //console.log("Task", cumulativeTask)
-          rollData.taskId = extendedTest[0].id
-        }else {
-          rollData.taskId = extendedTest[0].id
-        }
-      }
       this.startRoll(rollData)
     }
   }
@@ -698,17 +630,24 @@ export class DarkStarsActor extends Actor {
   rollWeapon(weaponId) {
     let weapon = this.items.get(weaponId)
     if (weapon) {
-      weapon = foundry.utils.duplicate(weapon)
+      weapon = duplicate(weapon)
       let skill = this.items.find(item => item.name.toLowerCase() == weapon.system.skill.toLowerCase())
       if (skill) {
-        skill = foundry.utils.duplicate(skill)
+        skill = duplicate(skill)
-        this.updateSkill(skill)
+        DarkStarsUtility.updateSkill(skill)
-        let rollData = this.getCommonRollData()
+        let abilityKey = skill.system.ability
+        let rollData = this.getCommonRollData(abilityKey)
         rollData.mode = "weapon"
         rollData.skill = skill
         rollData.weapon = weapon
-        this.checkAndPrepareEquipment(weapon)
         rollData.img = weapon.img
+        if (!rollData.forceDisadvantage) { // This is an attack, check if disadvantaged
+          rollData.forceDisadvantage = this.isAttackDisadvantage()
+        }
+        /*if (rollData.weapon.system.isranged && rollData.tokensDistance > DarkStarsUtility.getWeaponMaxRange(rollData.weapon) ) {
+          ui.notifications.warn(`Your target is out of range of your weapon (max: ${DarkStarsUtility.getWeaponMaxRange(rollData.weapon)}  - current : ${rollData.tokensDistance})` )
+          return
+        }*/
         this.startRoll(rollData)
       } else {
         ui.notifications.warn("Unable to find the relevant skill for weapon " + weapon.name)
@@ -716,8 +655,152 @@ export class DarkStarsActor extends Actor {
     }
   }
 
+  /* -------------------------------------------- */
+  rollDefenseMelee(attackRollData) {
+    let weapon = this.items.get(attackRollData.defenseWeaponId)
+    if (weapon) {
+      weapon = duplicate(weapon)
+      let skill = this.items.find(item => item.name.toLowerCase() == weapon.system.skill.toLowerCase())
+      if (skill) {
+        skill = duplicate(skill)
+        DarkStarsUtility.updateSkill(skill)
+        let abilityKey = skill.system.ability
+        let rollData = this.getCommonRollData(abilityKey)
+        rollData.defenderTokenId = undefined // Cleanup
+        rollData.mode = "weapondefense"
+        rollData.shield = this.getEquippedShield()
+        rollData.attackRollData = duplicate(attackRollData)
+        rollData.skill = skill
+        rollData.weapon = weapon
+        rollData.img = weapon.img
+        if (!rollData.forceDisadvantage) { // This is an attack, check if disadvantaged
+          rollData.forceDisadvantage = this.isDefenseDisadvantage()
+        }
+
+        this.startRoll(rollData)
+      } else {
+        ui.notifications.warn("Unable to find the relevant skill for weapon " + weapon.name)
+      }
+    } else {
+      ui.notifications.warn("Weapon not found ! ")
+    }
+  }
+
+  /* -------------------------------------------- */
+  rollDefenseRanged(attackRollData) {
+    let rollData = this.getCommonRollData()
+    rollData.defenderTokenId = undefined // Cleanup
+    rollData.mode = "rangeddefense"
+    if ( attackRollData) {
+      rollData.attackRollData = duplicate(attackRollData)
+      rollData.effectiveRange = DarkStarsUtility.getWeaponRange(attackRollData.weapon)
+      rollData.tokensDistance = attackRollData.tokensDistance // QoL copy
+    }
+    rollData.sizeDice = DarkStarsUtility.getSizeDice(this.system.biodata.size)
+    rollData.distanceBonusDice = 0 //Math.max(0, Math.floor((rollData.tokensDistance - rollData.effectiveRange) + 0.5))
+    rollData.hasCover = "none"
+    rollData.situational = "none"
+    rollData.useshield = false
+    rollData.shield = this.getEquippedShield()
+    this.startRoll(rollData)
+  }
+
+  /* -------------------------------------------- */
+  rollShieldDie() {
+    let shield = this.getEquippedShield()
+    if (shield) {
+      shield = duplicate(shield)
+      let rollData = this.getCommonRollData()
+      rollData.mode = "shield"
+      rollData.shield = shield
+      rollData.useshield = true
+      rollData.img = shield.img
+      this.startRoll(rollData)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async rollArmorDie(rollData = undefined) {
+    let armor = this.getEquippedArmor()
+    if (armor) {
+      armor = duplicate(armor)
+      let reduce = 0
+      let multiply = 1
+      let disadvantage = false
+      let advantage = false
+      let messages = ["Armor applied"]
+
+      if (rollData) {
+        if (DarkStarsUtility.isArmorLight(armor) && DarkStarsUtility.isWeaponPenetrating(rollData.attackRollData.weapon)) {
+          return { armorIgnored: true, nbSuccess: 0, messages: ["Armor ignored : Penetrating weapons ignore Light Armors."] }
+        }
+        if (DarkStarsUtility.isWeaponPenetrating(rollData.attackRollData.weapon)) {
+          messages.push("Armor reduced by 1 (Penetrating weapon)")
+          reduce = 1
+        }
+        if (DarkStarsUtility.isWeaponLight(rollData.attackRollData.weapon)) {
+          messages.push("Armor with advantage (Light weapon)")
+          advantage = true
+        }
+        if (DarkStarsUtility.isWeaponHeavy(rollData.attackRollData.weapon)) {
+          messages.push("Armor with disadvantage (Heavy weapon)")
+          disadvantage = true
+        }
+        if (DarkStarsUtility.isWeaponHack(rollData.attackRollData.weapon)) {
+          messages.push("Armor reduced by 1 (Hack weapon)")
+          reduce = 1
+        }
+        if (DarkStarsUtility.isWeaponUndamaging(rollData.attackRollData.weapon)) {
+          messages.push("Armor multiplied by 2 (Undamaging weapon)")
+          multiply = 2
+        }
+      }
+      let diceColor = armor.system.absorprionroll
+      let armorResult = await DarkStarsUtility.getRollTableFromDiceColor(diceColor, false)
+      console.log("Armor log", armorResult)
+      let armorValue = Math.max(0, (Number(armorResult.text) + reduce) * multiply)
+      if (advantage || disadvantage) {
+        let armorResult2 = await DarkStarsUtility.getRollTableFromDiceColor(diceColor, false)
+        let armorValue2 = Math.max(0, (Number(armorResult2.text) + reduce) * multiply)
+        if (advantage) {
+          armorValue = (armorValue2 > armorValue) ? armorValue2 : armorValue
+          messages.push(`Armor advantage - Roll 1 = ${armorValue} - Roll 2 = ${armorValue2}`)
+        }
+        if (disadvantage) {
+          armorValue = (armorValue2 < armorValue) ? armorValue2 : armorValue
+          messages.push(`Armor disadvantage - Roll 1 = ${armorValue} - Roll 2 = ${armorValue2}`)
+        }
+      }
+      armorResult.armorValue = armorValue
+      if (!rollData) {
+        ChatMessage.create({ content: "Armor result : " + armorValue })
+      }
+      messages.push("Armor result : " + armorValue)
+      return { armorIgnored: false, nbSuccess: armorValue, rawArmor: armorResult.text, messages: messages }
+    }
+    return { armorIgnored: true, nbSuccess: 0, messages: ["No armor equipped."] }
+  }
+
+  /* -------------------------------------------- */
+  rollSave(saveKey) {
+    let saves = this.getSaveRoll()
+    let save = saves[saveKey]
+    if (save) {
+      save = duplicate(save)
+      let rollData = this.getCommonRollData()
+      rollData.mode = "save"
+      rollData.save = save
+      if (rollData.target) {
+        ui.notifications.warn("You are targetting a token with a save roll - Not authorized.")
+        return
+      }
+      this.startRoll(rollData)
+    }
+
+  }
   /* -------------------------------------------- */
   async startRoll(rollData) {
+    this.syncRoll(rollData)
     let rollDialog = await DarkStarsRollDialog.create(this, rollData)
     rollDialog.render(true)
   }

modules/dark-stars-combat.js

@@ -4,44 +4,27 @@ import { DarkStarsUtility } from "./dark-stars-utility.js";
 export class DarkStarsCombat extends Combat {
   
   /* -------------------------------------------- */
-  processOtherTurns(c, initScore) {
+  async rollInitiative(ids, formula = undefined, messageOptions = {} ) {
-    let toCreate = []
-    let token = canvas.tokens.get(c.tokenId)
-    let hasLastWord = token.actor.hasLastWord()
-    while ( (initScore > 5) || (hasLastWord && initScore >= 5)) {
-      initScore -= 5;
-      toCreate.push({tokenId: c.tokenId, sceneId: c.sceneId, actorId: c.actorId, hidden: c.hidden, initiative: initScore, flags: { world: { isDuplicated: true} } } );
-    }
-    this.createEmbeddedDocuments("Combatant", toCreate);
-  }
-
-  /* -------------------------------------------- */
-  async rollInitiative(ids, formula = undefined, messageOptions = {}) {
     ids = typeof ids === "string" ? [ids] : ids;
-    for (let cId of ids) {
+    for (let cId = 0; cId < ids.length; cId++) {
-      const c = this.combatants.get(cId);
+      const c = this.combatants.get(ids[cId]);
       let id = c._id || c.id;
-      let initScore = c.actor ? await c.actor.getInitiativeScore(this.id, id) : -1;
+      let initBonus = c.actor ? c.actor.getInitiativeScore( this.id, id ) : -1;
-      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: initScore }]);
+      await this.updateEmbeddedDocuments("Combatant", [ { _id: id, initiative: initBonus } ]);
-      setTimeout(() => this.processOtherTurns(c, initScore), 400)
     }
-    return this;
-  }
 
-  /* -------------------------------------------- */
+    return this;
-  nextRound() {
-    super.nextRound()
-    let toDelete = []
-    for (let c of this.combatants) {
-      if (c.flags?.world?.isDuplicated) {
-        toDelete.push(c._id)
-      }
-    }
-    this.deleteEmbeddedDocuments("Combatant", toDelete);
   }
 
   /* -------------------------------------------- */
   _onUpdate(changed, options, userId) {
   }
 
+  /* -------------------------------------------- */
+  static async checkTurnPosition() {
+    while (game.combat.turn > 0) {
+      await game.combat.previousTurn()
+    }
+  }
+
 }

modules/dark-stars-config.js

@@ -1,78 +1,12 @@
 
 export const DARKSTARS_CONFIG = {
 
-  sizeOptions: {
-    "1": "Tiny",
-    "2": "Small",
-    "3": "Medium",
-    "4": "Large",
-    "5": "Huge",
-    "6": "Gargantuan"
-  },
-  classNPC: {
-    "none": "None",
-    "chaplain": "Chaplain",
-    "magus": "Magus",
-    "martial": "Martial",
-    "skalawag": "Skalawag",
-    "warden": "Warden"
-  },
-  synergyBonus: {
-    "0": "0",
-    "5": "+5%",
-    "+6": "+6%",
-    "+7": "+7%",
-    "+8": "+8%",
-    "+9": "+9%",
-    "+10": "+10%"
-  },
-  attributeModifier: [
-    {value: "0", label: "None"},
-    {value: "-1", label: "Difficult (-1)"},
-    {value: "-3", label: "Hard (-3)"},
-    {value: "-6", label: "Very Hard (-6)"},
-    {value: "-9", label: "Impossible (-9)"}
-  ],
-  weaponAiming: {
-    "none": "None",
-    " arm": "Arm (-50)",
-    "head": "Head (-50)",
-    "torso": "Torso(-30)",
-    "leg": "Leg (-30)",
-    "hand": "Hand/Weapon (-70)"
-  },
-  rollModifiers: [
-    { "value": "-80", "label": "-80%" },
-    { "value": "-70", "label": "-70%" },
-    { "value": "-60", "label": "-60%" },
-    { "value": "-50", "label": "-50%" },
-    { "value": "-40", "label": "-40%" },
-    { "value": "-30", "label": "-30%" },
-    { "value": "-20", "label": "-20%" },
-    { "value": "-10", "label": "-10%" },
-    { "value": "0", "label": "0%" },
-    { "value": "+10", "label": "+10%" },
-    { "value": "+20", "label": "+20%" },
-    { "value": "+30", "label": "+30%" },
-    { "value": "+40", "label": "+40%" }
-  ],
-  abilityValues: {
-    "0": "0",
-    "1": "1",
-    "2": "2",
-    "3": "3",
-    "4": "4",
-    "5": "5",
-    "6": "6",
-    "7": "7",
-    "8": "8"
-  },
   basebonus  : {
     "csb": "CSB",
+    "asb": "SSB",
     "ssb": "SSB",
     "msb": "MSB",
-    "psb": "PSB",
+    "psb": "PSB"
-    "asb": "ASB"
   },
   location  : {
     "head": "Head",
@@ -95,26 +29,6 @@ export const DARKSTARS_CONFIG = {
     "slug": "Slug throwers",
     "energy": "Energy"
   },
-  perktypes: {
-    "normal": "Normal",
-    "advanced": "Advanced",
-    "role": "Role",
-    "job": "Job"
-  },
-  magicTypes: {
-    "lemurian": "Lemurian", 
-    "bloodmagic": "Blood Magic Ritual", 
-    "ritual": "Ritual",
-    "miracle": "Miracle"
-  },
-  cyberTypes: {
-    "I": "I",
-    "P": "P",
-    "U": "U",
-    "W": "W",
-    "E": "E",
-    "GS": "GS"
-  },
   range: {
     "1": "Close",
     "2": "Short",

modules/dark-stars-item-sheet.js

@@ -9,7 +9,7 @@ export class DarkStarsItemSheet extends ItemSheet {
   /** @override */
   static get defaultOptions() {
 
-    return foundry.utils.mergeObject(super.defaultOptions, {
+    return mergeObject(super.defaultOptions, {
       classes: ["fvtt-dark-stars", "sheet", "item"],
       template: "systems/fvtt-dark-stars/templates/items/item-sheet.hbs",
       dragDrop: [{ dragSelector: null, dropSelector: null }],
@@ -49,7 +49,7 @@ export class DarkStarsItemSheet extends ItemSheet {
   /* -------------------------------------------- */
   async getData() {
     
-    let objectData = foundry.utils.duplicate(this.object.system)
+    let objectData = duplicate(this.object.system)
 
     let formData = {
       title: this.title,
@@ -59,7 +59,8 @@ export class DarkStarsItemSheet extends ItemSheet {
       name: this.object.name,
       editable: this.isEditable,
       cssClass: this.isEditable ? "editable" : "locked",
-      skills: DarkStarsUtility.getSkills(),
+      weaponSkills: DarkStarsUtility.getWeaponSkills(),
+      shieldSkills: DarkStarsUtility.getShieldSkills(),
       description: await TextEditor.enrichHTML(this.object.system.description, {async: true}),
       config: game.system.darkstars.config,
       system: objectData,
@@ -87,7 +88,7 @@ export class DarkStarsItemSheet extends ItemSheet {
 
   /* -------------------------------------------- */
   postItem() {
-    let chatData = foundry.utils.duplicate(DarkStarsUtility.data(this.item));
+    let chatData = duplicate(DarkStarsUtility.data(this.item));
     if (this.actor) {
       chatData.actor = { id: this.actor.id };
     }
@@ -132,9 +133,21 @@ export class DarkStarsItemSheet extends ItemSheet {
       this.deleteSubitem(ev);
     });
 
+    // Update Inventory Item
+    html.find('.item-delete').click(ev => {
+      const li = $(ev.currentTarget).parents(".item");
+      let itemId = li.data("item-id");
+      let itemType = li.data("item-type");
+    });
+
     html.find('.view-subitem').click(ev => {
       this.viewSubitem(ev);
     });
+
+    html.find('.view-spec').click(ev => {
+      this.manageSpec();
+    });
+
   }
 
   

modules/dark-stars-item.js

@@ -8,9 +8,7 @@ export const defaultItemImg = {
   perk: "systems/fvtt-dark-stars/images/icons/perk.webp",
   ability: "systems/fvtt-dark-stars/images/icons/ability.webp",
   genetic: "systems/fvtt-dark-stars/images/icons/genetic.webp",
-  cyber: "systems/fvtt-dark-stars/images/icons/cyber.webp",
+  cyber: "systems/fvtt-dark-stars/images/icons/cyber.webp"
-  spell: "systems/fvtt-dark-stars/images/icons/magic.webp",
-  psychic: "systems/fvtt-dark-stars/images/icons/psychicpowers.webp",
   }
 
 /**

modules/dark-stars-main.js

@@ -18,7 +18,6 @@ import { DarkStarsItem } from "./dark-stars-item.js";
 import { DarkStarsHotbar } from "./dark-stars-hotbar.js"
 import { DarkStarsCommands } from "./dark-stars-commands.js"
 import { DARKSTARS_CONFIG } from "./dark-stars-config.js";
-import { ClassCounter} from "https://www.uberwald.me/fvtt_appcount/count-class-ready.js"
 
 /* -------------------------------------------- */
 /*  Foundry VTT Initialization                  */
@@ -92,11 +91,15 @@ Hooks.once("ready", function () {
     });
   }
   
+  // CSS patch for v9
+  if (game.version) {
+    let sidebar = document.getElementById("sidebar");
+    sidebar.style.width = "min-content";
+  }
 
   welcomeMessage();
   DarkStarsUtility.ready()
   DarkStarsCommands.init()
-  ClassCounter.registerUsageCount()
 })
 
 /* -------------------------------------------- */

modules/dark-stars-npc-sheet.js

@@ -11,7 +11,7 @@ export class DarkStarsNPCSheet extends ActorSheet {
   /** @override */
   static get defaultOptions() {
 
-    return foundry.utils.mergeObject(super.defaultOptions, {
+    return mergeObject(super.defaultOptions, {
       classes: ["dark-stars-rpg", "sheet", "actor"],
       template: "systems/fvtt-dark-stars/templates/npc-sheet.hbs",
       width: 640,
@@ -25,7 +25,7 @@ export class DarkStarsNPCSheet extends ActorSheet {
   /* -------------------------------------------- */
   async getData() {
     const objectData = this.object.system
-    let actorData = foundry.utils.duplicate(objectData)
+    let actorData = duplicate(objectData)
 
     let formData = {
       title: this.title,
@@ -38,22 +38,21 @@ export class DarkStarsNPCSheet extends ActorSheet {
       data: actorData,
       limited: this.object.limited,
       skills: this.actor.getSkills( ),
-      weapons: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getWeapons()) ),
+      weapons: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getWeapons()) ),
-      armors: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getArmors())),
+      armors: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getArmors())),
-      shields: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getShields())),
+      shields: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getShields())),
-      spells: this.actor.checkAndPrepareEquipments( foundry.utils.duplicate(this.actor.getLore())),
+      spells: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getLore())),
-      equipments: this.actor.checkAndPrepareEquipments(foundry.utils.duplicate(this.actor.getEquipmentsOnly()) ),
+      equipments: this.actor.checkAndPrepareEquipments(duplicate(this.actor.getEquipmentsOnly()) ),
-      equippedWeapons: this.actor.checkAndPrepareEquipments(foundry.utils.duplicate(this.actor.getEquippedWeapons()) ),
+      equippedWeapons: this.actor.checkAndPrepareEquipments(duplicate(this.actor.getEquippedWeapons()) ),
       equippedArmor: this.actor.getEquippedArmor(),
       equippedShield: this.actor.getEquippedShield(),
-      feats: foundry.utils.duplicate(this.actor.getFeats()),
+      feats: duplicate(this.actor.getFeats()),
-      subActors: foundry.utils.duplicate(this.actor.getSubActors()),
+      subActors: duplicate(this.actor.getSubActors()),
-      race: foundry.utils.duplicate(this.actor.getRace()),
+      race: duplicate(this.actor.getRace()),
-      moneys: foundry.utils.duplicate(this.actor.getMoneys()),
+      moneys: duplicate(this.actor.getMoneys()),
       encCapacity: this.actor.getEncumbranceCapacity(),
       saveRolls: this.actor.getSaveRoll(),
       conditions: this.actor.getConditions(),
-      config: game.system.darkstars.config,
       containersTree: this.actor.containersTree,
       encCurrent: this.actor.encCurrent,
       options: this.options,

modules/dark-stars-roll-dialog.js

@@ -5,8 +5,8 @@ export class DarkStarsRollDialog extends Dialog {
   /* -------------------------------------------- */
   static async create(actor, rollData) {
 
-    let options = { classes: ["DarkStarsDialog"], width: 420, height: 'fit-content', 'z-index': 99999 };
+    let options = { classes: ["DarkStarsDialog"], width: 540, height: 340, 'z-index': 99999 };
-    let html = await renderTemplate('systems/fvtt-dark-stars/templates/apps/roll-dialog-generic.hbs', rollData);
+    let html = await renderTemplate('systems/fvtt-dark-stars/templates/roll-dialog-generic.hbs', rollData);
 
     return new DarkStarsRollDialog(actor, rollData, html, options);
   }
@@ -58,23 +58,27 @@ export class DarkStarsRollDialog extends Dialog {
     }
     $(function () { onLoad(); });
 
-    html.find('#bonusMalus').change((event) => {
+    html.find('#advantage').change((event) => {
-      this.rollData.bonusMalus = Number(event.currentTarget.value)
+      this.rollData.advantage = event.currentTarget.value
     })
-    html.find('#above-effective-range').change((event) => {
+    html.find('#disadvantage').change((event) => {
-      this.rollData.isAboveEffectiveRange = event.currentTarget.checked
+      this.rollData.disadvantage = event.currentTarget.value
     })
-    html.find('#weapon-aiming').change((event) => {
+    html.find('#rollAdvantage').change((event) => {
-      this.rollData.weaponAiming = String(event.currentTarget.value)
+      this.rollData.rollAdvantage = event.currentTarget.value
     })
-    html.find('#synergy-bonus').change((event) => {
+    html.find('#useshield').change((event) => {
-      this.rollData.synergyBonus = Number(event.currentTarget.value)
+      this.rollData.useshield = event.currentTarget.checked
     })
-    html.find('#extra-time').change((event) => {
+    html.find('#hasCover').change((event) => {
-      this.rollData.extraTime = event.currentTarget.checked
+      this.rollData.hasCover = event.currentTarget.value
     })
-    html.find('#attribute-modifier').change((event) => {
+    html.find('#situational').change((event) => {
-      this.rollData.attributeModifier = Number(event.currentTarget.value)
+      this.rollData.situational = event.currentTarget.value
     })
+    html.find('#distanceBonusDice').change((event) => {
+      this.rollData.distanceBonusDice = Number(event.currentTarget.value)
+    })
+    
   }
 }

modules/dark-stars-utility.js

@@ -11,7 +11,9 @@ export class DarkStarsUtility {
   /* -------------------------------------------- */
   static async init() {
     Hooks.on('renderChatLog', (log, html, data) => DarkStarsUtility.chatListeners(html));
-    Hooks.on('renderChatMessage', (message, html, data) => DarkStarsUtility.chatMessageHandler(message, html, data))
+    /*Hooks.on("dropCanvasData", (canvas, data) => {
+      DarkStarsUtility.dropItemOnToken(canvas, data)
+    });*/
 
     DarkStarsCommands.init();
 
@@ -41,28 +43,29 @@ export class DarkStarsUtility {
       return __locationNames[key]
     })
     
+
+    this.gameSettings()
+
   }
 
   /*-------------------------------------------- */
-  static async processOpposed(rollData) {
+  static gameSettings() {
-    if (this.currentOpposition) {
+    /*game.settings.register("fvtt-dark-stars", "dice-color-skill", {
-      let opposed = {
+      name: "Dice color for skills",
-        winner: this.currentOpposition,
+      hint: "Set the dice color for skills",
-        looser: rollData,
+      scope: "world",
-        isOpposed : true
+      config: true,
-      }
+      requiresReload: true ,
-      if (rollData.degrees > this.currentOpposition.degrees ) {
+      default: "#101010",
-        opposed.winner = rollData
+      type: String
-        opposed.looser = this.currentOpposition
+    })
-      }
+
-      let msg = await this.createChatWithRollMode(rollData.alias, {
+    Hooks.on('renderSettingsConfig', (event) => {
-        content: await renderTemplate(`systems/fvtt-dark-stars/templates/chat/chat-opposition-result.hbs`, opposed)
+      const element = event.element[0].querySelector(`[name='fvtt-dark-stars.dice-color-skill']`)
-      })
+      if (!element) return
-      await msg.setFlag("world", "darkstars-roll-data", opposed)
+      // Replace placeholder element
-    } else {
+      console.log("Element Found !!!!")
-      this.currentOpposition = rollData
+    })    */
-      ui.notifications.info("Opposed rolls started with " + rollData.alias );
-    }
   }
 
   /*-------------------------------------------- */
@@ -73,13 +76,27 @@ export class DarkStarsUtility {
 
   /*-------------------------------------------- */
   static getSkills() {
-    return foundry.utils.duplicate(this.skills)
+    return duplicate(this.skills)
+  }
+  /*-------------------------------------------- */
+  static getWeaponSkills() {
+    return duplicate(this.weaponSkills)
+  }
+  /*-------------------------------------------- */
+  static getShieldSkills() {
+    return duplicate(this.shieldSkills)
   }
 
   /* -------------------------------------------- */
   static async ready() {
-    const skills = await DarkStarsUtility.loadCompendium("fvtt-dark-stars.sprawl");
+    const skills = await DarkStarsUtility.loadCompendium("fvtt-dark-stars.skills")
-    this.skills = skills.filter(i => i.type == "skill").map(i => i.toObject());
+    this.skills = skills.map(i => i.toObject())
+    this.weaponSkills = duplicate(this.skills.filter(item => item.system.isweaponskill))
+    this.shieldSkills = duplicate(this.skills.filter(item => item.system.isshieldskill))
+
+    const rollTables = await DarkStarsUtility.loadCompendium("fvtt-dark-stars.rolltables")
+    this.rollTables = rollTables.map(i => i.toObject())
+
   }
 
   /* -------------------------------------------- */
@@ -99,21 +116,24 @@ export class DarkStarsUtility {
   static async chatListeners(html) {
 
     html.on("click", '.view-item-from-chat', event => {
-      game.system.darkstars.creator.openItemView(event)
+      game.system.crucible.creator.openItemView(event)
     })
-    html.on("click", '.chat-reroll', event => {
+    html.on("click", '.roll-defense-melee', event => {
-      let messageId = this.findChatMessageId(event.currentTarget)
+      let rollId = $(event.currentTarget).data("roll-id")
-      let message = game.messages.get(messageId)
+      let rollData = DarkStarsUtility.getRollData(rollId)
-      let rollData = message.getFlag("world", "darkstars-roll-data")
+      rollData.defenseWeaponId = $(event.currentTarget).data("defense-weapon-id")
-      rollData.reroll = true
+      let actor = game.canvas.tokens.get(rollData.defenderTokenId).actor
-      rollData.roll = undefined
+      if (actor && (game.user.isGM || actor.isOwner)) {
-      this.rollDarkStars(rollData)
+        actor.rollDefenseMelee(rollData)
+      }
     })
-    html.on("click", '.chat-roll-opposed', event => {
+    html.on("click", '.roll-defense-ranged', event => {
-      let messageId = this.findChatMessageId(event.currentTarget)
+      let rollId = $(event.currentTarget).data("roll-id")
-      let message = game.messages.get(messageId)
+      let rollData = DarkStarsUtility.getRollData(rollId)
-      let rollData = message.getFlag("world", "darkstars-roll-data")
+      let defender = game.canvas.tokens.get(rollData.defenderTokenId).actor
-      this.processOpposed(rollData)
+      if (defender && (game.user.isGM || defender.isOwner)) {
+        defender.rollDefenseRanged(rollData)
+      }
     })
 
   }
@@ -123,8 +143,10 @@ export class DarkStarsUtility {
 
     const templatePaths = [
       'systems/fvtt-dark-stars/templates/partials/editor-notes-gm.hbs',
+      'systems/fvtt-dark-stars/templates/partials/partial-roll-select.hbs',
       'systems/fvtt-dark-stars/templates/partials/partial-actor-ability-block.hbs',
       'systems/fvtt-dark-stars/templates/partials/partial-actor-status.hbs',
+      'systems/fvtt-dark-stars/templates/partials/partial-options-abilities.hbs',
       'systems/fvtt-dark-stars/templates/partials/partial-item-nav.hbs',
       'systems/fvtt-dark-stars/templates/partials/partial-item-description.hbs',
       'systems/fvtt-dark-stars/templates/partials/partial-actor-equipment.hbs'
@@ -256,141 +278,176 @@ export class DarkStarsUtility {
     }
   }
 
-  /* -------------------------------------------- */
-  static getAimingMalus(location) {
-    if (location == "arm" || location == "head") {
-      return -50
-    }
-    if (location == "torso" || location == "leg") {
-      return -30
-    }
-    if (location == "hand") {
-      return -70
-    }
-    return 0
-  }
-  /* -------------------------------------------- */
-  static getAimingLocation(roll) {
-    if (roll == 1) return "head"
-    if (roll >= 2 && roll <= 4) return "chest"
-    if (roll >= 5 && roll <= 6) return "abdomen"
-    if (roll == 7) return "leftarm"
-    if (roll == 8) return "rightarm"
-    if (roll == 9) return "rightleg"
-    if (roll == 10) return "leftleg"
-    return "abdomen"
-  }
-  /* -------------------------------------------- */
-  static locationMultiplier(location) {
-    if (location == "head") return 0.3
-    if (location.includes("arm")) return 0.2
-    if (location.includes("leg")) return 0.4
-    if (location == "chest") return 0.5
-    return 0.3 // Abdomen case
-  }
-
   /* -------------------------------------------- */
   static async rollDarkStars(rollData) {
 
     let actor = game.actors.get(rollData.actorId)
-    if (rollData.tokenId) {
-      actor = game.canvas.tokens.get(rollData.tokenId).actor
-    }
-
-    // Specific attribute
-    if (rollData.attr) {
-      rollData.isSuccess = false
-      rollData.isFailure = false
-      rollData.targetNumber = Math.max( rollData.attr.value + rollData.attributeModifier, 0)
-      let myRoll = await new Roll("1d10").roll()
-      await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
-      if (myRoll.total <= rollData.targetNumber) {
-        rollData.isSuccess = true
-        rollData.isFailure = false
-      }
-      rollData.roll = foundry.utils.duplicate(myRoll)
-      rollData.diceResult = myRoll.total
-      let msg = await this.createChatWithRollMode(rollData.alias, {
-        content: await renderTemplate(`systems/fvtt-dark-stars/templates/chat/chat-attribute-result.hbs`, rollData)
-      })  
-      msg.setFlag("world", "darkstars-roll-data", rollData)
-      return  
-    }
 
     // ability/save/size => 0
-    rollData.percentValue = 0
+    let diceFormula
+    let startFormula = "0d6cs>=5[blue]"
+    if (rollData.ability) {
+      startFormula = String(rollData.ability.value) + "d6cs>=5[blue]"
+    }
+    if (rollData.save) {
+      startFormula = String(rollData.save.value) + "d6cs>=5[blue]"
+    }
+    if (rollData.sizeDice) {
+      let nb = rollData.sizeDice.nb + rollData.distanceBonusDice + this.getDiceFromCover(rollData.hasCover) + this.getDiceFromSituational(rollData.situational)
+      startFormula = String(nb) + String(rollData.sizeDice.dice) + "cs>=5[blue]"
+    }
+    diceFormula = startFormula
+
+    // skill => 2
+    // feat => 4
+    // bonus => 6
     if (rollData.skill) {
-      rollData.percentValue = rollData.skill.total
+      let level = rollData.skill.system.level
-    }
+      if (rollData.skill.system.issl2) {
-    if (rollData.synergyBonus) {
+        rollData.hasSLBonus = true
-      rollData.percentValue += rollData.synergyBonus
+        level += 2
-    }
+        if (level > 7) { level = 7 }
-    if (rollData.extraTime) {
+      }
-      rollData.percentValue += 30
+      rollData.skill.system.skilldice = __skillLevel2Dice[level]
-    }
+      diceFormula += "+" + String(rollData.skill.system.skilldice) + "cs>=5[black]"
-    rollData.percentValue += rollData.bonusMalus
-    rollData.diceFormula = "1d100"
 
-    if (rollData.isAboveEffectiveRange) {
+      if (rollData.skill.system.skilltype == "complex" && rollData.skill.system.level == 0) {
-      rollData.percentValue -= 30
+        rollData.complexSkillDisadvantage = true
-      rollData.percentValue = Math.max(0, rollData.percentValue)
+        rollData.rollAdvantage = "roll-disadvantage"
+      }
+
+      if (rollData.skill.system.isfeatdie) {
+        rollData.hasFeatDie = true
+        diceFormula += "+ 1d10cs>=5[dark-stars-purple]"
+      } else {
+        diceFormula += `+ 0d10cs>=5[dark-stars-purple]`
+      }
+      if (rollData.skill.system.bonusdice != "none") {
+        rollData.hasBonusDice = rollData.skill.system.bonusdice
+        diceFormula += `+ ${rollData.hasBonusDice}cs>=5[black]`
+      } else {
+        diceFormula += `+ 0d6cs>=5[black]`
+      }
+    } else {
+      diceFormula += `+ 0d8cs=>5 + 0d10cs>=5 + 0d6cs>=5`
     }
 
-    if (rollData.mode == "weapon") {
+    // advantage => 8
-      rollData.locationMalus = this.getAimingMalus(rollData.weaponAiming)
+    let advFormula = "+ 0d8cs>=5"
-      rollData.percentValue += rollData.locationMalus
+    if (rollData.advantage == "advantage1" || rollData.forceAdvantage) {
+      advFormula = "+ 1d8cs>=5[dark-stars-darkgreen]"
+    }
+    if (rollData.advantage == "advantage2") {
+      advFormula = "+ 2d8cs>=5[dark-stars-darkgreen]"
+    }
+    diceFormula += advFormula
+
+    // disadvantage => 10
+    let disFormula = "- 0d8cs>=5"
+    if (rollData.disadvantage == "disadvantage1" || rollData.forceDisadvantage) {
+      disFormula = "- 1d8cs>=5[red]"
+    }
+    if (rollData.disadvantage == "disadvantage2") {
+      disFormula = "- 2d8cs>=5[red]"
+    }
+    diceFormula += disFormula
+
+    // armor => 12
+    let skillArmorPenalty = 0
+    for (let armor of rollData.armors) {
+      if (armor.system.equipped) {
+        skillArmorPenalty += armor.system.skillpenalty
+      }
+    }
+    if (rollData.skill && rollData.skill.system.armorpenalty && skillArmorPenalty > 0) {
+      rollData.skillArmorPenalty = skillArmorPenalty
+      diceFormula += `- ${skillArmorPenalty}d8cs>=5`
+    } else {
+      diceFormula += `- 0d8cs>=5`
+    }
+
+    // shield => 14
+    if (rollData.useshield && rollData.shield) {
+      diceFormula += "+ 1" + String(rollData.shield.system.shielddie) + "cs>=5[yellow]"
+    } else {
+      diceFormula += " + 0d6cs>=5"
     }
-    rollData.percentValue = Math.max(rollData.percentValue, 0)
 
     // Performs roll
+    console.log("Roll formula", diceFormula)
     let myRoll = rollData.roll
     if (!myRoll) { // New rolls only of no rerolls
-      myRoll = await new Roll(rollData.diceFormula).roll()
+      myRoll = new Roll(diceFormula).roll({ async: false })
       await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
     }
-    rollData.roll = foundry.utils.duplicate(myRoll)
+    rollData.rollOrder = 0
-    rollData.diceResult = myRoll.total
+    rollData.roll = myRoll
-    rollData.isCriticalSuccess = rollData.diceResult <= rollData.skill.derivated.value
+    rollData.nbSuccess = myRoll.total
-    rollData.isCriticalFailure = rollData.diceResult == 100
-    rollData.isSuccess = rollData.diceResult == 1 || rollData.diceResult <= rollData.percentValue
-    rollData.isFailure = rollData.diceResult == 100 || rollData.diceResult > rollData.percentValue
-    rollData.degrees = Math.floor((rollData.percentValue - rollData.diceResult) / 10)
-    rollData.damageMultiplier = rollData.isCriticalSuccess ? 2 : 1
 
-    if (rollData.reroll) {
+    if (rollData.rollAdvantage == "none" && rollData.forceRollAdvantage) {
-      actor.modifyRerolls(-1)
+      rollData.rollAdvantage = "roll-advantage"
-      rollData.rerolls = 0 // DIsable rerolls
     }
+    if (rollData.rollAdvantage == "none" && rollData.forceRollDisadvantage) {
+      rollData.rollAdvantage = "roll-disadvantage"
+    }
+    if (rollData.rollAdvantage != "none") {
 
-    if (rollData.mode == "weapon") {
+      rollData.rollOrder = 1
-      if (rollData.weaponAiming == "none") {
+      rollData.rollType = (rollData.rollAdvantage == "roll-advantage") ? "Advantage" : "Disadvantage"
-        let rollLoc = new Roll("1d10").roll({ async: false })
+      this.createChatWithRollMode(rollData.alias, {
-        rollData.weaponAiming = this.getAimingLocation(rollLoc.total)
+        content: await renderTemplate(`systems/fvtt-dark-stars/templates/chat-generic-result.hbs`, rollData)
+      })
+
+      rollData.rollOrder = 2
+      let myRoll2 = new Roll(diceFormula).roll({ async: false })
+      await this.showDiceSoNice(myRoll2, game.settings.get("core", "rollMode"))
+
+      rollData.roll = myRoll2 // Tmp switch to display the proper results
+      rollData.nbSuccess = myRoll2.total
+      this.createChatWithRollMode(rollData.alias, {
+        content: await renderTemplate(`systems/fvtt-dark-stars/templates/chat-generic-result.hbs`, rollData)
+      })
+      rollData.roll = myRoll // Revert the tmp switch
+      rollData.nbSuccess = myRoll.total
+
+      if (rollData.rollAdvantage == "roll-advantage") {
+        if (myRoll2.total > rollData.nbSuccess) {
+          hasChanged = true
+          rollData.roll = myRoll2
+          rollData.nbSuccess = myRoll2.total
+        }
+      } else {
+        if (myRoll2.total < rollData.nbSuccess) {
+          rollData.roll = myRoll2
+          rollData.nbSuccess = myRoll2.total
+        }
       }
-      // Compute
+      rollData.rollOrder = 3
-      rollData.locationMultiplier = this.locationMultiplier(rollData.weaponAiming)
     }
+    rollData.nbSuccess = Math.max(0, rollData.nbSuccess)
 
-    // Task management
+    rollData.isFirstRollAdvantage = false
-    if (rollData.taskId) {
+    // Manage exp
-      let task = actor.getItem(rollData.taskId)
+    if (rollData.skill && rollData.skill.system.level > 0) {
-      console.log(" Task", task, rollData.taskId)
+      let nbSkillSuccess = rollData.roll.terms[2].total
-      if (task) {
+      if (nbSkillSuccess == 0 || nbSkillSuccess == rollData.skill.system.level) {
-        let newCumulated = rollData.degrees + task.system.cumulated
+        actor.incrementSkillExp(rollData.skill.id, 1)
-        let nbrolls = task.system.nbrolls + 1
-        task.update({ 'system.cumulated': newCumulated, 'system.nbrolls': nbrolls })
-        rollData.taskName = task.name
-        rollData.taskCumulated = newCumulated
-        rollData.taskNbrolls = nbrolls
       }
     }
 
-    let msg = await this.createChatWithRollMode(rollData.alias, {
+    this.saveRollData(rollData)
-      content: await renderTemplate(`systems/fvtt-dark-stars/templates/chat/chat-generic-result.hbs`, rollData)
+    actor.lastRoll = rollData
+
+    this.createChatWithRollMode(rollData.alias, {
+      content: await renderTemplate(`systems/fvtt-dark-stars/templates/chat-generic-result.hbs`, rollData)
     })
-
     console.log("Rolldata result", rollData)
-    msg.setFlag("world", "darkstars-roll-data", rollData)
+
+    // Message response
+    this.displayDefenseMessage(rollData)
+
+    // Manage defense result
+    this.processAttackDefense(rollData)
   }
 
   /* -------------------------------------------- */
@@ -412,19 +469,6 @@ export class DarkStarsUtility {
   static getUsers(filter) {
     return game.users.filter(filter).map(user => user.id);
   }
-  /* -------------------------------------------- */
-  static async chatMessageHandler(message, html, data) {
-    const chatCard = html.find('.gm-actions')
-    if (chatCard.length > 0) {
-      // If the user is the message author or the actor owner, proceed
-      const actor = game.actors.get(data.message.speaker.actor)
-      if (actor?.isOwner) return
-      else if (game.user.isGM || data.author.id === game.user.id) return
-      const divButtons = chatCard.find('.gm-actions')
-      divButtons.hide()
-    }
-  }
-
   /* -------------------------------------------- */
   static getWhisperRecipients(rollMode, name) {
     switch (rollMode) {
@@ -442,7 +486,7 @@ export class DarkStarsUtility {
 
   /* -------------------------------------------- */
   static blindMessageToGM(chatOptions) {
-    let chatGM = foundry.utils.duplicate(chatOptions);
+    let chatGM = duplicate(chatOptions);
     chatGM.whisper = this.getUsers(user => user.isGM);
     chatGM.content = "Blinde message of " + game.user.name + "<br>" + chatOptions.content;
     console.log("blindMessageToGM", chatGM);
@@ -497,21 +541,15 @@ export class DarkStarsUtility {
         break;
     }
     chatOptions.alias = chatOptions.alias || name;
-    return ChatMessage.create(chatOptions);
+    ChatMessage.create(chatOptions);
   }
 
   /* -------------------------------------------- */
   static getBasicRollData() {
     let rollData = {
-      rollId: foundry.utils.randomID(16),
+      rollId: randomID(16),
       rollMode: game.settings.get("core", "rollMode"),
-      bonusMalus: 0,
+      advantage: "none"
-      isAboveEffectiveRange: false,
-      weaponAiming: "none",
-      synergyBonus: 0,
-      extraTime: false,
-      attributeModifier: 0,
-      config: game.system.darkstars.config,
     }
     DarkStarsUtility.updateWithTarget(rollData)
     return rollData
@@ -527,7 +565,7 @@ export class DarkStarsUtility {
 
   /* -------------------------------------------- */
   static createChatWithRollMode(name, chatOptions) {
-    return this.createChatMessage(name, game.settings.get("core", "rollMode"), chatOptions)
+    this.createChatMessage(name, game.settings.get("core", "rollMode"), chatOptions)
   }
 
   /* -------------------------------------------- */

packs/.directory

@@ -1,6 +0,0 @@
-[Dolphin]
-HeaderColumnWidths=301,118,148,122
-Timestamp=2024,1,26,8,35,29.906
-Version=4
-ViewMode=1
-VisibleRoles=Details_text,Details_size,Details_modificationtime,Details_creationtime,CustomizedDetails

packs/aldebaran/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000208

packs/aldebaran/LOG

@@ -1,7 +0,0 @@
-2024/06/12-11:13:40.413261 7f3f0d6006c0 Recovering log #206
-2024/06/12-11:13:40.424230 7f3f0d6006c0 Delete type=3 #204
-2024/06/12-11:13:40.424287 7f3f0d6006c0 Delete type=0 #206
-2024/06/12-11:16:23.489560 7f3f060006c0 Level-0 table #211: started
-2024/06/12-11:16:23.489605 7f3f060006c0 Level-0 table #211: 0 bytes OK
-2024/06/12-11:16:23.520840 7f3f060006c0 Delete type=0 #209
-2024/06/12-11:16:23.590686 7f3f060006c0 Manual compaction at level-0 from '!folders!MA6uFJMVebGeayIk' @ 72057594037927935 : 1 .. '!items!zhjdppKgrON7wJn7' @ 0 : 0; will stop at (end)

packs/aldebaran/LOG.old

@@ -1,7 +0,0 @@
-2024/06/12-11:13:16.247740 7f3f0ea006c0 Recovering log #202
-2024/06/12-11:13:16.258091 7f3f0ea006c0 Delete type=3 #200
-2024/06/12-11:13:16.258153 7f3f0ea006c0 Delete type=0 #202
-2024/06/12-11:13:34.719686 7f3f060006c0 Level-0 table #207: started
-2024/06/12-11:13:34.719708 7f3f060006c0 Level-0 table #207: 0 bytes OK
-2024/06/12-11:13:34.726803 7f3f060006c0 Delete type=0 #205
-2024/06/12-11:13:34.733250 7f3f060006c0 Manual compaction at level-0 from '!folders!MA6uFJMVebGeayIk' @ 72057594037927935 : 1 .. '!items!zhjdppKgrON7wJn7' @ 0 : 0; will stop at (end)

packs/armor/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000199

packs/armor/LOG

@@ -1,8 +0,0 @@
-2024/02/25-13:11:04.806524 7f0422a006c0 Recovering log #197
-2024/02/25-13:11:04.817703 7f0422a006c0 Delete type=3 #195
-2024/02/25-13:11:04.817799 7f0422a006c0 Delete type=0 #197
-2024/02/25-13:14:07.532693 7f0421a006c0 Level-0 table #202: started
-2024/02/25-13:14:07.532731 7f0421a006c0 Level-0 table #202: 0 bytes OK
-2024/02/25-13:14:07.539153 7f0421a006c0 Delete type=0 #200
-2024/02/25-13:14:07.539281 7f0421a006c0 Manual compaction at level-0 from '!items!0JWjCJaD6OOouqTj' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)
-2024/02/25-13:14:07.539306 7f0421a006c0 Manual compaction at level-1 from '!items!0JWjCJaD6OOouqTj' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)

packs/armor/LOG.old

@@ -1,8 +0,0 @@
-2024/02/25-13:04:05.224949 7f0428e006c0 Recovering log #193
-2024/02/25-13:04:05.236046 7f0428e006c0 Delete type=3 #191
-2024/02/25-13:04:05.236134 7f0428e006c0 Delete type=0 #193
-2024/02/25-13:10:09.480522 7f0421a006c0 Level-0 table #198: started
-2024/02/25-13:10:09.480555 7f0421a006c0 Level-0 table #198: 0 bytes OK
-2024/02/25-13:10:09.486678 7f0421a006c0 Delete type=0 #196
-2024/02/25-13:10:09.493365 7f0421a006c0 Manual compaction at level-0 from '!items!0JWjCJaD6OOouqTj' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)
-2024/02/25-13:10:09.499939 7f0421a006c0 Manual compaction at level-1 from '!items!0JWjCJaD6OOouqTj' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)

packs/beyondtheblacksea/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000201

packs/beyondtheblacksea/LOG

@@ -1,7 +0,0 @@
-2024/06/12-11:13:40.426654 7f3f0ea006c0 Recovering log #199
-2024/06/12-11:13:40.437435 7f3f0ea006c0 Delete type=3 #197
-2024/06/12-11:13:40.437506 7f3f0ea006c0 Delete type=0 #199
-2024/06/12-11:16:23.521086 7f3f060006c0 Level-0 table #204: started
-2024/06/12-11:16:23.521151 7f3f060006c0 Level-0 table #204: 0 bytes OK
-2024/06/12-11:16:23.553911 7f3f060006c0 Delete type=0 #202
-2024/06/12-11:16:23.590700 7f3f060006c0 Manual compaction at level-0 from '!folders!47aGmBuk1mHtbFFU' @ 72057594037927935 : 1 .. '!items!zwMpjsE84sk26eej' @ 0 : 0; will stop at (end)

packs/beyondtheblacksea/LOG.old

@@ -1,7 +0,0 @@
-2024/06/12-11:13:16.262812 7f3f0d6006c0 Recovering log #195
-2024/06/12-11:13:16.272606 7f3f0d6006c0 Delete type=3 #193
-2024/06/12-11:13:16.272662 7f3f0d6006c0 Delete type=0 #195
-2024/06/12-11:13:34.727044 7f3f060006c0 Level-0 table #200: started
-2024/06/12-11:13:34.727098 7f3f060006c0 Level-0 table #200: 0 bytes OK
-2024/06/12-11:13:34.733076 7f3f060006c0 Delete type=0 #198
-2024/06/12-11:13:34.733265 7f3f060006c0 Manual compaction at level-0 from '!folders!47aGmBuk1mHtbFFU' @ 72057594037927935 : 1 .. '!items!zwMpjsE84sk26eej' @ 0 : 0; will stop at (end)

packs/conditions/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000254

packs/conditions/LOG

@@ -1,7 +0,0 @@
-2024/06/12-11:13:40.356313 7f3f0d6006c0 Recovering log #252
-2024/06/12-11:13:40.366003 7f3f0d6006c0 Delete type=3 #250
-2024/06/12-11:13:40.366126 7f3f0d6006c0 Delete type=0 #252
-2024/06/12-11:16:23.317811 7f3f060006c0 Level-0 table #257: started
-2024/06/12-11:16:23.317841 7f3f060006c0 Level-0 table #257: 0 bytes OK
-2024/06/12-11:16:23.355645 7f3f060006c0 Delete type=0 #255
-2024/06/12-11:16:23.460439 7f3f060006c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/conditions/LOG.old

@@ -1,7 +0,0 @@
-2024/06/12-11:13:16.189039 7f3f0ea006c0 Recovering log #248
-2024/06/12-11:13:16.200829 7f3f0ea006c0 Delete type=3 #246
-2024/06/12-11:13:16.200927 7f3f0ea006c0 Delete type=0 #248
-2024/06/12-11:13:34.657802 7f3f060006c0 Level-0 table #253: started
-2024/06/12-11:13:34.657837 7f3f060006c0 Level-0 table #253: 0 bytes OK
-2024/06/12-11:13:34.663971 7f3f060006c0 Delete type=0 #251
-2024/06/12-11:13:34.681143 7f3f060006c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/currency/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000254

packs/currency/LOG

@@ -1,7 +0,0 @@
-2024/06/12-11:13:40.368093 7f3f0ea006c0 Recovering log #252
-2024/06/12-11:13:40.379978 7f3f0ea006c0 Delete type=3 #250
-2024/06/12-11:13:40.380078 7f3f0ea006c0 Delete type=0 #252
-2024/06/12-11:16:23.408873 7f3f060006c0 Level-0 table #257: started
-2024/06/12-11:16:23.408929 7f3f060006c0 Level-0 table #257: 0 bytes OK
-2024/06/12-11:16:23.460072 7f3f060006c0 Delete type=0 #255
-2024/06/12-11:16:23.460493 7f3f060006c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/currency/LOG.old

@@ -1,7 +0,0 @@
-2024/06/12-11:13:16.204139 7f3f0d6006c0 Recovering log #248
-2024/06/12-11:13:16.215399 7f3f0d6006c0 Delete type=3 #246
-2024/06/12-11:13:16.215490 7f3f0d6006c0 Delete type=0 #248
-2024/06/12-11:13:34.692534 7f3f060006c0 Level-0 table #253: started
-2024/06/12-11:13:34.692577 7f3f060006c0 Level-0 table #253: 0 bytes OK
-2024/06/12-11:13:34.698872 7f3f060006c0 Delete type=0 #251
-2024/06/12-11:13:34.713306 7f3f060006c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/cybernetics/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000128

packs/cybernetics/LOG

@@ -1,8 +0,0 @@
-2024/02/25-13:11:04.911848 7f0422a006c0 Recovering log #126
-2024/02/25-13:11:04.922320 7f0422a006c0 Delete type=3 #124
-2024/02/25-13:11:04.922392 7f0422a006c0 Delete type=0 #126
-2024/02/25-13:14:07.578457 7f0421a006c0 Level-0 table #131: started
-2024/02/25-13:14:07.578513 7f0421a006c0 Level-0 table #131: 0 bytes OK
-2024/02/25-13:14:07.585654 7f0421a006c0 Delete type=0 #129
-2024/02/25-13:14:07.592632 7f0421a006c0 Manual compaction at level-0 from '!items!0SbSmYdxJSlcNr6x' @ 72057594037927935 : 1 .. '!items!yyCPVVl8vmMOfPcN' @ 0 : 0; will stop at (end)
-2024/02/25-13:14:07.592676 7f0421a006c0 Manual compaction at level-1 from '!items!0SbSmYdxJSlcNr6x' @ 72057594037927935 : 1 .. '!items!yyCPVVl8vmMOfPcN' @ 0 : 0; will stop at (end)

packs/cybernetics/LOG.old

@@ -1,8 +0,0 @@
-2024/02/25-13:04:05.332283 7f0428e006c0 Recovering log #122
-2024/02/25-13:04:05.343337 7f0428e006c0 Delete type=3 #120
-2024/02/25-13:04:05.343387 7f0428e006c0 Delete type=0 #122
-2024/02/25-13:10:09.539934 7f0421a006c0 Level-0 table #127: started
-2024/02/25-13:10:09.539956 7f0421a006c0 Level-0 table #127: 0 bytes OK
-2024/02/25-13:10:09.546327 7f0421a006c0 Delete type=0 #125
-2024/02/25-13:10:09.552649 7f0421a006c0 Manual compaction at level-0 from '!items!0SbSmYdxJSlcNr6x' @ 72057594037927935 : 1 .. '!items!yyCPVVl8vmMOfPcN' @ 0 : 0; will stop at (end)
-2024/02/25-13:10:09.552755 7f0421a006c0 Manual compaction at level-1 from '!items!0SbSmYdxJSlcNr6x' @ 72057594037927935 : 1 .. '!items!yyCPVVl8vmMOfPcN' @ 0 : 0; will stop at (end)

packs/darkstars-sf/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000066

packs/darkstars-sf/LOG

@@ -1,8 +0,0 @@
-2024/06/12-11:13:40.398008 7f3f0d6006c0 Recovering log #64
-2024/06/12-11:13:40.408278 7f3f0d6006c0 Delete type=3 #62
-2024/06/12-11:13:40.408353 7f3f0d6006c0 Delete type=0 #64
-2024/06/12-11:16:23.554104 7f3f060006c0 Level-0 table #69: started
-2024/06/12-11:16:23.554144 7f3f060006c0 Level-0 table #69: 0 bytes OK
-2024/06/12-11:16:23.590465 7f3f060006c0 Delete type=0 #67
-2024/06/12-11:16:23.590737 7f3f060006c0 Manual compaction at level-0 from '!folders!La3YsNYFddQnmsba' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)
-2024/06/12-11:16:23.590756 7f3f060006c0 Manual compaction at level-1 from '!folders!La3YsNYFddQnmsba' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)

packs/darkstars-sf/LOG.old

@@ -1,8 +0,0 @@
-2024/06/12-11:13:16.233304 7f3f0ea006c0 Recovering log #60
-2024/06/12-11:13:16.243341 7f3f0ea006c0 Delete type=3 #58
-2024/06/12-11:13:16.243395 7f3f0ea006c0 Delete type=0 #60
-2024/06/12-11:13:34.713340 7f3f060006c0 Level-0 table #65: started
-2024/06/12-11:13:34.713379 7f3f060006c0 Level-0 table #65: 0 bytes OK
-2024/06/12-11:13:34.719558 7f3f060006c0 Delete type=0 #63
-2024/06/12-11:13:34.733213 7f3f060006c0 Manual compaction at level-0 from '!folders!La3YsNYFddQnmsba' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)
-2024/06/12-11:13:34.733290 7f3f060006c0 Manual compaction at level-1 from '!folders!La3YsNYFddQnmsba' @ 72057594037927935 : 1 .. '!items!zzDfuUJpQzzz262R' @ 0 : 0; will stop at (end)

packs/equipment/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000199

packs/equipment/LOG

@@ -1,8 +0,0 @@
-2024/02/25-13:11:04.819236 7f0428e006c0 Recovering log #197
-2024/02/25-13:11:04.829162 7f0428e006c0 Delete type=3 #195
-2024/02/25-13:11:04.829232 7f0428e006c0 Delete type=0 #197
-2024/02/25-13:14:07.545758 7f0421a006c0 Level-0 table #202: started
-2024/02/25-13:14:07.545813 7f0421a006c0 Level-0 table #202: 0 bytes OK
-2024/02/25-13:14:07.552067 7f0421a006c0 Delete type=0 #200
-2024/02/25-13:14:07.565492 7f0421a006c0 Manual compaction at level-0 from '!items!05RVU3UcRabogEvL' @ 72057594037927935 : 1 .. '!items!zaxcUsWUZ1vvl0p8' @ 0 : 0; will stop at (end)
-2024/02/25-13:14:07.565529 7f0421a006c0 Manual compaction at level-1 from '!items!05RVU3UcRabogEvL' @ 72057594037927935 : 1 .. '!items!zaxcUsWUZ1vvl0p8' @ 0 : 0; will stop at (end)

packs/equipment/LOG.old

@@ -1,8 +0,0 @@
-2024/02/25-13:04:05.239972 7f0423e006c0 Recovering log #193
-2024/02/25-13:04:05.249512 7f0423e006c0 Delete type=3 #191
-2024/02/25-13:04:05.249560 7f0423e006c0 Delete type=0 #193
-2024/02/25-13:10:09.473431 7f0421a006c0 Level-0 table #198: started
-2024/02/25-13:10:09.473459 7f0421a006c0 Level-0 table #198: 0 bytes OK
-2024/02/25-13:10:09.480345 7f0421a006c0 Delete type=0 #196
-2024/02/25-13:10:09.493344 7f0421a006c0 Manual compaction at level-0 from '!items!05RVU3UcRabogEvL' @ 72057594037927935 : 1 .. '!items!zaxcUsWUZ1vvl0p8' @ 0 : 0; will stop at (end)
-2024/02/25-13:10:09.499930 7f0421a006c0 Manual compaction at level-1 from '!items!05RVU3UcRabogEvL' @ 72057594037927935 : 1 .. '!items!zaxcUsWUZ1vvl0p8' @ 0 : 0; will stop at (end)

packs/genetics/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000075

packs/genetics/LOG

@@ -1,8 +0,0 @@
-2024/02/25-13:11:04.925036 7f0428e006c0 Recovering log #73
-2024/02/25-13:11:04.935090 7f0428e006c0 Delete type=3 #71
-2024/02/25-13:11:04.935353 7f0428e006c0 Delete type=0 #73
-2024/02/25-13:14:07.585843 7f0421a006c0 Level-0 table #78: started
-2024/02/25-13:14:07.585896 7f0421a006c0 Level-0 table #78: 0 bytes OK
-2024/02/25-13:14:07.592513 7f0421a006c0 Delete type=0 #76
-2024/02/25-13:14:07.592640 7f0421a006c0 Manual compaction at level-0 from '!items!56A3sVsiN7KI6a45' @ 72057594037927935 : 1 .. '!items!zJiASbV3QqH2oHb1' @ 0 : 0; will stop at (end)
-2024/02/25-13:14:07.592670 7f0421a006c0 Manual compaction at level-1 from '!items!56A3sVsiN7KI6a45' @ 72057594037927935 : 1 .. '!items!zJiASbV3QqH2oHb1' @ 0 : 0; will stop at (end)

packs/genetics/LOG.old

@@ -1,8 +0,0 @@
-2024/02/25-13:04:05.347457 7f0423e006c0 Recovering log #69
-2024/02/25-13:04:05.356885 7f0423e006c0 Delete type=3 #67
-2024/02/25-13:04:05.356934 7f0423e006c0 Delete type=0 #69
-2024/02/25-13:10:09.533502 7f0421a006c0 Level-0 table #74: started
-2024/02/25-13:10:09.533526 7f0421a006c0 Level-0 table #74: 0 bytes OK
-2024/02/25-13:10:09.539823 7f0421a006c0 Delete type=0 #72
-2024/02/25-13:10:09.552630 7f0421a006c0 Manual compaction at level-0 from '!items!56A3sVsiN7KI6a45' @ 72057594037927935 : 1 .. '!items!zJiASbV3QqH2oHb1' @ 0 : 0; will stop at (end)
-2024/02/25-13:10:09.552738 7f0421a006c0 Manual compaction at level-1 from '!items!56A3sVsiN7KI6a45' @ 72057594037927935 : 1 .. '!items!zJiASbV3QqH2oHb1' @ 0 : 0; will stop at (end)

packs/nightborough/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000221

packs/nightborough/LOG

@@ -1,7 +0,0 @@
-2024/06/12-11:13:40.440639 7f3f0d6006c0 Recovering log #219
-2024/06/12-11:13:40.450523 7f3f0d6006c0 Delete type=3 #217
-2024/06/12-11:13:40.450593 7f3f0d6006c0 Delete type=0 #219
-2024/06/12-11:16:23.645974 7f3f060006c0 Level-0 table #224: started
-2024/06/12-11:16:23.646004 7f3f060006c0 Level-0 table #224: 0 bytes OK
-2024/06/12-11:16:23.683161 7f3f060006c0 Delete type=0 #222
-2024/06/12-11:16:23.683408 7f3f060006c0 Manual compaction at level-0 from '!folders!2iZtDz80npHPIwkS' @ 72057594037927935 : 1 .. '!items!zyFR9C1jBTeFzbxg' @ 0 : 0; will stop at (end)

packs/nightborough/LOG.old

@@ -1,7 +0,0 @@
-2024/06/12-11:13:16.276335 7f3f0ea006c0 Recovering log #215
-2024/06/12-11:13:16.287074 7f3f0ea006c0 Delete type=3 #213
-2024/06/12-11:13:16.287130 7f3f0ea006c0 Delete type=0 #215
-2024/06/12-11:13:34.733411 7f3f060006c0 Level-0 table #220: started
-2024/06/12-11:13:34.733492 7f3f060006c0 Level-0 table #220: 0 bytes OK
-2024/06/12-11:13:34.741601 7f3f060006c0 Delete type=0 #218
-2024/06/12-11:13:34.741825 7f3f060006c0 Manual compaction at level-0 from '!folders!2iZtDz80npHPIwkS' @ 72057594037927935 : 1 .. '!items!zyFR9C1jBTeFzbxg' @ 0 : 0; will stop at (end)

packs/perks/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000199

packs/perks/LOG

@@ -1,8 +0,0 @@
-2024/02/25-13:11:04.899830 7f0428e006c0 Recovering log #197
-2024/02/25-13:11:04.909890 7f0428e006c0 Delete type=3 #195
-2024/02/25-13:11:04.909976 7f0428e006c0 Delete type=0 #197
-2024/02/25-13:14:07.614576 7f0421a006c0 Level-0 table #202: started
-2024/02/25-13:14:07.614602 7f0421a006c0 Level-0 table #202: 0 bytes OK
-2024/02/25-13:14:07.621467 7f0421a006c0 Delete type=0 #200
-2024/02/25-13:14:07.628014 7f0421a006c0 Manual compaction at level-0 from '!items!0K3CVEKsq67oKiYE' @ 72057594037927935 : 1 .. '!items!zwZoHMkWYtMCNx9f' @ 0 : 0; will stop at (end)
-2024/02/25-13:14:07.628055 7f0421a006c0 Manual compaction at level-1 from '!items!0K3CVEKsq67oKiYE' @ 72057594037927935 : 1 .. '!items!zwZoHMkWYtMCNx9f' @ 0 : 0; will stop at (end)

packs/perks/LOG.old

@@ -1,8 +0,0 @@
-2024/02/25-13:04:05.318599 7f0423e006c0 Recovering log #193
-2024/02/25-13:04:05.328529 7f0423e006c0 Delete type=3 #191
-2024/02/25-13:04:05.328597 7f0423e006c0 Delete type=0 #193
-2024/02/25-13:10:09.519595 7f0421a006c0 Level-0 table #198: started
-2024/02/25-13:10:09.519645 7f0421a006c0 Level-0 table #198: 0 bytes OK
-2024/02/25-13:10:09.526863 7f0421a006c0 Delete type=0 #196
-2024/02/25-13:10:09.527031 7f0421a006c0 Manual compaction at level-0 from '!items!0K3CVEKsq67oKiYE' @ 72057594037927935 : 1 .. '!items!zwZoHMkWYtMCNx9f' @ 0 : 0; will stop at (end)
-2024/02/25-13:10:09.527062 7f0421a006c0 Manual compaction at level-1 from '!items!0K3CVEKsq67oKiYE' @ 72057594037927935 : 1 .. '!items!zwZoHMkWYtMCNx9f' @ 0 : 0; will stop at (end)

packs/shields/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000198

packs/shields/LOG

@@ -1,7 +0,0 @@
-2024/02/25-13:11:04.832847 7f0422a006c0 Recovering log #196
-2024/02/25-13:11:04.844534 7f0422a006c0 Delete type=3 #194
-2024/02/25-13:11:04.844584 7f0422a006c0 Delete type=0 #196
-2024/02/25-13:14:07.539362 7f0421a006c0 Level-0 table #201: started
-2024/02/25-13:14:07.539386 7f0421a006c0 Level-0 table #201: 0 bytes OK
-2024/02/25-13:14:07.545589 7f0421a006c0 Delete type=0 #199
-2024/02/25-13:14:07.565459 7f0421a006c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/shields/LOG.old

@@ -1,7 +0,0 @@
-2024/02/25-13:04:05.255291 7f0428e006c0 Recovering log #192
-2024/02/25-13:04:05.265834 7f0428e006c0 Delete type=3 #190
-2024/02/25-13:04:05.265885 7f0428e006c0 Delete type=0 #192
-2024/02/25-13:10:09.486767 7f0421a006c0 Level-0 table #197: started
-2024/02/25-13:10:09.486786 7f0421a006c0 Level-0 table #197: 0 bytes OK
-2024/02/25-13:10:09.493210 7f0421a006c0 Delete type=0 #195
-2024/02/25-13:10:09.499919 7f0421a006c0 Manual compaction at level-0 from 'undefined' @ 72057594037927935 : 1 .. 'undefined' @ 0 : 0; will stop at (end)

packs/skills/CURRENT

@@ -1 +0,0 @@
-MANIFEST-000199

packs/skills/LOG

@@ -1,8 +0,0 @@
-2024/02/25-13:11:04.885568 7f0422a006c0 Recovering log #197
-2024/02/25-13:11:04.896289 7f0422a006c0 Delete type=3 #195
-2024/02/25-13:11:04.896428 7f0422a006c0 Delete type=0 #197
-2024/02/25-13:14:07.572202 7f0421a006c0 Level-0 table #202: started
-2024/02/25-13:14:07.572243 7f0421a006c0 Level-0 table #202: 0 bytes OK
-2024/02/25-13:14:07.578291 7f0421a006c0 Delete type=0 #200
-2024/02/25-13:14:07.592622 7f0421a006c0 Manual compaction at level-0 from '!items!5YJWuGaagmi1dgbv' @ 72057594037927935 : 1 .. '!items!z3j0TW0hqigz6UP5' @ 0 : 0; will stop at (end)
-2024/02/25-13:14:07.592664 7f0421a006c0 Manual compaction at level-1 from '!items!5YJWuGaagmi1dgbv' @ 72057594037927935 : 1 .. '!items!z3j0TW0hqigz6UP5' @ 0 : 0; will stop at (end)

packs/skills/LOG.old

@@ -1,8 +0,0 @@
-2024/02/25-13:04:05.306405 7f0428e006c0 Recovering log #193
-2024/02/25-13:04:05.315767 7f0428e006c0 Delete type=3 #191
-2024/02/25-13:04:05.315959 7f0428e006c0 Delete type=0 #193
-2024/02/25-13:10:09.513533 7f0421a006c0 Level-0 table #198: started
-2024/02/25-13:10:09.513561 7f0421a006c0 Level-0 table #198: 0 bytes OK
-2024/02/25-13:10:09.519495 7f0421a006c0 Delete type=0 #196
-2024/02/25-13:10:09.527015 7f0421a006c0 Manual compaction at level-0 from '!items!5YJWuGaagmi1dgbv' @ 72057594037927935 : 1 .. '!items!z3j0TW0hqigz6UP5' @ 0 : 0; will stop at (end)
-2024/02/25-13:10:09.527047 7f0421a006c0 Manual compaction at level-1 from '!items!5YJWuGaagmi1dgbv' @ 72057594037927935 : 1 .. '!items!z3j0TW0hqigz6UP5' @ 0 : 0; will stop at (end)