1038 lines
26 KiB
Ruby
1038 lines
26 KiB
Ruby
# Show syndromes affecting units and the remaining and maximum duration
|
|
# original author: drayath
|
|
# edited by expwnent
|
|
=begin
|
|
|
|
show-unit-syndromes
|
|
===================
|
|
Show syndromes affecting units and the remaining and maximum duration, along
|
|
with (optionally) substantial detail on the effects.
|
|
|
|
Use one or more of the following options:
|
|
|
|
:help: Show the help message
|
|
:showall: Show units even if not affected by any syndrome
|
|
:showeffects: Show detailed effects of each syndrome
|
|
:showdisplayeffects: Show effects that only change the look of the unit
|
|
:ignorehiddencurse: Hide syndromes the user should not be able to know about (TODO)
|
|
:selected: Show selected unit
|
|
:dwarves: Show dwarves
|
|
:livestock: Show livestock
|
|
:wildanimals: Show wild animals
|
|
:hostile: Show hostiles (e.g. invaders, thieves, forgotten beasts etc)
|
|
:world: Show all defined syndromes in the world
|
|
:export: ``export:<filename>`` sends output to the given file, showing all
|
|
syndromes affecting each unit with the maximum and present duration.
|
|
|
|
=end
|
|
|
|
#TODO: When showing effects on a unit, show the actual change to the unit
|
|
# E.g. if +150%, +500 strength show actual total bonus based on the unit stats.
|
|
# For this also need to know
|
|
# how does size_delays affect the start/peak/end time
|
|
# how does size_dilute affect the Severity, does it also affect the phy/mental stat adjustments?
|
|
# how does peak affect the Severity, does it also affect the phy/mental stat adjustments?
|
|
#TODO: Add interaction info needs to display a bit more data, but the required structures are not yet decoded
|
|
|
|
#TODO: Several of the unk_xxx fields have been identified here, and can get some more by comparing the raws with the printed interaction and effect information. Pass these onto the dfhack guys.
|
|
|
|
def print_help()
|
|
puts "Use one or more of the following options:"
|
|
puts " showall: Show units even if not affected by any syndrome"
|
|
puts " showeffects: shows detailed effects of each syndrome"
|
|
puts " showdisplayeffects: show effects that only change the look of the unit"
|
|
puts " ignorehiddencurse: Hides syndromes the user should not be able to know about (TODO)"
|
|
puts " selected: Show selected unit"
|
|
puts " dwarves: Show dwarves"
|
|
puts " livestock: Show livestock"
|
|
puts " wildanimals: Show wild animals"
|
|
puts " hostile: Show hostiles (e.g. invaders, thieves, forgotten beasts etc)"
|
|
puts " world: Show all defined syndromes in the world"
|
|
puts " export:<filename> Write the output to a file instead of the console."
|
|
puts ""
|
|
puts "Will show all syndromes affecting each units with the maximum and present duration."
|
|
end
|
|
|
|
class Output
|
|
attr_accessor :fileLogger, :indent_level
|
|
|
|
def initialize(filename)
|
|
indent_level = ""
|
|
if filename==nil
|
|
@fileLogger = nil
|
|
else
|
|
@fileLogger = File.new(filename + ".html", "w")
|
|
@fileLogger.puts("<html><body>")
|
|
end
|
|
end
|
|
|
|
RED = "red"
|
|
GREEN = "green"
|
|
BLUE = "blue"
|
|
DEFAULT = "black"
|
|
HIGHLIGHT = "black\" size=\"+1"
|
|
|
|
def colorize(text, color_code)
|
|
if @fileLogger == nil
|
|
return text
|
|
else
|
|
new_text = "<font color=\"#{color_code}\">#{text}</font>"
|
|
if color_code == HIGHLIGHT
|
|
new_text = "<b>" + new_text + "</b>"
|
|
end
|
|
|
|
return new_text
|
|
end
|
|
end
|
|
|
|
def inactive(text)
|
|
if @fileLogger == nil
|
|
return "###" + text
|
|
else
|
|
return "<del>#{text}</del>"
|
|
end
|
|
end
|
|
|
|
def indent()
|
|
if @fileLogger == nil
|
|
@indent_level = "#{@indent_level} - "
|
|
else
|
|
@fileLogger.puts("<ul>")
|
|
end
|
|
end
|
|
|
|
def unindent()
|
|
if @fileLogger == nil
|
|
@indent_level = @indent_level.chomp(" - ")
|
|
else
|
|
@fileLogger.puts("</ul>")
|
|
end
|
|
end
|
|
|
|
def break()
|
|
if @fileLogger == nil
|
|
puts("\n")
|
|
else
|
|
@fileLogger.puts("<hr/></br>")
|
|
end
|
|
end
|
|
|
|
def close()
|
|
if @fileLogger != nil
|
|
@fileLogger.puts("</body></html>")
|
|
@fileLogger.flush
|
|
@fileLogger.close
|
|
@fileLogger = nil
|
|
end
|
|
end
|
|
|
|
def log(text, color=nil)
|
|
if @fileLogger == nil
|
|
puts("#{@indent_level}#{text}")
|
|
elsif color==nil
|
|
@fileLogger.puts(text+"<br/>")
|
|
elsif @indent_level == ""
|
|
@fileLogger.puts(colorize(text, color))
|
|
else
|
|
@fileLogger.puts("<li>" + colorize(text, color)+"</li>")
|
|
end
|
|
end
|
|
end
|
|
|
|
def get_mental_att(att_index)
|
|
|
|
case att_index
|
|
when 0
|
|
return "Analytical Ability"
|
|
when 1
|
|
return "Focus"
|
|
when 2
|
|
return "Willpower"
|
|
when 3
|
|
return "Creativity"
|
|
when 4
|
|
return "Intuition"
|
|
when 5
|
|
return "Patience"
|
|
when 6
|
|
return "Memory"
|
|
when 7
|
|
return "Linguistics"
|
|
when 8
|
|
return "Spacial Sense"
|
|
when 9
|
|
return "Musicality"
|
|
when 10
|
|
return "Kinesthetic Sense"
|
|
when 11
|
|
return "Empathy"
|
|
when 12
|
|
return "Social Awareness"
|
|
else
|
|
return "Unknown"
|
|
end
|
|
end
|
|
|
|
def get_physical_att(att_index)
|
|
|
|
case att_index
|
|
when 0
|
|
return "strength"
|
|
when 1
|
|
return "agility"
|
|
when 2
|
|
return "toughness"
|
|
when 3
|
|
return "endurance"
|
|
when 4
|
|
return "recuperation"
|
|
when 5
|
|
return "disease resistance"
|
|
else
|
|
return "unknown"
|
|
end
|
|
end
|
|
|
|
def get_effect_target(target)
|
|
|
|
values = []
|
|
|
|
limit = target.key.length - 1
|
|
for i in (0..limit)
|
|
|
|
if(target.mode[i].to_s() != "")
|
|
|
|
items = ""
|
|
|
|
#case target.mode[i].to_s()
|
|
#when "BY_TYPE"
|
|
# item = "type("
|
|
#when "BY_TOKEN"
|
|
# item = "token("
|
|
#when "BY_CATEGORY"
|
|
# item = "category("
|
|
#end
|
|
|
|
if(target.key[i].to_s()!="")
|
|
item = "#{item}#{target.key[i].to_s().capitalize()}"
|
|
end
|
|
|
|
if target.tissue[i].to_s() != "ALL"
|
|
if(target.key[i].to_s()!="" and target.tissue[i].to_s()!="")
|
|
item = "#{item}:"
|
|
end
|
|
|
|
if(target.tissue[i].to_s()!="")
|
|
item = "#{item}#{target.tissue[i].to_s().capitalize()}"
|
|
end
|
|
end
|
|
|
|
#item = item + ")"
|
|
|
|
values.push(item)
|
|
end
|
|
|
|
end
|
|
|
|
if values.length == 0 or (values.length == 1 and values[0] == "All")
|
|
return ""
|
|
else
|
|
return ", target=" + values.join(", ")
|
|
end
|
|
end
|
|
|
|
def get_att_pairs(values, percents, physical)
|
|
|
|
items = []
|
|
|
|
color = Output::DEFAULT
|
|
|
|
limit = values.length - 1
|
|
for i in (0..limit)
|
|
if (values[i] != 0 or percents[i] != 100)
|
|
|
|
if physical
|
|
item = "#{get_physical_att(i)}("
|
|
else
|
|
item = "#{get_mental_att(i)}("
|
|
end
|
|
|
|
if(values[i]!=0)
|
|
item = item + "%+d" % values[i]
|
|
end
|
|
|
|
if (values[i]!=0 and percents[i]!=100)
|
|
item = item + ", "
|
|
end
|
|
|
|
if (percents[i]!=100 or values[i]==0)
|
|
item = item + "%d" % percents[i] + "%"
|
|
end
|
|
|
|
item = item + ")"
|
|
|
|
if color != Output::RED and values[i] >= 0 and percents[i] > 100
|
|
color = Output::GREEN
|
|
elsif values[i] <0 || percents[i] < 100
|
|
color = Output::RED
|
|
end
|
|
|
|
items.push(item)
|
|
end
|
|
end
|
|
|
|
return items.join(", "), color
|
|
end
|
|
|
|
def get_display_name(name, verb)
|
|
if name != nil and name != ""
|
|
return name.capitalize()
|
|
end
|
|
|
|
if verb == nil or verb == ""
|
|
return "Mystery"
|
|
end
|
|
|
|
if verb.length > 100
|
|
verb = verb.slice(0, 100).capitalize()
|
|
end
|
|
|
|
pos = verb.index(".")
|
|
if pos == nil
|
|
return verb.slice(0, verb.rindex(" ")).capitalize()
|
|
else
|
|
return verb.slice(0, pos).capitalize()
|
|
end
|
|
end
|
|
|
|
def get_interaction(interaction)
|
|
|
|
# name, USAGE_HINT, range, wait period are probably all we really want to show.
|
|
|
|
#result = "a=#{interaction.unk_6c} b=#{interaction.unk_7c} c=#{interaction.unk_8c} d=#{interaction.unk_a8} e=#{interaction.unk_c4} f=#{interaction.unk_e4} "
|
|
#result = result + "g=#{interaction.unk_e0} h=#{interaction.unk_e4} i=#{interaction.unk_100} j=#{interaction.unk_11c} k=#{interaction.unk_138} l=#{interaction.unk_154} "
|
|
#result = result + "m=#{interaction.unk_170} n=#{interaction.unk_18c} o=#{interaction.unk_1a8} p=#{interaction.unk_1c4} q=#{interaction.unk_1e8} r=#{interaction.unk_25c} "
|
|
#result = result + "s=#{interaction.unk_278}"
|
|
|
|
if interaction.name == ""
|
|
name = "mystery"
|
|
else
|
|
name = interaction.name
|
|
end
|
|
|
|
return "ability=#{get_display_name(interaction.name, interaction.verb[0])}, delay=#{interaction.usage_delay}, actionType=TODO, range=TODO, maxTargets=TODO"
|
|
end
|
|
|
|
def get_effect_flags(flags)
|
|
|
|
values = []
|
|
|
|
if(flags.SIZE_DELAYS) then values.push("size delays") end
|
|
if(flags.SIZE_DILUTES) then values.push("size dilutes") end
|
|
if(flags.VASCULAR_ONLY) then values.push("vascular only") end
|
|
if(flags.MUSCULAR_ONLY) then values.push("muscles only") end
|
|
if(flags.RESISTABLE) then values.push("resistable") end
|
|
if(flags.LOCALIZED) then values.push("localized") end
|
|
|
|
return values.join(",")
|
|
end
|
|
|
|
def get_tag1_flags(logger, flags, add)
|
|
|
|
values = []
|
|
|
|
good = false
|
|
bad = false
|
|
|
|
if add
|
|
good_color = Output::GREEN
|
|
bad_color = Output::RED
|
|
else
|
|
good_color = Output::RED
|
|
bad_color = Output::GREEN
|
|
end
|
|
|
|
if(flags.EXTRAVISION)
|
|
values.push(logger.colorize("extravision", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.OPPOSED_TO_LIFE)
|
|
values.push(logger.colorize("attack the living", bad_color))
|
|
bad = true
|
|
end
|
|
|
|
if(flags.NOT_LIVING)
|
|
values.push(logger.colorize("undead", Output::DEFAULT))
|
|
end
|
|
|
|
if(flags.NOEXERT)
|
|
values.push(logger.colorize("does not tire", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NOPAIN)
|
|
values.push(logger.colorize("does not feel pain", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NOBREATHE)
|
|
values.push(logger.colorize("does not breathe", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.HAS_BLOOD)
|
|
values.push(logger.colorize("has blood", Output::DEFAULT))
|
|
end
|
|
|
|
if(flags.NOSTUN)
|
|
values.push(logger.colorize("can't be stunned", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NONAUSEA)
|
|
values.push(logger.colorize("does not get nausea", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NO_DIZZINESS)
|
|
values.push(logger.colorize("does not get dizzy", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NO_FEVERS)
|
|
values.push(logger.colorize("does not get fever", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.TRANCES)
|
|
values.push(logger.colorize("can enter trance", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NOEMOTION)
|
|
values.push(logger.colorize("feels no emotion", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.LIKES_FIGHTING)
|
|
values.push(logger.colorize("like fighting", Output::DEFAULT))
|
|
end
|
|
|
|
if(flags.PARALYZEIMMUNE)
|
|
values.push(logger.colorize("can't be paralyzed", good_color))
|
|
good = true
|
|
end
|
|
if(flags.NOFEAR)
|
|
values.push(logger.colorize("does not feel fear", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NO_EAT)
|
|
values.push(logger.colorize("does not eat", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NO_DRINK)
|
|
values.push(logger.colorize("does not drink", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NO_SLEEP)
|
|
values.push(logger.colorize("does not sleep", good_color))
|
|
good = true
|
|
end
|
|
if(flags.MISCHIEVOUS)
|
|
values.push(logger.colorize("mischievous", Output::DEFAULT))
|
|
end
|
|
|
|
if(flags.NO_PHYS_ATT_GAIN)
|
|
values.push(logger.colorize("physical stats cant improve", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NO_PHYS_ATT_RUST)
|
|
values.push(logger.colorize("physical stats do not rust", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.NOTHOUGHT)
|
|
values.push(logger.colorize("stupid", bad_color))
|
|
bad = true
|
|
end
|
|
|
|
if(flags.NO_THOUGHT_CENTER_FOR_MOVEMENT)
|
|
values.push(logger.colorize("no brain needed to move", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.CAN_SPEAK)
|
|
values.push(logger.colorize("can speak", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.CAN_LEARN)
|
|
values.push(logger.colorize("can learn", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.UTTERANCES)
|
|
values.push(logger.colorize("utterances", Output::DEFAULT))
|
|
end
|
|
|
|
if(flags.CRAZED)
|
|
values.push(logger.colorize("crazed", bad_color))
|
|
bad = true
|
|
end
|
|
|
|
if(flags.BLOODSUCKER)
|
|
values.push(logger.colorize("drinks blood", bad_color))
|
|
bad = true
|
|
end
|
|
|
|
if(flags.NO_CONNECTIONS_FOR_MOVEMENT)
|
|
values.push(logger.colorize("can move without nerves", good_color))
|
|
good = true
|
|
end
|
|
|
|
if(flags.SUPERNATURAL)
|
|
values.push(logger.colorize("supernatural", good_color))
|
|
good = true
|
|
end
|
|
|
|
if add
|
|
if bad
|
|
color = Output::RED
|
|
elsif good
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
else
|
|
if good
|
|
color = Output::RED
|
|
elsif bad
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
end
|
|
|
|
return values.join(", "), color
|
|
end
|
|
|
|
def get_tag2_flags(logger, flags, add)
|
|
values = []
|
|
|
|
good = false
|
|
bad = false
|
|
|
|
if add
|
|
good_color = Output::GREEN
|
|
bad_color = Output::RED
|
|
else
|
|
good_color = Output::RED
|
|
bad_color = Output::GREEN
|
|
end
|
|
|
|
if(flags.NO_AGING)
|
|
good = true
|
|
values.push(logger.colorize("does not age", good_color))
|
|
end
|
|
|
|
if(flags.MORTAL)
|
|
bad = true
|
|
values.push(logger.colorize("mortal", bad_color))
|
|
end
|
|
|
|
if(flags.STERILE)
|
|
values.push(logger.colorize("can't have children", Output::DEFAULT))
|
|
end
|
|
|
|
if(flags.FIT_FOR_ANIMATION)
|
|
values.push(logger.colorize("can be animated", Output::DEFAULT))
|
|
end
|
|
|
|
if(flags.FIT_FOR_RESURRECTION)
|
|
good = true
|
|
values.push(logger.colorize("can be resurrected", Output::DEFAULT))
|
|
end
|
|
|
|
if add
|
|
if bad
|
|
color = Output::RED
|
|
elsif good
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
else
|
|
if good
|
|
color = Output::RED
|
|
elsif bad
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
end
|
|
|
|
return values.join(", "), color
|
|
end
|
|
|
|
def find_creature_name(id, casteid)
|
|
creature = df.world.raws.creatures.all.find{ |c| c.creature_id == id }
|
|
|
|
if creature == nil
|
|
return id, casteid
|
|
end
|
|
|
|
creature_name = creature.name[0].capitalize()
|
|
|
|
if casteid == "DEFAULT"
|
|
return creature_name, ""
|
|
end
|
|
|
|
caste = creature.caste.find{ |c| c.caste_id == casteid }
|
|
|
|
if caste == nil
|
|
return creature_name, casteid
|
|
elsif creature.name[0].downcase() == caste.caste_name[0].downcase()
|
|
return creature_name, ""
|
|
else
|
|
castename = caste.caste_name[0].downcase().chomp(creature.name[0].downcase()).strip()
|
|
|
|
if castename.start_with?(creature.name[0])
|
|
castename = castename.slice(creature.name[0].length, castename.length - creature.name[0].length).strip()
|
|
end
|
|
|
|
if castename.start_with?("of the")
|
|
castename = castename.slice("of the".length, castename.length - "of the".length).strip()
|
|
end
|
|
|
|
return creature_name, castename.downcase()
|
|
end
|
|
end
|
|
|
|
def get_effect(logger, ce, ticks, showdisplayeffects)
|
|
|
|
flags = get_effect_flags(ce.flags)
|
|
if flags != ""
|
|
flags = " (#{flags})"
|
|
end
|
|
|
|
if ce.end == -1
|
|
duration = " [permanent]"
|
|
elsif ce.start >= ce.peak or ce.peak <= 1
|
|
duration = " [#{ce.start}-#{ce.end}]"
|
|
else
|
|
duration = " [#{ce.start}-#{ce.peak}-#{ce.end}]"
|
|
end
|
|
|
|
case ce.getType().to_s()
|
|
when "PAIN"
|
|
name = "Pain"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "SWELLING"
|
|
name = "Swelling"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "OOZING"
|
|
name = "Oozing"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "BRUISING"
|
|
name = "Bruising"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "BLISTERS"
|
|
name = "Blisters"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "NUMBNESS"
|
|
name = "Numbness"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::GREEN
|
|
when "PARALYSIS"
|
|
name = "Paralysis"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "FEVER"
|
|
name = "Fever"
|
|
desc = "power=#{ce.sev}"
|
|
color = Output::RED
|
|
when "BLEEDING"
|
|
name = "Bleeding"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "COUGH_BLOOD"
|
|
name = "Cough Blood"
|
|
desc = "power=#{ce.sev}"
|
|
color = Output::RED
|
|
when "VOMIT_BLOOD"
|
|
name = "Vomit Blood"
|
|
desc = "power=#{ce.sev}"
|
|
color = Output::RED
|
|
when "NAUSEA"
|
|
name = "Nausea"
|
|
desc = "power=#{ce.sev}"
|
|
color = Output::RED
|
|
when "UNCONSCIOUSNESS"
|
|
name = "Unconsciousness"
|
|
desc = "power=#{ce.sev}"
|
|
color = Output::RED
|
|
when "NECROSIS"
|
|
name = "Necrosis"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "IMPAIR_FUNCTION"
|
|
name = "Impairs"
|
|
desc = "power=#{ce.sev}#{get_effect_target(ce.target)}"
|
|
color = Output::RED
|
|
when "DROWSINESS"
|
|
name = "Drowsiness"
|
|
desc = "power=#{ce.sev}"
|
|
color = Output::RED
|
|
when "DIZZINESS"
|
|
name = "Dizziness"
|
|
desc = "power=#{ce.sev}"
|
|
color = Output::RED
|
|
when "ADD_TAG"
|
|
name = "Add"
|
|
tags1 = get_tag1_flags(logger, ce.tags1, true)
|
|
tags2 = get_tag2_flags(logger, ce.tags2, true)
|
|
desc = "#{tags1[0]},#{tags2[0]}"
|
|
|
|
if tags1[1] == Output::RED || tags2[1] == Output::RED
|
|
color = Output::RED
|
|
elsif tags1[1] == Output::GREEN || tags2[1] == Output::GREEN
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
when "REMOVE_TAG"
|
|
name = "Remove"
|
|
tags1 = get_tag1_flags(logger, ce.tags1, true)
|
|
tags2 = get_tag2_flags(logger, ce.tags2, true)
|
|
desc = "#{tags1[0]},#{tags2[0]}"
|
|
|
|
if tags1[1] == Output::RED || tags2[1] == Output::RED
|
|
color = Output::RED
|
|
elsif tags1[1] == Output::GREEN || tags2[1] == Output::GREEN
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
when "DISPLAY_TILE"
|
|
if !showdisplayeffects then return "", Output::DEFAULT end
|
|
name = "Tile"
|
|
desc = "Tile=#{ce.tile}, Colour=#{ce.color}"
|
|
color = Output::DEFAULT
|
|
when "FLASH_TILE"
|
|
if !showdisplayeffects then return "", Output::DEFAULT end
|
|
name = "Flash"
|
|
color = ce.sym_color >> 8
|
|
tile = ce.sym_color - (color * 256)
|
|
desc = "tile = #{tile}, colour=#{color}, time=#{ce.period}, period=#{ce.time}"
|
|
color = Output::DEFAULT
|
|
when "SPEED_CHANGE"
|
|
name = "Physical"
|
|
desc = "speed("
|
|
|
|
value = ce.bonus_add
|
|
percent = ce.bonus_perc
|
|
if(value!=0)
|
|
desc = desc + "%+d" % value
|
|
end
|
|
|
|
if (value!=0 and percent!=100)
|
|
desc = desc + ", "
|
|
end
|
|
|
|
if (percent!=100 or value==0)
|
|
desc = desc + "%d" % percent + "%"
|
|
end
|
|
|
|
desc = desc + ")"
|
|
|
|
if value < 0 or percent < 100
|
|
color = Output::RED
|
|
elsif value >0 or percent >100
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
|
|
when "CAN_DO_INTERACTION"
|
|
name = "Add interaction"
|
|
desc = "#{get_interaction(ce)}"
|
|
color = Output::GREEN
|
|
when "SKILL_ROLL_ADJUST"
|
|
name = "Skill check"
|
|
desc = "modifier=#{ce.multiplier}%, chance=#{ce.chance}%"
|
|
|
|
if ce.multiplier > 100
|
|
color = Output::GREEN
|
|
elsif ce.multiplier < 100
|
|
color = Output::RED
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
|
|
when "BODY_TRANSFORMATION"
|
|
name = "Transformation"
|
|
|
|
if ce.chance > 0
|
|
chance = ", chance=#{ce.chance} "
|
|
else
|
|
chance = ""
|
|
end
|
|
|
|
creature_name = find_creature_name(ce.race_str, ce.caste_str)
|
|
|
|
if creature_name[1] == ""
|
|
desc = "#{creature_name[0]}#{chance}"
|
|
else
|
|
desc = "#{creature_name[0]}(#{creature_name[1]})#{chance}"
|
|
end
|
|
|
|
color = Output::BLUE
|
|
when "PHYS_ATT_CHANGE"
|
|
name = "Physical"
|
|
data = get_att_pairs(ce.phys_att_add, ce.phys_att_perc, true)
|
|
desc = data[0]
|
|
color = data[1]
|
|
when "MENT_ATT_CHANGE"
|
|
name = "Mental"
|
|
data = get_att_pairs(ce.ment_att_add, ce.ment_att_perc, false)
|
|
desc = data[0]
|
|
color = data[1]
|
|
when "MATERIAL_FORCE_MULTIPLIER"
|
|
name = "Material force multiplier"
|
|
desc = "received damage scaled by #{(ce.fraction_mul * 100 / ce.fraction_div * 100)/100}%"
|
|
if ce.fraction_div > ce.fraction_mul
|
|
color = Output::GREEN
|
|
elsif ce.fraction_div < ce.fraction_mul
|
|
color = Output::RED
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
|
|
if ce.mat_index >=0
|
|
mat = df.decode_mat(ce.mat_type, ce.mat_index )
|
|
elsif ce.mat_type >= 0
|
|
mat = df.decode_mat(ce.mat_type, 0 )
|
|
else
|
|
mat = nil
|
|
end
|
|
|
|
if mat!= nil
|
|
token = mat.token
|
|
if token.start_with?("INORGANIC:")
|
|
token = token.slice("INORGANIC:".length, token.length - "INORGANIC:".length)
|
|
end
|
|
|
|
desc = "#{desc} vs #{token.capitalize()}"
|
|
end
|
|
|
|
when "BODY_MAT_INTERACTION"
|
|
# interactionId, SundromeTriggerType
|
|
name = "Body material interaction"
|
|
desc = "a???=#{ce.unk_6c}, b???=#{ce.unk_88}, c???=#{ce.unk_8c}, d???=#{ce.unk_90}, e???=#{ce.unk_94}"
|
|
color = Output::DEFAULT
|
|
when "BODY_APPEARANCE_MODIFIER"
|
|
if !showdisplayeffects then return "", Output::DEFAULT end
|
|
# !!! seems to be missing info class !!!
|
|
# should be enum and value
|
|
name = "Body Appearance"
|
|
desc = "<TODO>"
|
|
color = Output::DEFAULT
|
|
when "BP_APPEARANCE_MODIFIER"
|
|
if !showdisplayeffects then return "", Output::DEFAULT end
|
|
name = "Body part appearance"
|
|
desc = "value=#{ce.value} change_type_enum?=#{ce.unk_6c}#{get_effect_target(ce.target)}"
|
|
color = Output::DEFAULT
|
|
when "DISPLAY_NAME"
|
|
if !showdisplayeffects then return "", Output::DEFAULT end
|
|
name = "Set display name"
|
|
desc = "#{ce.name}"
|
|
color = Output::DEFAULT
|
|
else
|
|
name = "Unknown"
|
|
color = Output::HIGHLIGHT
|
|
end
|
|
|
|
text = "#{name}#{duration}#{flags} #{desc}"
|
|
if ticks > 0 and ((ce.start > 0 and ticks < ce.start) or (ce.end > 0 and ticks > ce.end))
|
|
text = logger.inactive(text)
|
|
end
|
|
|
|
return text, color
|
|
end
|
|
|
|
print_syndrome = lambda { |logger, syndrome, showeffects, showdisplayeffects|
|
|
rawsyndrome = df.world.raws.syndromes.all[syndrome.type]
|
|
duration = rawsyndrome.ce.minmax_by{ |ce| ce.end }
|
|
|
|
if duration[0].end == -1
|
|
durationStr = "permanent"
|
|
else
|
|
if duration[0].end == duration[1].end
|
|
durationStr = "#{syndrome.ticks} of #{duration[0].end}"
|
|
else
|
|
durationStr = "#{syndrome.ticks} of #{duration[0].end}-#{duration[1].end}"
|
|
end
|
|
end
|
|
|
|
effects = rawsyndrome.ce.collect { |effect| get_effect(logger, effect, syndrome.ticks, showdisplayeffects) }
|
|
|
|
if effects.any?{ |text, color| color==Output::RED }
|
|
color = Output::RED
|
|
elsif effects.any?{|text, color| color==Output::GREEN }
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
|
|
logger.indent()
|
|
logger.log "#{get_display_name(rawsyndrome.syn_name, "")} [#{durationStr}]", color
|
|
|
|
if showeffects
|
|
logger.indent()
|
|
effects.each{ |text, color| if text!="" then logger.log text, color end }
|
|
logger.unindent()
|
|
end
|
|
logger.unindent()
|
|
}
|
|
|
|
print_raw_syndrome = lambda { |logger, rawsyndrome, showeffects, showdisplayeffects|
|
|
|
|
effects = rawsyndrome.ce.collect { |effect| get_effect(logger, effect, -1, showdisplayeffects) }
|
|
|
|
if effects.any?{ |item| item[1]==Output::RED }
|
|
color = Output::RED
|
|
elsif effects.any?{|item| item[1]==Output::GREEN }
|
|
color = Output::GREEN
|
|
else
|
|
color = Output::DEFAULT
|
|
end
|
|
|
|
logger.indent()
|
|
logger.log get_display_name(rawsyndrome.syn_name, ""), color
|
|
|
|
if showeffects
|
|
logger.indent()
|
|
effects.each{ |text, color| if text!="" then logger.log text, color end }
|
|
logger.unindent()
|
|
end
|
|
logger.unindent()
|
|
}
|
|
|
|
print_syndromes = lambda { |logger, unit, showrace, showall, showeffects, showhiddencurse, showdisplayeffects|
|
|
|
|
if showhiddencurse
|
|
syndromes = unit.syndromes.active
|
|
else
|
|
syndromes = unit.syndromes.active
|
|
# TODO: syndromes = unit.syndromes.active.select{ |s| visible_syndrome?(unit, s) }
|
|
end
|
|
|
|
if !syndromes.empty? or showall
|
|
if showrace
|
|
logger.log "#{df.world.raws.creatures.all[unit.race].name[0]}#{unit.name == '' ? "" : ": "}#{unit.name}", Output::HIGHLIGHT
|
|
else
|
|
logger.log "#{unit.name}", Output::HIGHLIGHT
|
|
end
|
|
end
|
|
|
|
syndromes.each { |syndrome| print_syndrome[logger, syndrome, showeffects, showdisplayeffects] }
|
|
}
|
|
|
|
def starts_with?(str, prefix)
|
|
prefix = prefix.to_s
|
|
str[0, prefix.length] == prefix
|
|
end
|
|
|
|
showall = false
|
|
showeffects = false
|
|
selected = false
|
|
dwarves = false
|
|
livestock = false
|
|
wildanimals = false
|
|
hostile = false
|
|
world = false
|
|
showhiddencurse = false
|
|
showdisplayeffects = false
|
|
|
|
if $script_args.any?{ |arg| arg == "help" or arg == "?" or arg == "-?" }
|
|
print_help()
|
|
elsif $script_args.empty?
|
|
dwarves = true
|
|
showeffects = true
|
|
else
|
|
if $script_args.any?{ |arg| arg == "showall" } then showall=true end
|
|
if $script_args.any?{ |arg| arg == "showeffects" } then showeffects=true end
|
|
if $script_args.any?{ |arg| arg == "ignorehiddencurse" } then showhiddencurse=true end
|
|
if $script_args.any?{ |arg| arg == "showdisplayeffects" } then showdisplayeffects=true end
|
|
if $script_args.any?{ |arg| arg == "selected" } then selected=true end
|
|
if $script_args.any?{ |arg| arg == "dwarves" } then dwarves=true end
|
|
if $script_args.any?{ |arg| arg == "livestock" } then livestock=true end
|
|
if $script_args.any?{ |arg| arg == "wildanimals" } then wildanimals=true end
|
|
if $script_args.any?{ |arg| arg == "hostile" } then hostile=true end
|
|
if $script_args.any?{ |arg| arg == "world" } then world=true end
|
|
if $script_args.any?{ |arg| starts_with?(arg, "export:") }
|
|
exportfile = $script_args.find{ |arg| starts_with?(arg, "export:") }.gsub("export:", "")
|
|
export=true
|
|
end
|
|
end
|
|
|
|
if export
|
|
logger = Output.new(exportfile)
|
|
else
|
|
logger = Output.new(nil)
|
|
end
|
|
|
|
if selected
|
|
print_syndromes[logger, df.unit_find(), true, showall, showeffects, showhiddencurse, showdisplayeffects]
|
|
logger.break()
|
|
end
|
|
|
|
if dwarves
|
|
logger.log "Dwarves", Output::HIGHLIGHT
|
|
df.unit_citizens.each { |unit|
|
|
print_syndromes[logger, unit, false, showall, showeffects, showhiddencurse, showdisplayeffects]
|
|
}
|
|
logger.break()
|
|
end
|
|
|
|
if livestock
|
|
logger.log "Livestock", Output::HIGHLIGHT
|
|
df.world.units.active.find_all { |u| df.unit_category(u) == :Livestock }.each { |unit|
|
|
print_syndromes[logger, unit, true, showall, showeffects, showhiddencurse, showdisplayeffects]
|
|
}
|
|
logger.break()
|
|
end
|
|
|
|
if wildanimals
|
|
logger.log "Wild animals", Output::HIGHLIGHT
|
|
df.world.units.active.find_all { |u| df.unit_category(u) == :Other and df.unit_other_category(u) == :Wild }.each { |unit|
|
|
print_syndromes[logger, unit, true, showall, showeffects, showhiddencurse, showdisplayeffects]
|
|
}
|
|
logger.break()
|
|
end
|
|
|
|
if hostile
|
|
logger.log "Hostile units", Output::HIGHLIGHT
|
|
df.unit_hostiles.each { |unit|
|
|
print_syndromes[logger, unit, true, showall, showeffects, showhiddencurse, showdisplayeffects]
|
|
}
|
|
logger.break()
|
|
end
|
|
|
|
if world
|
|
logger.log "All syndromes", Output::HIGHLIGHT
|
|
df.world.raws.syndromes.all.each { |syndrome| print_raw_syndrome[logger, syndrome, showeffects, showdisplayeffects] }
|
|
end
|
|
|
|
logger.close()
|