out_custom.dat

<?xml version="1.0" encoding="UTF-8"?>

<!-- This file contains the definition of the custom XML output for the
      game system. The statblock is defined as a dossier and then uses an assortment
      of procedures to orchestrate the synthesis of the xml file.

      CRITICAL NOTE! If your game system allows minions to be created (i.e.
        heroes which are children of heroes), you MUST include custom output
        that outputs images and minions. Without that, the images for minions
        will not be generated properly for the public index.
        (Images are generated automatically for top-level heroes in the public
        index, just not for minions, so if your game doesn't use minions you
        don't need to worry about this.)
-->

<document signature="Hero Lab Data">


  <!-- Procedure xoname
        Get the character's name, using a suitable default if unnamed. The name is
        placed in the "name" text variable.

        Outbound parameter: name
  -->
  <procedure id="xoname" scripttype="dossierxml"><![CDATA[
    var name as string
    if (empty(hero.actorname) = 0) then
      name = hero.actorname
    else
      name = "Unnamed Character"
      endif
    ]]></procedure>


  <!-- Procedure xodescript
        Add the specified text as a child description node, to avoid problems
        with "mixed mode" (i.e. pcdata and elements under a node).
  -->
  <procedure id="xodescript" scripttype="dossierxml"><![CDATA[
    var node as number
    var xodescript as string

    var child as number
    child = xml[node].addchild["description"]
    xml[child].text = xodescript
    ]]></procedure>


  <!-- Procedure xotraits
        Output all of the traits that satisfy the provided tag expression, reporting
        the name and final value for each. The "tagexpr" text variable specifies the
        constraints that must be satisfied for the list of traits. The "parentnode"
        numeric variable is the node under which to add the attributes. The
        "nodename" text variable is the name of the node to create.

        Inbound parameter:  tagexpr, nodename, parentnode
  -->
  <procedure id="xotraits" scripttype="dossierxml"><![CDATA[
    var tagexpr as string
    var nodename as string
    var parentnode as number

    var node as number
    var xodescript as string

    foreach pick in hero where tagexpr sortas explicit
      node = xml[parentnode].addchild[nodename]
      xml[node].attr["name"] = eachpick.field[name].text
      xml[node].attr["value"] = eachpick.field[abiFinal].text
      xodescript = eachpick.field[descript].text
      call xodescript

      if (eachpick.tagis[thing.user_added] = 0) then
        xml[node].attr["useradded"] = "no"
        endif
      nexteach
    ]]></procedure>


  <!-- Procedure xogrbasics
        Output basic details for the gear that is the focus pick.
  -->
  <procedure id="xogrbasics" scripttype="dossierxml"><![CDATA[
    var node as number

    doneif (state.isfocus = 0)

    var child as number
    var xodescript as string

    if (focus.tagis[thing.user_added] = 0) then
      xml[node].attr["useradded"] = "no"
      endif

    if (focus.tagis[component.Gear] <> 0) then
      child = xml[node].addchild["weight"]
      xml[child].attr["text"] = focus.field[gearWeight].text
      xml[child].attr["value"] = focus.field[gearWeight].value

      child = xml[node].addchild["cost"]
      xml[child].attr["text"] = focus.field[grCost].text
      xml[child].attr["value"] = focus.field[grCost].value
      endif

    if (focus.stackable <> 0) then
      xml[node].attr["quantity"] = focus.field[stackQty].text
      endif

    xodescript = focus.field[descript].text
    call xodescript
    ]]></procedure>


  <!-- Procedure xoweapons
        Output all of the weapons possessed by the character, listing equipped
        weapons first and including attack values, damage, and ranges for eachpick.
  -->
  <procedure id="xoweapons" scripttype="dossierxml"><![CDATA[
    var parentnode as number
    var node as number

    parentnode = xmlroot.addchild["attacks"]

    ~output a list of all weapons (equipped first)
    foreach pick in hero from WeaponBase sortas Armory
      node = xml[parentnode].addchild["attack"]

      xml[node].attr["name"] = eachpick.field[name].text
      xml[node].attr["attack"] = eachpick.field[wpNetAtk].text
      xml[node].attr["damage"] = eachpick.field[wpDamage].value

      if (eachpick.field[grIsEquip].value <> 0) then
        xml[node].attr["equipped"] = "yes"
        endif

      if (eachpick.tagis[component.WeapRange] <> 0) then
        xml[node].attr["shortrange"] = eachpick.field[wpShort].text
        xml[node].attr["mediumrange"] = eachpick.field[wpMedium].text
        xml[node].attr["longrange"] = eachpick.field[wpLong].text
        endif

      ~output basic gear details
      perform eachpick.setfocus
      call xogrbasics
      nexteach
    ]]></procedure>


  <!-- Procedure xoarmor
        Output all of the armor possessed by the character, listing equipped gear
        first and including the defense value for eachpick.
  -->
  <procedure id="xoarmor" scripttype="dossierxml"><![CDATA[
    var parentnode as number
    var node as number

    parentnode = xmlroot.addchild["defenses"]

    ~output the details of all armor (equipped first)
    foreach pick in hero from Defense sortas Armory
      node = xml[parentnode].addchild["defense"]

      xml[node].attr["name"] = eachpick.field[name].text
      xml[node].attr["defense"] = eachpick.field[defResist].text

      if (eachpick.field[grIsEquip].value <> 0) then
        xml[node].attr["equipped"] = "yes"
        endif

      ~output basic gear details
      perform eachpick.setfocus
      call xogrbasics
      nexteach
    ]]></procedure>


  <!-- Procedure xogear
        Synthesize all of the gear possessed by the character, showing quantities
        for appropriate gear.
  -->
  <procedure id="xogear" scripttype="dossierxml"><![CDATA[
    var parentnode as number
    var node as number

    parentnode = xmlroot.addchild["gear"]

    foreach pick in hero from Equipment where "!Print.NoPrint"
      node = xml[parentnode].addchild["item"]
      xml[node].attr["name"] = eachpick.field[name].text

      ~output basic gear details
      perform eachpick.setfocus
      call xogrbasics
      nexteach
    ]]></procedure>


  <!-- Procedure xotrackres
        Output all of the tracked resources possessed by the character.
  -->
  <procedure id="xotrackres" scripttype="dossierxml"><![CDATA[
    var parentnode as number
    var node as number

    parentnode = xmlroot.addchild["trackers"]

    ~output the details of all resources
    foreach pick in hero from Tracker where "!Hide.Tracker"
      node = xml[parentnode].addchild["tracker"]

      xml[node].attr["name"] = eachpick.field[name].text
      xml[node].attr["text"] = eachpick.field[trkUser].text
      xml[node].attr["used"] = eachpick.field[trkUser].value
      xml[node].attr["left"] = eachpick.field[trkLeft].value
      xml[node].attr["min"] = eachpick.field[trkMin].value
      xml[node].attr["max"] = eachpick.field[trkMax].value
      nexteach
    ]]></procedure>


  <!-- Procedure xonpcinfo
        Checks all npc info picks with a certain tag expression and appends
        their info to the text.
  -->
  <procedure id="xonpcinfo" scripttype="dossierxml"><![CDATA[
    var parentnode as number
    var tagexpr as string

    var node as number

    ~go through the npc info picks, adding them to the info string
    foreach pick in hero from NPCInfo where tagexpr sortas explicit
      node = xml[parentnode].addchild["npcinfo"]

      xml[node].attr["name"] = eachpick.field[name].text
      xml[node].text = eachpick.field[npcInfo].text
      nexteach
    ]]></procedure>


  <!-- Procedure xoimages
        Output all images, if required by the custom output type.
  -->
  <procedure id="xoimages" scripttype="dossierxml"><![CDATA[
    ~no need to do anything if this custom output doesn't want images
    doneif (state.iscustimgs = 0)

    var parentnode as number
    var node as number

    parentnode = xmlroot.addchild["images"]
    foreach pick in hero from UserImage where "fieldval:uimgImage <> 0"
      node = xml[parentnode].addchild["image"]
      perform eachpick.field[uimgImage].xmlimgattr[node,"filename"]
      nexteach
    ]]></procedure>


  <!-- Define the statblock as a text-based dossier. The "heroxml" script actually
        generates the output.
  -->
  <dossier
    id="custom"
    name="Custom Output">
    <dossier_custom
      default="yes">
      <heroxml><![CDATA[
        var txt as string
        var tagexpr as string
        var node as number
        var parentnode as number
        var nodename as string
        var xodescript as string

        ~all heroes in the sample game system can be output using the same
        ~character sheet, so they all have the same nature
        xmlroot.attr["nature"] = "normal"

        ~There's no distinction other than PC or NPC, since every character is
        ~built with the same rules
        if (hero.tagis[CharType.typSupport] <> 0) then
          xmlroot.attr["role"] = "npc"
        else
          xmlroot.attr["role"] = "pc"
          endif

        ~for NPCs, add a "book" node if they have sourcebook information
        if (hero.tagis[CharType.typSupport] <> 0) then
          if (herofield[acBookId].isempty + herofield[acBookName].isempty < 2) then
            node = xmlroot.addchild["bookinfo"]
            endif
          if (herofield[acBookId].isempty = 0) then
            xml[node].attr["id"] = herofield[acBookId].text
            endif
          if (herofield[acBookName].isempty = 0) then
            xml[node].attr["name"] = herofield[acBookName].text
            endif
          endif

        ~ally/enemy status
        if (hero.tagis[tactical.ally] <> 0) then
          xmlroot.attr["relationship"] = "ally"
        else
          xmlroot.attr["relationship"] = "enemy"
          endif

        ~start by outputting our name
        var name as string
        call xoname
        xmlroot.attr["name"] = name

        ~also player name
        xmlroot.attr["playername"] = playername

        ~output any species
        txt = hero.findchild[Species].field[name].text
        node = xmlroot.addchild["species"]
        xml[node].attr["name"] = txt

        ~output our total cash and XP
        node = xmlroot.addchild["xp"]
        xml[node].attr["total"] = #resmax[resXP]
        node = xmlroot.addchild["cash"]
        xml[node].attr["total"] = herofield[acCashNet].value

        ~output age, height and weight
        parentnode = xmlroot.addchild["personal"]
        xml[parentnode].attr["gender"] = child[mscPerson].field[perGender].text
        xml[parentnode].attr["age"] = hero.child[mscPerson].field[perAge].text
        xml[parentnode].attr["hair"] = hero.child[mscPerson].field[perHair].text
        xml[parentnode].attr["eyes"] = hero.child[mscPerson].field[perEyes].text
        xml[parentnode].attr["skin"] = hero.child[mscPerson].field[perSkin].text
        node = parentnode
        xodescript = hero.child[mscPerson].field[perInfo].text
        call xodescript

        ~height and weight go in separate child elements
        node = xml[parentnode].addchild["charheight"]
        xml[node].attr["text"] = hero.child[mscPerson].field[perHeight].text
        xml[node].attr["value"] = hero.child[mscPerson].field[perHeight].value
        node = xml[parentnode].addchild["charweight"]
        xml[node].attr["text"] = hero.child[mscPerson].field[perWeight].text
        xml[node].attr["value"] = hero.child[mscPerson].field[perWeight].value

        ~output attributes
        parentnode = xmlroot.addchild["attributes"]
        nodename = "attrsys"
        tagexpr = "component.AttrSys"
        call xotraits

        ~output skills
        parentnode = xmlroot.addchild["skills"]
        nodename = "skill"
        tagexpr = "component.Skill"
        call xotraits

        ~output special talents
        parentnode = xmlroot.addchild["talent"]
        nodename = "talent"
        tagexpr = "component.Talent"
        call xotraits

        ~output derived traits
        parentnode = xmlroot.addchild["traits"]
        foreach pick in hero from Derived sortas explicit
          node = xml[parentnode].addchild["trait"]
          xml[node].attr["name"] = eachpick.field[name].text
          xml[node].attr["value"] = eachpick.field[abiFinal].text
          nexteach

        ~output weapons/attacks
        call xoweapons

        ~output armor
        call xoarmor

        ~output gear
        call xogear

        ~output tracked resources
        call xotrackres

        ~output journal entries
        parentnode = xmlroot.addchild["journals"]
        foreach pick in hero from Journal
          node = xml[parentnode].addchild["journal"]
          xml[node].attr["name"] = eachpick.field[jrnTitle].text
          xml[node].attr["gamedate"] = eachpick.field[jrnGame].text
          xml[node].attr["realdate"] = eachpick.field[jrnReal].text
          xml[node].attr["xp"] = eachpick.usagepool[JrnlXP].value
          xml[node].attr["cash"] = eachpick.usagepool[JrnlCash].value
          xodescript = eachpick.field[jrnDescr].text
          call xodescript
          nexteach

        ~output user images
        call xoimages

        ~output validation details
        parentnode = xmlroot.addchild["validation"]
        node = xml[parentnode].addchild["report"]
        xml[node].text = hero.errorlist
        if (hero.errorcount <> 0) then
          foreach pick in hero.child[validgizmo].gizmo from validentry
            node = xml[parentnode].addchild["validmessage"]
            xml[node].text = eachpick.field[validentry].text
            nexteach
          endif

        ~output sources in use
        node = xmlroot.addchild["settings"]
        xml[node].attr["summary"] = hero.sourcetree

        ~output NPC details if this character is a NPC - if any field for any
        ~of the three blocks of text is set, output that block
        if (hero.tagis[CharType.typSupport] <> 0) then
          var tagexpr as string
          var title as string

          ~add a node for NPC info
          var npc as number
          npc = xmlroot.addchild["npc"]

          ~values of up to 15 are basic details only
          tagexpr = "val:explicit.? <= 15"
          parentnode = xml[npc].addchild["basics"]
          call xonpcinfo

          ~values of up to 30 are tactics
          tagexpr = "val:explicit.? > 15 & val:explicit.? <= 30"
          parentnode = xml[npc].addchild["tactics"]
          call xonpcinfo

          ~values of up to 45 are ecology
          tagexpr = "val:explicit.? > 30 & val:explicit.? <= 45"
          parentnode = xml[npc].addchild["ecology"]
          call xonpcinfo

          ~anything else is extra
          tagexpr = "val:explicit.? > 45"
          parentnode = xml[npc].addchild["additional"]
          call xonpcinfo
          endif

        ~output minions
        parentnode = xmlroot.addchild["minions"]
        foreach pick in hero where "system_tag.minion"
          node = xml[parentnode].addchild["character"]
          xml[node].attr["name"] = eachpick.field[name].text
          perform eachpick.minion.toxml[node]
          nexteach
        ]]></heroxml>
      </dossier_custom>
    </dossier>

  </document>