common: bump version to 1.11
[sheet.git] / sc.plp
diff --git a/sc.plp b/sc.plp
index 4706bbf..3437f8f 100644 (file)
--- a/sc.plp
+++ b/sc.plp
 <(common.inc.plp)><:
+use List::Util qw(max sum);
 
-my $datafile = 'sc-units.inc.pl';
-if ($ENV{PATH_INFO} and $ENV{PATH_INFO} eq '/2') {
-       $datafile = 'sc2-units.inc.pl';
+my %scver = (
+       id => 'bw',
+       name => 'Brood War',
+       title => 'starcraft',
+       game => 'StarCraft',
+       major => 1,
+);
+
+if ($Request and $Request eq '2') {
+       %scver = (
+               id => 'hots',
+               name => 'Heart of the Swarm',
+               title => 'starcraft2',
+               game => 'StarCraft II',
+               major => 2,
+       );
 }
+my $datafile = "sc-units-$scver{id}.inc.pl";
 
 Html({
-       title => 'starcraft unit cheat sheet',
-       version => 'v1.0',
+       title => "$scver{title} unit cheat sheet",
+       version => '1.1',
        description => [
-               'Reference of StarCraft unit properties,'
-               . ' comparing various statistics of all the units in Brood War'
+               "Reference of $scver{game} unit properties,"
+               . " comparing various statistics of all the units in $scver{name}"
                . ' including costs, damage, defense, speed, ranges, and abilities.',
        ],
-       keywords => [qw'
+       keywords => [
+               qw'
                starcraft game unit statistics stats comparison table sheet cheat
                reference software attributes properties
-       '],
+               ',
+               $scver{major} < 2 ? qw' bw broodwar brood war ' : qw' starcraft2 hots ',
+       ],
        stylesheet => [qw'light'],
        raw => '<link rel="stylesheet" type="text/css" media="all" href="/sc.css?1.1" title="light">',
        data => [$datafile],
 });
 
-:>
-<h1>StarCraft units</h1>
+say "<h1>$scver{game} units</h1>\n";
 
-<p>
-Unit properties as seen or measured in Brood War
-<span title="no known changes as of v1.16.1">version≥1.08</span>.
-</p>
+my $units = do $datafile;
+die "Cannot open unit data: $_\n" for $@ || $! || ();
+my $patch = shift @{$units}
+       or die "Cannot open unit data: metadata not found\n";
+
+say "<p>Unit properties as seen or measured in $scver{name}\n$patch.";
+say "Also see the $_ table." for join(', ',
+       (showlink('StarCraft 2: HotS', '/sc/2'))    x ($scver{major} < 2),
+       (showlink('original SC: Brood War', '/sc')) x ($scver{major} > 1),
+);
+say "</p>\n";
+
+sub addupgrade {
+       my ($ref, $increase, $org) = @_;
+       if (ref $increase eq 'HASH') {
+               addupgrade(\${$ref}->{$_}, $increase->{$_}, $org->{$_}) for keys %{$increase};
+       }
+       elsif (ref $increase eq 'ARRAY') {
+               addupgrade(\${$ref}->[$_], $increase->[$_], $org->[$_]) for 0 .. $#{$increase};
+       }
+       ${$ref} //= $org;
+       ${$ref} += $increase if $increase =~ /^-?[0-9.]+/;
+}
+
+for my $unit (@{$units}) {
+       for my $upgrade (@{ $unit->{upgrade} }) {
+               while (my ($col, $increase) = each %{$upgrade}) {
+                       defined $unit->{$col} or next;
+                       addupgrade(\$unit->{upgraded}->{$col}, $increase, $unit->{$col});
+               }
+       }
+       for my $special (@{ $unit->{special} }) {
+               for my $upgrade (@{ $special->{upgrade} }) {
+                       while (my ($col, $increase) = each %{$upgrade}) {
+                               defined $special->{$col} or next;
+                               addupgrade(\$special->{upgraded}->{$col}, $increase, $special->{$col});
+                       }
+               }
+       }
+}
 
-<:
 sub coltoggle {
-       my ($name, $id) = @_;
-       return sprintf(
-               (defined $get{order} ? $get{order} eq $id : !$id) ? '%2$s ▼'
-                       : '<a href="?%s">%s</a>',
-               $id && "order=$id", $name
-       );
+       my ($name, $id, $nolink) = @_;
+       return "$name ▼" if defined $get{order} ? $get{order} eq $id : !$id;
+       return $name if $nolink;
+       return showlink($name, '?'.($id && "order=$id"));
 }
 :><table class="units">
 <thead><tr>
        <th></th>
        <th><:= coltoggle('name', '') :></th>
-       <th class="val min"><img src="/minerals.png" alt="min"></th>
-       <th class="val gas"><img src="/gas.png" alt="gas"></th>
+       <th class="val min" title=minerals>cost</th>
+       <th class="val gas">gas</th>
        <th class="val time"><:= coltoggle(qw'build cost') :></th>
        <th class="unit" colspan="2"><:= coltoggle(qw'size size') :></th>
+       <th class="unit" colspan="2">attr</th>
        <th class="val unit-hp">HP</th>
        <th class="val unit-shield">shield</th>
-       <th class="val unit-armor">armor</th>
-       <th class="val hurt" colspan="2">ground</th>
-       <th class="val hurt" colspan="2">air</th>
-       <th class="val unit-range">range</th>
+       <th class="val unit-armor" title="armor">⛨</th>
+       <th class="val hurt">attack</th>
+       <th class="hurt hurtrel"><:= coltoggle(qw'dps attack 1') :></th>
+       <th class="val unit-range" colspan=3>range</th>
        <th class="val unit-sight">sight</th>
        <th class="val unit-speed">speed</th>
        <th class="unit-magic">specials</th>
@@ -60,80 +111,120 @@ sub coltoggle {
 <:
 sub showrange {
        my ($min, $max) = @_;
-       $_ = int($_ + .5) for $min, $max;  # round halves up
-       return $min == $max ? $min : "$min-$max";
+       return '' if not defined $min;
+       return $min || '-' if !$max or $min == $max;
+       return "$min-$max";
 }
 
-sub showval {
-       my ($row, @elements) = @_;
-       my ($min, $max);
-
-       my $value = $row;
-       $value = ref $value eq 'HASH' && $value->{$_} or last for @elements;
-       if (ref $value eq 'ARRAY') {
-               $min = $value->[0];
-               $max = $value->[-1];
-       }
-       else {
-               $min = $max = $value;
-       }
-       defined $min or return '';
+sub showrangeint {
+       $_ &&= int($_ + .5) for @_;  # round halves up
+       return showrange(@_);
+}
 
-       if ($row->{upgrade}) {
-               for (@{ $row->{upgrade} }) {
-                       my $increase = $_ or next;
-                       $increase = ref $increase eq 'HASH' && $increase->{$_} or last for @elements;
-                       $increase = $increase->[-1] if ref $increase eq 'ARRAY';
-                       $max += $increase if $increase;
-               }
+       sub showcost {
+               my ($row, $unit) = @_;
+               return join(' ',
+                       sprintf('cost %s%%', join '-',
+                               map { $_ && sprintf '%.0f', 100 * $row->{cost} / $_ } grep { defined $_ }
+                               $unit->{energy},
+                               $unit->{upgraded}->{energy},
+                               $unit->{capacity},
+                               $unit->{upgraded}->{capacity},
+                       ),
+                       !defined $row->{maint} ? () : sprintf('+%s%%/s', join '-',
+                               map { sprintf '%.1f', 100 * $row->{maint} / $_ } grep $_,
+                               $unit->{capacity},
+                               $unit->{upgraded}->{capacity},
+                       ),
+               );
        }
 
-       if ($elements[0] eq 'attack' and $elements[1] ne 'range' and $elements[2] eq 'dps') {{
-               my $attack = $row->{ $elements[0] }->{ $elements[1] };
-               ref $attack or $attack = $row->{ $elements[0] }->{$attack}; # follow
-               my $type = $attack->{type} or next;
-               if ($type eq 'explosive') {
-                       $min /= 2;
-               }
-               elsif ($type eq 'implosive') {
-                       $min /= 4;
-               }
-       }}
-       return showrange($min, $max);
-}
-
        sub showattack {
                my ($row, $area) = @_;
-               my $attack = $row->{attack}->{$area};
-               if (not ref $attack) {
-                       # reference to another area
-                       $area = $attack;
-                       $attack = $row->{attack}->{$area};
-               }
+               my $attack = $row->{attack}->[$area]
+                       or return '<td colspan=5 class="hurt">';
 
-               return '<td colspan="2" class="hurt">' unless $attack;
+               my $upattack = $row->{upgraded}->{attack}->[$area];
+               my $damage = $attack->{damage};
+               my $maxdamage = $upattack->{damage} // $damage;
+               $maxdamage += ($upattack->{upgrade} // $attack->{upgrade}) * 3;
+
+               my $out = '<td class="val hurt">';
+               $out .= sprintf '<span title="%s">¤</span> ', showcost($attack, $row)
+                       if $attack->{cost};
+               $out .= sprintf('<small>%s× </small>',
+                       showrangeint($attack->{count}, $upattack->{count}),
+               ) if $attack->{count} > 1;
+               $out .= '<span class="unit-l" title="explosive">*</span>'
+                       if $attack->{type} eq 'explosive';
+               $out .= '<span class="unit-s" title="implosive">~</span>'
+                       if $attack->{type} eq 'implosive';
+       if (my @bonus = sort grep { !/^-/ } keys %{ $attack->{bonus} }) {
+               $out .= sprintf('<span class="%s" title="%s">&ge;</span>',
+                       (map {
+                               $_ eq 'light' ? 'unit-s' :
+                               $_ eq 'armored' ? 'unit-l' :
+                               $_ eq 'organic' ? 'unit-o' :
+                               $_ eq 'massive' ? 'unit-h' :
+                               $_ eq 'shields' ? 'unit-shield' :
+                               '',
+                       } join '_', @bonus),
+                       join(', ', map {(
+                               sprintf('+%s vs %s',
+                                       showrangeint(
+                                               $attack->{bonus}->{$_},
+                                               $attack->{bonus}->{$_} + $attack->{bonus}->{"-$_"} * 3,
+                                       ),
+                                       $_,
+                               ),
+                       )} @bonus),
+               );
+       }
+               $out .= '<span class="unit-pdd" title="projectile">•</span>'
+                       if $attack->{type} eq 'projectile';
 
-               my $tagbase = '<td class="val hurt';
-               if (ref $attack and $attack->{type}) {
-                       if ($attack->{type} eq 'explosive') {
-                               $tagbase .= ' unit-l';
+               $out .= sprintf '<span title="%s">', $attack->{name} if $attack->{name};
+               $out .= showrangeint($damage, $maxdamage);
+               $out .= '</span>' if $attack->{name};
+               $out .= sprintf('<span class="unit-splash" title="%s">%s</span>',
+                       $attack->{splash} eq 'line' ? ('linear', '+') : ('splash', '⁜')
+               ) if $attack->{splash};
+
+               $out .= '<td class="val hurt hurtrel">';
+               if ($attack->{dps}) {
+                       # precalculated dps, do not touch
+                       $out .= showrangeint($attack->{dps}->[0],
+                               $upattack->{dps}->[-1] // $attack->{dps}->[-1]
+                       );
+               }
+               elsif ($attack->{cooldown}) {
+                       if (my $type = $attack->{type}) {
+                               if ($type eq 'explosive') {
+                                       $damage /= 2;
+                               }
+                               elsif ($type eq 'implosive') {
+                                       $damage /= 4;
+                               }
                        }
-                       elsif ($attack->{type} eq 'implosive') {
-                               $tagbase .= ' unit-s';
+                       $damage *= ($attack->{count} // 1) / $attack->{cooldown};
+                       if (my $bonus = $upattack->{bonus} // $attack->{bonus}) {
+                               $maxdamage += $_ for max(
+                                       map { $bonus->{$_} + $bonus->{"-$_"} * 3 }
+                                       grep { !/^-/ } keys %{$bonus}
+                               );
                        }
+                       $maxdamage *= ($upattack->{count} // $attack->{count} // 1)
+                                   / ($upattack->{cooldown} // $attack->{cooldown});
+                       $out .= showrangeint($damage, $maxdamage);
                }
-               $tagbase .= '">';
 
-               my $out = showval($row, 'attack', $area, 'damage');
-               $out .= '<span class="unit-splash">+</span>' if $attack->{splash};
-               $attack->{dps} = $attack->{cooldown} && [
-                       map { 24 * $_ / $attack->{cooldown} * ($attack->{count} // 1) }
-                       map { ref $_ ? @{$_} : $_ }
-                       $attack->{damage}
-                       #TODO: upgrade (zergling)
-               ];
-               $out .= '<td class="val hurt hurtrel">' . showval($row, 'attack', $area, 'dps');
-               return $tagbase . $out;
+               $out .= '<td class="unit hurt-g">' . '▽' x !!($attack->{anti} & 1);
+               $out .= '<td class="unit hurt-a">' . '△' x !!($attack->{anti} & 2);
+
+               $out .= '<td class="val unit-range">' .
+                       showrangeint($attack->{range}, $upattack->{range});
+
+               return $out;
        }
 
        sub showmagic {
@@ -145,12 +236,12 @@ sub showval {
                                join('',
                                        $_->{name},
                                        $_->{desc} ? ": $_->{desc}" : '',
-                                       $_->{range} || $_->{cost} ? sprintf(' (%s)', join ', ',
+                                       (map { $_ && " ($_)" } join ', ',
+                                               #TODO: apply upgrades
                                                $_->{range} ? "range $_->{range}" : (),
-                                               $_->{cost} ? sprintf('cost %.0f%%',
-                                                       100 * $_->{cost} / $row->{energy}
-                                               ) : (),
-                                       ) : '',
+                                               $_->{cost} ? showcost($_, $row) :
+                                               $_->{cooldown} ? "cooldown $_->{cooldown}s" : (),
+                                       ),
                                ),
                                sprintf($_->{build} ? '(%s)' : '%s', $_->{abbr}),
                } grep { defined $_->{abbr} } @{$specials};
@@ -160,10 +251,6 @@ sub showval {
                my ($row) = @_;
                local $_ = $row;
                $_->{hp} += $_->{shield} if $_->{shield};
-               my $suitchar = '';
-               if ($_->{suit}) {
-                       $suitchar = [qw/? s m l/]->[$_->{suit}];
-               }
 
                return (
                        '<td class="val min">' . ($_->{min} // ''),
@@ -172,45 +259,110 @@ sub showval {
                                !!$_->{base} && '<span class="unit-composed">+</span>',
                                $_->{build} || '0',
                        ),
-                       !$suitchar ? '<td>' : sprintf('<td class="unit unit-%s">%s', $suitchar, ucfirst $suitchar),
-                       '<td class="val unit">' . join('',
-                               defined $_->{unit} && $_->{unit} == .5 ? '½' : $_->{unit},
-                               defined $_->{organic} && sprintf(
-                                       '<span class="unit-%s" title="%s">%s</span>',
-                                       $_->{organic} ? 'o' : 'u',
-                                       $_->{organic} ? 'organic' : 'mechanic',
-                                       $_->{organic} ? 'o' : 'm',
+                       sprintf('<td class="unit unit-%s" title="%4$s%3$s">%s',
+                               $_->            {cargo} < 0 ? ('supply',           T => 'transport') :
+                               $_->{upgraded}->{cargo} < 0 ? ('supply magic-opt', T => 'optional transport') :
+                               $_->{attr}->{flying}    ? ('air', F => 'flying') :
+                               $_->{attr}->{structure} ? ('x',   B => 'building') :
+                               (
+                                       [qw( x s m l l h h h h )]->[ $_->{cargo} ],
+                                       $_->{cargo} || '-',
+                                       $_->{cargo} ? 'transportable' : 'untransportable',
                                ),
+                               defined $_->{size} && sprintf('⌀%.1f ', $_->{size}),
                        ),
-                       '<td class="val unit-hp">' . $_->{hp} // '',
-                       '<td class="val unit-shield">' . (
-                               $_->{shield} ? sprintf('%.0f%%', 100 * $_->{shield} / $_->{hp}) : '&nbsp;'
+                       sprintf('<td class="val unit%s">%s',
+                               defined $_->{pop} && $_->{pop} < 0 && ' unit-supply',
+                               defined $_->{pop} && $_->{pop} == .5 ? '½' : $_->{pop},
                        ),
-                       '<td class="val unit-armor">' . showval($_, 'armor'),
-                       showattack($_, 'ground'),
-                       showattack($_, 'air'),
-                       '<td class="val unit-range">' . showval($_, 'attack', 'range'),
+                       '<td class="unit unit-type">' . join('', grep { $_ }
+                               (defined $_->{organic} ? !$_->{organic} : $_->{attr}->{mech})
+                                       && '<span class="unit-u" title="mechanic">m</span>',
+                               ($_->{organic} || $_->{attr}->{organic})
+                                       && '<span class="unit-o" title="organic">o</span>',
+                               $_->{attr}->{psionic}
+                                       && '<span class="unit-p" title="psionic">ψ</span>',
+                       ),
+                       '<td class="unit unit-attr">' . join('', grep { $_ }
+                               $_->{attr}->{armored}
+                                       && '<span class="unit unit-l" title="armored">A</span>',
+                               $_->{attr}->{light}
+                                       && '<span class="unit unit-s" title="light">L</span>',
+                               $_->{suit} && sprintf(
+                                       '<span class="unit unit-%s" title="%3$s">%s</span>',
+                                       map { @{$_} } [
+                                               [qw( x ? unknown )],
+                                               [qw( s S small )],
+                                               [qw( m M medium )],
+                                               [qw( l L large )],
+                                       ]->[ $_->{suit} ],
+                               ),
+                               $_->{attr}->{massive}
+                                       && '<span class="unit-massive" title="massive">⚓</span>',
+                       ),
+                       '<td class="val unit-hp">' . $_->{hp} // '',
+                       $_->{shield} ? sprintf('<td class="val unit-shield">%.0f%%<td',
+                               100 * $_->{shield} / $_->{hp}
+                       ) : '<td colspan=2',
+                       ' class="val unit-armor">' .
+                               showrangeint($_->{armor}, $_->{upgraded}->{armor}),
+                       showattack($_, 0),
                        '<td class="val unit-sight">' . sprintf(
                                $_->{detect} ? '<strong class="unit-detect">%s</strong>' : '%s',
-                               showval($_, 'sight')
+                               showrangeint($_->{sight}, $_->{upgraded}->{sight})
+                       ),
+                       sprintf('<td class="val unit-speed"%2$s>%s',
+                               showrange(
+                                       map { $_ && sprintf '%.1f', $_ }
+                                       $_->{speed}, $_->{upgraded}->{speed}
+                               ),
+                               defined $_->{creep} && sprintf(' title="%s on creep"',
+                                       $_->{creep} == 1 ? 'same' : showrange(
+                                               map { $_ && sprintf '%.1f', $_ }
+                                               $_->{speed} * $_->{creep},
+                                               $_->{upgraded}->{speed} && $_->{upgraded}->{speed} *
+                                                       ($_->{upgraded}->{creep} // $_->{creep}),
+                                       ),
+                               ),
                        ),
-                       '<td class="val unit-speed">' . showval($_, 'speed'),
+                       $_->{attr}->{jump}
+                               && qq'<span class="unit unit-jump" title="$_->{attr}->{jump}">↕</span>',
                        '<td class="unit-magic">' . showmagic($_),
+                       !$_->{attack}->[1] ? () : (
+                               '<tr><td colspan=12>', showattack($_, 1), '<td colspan=3>'
+                       ),
+                       !$_->{attack}->[2] ? () : (
+                               '<tr><td colspan=12>', showattack($_, 2), '<td colspan=3>'
+                       ),
                        "\n"
                );
        }
 
-       my $units = do $datafile;
-       die "Cannot open unit data: $_\n" for $@ || $! || ();
        my $grouped = 1;  # race headers
        if (exists $get{order}) {
                $grouped = 0;
                $get{order} ||= '';
                if ($get{order} eq 'size') {
-                       $_->{order} = $_->{unit}*8 + $_->{suit} + $_->{hp}/512 + $_->{min}/8192 for @$units;
+                       $_->{order} = (
+                               $_->{pop}*16 + ($_->{size} // $_->{suit}) + $_->{cargo}/8
+                               + $_->{hp}/512 + $_->{min}/8192
+                       ) for @$units;
                }
                elsif ($get{order} eq 'cost') {
-                       $_->{order} = $_->{gas}*1.5 + $_->{min} + $_->{unit}/8 + $_->{build}/256/8 for @$units;
+                       $_->{order} = (
+                               $_->{gas}*1.5 + $_->{min} + $_->{pop}/8 + $_->{build}/256/8
+                       ) for @$units;
+               }
+               elsif ($get{order} eq 'attack') {
+                       $_->{order} = $_->{hp} / 1024 + $_->{shield} / 1008 + max(
+                               map {
+                                       ($_->{damage} + $_->{upgrade} * 3)
+                                       * ($_->{count} // 1) / ($_->{cooldown} // 1)
+                                       * ($_->{splash} ? 1.01 : 1)
+                                       * ($_->{type} eq 'implosive' ? .96 : 1)
+                                       * ($_->{type} eq 'explosive' ? .98 : 1)
+                               } @{ $_->{attack} }
+                       ) for @$units;
                }
                else {
                        $units->[$_]->{order} = $_ for 0 .. $#$units;
@@ -222,7 +374,7 @@ sub showval {
        my ($race, $cat) = ('', '');
        for (@rows) {
                if ($grouped) {
-                       printf '<tbody id="%s"><tr class="race"><th colspan="18"><h2>%s</h2>'."\n",
+                       say sprintf '<tbody id="%s"><tr class="race"><th colspan="20"><h2>%s</h2>',
                                $race = $_->{race}, ucfirst $race
                                        unless $race eq $_->{race};
                }
@@ -232,17 +384,15 @@ sub showval {
 
                print(
                        '<tr>',
-                       sprintf('<t%s class="cat">%s',
-                               $cat ne $_->{cat} ? ('h', $cat = $_->{cat}) : ('d', '&nbsp;')
-                       ),
-                       '<td>' . $_->{name},
+                       '<th class="cat">', $cat ne $_->{cat} && ($cat = $_->{cat}),
+                       '<td>', $_->{name},
                        showunitcols($_),
                );
 
                for my $subrow (@{ $_->{special} }) {
                        $subrow->{alt} or next;
                        print(
-                               '<tr class="alt"><td class="cat"><td>' . $subrow->{alt},
+                               '<tr class="alt"><th class="cat"><td>', $subrow->{alt},
                                showunitcols($subrow),
                        );
                }
@@ -255,56 +405,104 @@ sub showval {
 
 <dl>
 <dt>cost
-       <dd>minerals+gas required to create one unit
+       <dd>minerals and gas required to create one unit
        <dd>includes total expenses if based on existing units
 <dt>build
        <dd>relative time needed to create at least one unit
        <dd>excludes construction of dependencies such as buildings
                and <span class="unit-composed">+</span>parent units
 <dt>size
+       <dd><span class="unit unit-supply">T</span>ransports can fit upto
+               8 non-<span class="unit unit-air">F</span>lying cargo units
+       <dd>number of command points taken while alive
+       <dd><:
+if ($scver{major} > 1) {
+               :>received damage depends on
+               <span class="unit unit-o">o</span>rganic,
+               <span class="unit unit-u">m</span>echanic,
+               <span class="unit unit-p">ψ</span>(ps)ionic,
+               <span class="unit unit-s">L</span>ight, and
+               <span class="unit unit-l">A</span>rmored
+               attributes
+       <dd>massive <span class="unit-massive">⚓</span> units
+               cannot be lifted or slowed and can break force fields<:
+} else {
+               :>abilities may hit only <span class="unit unit-o">o</span>rganic
+               or <span class="unit unit-u">m</span>echanic targets
        <dd>affected by <span class="unit unit-s">S</span>mall,
-               <span class="unit unit-m">M</span>edium,
-               or <span class="unit unit-l">L</span>arge unit damage
-       <dd>number of command points taken per unit
-       <dd><span class="unit unit-o">o</span>rganic/<span class="unit unit-u">m</span>echanic unit
-<dt>HP<dd>
-       total number of hitpoints (including shields)
+               <span class="unit unit-m">M</span>edium, or
+               <span class="unit unit-l">L</span>arge damage<:
+} :>
+<dt>HP
+       <dd>total number of hitpoints (including shields)
+       <dd>everything zerg (except for eggs) regenerates one point every
+               <:= $scver{major} == 1 ? '4½' : '3.7' :> seconds
 <dt>shield
        <dd>percentage of HP in shields
-       <dd>shields always take full damage, irrelevant of unit size
-       <dd>does not take armor bonuses, but upgrades can decrease damage to any shield hit by upto 3
+       <dd><:
+if ($scver{major} > 1) {
+               :>shields always take full damage, irrelevant of unit size
+       <dd><:
+}
+               :>does not take armor bonuses,
+               but upgrades can decrease damage to any shield hit by upto 3
+       <dd><:
+if ($scver{major} > 1) {
+               :>after 10 seconds out of combat, 2 points are recharged per game second<:
+} else {
+               :>recharges one point every 2½ seconds<:
+} :>
 <dt>armor
        <dd>base unit armor
        <dd>can be increased by upto 3 at various facilities
        <dd>each point decreases damage per hit by one, upto a minimum of ½
-       <dd>reduction applies to initial damage, before size penalties <small>(so a plasma hit of 12 to 4 armor large deals 2 damage, not ½)</small>
-<dt>ground/air
-       <dd>damage done per single attack against ground/air units
-       <dd>2nd column indicates relative amount of damage done in
-               1 second of fastest game time
-       <dd>splash damage<span class="unit-splash">+</span> hits nearby objects as well
-       <dd><span class="hurt unit-l">explosive</span> damage does only
-               50% damage to small units, 75% to medium, 100% to large
-       <dd><span class="hurt unit-s">concussive/plasma</span> damage does
-               25% to large, 50% medium, 100% to small units
+       <dd>reduction applies to initial damage, before size penalties
+               <small>(so a plasma hit of 12 to 4 armor large deals 2 damage, not ½)</small>
+<dt>attack
+       <dd>damage per single hit
+       <dd>some weapons fire multiple × times, multiplying armor penalties
+       <dd>splash damage hits all objects nearby <span class="unit-splash">⁜</span>
+               or in a straight line <span class="unit-splash">+</span>.
+       <dd><:
+if ($scver{major} > 1) {
+               :>does not include <span>&ge;</span>bonus damage
+               dealt to susceptible unit types
+       <dd><span class="unit-pdd">•</span>projectile shots are negated by
+               Point Defense Drones<:
+} else {
+               :><span class="unit-l">*</span>explosive damage does only
+               50% damage to <span class="unit unit-s">S</span>mall units,
+               75% to <span class="unit unit-m">M</span>edium,
+               100% to <span class="unit unit-l">L</span>arge
+       <dd><span class="unit-s">~</span>concussive/plasma damage does
+               25% to <span class="unit unit-l">L</span>arge,
+               50% <span class="unit unit-m">M</span>edium,
+               100% to <span class="unit unit-s">S</span>mall units<:
+} :>
+       <dd><span class="hurtrel">dps</span> indicates relative total amount of damage
+               done in 1 second of <:= $scver{major} > 1 ? '<em>Normal</em> in-game time' :
+               'time on <em>Fast</em> game speed' :>
+       <dd>targets <span class="hurt-g">▽</span>&nbsp;ground
+               and/or  <span class="hurt-a">△</span>&nbsp;air
+<dt>range
+       <dd>maximum hex distance a weapon can fire (note Sieged Tank also has a minimum)
 <dt>sight
        <dd>range in which the unit detects other units
        <dd><strong class="unit-detect">emphasis</strong> indicates ability to detect cloaked units
-<dt>range
-       <dd>maximum range of weapon (note siege tank also has a minimum range)
 <dt>speed
-       <dd>relative speed of movement (when in full motion, startup speed ignored)
+       <dd>top movement speed in hex per second
+       <dd>acceleration and deceleration ignored
 <dt>specials
-       <dd>special abilities are usually casted manually, but some are <span class="magic-perma">always active</span>
        <dd>parentheses () indicate that it needs to be researched first
+       <dd><span class="magic-perma">passive</span> abilities are always enabled
        <dd>hover for description
-       <dd>range is maximum range required to activate
-       <dd>cost is percentage of total energy lost
+       <dd>range is maximum distance allowed to activate
+       <dd>cost describes energy loss percentage on spawn and when fully charged
 </dl>
 
 <p>
-When two values are given (1-2), second value indicates attribute after all
-possible upgrades.
+When two values are given (1-2), the second value indicates the attribute
+after all possible upgrades.
 </p>
 
 </div>