bigshot1.lic

=begin

	bigshot.lic: the new optimus prime

	hunting script for hunting

	      author: Sheikhh
	contributers: SpiffyJr, Tillmen
	        game: Gemstone
	        tags: hunting
	     version: 3.0

	changelog:
		3.0 (2015-05-30):
			stop trying to attack monsters that aren't in the room (wild guess, untested)
			bumped version up from 2.12052012 to 3.0, because 2.12052012 is a stupid version format
			added message to trust script
        3.01 (2015-12-01):by Kalros
            Rewrote parts of the targeting section and wander section to remove poaching.
            Removed group hunt section as it was part of the poaching issue.  Will address later.
            Added exec script to account for ambushers.

=end

#Kalros To-Do List
# Add group check back to poach check
# Add familiar/ranger pets to poach check
# Add more regex messaging to ambush portion.


# FIXME: Use new empty_hand(s)/fill_hand(s)
# FIXME: Is poaching?() redundant?
# FIXME: Instead of the head reiterating :ATTACK to tail every 15 seconds, have the tail loop upon :ATTACK until the room id changes

$bigshot_debug = false
$exec_ambush = false

if $SAFE > 0
	echo "error: This script needs to be trusted to work. (;trust #{script.name})"
	exit
end

require 'drb'

# fixme: these constants and global variables could conflict with other scripts
BIGSHOT_VERSION ||= '3.0'
RALLY_TIME ||= 5
REST_INTERVAL ||= 30
$rest_reason = nil
$not_hunting_reason = nil
$bigshot_status = nil
$bigshot_should_rest = false

def spam
    def waitcastrt?
        return if Spell[515].active?
        if (XMLData.cast_roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f) > 0
            sleep((XMLData.cast_roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f).abs)
        end
    end

    def waitrt?
        if (XMLData.roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f) > 0
            sleep((XMLData.roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f).abs)
        end
    end
end

def unspam
    def waitcastrt?
        if (XMLData.cast_roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f) > 0
            sleep((XMLData.cast_roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f + "0.6".to_f).abs)
        end
    end

    def waitrt?
        if (XMLData.roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f) > 0
            sleep((XMLData.roundtime_end.to_f - Time.now.to_f + XMLData.server_time_offset.to_f + "0.6".to_f).abs)
        end
    end
end

before_dying { unspam() }
before_dying { $bigshot.gather_ammo }

class Event
    attr_accessor :type, :created_at, :room_id
    @@RECOGNIZED = [ :HUNTING_PREP_COMMANDS, :HUNTING_SCRIPTS_START, :CAST_SIGNS, :ATTACK,
        :HUNTING_SCRIPTS_STOP, :RESTING_SCRIPTS_START, :RESTING_PREP_COMMANDS, :DISPLAY_WATCH ]

    def initialize( type, time_stamp, room_id )
        raise "Event type not recognized" unless @@RECOGNIZED.include?(type)
        @type       = type
        @created_at = time_stamp
        @room_id    = room_id
    end

    def stale?
        if( Room.current.id != @room_id || Time.now.to_i - @created_at > 15 )
            return true
        else
            return false
        end
    end

    def type
        return @type
    end
end

class Group
    include DRbUndumped
    attr_accessor :leader, :members

    def initialize()
        @members = Hash.new
    end

    def set_leader(leader)
        @leader = leader
    end

    def add_member(member)
        @members[member.name()] = member
    end

    def size()
        return @members.size
    end

    def get_names
        return @members.keys + [@leader.name]
    end

    def room_id()
        return @leader.room_id()
    end

    def add_event(type)
        @members.each_pair { |k,v|
            begin
                v.add_event( type, Time.now.to_i, Room.current.id )
            rescue
                @leader.message("Error adding #{type.to_s} event to members stack: #{$!}")
                @leader.message($!.backtrace.join("\n"))
            end
        }
    end
 
    def add_leader_event(event)
        @leader.add_event( Event.new(event) ) unless @leader.event_stack.size > 5
    end

    def roundtime?()
        @members.each_pair { |k,v|
            begin
                return true if v.rt? > 0
            rescue
                @leader.message("Error polling member for RT. Removing!")
                @members.delete(k)
            end
        }
        return false
    end

    def should_hunt?()
        emergency = @leader.event_stack.size == 0 ? nil : @leader.event_stack.shift
        if(emergency)
            @leader.clear_events
            return false
        end

        @members.each_pair { |k,v|
            begin
                return false if !v.should_hunt?
            rescue
                @leader.message("Error polling member. Removing!")
                @members.delete(k)
            end
        }
		$bigshot_status = :hunting
        return true
    end

    def should_rest?()
        @members.each_pair { |k,v|
            begin
                return false if !v.should_rest?
            rescue
                @leader.message("Error polling member. Removing!")
                @members.delete(k)
            end
        }
        return true
    end
    
    def emergency_rest?()
        @members.each_pair { |k,v|
            begin
                return true if v.wounded?
            rescue
                @leader.message("Error polling member. Removing!")
                @members.delete(k)
            end
        }
        return false
    end
end

class Bigshot
    include DRbUndumped
    attr_accessor :BIRTH_TIME, :START_TIME, :STORED_TIMES, :FRIED, :OOM,
        :SIGNS, :TARGETS, :INVALID_TARGETS, :FLEE_COUNT, :ALWAYS_FLEE_FROM,
        :USE_WRACKING, :AMMO, :AMMO_CONTAINER, :HIDE_FOR_AMMO,
        :REST_TILL_EXP, :REST_TILL_MANA, :USE_HERBS, :DEAD_MAN_SWITCH,
        :RESTING_ROOM_ID, :RESTING_COMMANDS, :RESTING_SCRIPTS, :HUNTING_ROOM_ID,
        :HUNTING_BOUNDARIES, :HUNTING_SCRIPTS, :HUNTING_COMMANDS,
        :DISABLE_COMMANDS, :HUNTING_STANCE, :HUNTING_PREP_COMMANDS,
        :MONITOR_INTERACTION, :FLEE_CLOUDS, :WRACKING_SPIRIT,
        :REST_TILL_SPIRIT, :BOUNTY_MODE,
        :event_stack, :followers

    PRONE = /sleeping|webbed|stunned|kneeling|sitting|^lying|prone/

    def add_event( type, time_stamp, room_id )
        unless( @event_stack.size > 5 && type == :ATTACK )
            @event_stack.push( Event.new( type, time_stamp, room_id ) )
        end
    end

    def grab_event()
        @event_stack.shift()
    end

    def clear_events()
        @event_stack.clear
    end

    def initialize(bounty_mode=nil)
		$bigshot = self
        if bounty_mode
            @BOUNTY_MODE = true
        end
		
        UserVars.op ||= Hash.new
        CharSettings['targetable']   ||= Array.new
        CharSettings['untargetable'] ||= Array.new
        @BIRTH_TIME   = Time.now.to_i
        @START_TIME   = 1
        @STORED_TIMES = Array.new

        @followers = nil
        @event_stack = Array.new

        load_settings()
        dead_man_switch()

        # this is mainly for azbounty:
        before_dying {
            @HUNTING_SCRIPTS.each { |i|
                echo "Cleaning up hunting scripts: #{i}."
                stop_script(i) if running?(i)
            }
        }
                
    end
	
	def load_settings()
		set_value_required( 'hunting_commands',     'split_xx' )
        set_value_required( 'fried',                'to_i'     )
        set_value_required( 'oom',                  'to_i'     )
        set_value_required( 'rest_till_mana',       'to_i'     )
        set_value_required( 'rest_till_exp',        'to_i'     )

        set_value( 'hunting_room_id',      'to_i',  4 )
        set_value( 'resting_room_id',      'to_i',  4 )
        set_value( 'hunting_boundaries',   'split',    Array.new )
        set_value( 'hunting_commands_b',   'split_xx', Array.new )
        set_value( 'hunting_commands_c',   'split_xx', Array.new )
        set_value( 'disable_commands',     'split_xx', Array.new )
		
        set_value( 'targets',          'targets',         nil       )
        set_value( 'dead_man_switch',     '',             false     )
        set_value( 'monitor_interaction', '',             false     )
        set_value( 'depart_switch',       '',             false     )
        set_value( 'encumbered',       'to_i',            200       )
        set_value( 'signs',            'split',           Array.new )
        set_value( 'spam',             '',                true      )
        set_value( 'flee_count',       'to_i',            10        )
        set_value( 'wracking_spirit',  'to_i',            0         )
        set_value( 'invalid_targets',  'split',           Array.new )
        set_value( 'always_flee_from', 'split',           Array.new )
        set_value( 'flee_clouds',      '',                false     )
        set_value( 'use_wracking',     '',                false     )
        set_value( 'lone_targets_only', '',               false     )
        set_value( 'rest_till_spirit', 'to_i',            0         )
        set_value( 'ammo',             '',                nil       )
        set_value( 'ammo_container',   '',                nil       )
        set_value( 'fresh_wand_container',   '',          nil       )
        set_value( 'dead_wand_container',    '',          nil       )
        set_value( 'wand',                   '',          nil       )
        set_value( 'wand_if_oom',            '',          false     )
        set_value( 'hide_for_ammo',    '',                nil       )
        set_value( 'wounded_eval',     '',                nil       )
        set_value( 'resting_scripts',  'split',           Array.new )
        set_value( 'hunting_scripts',  'split',           Array.new )
        set_value( 'loot_script',      '',                nil       )
        set_value( 'hunting_stance',   '',                'defensive')
        set_value( 'resting_commands',           'split_xx',      Array.new )
        set_value( 'hunting_prep_commands',      'split_xx',      Array.new )
	end

    def clean_value( clean, value )
        if( clean == 'to_i' )
            return value.to_i
        elsif( clean == 'split' )
            return value.split(/,\s*/)
        elsif( clean == 'split_xx' )
            cleaned = Array.new
            value.split(/,\s*/).each { |i|
                rep = 1
                cmd = ''
                if( i =~ /(.*)\(x(\d+)\)$/ )
                    rep = $2.to_i
                    cmd = $1
                elsif( i =~ /(.*)\(xx\)/ )
                    rep = 5
                    cmd = $1
                else
                    cmd = i
                end
                and_tokens = cmd.split(/\sand\s/)
                cmd = and_tokens.size == 1 ? and_tokens[0] : and_tokens
                rep.times do cleaned.push(cmd) end
            }
            return cleaned
        elsif( clean == 'targets' )
            targets = Hash.new
            tokens = value.split(/,/)
            tokens.each do |i|
                if( i =~ /(.*)\(([a|b|c|A|B|C])\)/ )
                    targets[$1.downcase.strip] = $2.downcase.strip
                else
                    targets[i.downcase.strip] = 'a'
                end
            end
            return targets
        else
            return value
        end
    end

    def set_value( key, clean, default )
        if( !UserVars.op[key].nil? && UserVars.op[key] !~ /^\s*$/ )
            cleaned = clean_value( clean, UserVars.op[key] )
            instance_variable_set( "@#{key.upcase}", cleaned )
        else
            instance_variable_set( "@#{key.upcase}", default )
        end
    end

    def set_value_required( key, clean )
        if( !UserVars.op[key].nil? && UserVars.op[key] !~ /^\s*$/ )
            set_value( key, clean, nil )
        else
            message("ERROR: Missing required setting: #{key}")
            message("(fried? is percenthealth and oom is percentmana)")
            Script.self.kill
        end
    end

    def cmd( command, npc = nil, stance_dance = true )
        command = command.dup

        if( command.class.to_s == 'Array' )
            stance_dance = false if command.any? { |j| j =~ /stance/ }
            command.each do |i|
                echo i if $bigshot_debug
                cmd( i, npc, stance_dance )
            end
            return
        end

        # check mana/stamina
        if( command =~ /(.*)\(([s|m])(\d+)\)$/ )
            if( $2 == 's' )
                return if !checkstamina($3.to_i)
            elsif( $2 == 'm' )
                return if !checkmana($3.to_i)
            end
            command = $1
        end
        
        if( command =~ /force\s+(.*)\s+(?:till|until)\s+(\d+)/ )            
            cmd_force( $1, $2.to_i, npc )
            return
        end
        
        # sub id
        command.gsub!( /target/, "##{npc.id}" ) if !npc.nil?
        
        # waitrt/waitcastrt
        unless( command =~ /^nudgeweapons?/ )
            waitrt?
            waitcastrt? if command =~ /^\d+|incant/
        end

        # change_stance
        stand()
        unless( command =~ /^(?:\d+|wait|sleep|wand|berserk|script|hide|nudgeweapon)/ )
            change_stance(@HUNTING_STANCE) if stance_dance
        end

        return if npc && !valid_target?(npc)

        if( command =~ /^(\d+)(.*)$/ )
            cmd_spell( $1.to_i, $2.strip, npc )
		elsif( command =~ /^throw/i )
			cmd_throw( npc )
		elsif( command =~ /^k?weed/i )
			cmd_weed( command, npc )
        elsif( command =~ /^wand\s+(.*)/i )
            cmd_wand(npc)
        elsif( command =~ /^hide/i )
            cmd_hide()
        elsif( command =~ /^mstrike/i )
            cmd_mstrike( command, npc )
        elsif( command =~ /^fire/i )
            cmd_ranged(npc)
        elsif( command =~ /^berserk/i )
            cmd_berserk()
        elsif( command =~ /^script\s+(.*?)(\s|$)(.*)/i )
            cmd_run_script( $1, $3 )
        elsif( command =~ /^sleep\s+(\d+)/i )
            cmd_sleep( $1, npc )
        elsif( command =~ /^stance\s+(.*)/i )
            change_stance($1)
        elsif( command =~ /^wait\s+(\d+)/i )
            wait_for_swing( $1.to_i, npc )
        elsif( command =~ /^nudgeweapons?\s*/i )
            cmd_nudge_weapons
        else
            return if command =~ /1030/ && checkmana < 10
            return if $ambusher_here
            echo "inside cmd: #{command}" if $bigshot_debug
            bs_put command
        end
    end
	
	def cmd_throw( npc )
		unless npc.status == 'lying down'
			empty_hands
			dothistimeout "throw ##{npc.id}", 1, /^You attempt to throw a .*\!$/
			waitrt?
			fill_hands
		end
	end
    
    def cmd_force( force_this, goal, npc )
        start = Time.now
        loop {
            cmd( force_this, npc )
            buffer = reget(20)
            buffer.each_with_index { |line, i|
                if( line =~ /^You.*(#{checknpcs.join('|')})(\.|!)|^You feint (high|low|(to the (left|right)))/ )
                    if buffer[i + 1] && buffer[i + 1] =~ /== \+(\d+)/
                        return if $1.to_i >= goal # spell/swing
                    elsif buffer[i - 1] && buffer[i - 1] =~ /^\[Roll result: (\d+)/
                        return if $1.to_i >= goal # cman
                    elsif buffer[i + 1] =~ /^As you focus on your magic, your vision swims with a swirling haze of crimson/
                        return
                    end
                elsif( line =~ /^You do not have enough stamina to attempt this maneuver\./ )
                    return
                elsif( line =~ /^Your magic fizzles ineffectually\./ )
                    return
                end
            }
            if ( force_this =~ /^(\d+) / && !Spell[$1.to_i].affordable? )
                message("Force ran out of mana. Giving up."); return;
            end
            return if GameObj.npcs.size.nil? || GameObj.npcs.size == 0
            return if should_flee?
            return if should_rest?
            return if npc.status =~ /dead|gone/
            return if ( Time.now - start ) > 30
        }
    end
	
	def cmd_weed( command, target )
		return if target.status =~ /dead|gone/
		return if GameObj.loot.find { |loot| loot.name =~ /vine/ }
		return unless Spell[610].known? and Spell[610].affordable?
		
		waitcastrt?
		change_stance('offensive') if command == 'kweed'
		Spell[610].cast("##{target.id}")
		change_stance('guarded') if command == 'kweed'
		waitcastrt?
	end

    def cmd_spell( id, target_id, target )
        if ( checkprep != "None" and checkprep != Spell[id].name )
            fput 'release'
        end

        return if id == 506 and Spell[506].active?
        return if id == 9605 and Spell[9606].active? # surge cooldown
		return if target.status =~ /dead|gone/
        unless( Spell[id].affordable? )
            if(@WAND_IF_OOM)
                cmd_wand(target); return;
            end
            if(@USE_WRACKING)
                wrack()
            end
        end
		
		if ( !Spell[id].affordable? and id != 9605 and id != 506 )
			$bigshot_should_rest = true
			$rest_reason = "out of mana"
		end
        waitcastrt?
        Spell[id].cast(target_id)
    end

    def cmd_wand(target)
        if(@FRESH_WAND_CONTAINER)
            hands = GameObj.right_hand.name.to_s + GameObj.left_hand.name.to_s
            wand  = ( @WAND && @WAND !~ /^\s*$/ ) ? @WAND : 'wand'
            until( (GameObj.right_hand.name.to_s + GameObj.left_hand.name.to_s) =~ /#{wand}/i )
                result = dothistimeout( "get #{wand} from my #{@FRESH_WAND_CONTAINER}", 3, /You remove|You slip|Get what/ )
                if( result =~ /Get what/ )
                    message("ERROR: Couldn't find fresh wand. Gonna rest."); $bigshot_should_rest = true; return;
                elsif(result.nil?)
                    message("ERROR: Timed out looking for wand."); return;
                end
            end

            change_stance('offensive')
            result = dothistimeout( "wave my wand at ##{target.id}", 2, /d100|You hurl|is already dead|You do not see that here|You are in no condition|I could not find|Wait/ )
            change_stance('defensive')
            
            if( result =~ /You are in no condition/ )
                message("ERROR: Wounded. Gonna rest."); $bigshot_should_rest = true; return;
            elsif(result.nil?)
                if(@DEAD_WAND_CONTAINER)
                    bs_put "put my wand in my #{@DEAD_WAND_CONTAINER}"
                else
                    bs_put "drop my wand"
                end
            end
        else
            message("ERROR: Wand command called but fresh wand container not defined.")
        end
    end

    def cmd_hide()
        tries = 0
        until(hiding?)
            break if tries > 3 || should_flee?
            change_stance('defensive')
            bs_put 'hide'; tries += 1;
        end
    end

    def cmd_mstrike( command, target )
        if( !Spell[9005].active? && Skills.multiopponentcombat >= 30 && GameObj.npcs.all? { |i| i.noun !~ /nest/i } )
            if( GameObj.npcs.size > 1 and target.nil? )
                bs_put "mstrike"
            else
                bs_put "mstrike ##{target.id}"
            end
        else
            bs_put "kill ##{target.id}"
        end
    end

    def cmd_ranged(npc)
        waitrt?

        result = dothistimeout "get 1 my #{@AMMO.sub(/s$/, '')}", 2, /You remove|Get what\?|You already/
		if( result =~ /Get what\?/ )
			$bigshot_should_rest = true
            $rest_reason = "Out of ammo"
			return
		end
		
        result = dothistimeout(
            "fire ##{npc.id}",
            2,
            /You fire|You cannot|Could not find|seconds|Get what?/
        )
        if( result =~ /^Could not find/ )
			#$bigshot_should_rest = true
            #$rest_reason = "Out of ammo"
			gather_ammo
		elsif( result =~ /You cannot fire/ )
			unless GameObj.right_hand.id.nil?
				line = dothistimeout "stow ##{GameObj.right_hand.id}", 3, /put|closed/
				if line =~ /closed/
					fput "open my #{@AMMO_CONTAINER}"
					fput "put ##{GameObj.right_hand.id} in my ##{@AMMO_CONTAINER}"
				end
			end
		elsif( result =~ /but it has no effect/ )
            $bigshot_should_rest = true
            $rest_reason = "Ammo had no effect (need blessed or magical)"
		elsif ( result == false )
			$bigshot_should_rest = true
			$rest_reason = "Unknown result from fire routine: #{result}"
        end
    end

    def cmd_berserk()
        if( checkstamina(20) )
            put 'stance def'
            until( get =~ /^Everything around you turns red|^You scream/ )
                bs_put 'berserk'
            end
            until( get =~ /^The redness fades from the world/ )
                break if checkmind(7)
            end
        else
            bs_put 'target random'; bs_put 'kill';
        end
    end

    def cmd_run_script( name, args )
        if( args == nil || args =~ /^\s*$/ )
            run_script( name, true )
        else
            args = args.split(/ /)
            run_script( name, true, args )
        end
    end

    def cmd_sleep( time, npc )
        change_stance('defensive')
        time.to_i.times do
            sleep 1
            break if should_rest?
            break if npc && npc.status =~ /dead|gone/
        end
    end
    
    def cmd_nudge_weapons()
        return if checkpaths.size == 0

        GameObj.loot.each { |i|
            next unless i.noun =~ /axe|scythe|pitchfork|falchion|sword|lance|sword|dagger|estoc|falchion|handaxe|katana|katar|gauche|rapier|scimitar|whip-blade|cudgel|crowbill|whip|mace|star|hammer|claidhmore|flail|flamberge|maul|pick|staff|mattock/
            change_stance('defensive')
            
            sheathed = false
            unless( righthand.nil? || lefthand.nil? )
                sheathed = true
                fput 'sheath'
                unless( righthand.nil? || lefthand.nil? )
                    message("Unable to empty hands via sheath.")
                    return
                end
            end
        
            dirs = checkpaths
            dir  = checkpaths.shift
            fput "get ##{i.id}"
            put dir
            put "drop ##{i.id}"
            fput reverse_direction(dir)
            fput "gird" if sheathed
        }
    end

    def message(text)
        string = ''
        if $fake_stormfront then string.concat("\034GSL\r\n ") else string.concat("<pushBold\/>") end
        if( text.index('\n') )
            text.split('\n').each { |line| string.concat("| #{line}") }
        else
            string.concat('| ' + text)
        end
        if $fake_stormfront then string.concat("\034GSM\r\n ") else string.concat("<popBold\/>") end
        puts string
    end

    def dead_man_switch()
        if @DEAD_MAN_SWITCH
            Thread.new {
                while( running?('bigshot') )
                    if( dead? ||  percenthealth < 40 )
                        echo 'AUTOBOT ALERT: Your character is in trouble!'
                        fput 'quit'
                    end
                    sleep 2
                end
            };
        elsif @DEPART_SWITCH
            start_exec_script( <<-EOF
                while( running?('bigshot') );
                    if(dead?);
                        stop_script('bigshot');
                        fput 'depart'; fput 'depart';
                        fput 'depart confirm'; fput 'depart confirm';
                        start_script('waggle');
                        15.times { sleep 60; fput info; };
                        sleep 1 until percentspirit == 100 && !running?('waggle');
                        start_script( 'bigshot', ['solo'] );
                        Script.self.kill;
                    end;
                    sleep 5;
                end;
                EOF
            );
        else
            Thread.new {
                loop { Script.self.kill if dead?; sleep 5; }
            }
        end
    end

    def keep_awake()
        Thread.new {
            while( running?('bigshot') )
                sleep 150; put 'look';
            end
        }
    end 

    def monitor_interaction()
        if @MONITOR_INTERACTION
            start_exec_script( <<-eos
                def show_window(line);
                    window_title = Char.name + ':' + line;
                    Gtk.queue {
                        $myWindow = Gtk::Window.new;
                        $myWindow.title = "Autobot Alert!";
                        $myWindow.set_size_request(450, 25);
                        label = Gtk::Label.new window_title;
                        $myWindow.add(label);
                        $myWindow.show_all;
                    };
                end;
                while(line = get);
                    break unless running?('bigshot');
                    if(line =~ /SEND|POLICY|[Rr](\s)*[Ee](\s)*[Pp](\s)*[Oo](\s)*[Rr](\s)*[Tt]|peaking to you|unresponsive|taps you|nods to you|lease respond|not in control|character|violation|lease speak|peak out loud|Y U SHOU D|whispers,|speaking to you|smiles at you|waves to you|grins at you|hugs you|takes hold your hand|grabs your hand|clasps your hand|trying to drag you/);
                        unless(line =~ /LNet/);
                            show_window(line);
                            echo "AUTOBOT ALERT: " + line;
                        end;
                    end;
                end;
            eos
            )
        end
    end

    def wrack()
        if Spell[9918].known? and not Spell[9012].active?
            Spell[9918].cast if checkspirit >= @WRACKING_SPIRIT
        elsif Spell[9718].known?
            ( checkstamina / 50 ).times { Spell[9718].cast }
        end
    end

    def change_stance( new_stance, force = true )
        #return unless new_stance =~ /off/ # pookahs/bog
        return if Spell[1617].active? || Spell[216].active? || dead?

        if( stance() =~ /#{new_stance}/ )
            return
        elsif( checkcastrt() > 0 && new_stance =~ /def/ )
            return if stance() == 'guarded'
        end

        if(force)
            result = dothistimeout( "stance #{new_stance}", 3, /You are now in an?|Cast Round Time in effect|You are unable to change/ )
        else
            put "stance #{new_stance}"
        end
    end

    def wait_for_swing( seconds, target = nil )
        status_tags
        start = Time.now
        swung = false
        while(1)
            change_stance( 'defensive', false ) unless target && target.status =~ PRONE
            stand()
            
            pcs = checkpcs ? ' you(\.|!|r? )|' + checkpcs.join('|') : 'you(\.|!|r? )'
            break if clear.any? { |line| line =~ /#{target.id}.*(#{pcs})/ && line !~ /^<style id=""\/><style id="roomDesc"\/>|<component id='room objs'>|<compDef id='room objs'>/ }
            break if GameObj.npcs.size.nil? || GameObj.npcs.size == 0
            break if should_flee?
            break if target && target.status =~ PRONE
            break if ( Time.now - start ) > seconds
            sleep 0.50
        end
        status_tags
    end

    def croak(message)
        message(message);
        croak_scripts( ['bigshot'] )
    end

    def run_script( name, pause_bigshot = false, args = [] )
        if Script.running.find { |s| s.name.downcase == name.downcase }.paused or running? name
            stop_script name
            wait_while { running? name }
        end

        start_script name, args 
        if pause_bigshot
            wait_until { !running? name }
        end
    end

    def run_scripts( scripts, pause_bigshot = false )
        scripts.each do |i|
            tokens = i.split(/\s+/)
            if( tokens.size > 1 )
                run_script( tokens[0], pause_bigshot, tokens[1..-1] )
            else
                run_script( tokens[0], pause_bigshot )
            end
        end
    end

    def croak_script(name)
        kill_script(name) if running?(name)
    end

    def croak_scripts(scripts)
        scripts.each { |i| croak_script(i) }
    end

    def stand()
        until(standing?)
            change_stance('defensive')
            bs_put 'stand'
        end
    end

    def lead( my_group = nil )
        monitor_interaction()
        @followers = my_group || Group.new()

        if(should_rest?)
            rest()
        else
            hunt()
        end
    end

    def find_routine(target)
        if( !solo? && fried? )
            return @DISABLE_COMMANDS
        else
			key = @TARGETS.keys.find { |k| target.name =~ /^#{k}$/ or target.noun =~ /^#{k}$/ }
			if key.nil?
				routine_letter = 'a'
			else
				routine_letter = @TARGETS[key]
			end
			
			if routine_letter == 'c'
				return @HUNTING_COMMANDS_C unless @HUNTING_COMMANDS_C.size == 0
			elsif routine_letter == 'b'
				return @HUNTING_COMMANDS_B unless @HUNTING_COMMANDS_B.size == 0
			end
			
			return @HUNTING_COMMANDS
        end
    end

    def solo?
        # tails wont have followers
        if( @followers && @followers.size == 0 )
            return true
        else
            return false
        end
    end

    def leading?
        return !following?
    end
    
    def following?
        return @followers.nil?
    end
    
    def no_players()
        return false if GameObj.loot.find { |obj| obj.noun == 'disk' and obj.name !~ /#{Char.name}/}
        return false if checkpcs or $ambusher_here
        return true
    end

    def pre_hunt()
        # prep/go
        @followers.add_event(:HUNTING_PREP_COMMANDS)
        @HUNTING_PREP_COMMANDS.each { |i|
            if i =~ /^script\s+(.*?)(\s|$)(.*)/i
               cmd_run_script( $1, $3 )
            else 
                fput(i)
            end
        }

        @followers.add_event(:CAST_SIGNS)
        cast_signs()

        @followers.add_event(:HUNTING_SCRIPTS_START)
        run_scripts( @HUNTING_SCRIPTS, false )

        goto(@HUNTING_ROOM_ID)
        if( !solo? && @followers.get_names.any? { |i| !checkpcs.include?(i) } )
            @followers.add_event(:CAST_SIGNS) # trigger rubber band
            sleep 10 # wait for followers
        end
    end
    
    def do_hunt()
        spam() if UserVars.op['spam']
        
        start_watch()
        message('Bigshot hunting')

        # loop
        target = nil
        just_arrived = true
        last_attack = 0
        $ambusher_here = false
    
    if $exec_ambush == false then
    start_exec_script( <<-eos
        while(line = get);
            break unless running?('bigshot');
            $ambusher_here = true if line =~ /^\w+ leaps from hiding to attack/;
        end;
        eos
        )
    $exec_ambush = true
    end


    while true
        while( (target = find_target(target, just_arrived)) && !should_rest? && no_players == true)
            echo target if $bigshot_debug
            if( (Time.now.to_i - last_attack > 15) || just_arrived )
                @followers.add_event(:ATTACK)
                last_attack = Time.now.to_i
            end
            attack(target)
            just_arrived = false
            loot() if $ambusher_here == false
        end
        
        echo "Exiting attack loop" if $bigshot_debug
        gather_ammo()

        if(should_rest?)
            break
        else
            prepare_for_movement()
            target = bs_wander()
			sleep 1
            just_arrived = true
        end
        
    end

        unspam()
    end

    # this is a leader method
    def hunt()
        pre_hunt()
        do_hunt()
        rest()
    end

    # this is a leader method
    def rest()
        message("Bigshot resting: #{$rest_reason}")
        $bigshot_should_rest = nil
        if @BOUNTY_MODE # bounty script should take over from here
          echo "Bounty mode. Killing self. Reason: #{$rest_reason}"
          Script.self.kill
        end
          
        stop_watch()

        # prep/go
        goto(@RESTING_ROOM_ID)
        @followers.add_event(:DISPLAY_WATCH)

        @followers.add_event(:HUNTING_SCRIPTS_STOP)
        croak_scripts(@HUNTING_SCRIPTS)
        
        @followers.add_event(:RESTING_PREP_COMMANDS)
        @RESTING_COMMANDS.each { |i| fput(i) }

        @followers.add_event(:RESTING_SCRIPTS_START)
        run_scripts( @RESTING_SCRIPTS, true )

        # loop
        until(should_hunt?)
            fput 'exp'
            display_watch_current()
            display_watch_average()
            display_watch_total()
            message( "Bigshot last rested because: #{$rest_reason}" ) if $rest_reason
            message( "Bigshot isn't hunting because: #{$not_hunting_reason}" ) if $not_hunting_reason
            sleep REST_INTERVAL
        end

        hunt()
    end

    def attack(target)
        commands = find_routine(target)
        echo commands if $bigshot_debug

        commands.each do |i|
            break unless valid_target?(target)
            break if wounded? || $bigshot_should_rest
            break if $ambusher_here
            stand()
            cast_signs()
            
            cmd( i, target )
        end
        echo commands.size if $bigshot_debug
        #sleep 1 if commands.size == 0
    end

    def goto(id)
        prepare_for_movement()
        until( Room.current.id == id )
            run_script( 'go2', true, [ id, '_disable_confirm_' ] )
        end
    end

    def start_watch()
        @START_TIME = Time.now.to_i
    end

    def stop_watch()
        if( @START_TIME > 100 )
            @STORED_TIMES.push( Time.now.to_i - @START_TIME )
        end
        @START_TIME = 0
    end

    def display_watch_current()
        if( @STORED_TIMES.size > 0 )
            seconds = @STORED_TIMES[-1]
            message( sprintf( "Bigshot: Last Hunt: %d min. %0.2f secs.",
                seconds / 60, seconds % 60 ) )
        end
    end

    def display_watch_average()
        average = 0
        if( @STORED_TIMES.size == 1 )
            average = @STORED_TIMES[0]
        elsif( @STORED_TIMES.size > 1 )
            @STORED_TIMES.each { |i| average += i }
            average /= @STORED_TIMES.size
        else
            return
        end
        message( sprintf( "Bigshot: Average Hunt: %d min. %0.2f secs.",
            average / 60, average % 60 ) )
    end

    def display_watch_total()
        total = Time.now.to_i - @BIRTH_TIME
        message( sprintf( "Bigshot: Total Time Running: %d min.  %0.2f secs.",
            total / 60, total % 60 ) )
    end

    def room_id()
        return Room.current.id()
    end

    def name()
        return Char.name
    end

    def poaching?()
        if(leading?)
            checkpcs.each { |i| return true unless @followers.get_names.include?(i) }
            return false
        else
            return false
        end
    end

    def should_flee?( just_entered = false )
        GameObj.loot.each { |i| return true if i.noun == 'cloud' } if @FLEE_CLOUDS
        return true if GameObj.npcs.any?  { |i| @ALWAYS_FLEE_FROM.include?(i.noun) }
        return true if checkpcs.any?      { |i| @ALWAYS_FLEE_FROM.include?(i) }
        return true if !leading? && checkpcs.empty?

        npcs = GameObj.npcs.find_all { |i| i.status !~ /dead|gone/ }
		npcs.delete_if { |npc| (@INVALID_TARGETS.include?(npc.name) or @INVALID_TARGETS.include?(npc.noun)) }
		
		flee_count = (just_entered && @LONE_TARGETS_ONLY) ? 1 : @FLEE_COUNT
		if npcs.size > flee_count
			return true
		end
    end

    def valid_target?( target, just_entered = false )
        return false if target == nil || target == false
        return false if should_flee?(just_entered)
        return false if just_entered && poaching?
        return false if target.noun =~ /child|traveller|scribe|merchant|dignitary|official|magistrate/i
        
        if( !CharSettings['targetable'].include?(target.noun) && !CharSettings['untargetable'].include?(target.name) )
            result = dothistimeout( "target ##{target.id}", 3, /^You are now targeting|^You can't target/ )
            if( result =~ /^You are now targeting/ )
                CharSettings['targetable'].push(target.noun)
            elsif( result =~ /^You can't target/ )
                CharSettings['untargetable'].push(target.noun)
            end
        end
        return false if CharSettings['untargetable'].include?(target.noun)
        if (target.status !~ /dead|gone/) and GameObj.npcs.any? { |n| n.id == target.id } and (@TARGETS.nil? or @TARGETS.keys.any? { |i| target.name =~ /^#{i}$/i or target.noun =~ /^#{i}$/i })
            return true
        else
            return false
        end
    end

    def sort_npcs()
		targets = @TARGETS
			
		npcs = GameObj.npcs
		sorted = Array.new
		
		targets.keys.each { |target| sorted += npcs.find_all { |npc| (npc.name =~ /^#{target}$/i or npc.noun =~ /^#{target}$/i) }.to_a }
		sorted.flatten
    end
	
    def find_target( target, just_entered = false )
        return target if valid_target?(target, just_entered)
		
        sort_npcs.each { |i| return i if valid_target?( i, just_entered ) }
        
        # nothing valid
        return nil
    end

    def rt?()
        return checkrt()
    end

    def fried?()
        if( percentmind() >= @FRIED )
            return true
        end
        return false
    end

    def oom?()
        if( percentmana() < @OOM )
            return true
        end
        return false
    end

    def ammo_on_ground(ammo)
        return GameObj.loot.find { |i| i.name =~ /^#{ammo}$/i or i.noun =~ /#{ammo}s?/i }
    end

    def gather_ammo()
        ammo = @AMMO; container = @AMMO_CONTAINER; hide = @HIDE_FOR_AMMO;
        return if ammo == nil || wounded?
 
        while( ammo_on_ground(ammo) )
            change_stance('defensive')
			
			unless GameObj.right_hand.id.nil?
				line = dothistimeout "stow ##{GameObj.right_hand.id}", 3, /put|closed/
				if line =~ /closed/
					fput "open my #{@AMMO_CONTAINER}"
					fput "put ##{GameObj.right_hand.id} in my ##{@AMMO_CONTAINER}"
				end
			end
			
            result = dothistimeout(
                "gather #{ammo}",
                2,
                /^You gather|^You pick up|^I could not|^What were you|^You may only|reach|on the ground/
            )
			
			if( result =~ /on the ground/)
				result = dothistimeout "get arrows", 3, /^You gather|^You pick up|^I could not|^What were you|^You may only|reach|on the ground/
			end

            if( result =~ /^You gather|^You pick up/ )
                dothistimeout(
                    "put my #{ammo} in my #{ammo} in my #{container}",
                    2,
                    /^I could not find|^You can't seem to|^You add|^You bundle|You cannot bundle/
                )
                bs_put "put my #{ammo} in my #{container}" if righthand?
			elsif( result =~ /You may only/ )
				return
            elsif( result == false || result =~ /^I could not find|^What were you/ )
                return
            elsif( result =~ /reach/ )
				bs_put 'hide' if hide and not hidden?
				sleep 4
            end
        end
    end

    def wounded?()
        if(@WOUNDED_EVAL)
            return eval @WOUNDED_EVAL
        else
            return false
        end
    end

    def should_hunt?()
        if(wounded?)
            $not_hunting_reason = 'wounded.'
            return false
        end
        if( percentencumbrance >= @ENCUMBERED )
            $not_hunting_reason = 'encumbered.'
            return false
        end
        if( @RESTING_SCRIPTS.any? { |i| running?(i) } )
            $not_hunting_reason = 'resting scripts still running.'
            return false
        end

        followers_should = (leading? && !solo?) ? @followers.should_hunt? : true
        if(followers_should)
            if( percentmind() > @REST_TILL_EXP )
                $not_hunting_reason = 'mind still above threshold.'
                return false
            elsif( percentmana() < @REST_TILL_MANA )
                $not_hunting_reason = 'mana still below threshold.'
                return false
            elsif( checkspirit() < @REST_TILL_SPIRIT )
                $not_hunting_reason = 'spirit still below threshold.'
                return false
            end
        else
            $not_hunting_reason = 'followers still need rest.'
            return false
        end
		$bigshot_status = :hunting
        return true
    end

    def should_rest?()
        if($bigshot_should_rest)
            $rest_reason = "$bigshot_should_rest was set to true." unless $rest_reason
			$bigshot_status = :resting
            return true
        elsif(wounded?)
            $rest_reason = "wounded."
			$bigshot_status = :resting
            return true
        elsif( percentencumbrance >= @ENCUMBERED )
            $rest_reason = "encumbered."
			$bigshot_status = :resting
            return true
        elsif( leading? && !solo? && @followers.emergency_rest? )
            $rest_reason = "emergency rest."
			$bigshot_status = :resting
            return true
        end

        followers_fried = (leading? && !solo?) ? @followers.should_rest? : true

        if(followers_fried)
            if(fried?)
                $rest_reason = "fried."
				$bigshot_status = :resting
                return true
            elsif(oom?)
                wrack() if @USE_WRACKING
                return false if !oom?
                
                $rest_reason = "out of mana."
				$bigshot_status = :resting
                return true
            end
        end
        
        $rest_reason = "none."
        return false
    end

    def cast_signs(single_cast = false)
        @SIGNS.each do |i|
            i = i.to_i
			next if [ 9903,9904,9905,9906,9907,9908,9909,9910,9912,9913,9914,9918 ].include?(i) and Spell[9012].active?
            next if i == 9918
            next if i == 9603 && Spell[9604].active?
            next if i == 9605 && Spell[9606].active?
            sign = Spell[i]
            next unless sign.known?

            # wrack?
            mana_cost = sign.mana_cost > 1 ? sign.mana_cost : 0 # Many erroneously return 1
            wrack() if !sign.affordable? and mana_cost > checkmana and @USE_WRACKING

            if( !sign.active? && sign.affordable? )
                if( i  == 9805 )
                    2.times { sign.cast }
                else
                    while(1)
                        result = sign.cast
                        break if result !~ /Spell Hindrance/ || !sign.affordable? || dead?
                    end
                end
				
				break if single_cast
            end
        end
    end

    def loot()
		dead_npcs = GameObj.npcs.find_all { |i| i.status == 'dead' }
        dead_npcs.each { |i|
			change_stance('defensive')
            if(@LOOT_SCRIPT)
                run_script( @LOOT_SCRIPT, true )
                break
            else
                bs_put 'loot'
            end
        }
    end

    def prepare_for_movement()
        change_stance('defensive')
        if( leading? && !solo? )
            wait_while { @followers.roundtime? }
            sleep 1
        end
    end

    def bs_wander()
		wander_last_room = nil
		
        wander = proc {
            room = Room.current
            next_room_options = room.wayto.keys - @HUNTING_BOUNDARIES
            if next_room_options.length > 1
                next_room_options.delete_if { |option| option == wander_last_room }
            end
            next_room = next_room_options[rand(next_room_options.length)]
            way = room.wayto[next_room]
            if way.class == String 
				sleep 0.3
                move(way)
            else
                way.call
            end
			cast_signs(true)
            wander_last_room = room.id.to_s
        }
        
        while true  # wander, check for players
            echo "no_players: #{no_players}" if $bigshot_debug
            npcs = GameObj.npcs
            npcs.delete_if { |npc| (npc.status =~ /dead|gone/) }
            sort_npcs.each { |i| return i if valid_target?( i, true ) and no_players == true and GameObj.npcs.size > 0 } 
            return if should_rest?
            wander.call
            sleep 0.1
            $ambusher_here = false    
        end
    end

    def bs_put(message)
        unless script = Script.self then respond('--- waitfor: Unable to identify calling script.'); return false; end
        clear
        put(message)

        while string = get
            if string =~ /(?:\.\.\.wait |Wait )[0-9]+/
                hold_up = string.slice(/[0-9]+/).to_i
                sleep(hold_up - 1) unless hold_up.nil? || hold_up == 1
                clear
                put(message)
                next
            elsif string =~ /struggle.+stand/
                clear
                bs_put("stand")
                next
            elsif string =~ /stunned|can't do that while|cannot seem|can't seem|don't seem|Sorry, you may only type ahead/
                if dead?
                    echo("You're dead...! You can't do that!")
                    sleep 0.25
                    script.downstream_buffer.unshift(string)
                    return false
                elsif checkstunned
                    while checkstunned
                        sleep("0.25".to_f)
                    end
                elsif checkwebbed
                    while checkwebbed
                        sleep("0.25".to_f)
                    end
                else
                    sleep(0.25)
                end
                clear
                put(message)
                next
            else
                script.downstream_buffer.unshift(string)
                return string
            end
        end
    end

    # gui
    def self.setup
        Gtk.queue {
            $OP_WINDOW = Gtk::Window.new
            $OP_WINDOW.title = "Big Shot: v#{BIGSHOT_VERSION}"
            $OP_WINDOW.set_border_width(10)
            $OP_BOX = Gtk::VBox.new(false)
            $OP_BOX.set_border_width(5)

            $OP_VERTICAL_BOX1 = Gtk::VBox.new(false, 0)
            $OP_VERTICAL_BOX2 = Gtk::VBox.new(false, 0)
            $OP_VERTICAL_BOX3 = Gtk::VBox.new(false, 0)
            $OP_VERTICAL_BOX4 = Gtk::VBox.new(false, 0)
            $OP_VERTICAL_BOX5 = Gtk::VBox.new(false, 0)
            $OP_VERTICAL_BOX6 = Gtk::VBox.new(false, 0)
            $OP_VERTICAL_BOX7 = Gtk::VBox.new(false, 0)
            $OP_VERTICAL_BOX8 = Gtk::VBox.new(false, 0)

            $OP_WINDOW.add($OP_BOX)
            $OP_NOTEBOOK = Gtk::Notebook.new
            $OP_NOTEBOOK.set_show_border(true)
            $OP_BOX.add($OP_NOTEBOOK)
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX1, Gtk::Label.new('General'))
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX2, Gtk::Label.new('Resting'))
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX3, Gtk::Label.new('Hunting Map'))
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX4, Gtk::Label.new('Hunting'))
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX5, Gtk::Label.new('Attacking'))
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX6, Gtk::Label.new('Should_hunt?')) 
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX7, Gtk::Label.new('Should_rest?'))
            $OP_NOTEBOOK.append_page($OP_VERTICAL_BOX8, Gtk::Label.new('Ammo/Wands')) 

            $OP_ENTRY = Hash.new # For mapping entries to variables
            $OP_TABLE_SIZE = Hash.new # For mapping table sizes
        }

        Gtk.queue {
            $OP_TABLE1 = Gtk::Table.new(6, 3, false)
            $OP_TABLE1.row_spacings=3
            $OP_TABLE1.column_spacings=3
            $OP_VERTICAL_BOX1.pack_start($OP_TABLE1, false, false, 0)

            $OP_TABLE2 = Gtk::Table.new(6, 3, false)
            $OP_TABLE2.row_spacings=3
            $OP_TABLE2.column_spacings=3
            $OP_VERTICAL_BOX2.pack_start($OP_TABLE2, false, false, 0)

            $OP_TABLE3 = Gtk::Table.new(6, 3, false)
            $OP_TABLE3.row_spacings=3
            $OP_TABLE3.column_spacings=3
            $OP_VERTICAL_BOX3.pack_start($OP_TABLE3, false, false, 0)

            $OP_TABLE4 = Gtk::Table.new(6, 3, false)
            $OP_TABLE4.row_spacings=3
            $OP_TABLE4.column_spacings=3
            $OP_VERTICAL_BOX4.pack_start($OP_TABLE4, false, false, 0)

            $OP_TABLE5 = Gtk::Table.new(6, 3, false)
            $OP_TABLE5.row_spacings=3
            $OP_TABLE5.column_spacings=3
            $OP_VERTICAL_BOX5.pack_start($OP_TABLE5, false, false, 0)

            $OP_TABLE6 = Gtk::Table.new(6, 3, false)
            $OP_TABLE6.row_spacings=3
            $OP_TABLE6.column_spacings=3
            $OP_VERTICAL_BOX6.pack_start($OP_TABLE6, false, false, 0)

            $OP_TABLE7 = Gtk::Table.new(6, 3, false)
            $OP_TABLE7.row_spacings=3
            $OP_TABLE7.column_spacings=3
            $OP_VERTICAL_BOX7.pack_start($OP_TABLE7, false, false, 0)

            $OP_TABLE8 = Gtk::Table.new(6, 3, false)
            $OP_TABLE8.row_spacings=3
            $OP_TABLE8.column_spacings=3
            $OP_VERTICAL_BOX8.pack_start($OP_TABLE8, false, false, 0)
        }

        def self.add_label_entry(table, label, variable)
            size = $OP_TABLE_SIZE[table] || 0

            label = Gtk::Label.new(label)
            align = Gtk::Alignment.new 1, 0, 0, 0
            align.set_padding(4, 0, 3, 4)
            align.add(label)
            table.attach(align, 0, 1, size, size + 1)

            entry = Gtk::Entry.new
            entry.text = UserVars.op[variable].to_s
            entry.set_width_request(157)
            table.attach(entry, 1, 2, size, size + 1)

            $OP_ENTRY[variable] = entry
            $OP_TABLE_SIZE[table] += 1
        end

        Gtk.queue {
            $OP_ENTRY = Hash.new
            add_label_entry($OP_TABLE2, "*room id:", 'resting_room_id')
            add_label_entry($OP_TABLE2, "pre-rest commands:", 'resting_commands')
            add_label_entry($OP_TABLE2, "active resting scripts:", 'resting_scripts')
            add_label_entry($OP_TABLE3, "*starting room ID:", 'hunting_room_id')
            add_label_entry($OP_TABLE3, "*boundary rooms:", 'hunting_boundaries') 
            add_label_entry($OP_TABLE4, "valid targets:", 'targets')
            add_label_entry($OP_TABLE4, "attack stance:", 'hunting_stance')
            add_label_entry($OP_TABLE4, "pre-hunt commands:", 'hunting_prep_commands')
            add_label_entry($OP_TABLE4, "active hunting scripts:", 'hunting_scripts')
            add_label_entry($OP_TABLE4, "society abilities/spells/cmans:", 'signs')
            add_label_entry($OP_TABLE4, "loot script:", 'loot_script')
            add_label_entry($OP_TABLE4, "wracking spirit >=", 'wracking_spirit')
            add_label_entry($OP_TABLE5, "*hunting commands:", 'hunting_commands')
            add_label_entry($OP_TABLE5, "hunting commands(b):", 'hunting_commands_b')
            add_label_entry($OP_TABLE5, "hunting commands(c):", 'hunting_commands_c')
            add_label_entry($OP_TABLE5, "fried hunting commands:", 'disable_commands')
            add_label_entry($OP_TABLE5, "flee if enemy count is >", 'flee_count')
            add_label_entry($OP_TABLE5, "...but don't count these:", 'invalid_targets')
            add_label_entry($OP_TABLE5, "...and always flee from:", 'always_flee_from')
            add_label_entry($OP_TABLE6, "*when percentmind <=", 'rest_till_exp')
            add_label_entry($OP_TABLE6, "...*and percentmana >=", 'rest_till_mana')
            add_label_entry($OP_TABLE6, "...and CHECKspirit >=", 'rest_till_spirit')
            add_label_entry($OP_TABLE7, "*when percentmind >=", 'fried')
            add_label_entry($OP_TABLE7, "...*or percentmana <=", 'oom')
            add_label_entry($OP_TABLE7, "...or percentencumbrance >=", 'encumbered')
            add_label_entry($OP_TABLE7, "...or wounded eval:", 'wounded_eval')
            add_label_entry($OP_TABLE8, "find ammo in this container:", 'ammo_container')
            add_label_entry($OP_TABLE8, "use this ammo type:", 'ammo')
            add_label_entry($OP_TABLE8, "fresh wand container:", 'fresh_wand_container')
            add_label_entry($OP_TABLE8, "dead wand container:", 'dead_wand_container')
            add_label_entry($OP_TABLE8, "use this wand type:", 'wand')
        }

        def self.add_checkbox(table, x_pos, label, variable, default = false)
            size = $OP_TABLE_SIZE[table] || 0
            checkbox = Gtk::CheckButton.new label
            value = UserVars.op[variable].nil? ? default : UserVars.op[variable]
            checkbox.set_active(value)
            table.attach(checkbox, x_pos, x_pos + 1, size, size + 1)
            $OP_ENTRY[variable] = checkbox
            $OP_TABLE_SIZE[table] += 1 if x_pos == 1
        end
 
        Gtk.queue {
            add_checkbox($OP_TABLE1, 0, "Engage deadmans switch", 'dead_man_switch')
            add_checkbox($OP_TABLE1, 1, "Monitor interaction", 'monitor_interaction')
            add_checkbox($OP_TABLE1, 0, "Depart/rerun if dead", 'depart_switch')
            add_checkbox($OP_TABLE1, 1, "Flee from clouds", 'flee_clouds') 
            add_checkbox($OP_TABLE4, 1, "Use sign of wracking/sigil of power", 'use_wracking')
            add_checkbox($OP_TABLE5, 1, "Spam attacks (recommended)", 'spam', true)
            add_checkbox($OP_TABLE5, 1, "Approach lone targets only", 'lone_targets_only', false)
            add_checkbox($OP_TABLE8, 1, "Hide while waiting to pick up ammo", 'hide_for_ammo')
            add_checkbox($OP_TABLE8, 1, "Use wands when out of mana", 'wand_if_oom')
        }
        
        Gtk.queue {
            $OP_WINDOW.signal_connect("delete_event") {
                $OP_SETUP_COMPLETED = true
            }
        }
        
        Gtk.queue {
            $OP_TOOLTIPS = Gtk::Tooltips.new
            $OP_TOOLTIPS.enable

            label = Gtk::Label.new
            label.set_markup("<i>Bigshot is the leader of the Battle Patrol.\nHe comes equipped with a gun as long as his entire superstructure.\nTakes the edge off.\n\n\n***Settings with * are required.***</i>")
            align = Gtk::Alignment.new(1, 0, 0, 0)
            align.set_padding(50, 0, 0, 40)
            align.add(label)
            $OP_TABLE1.attach(align, 1, 2, 8, 9)

            commands_tip =  "Example 1: 413 target, 903 target\nExample 2: 903 target(x2)\nExample 3: 903 target(xx)\nExample 4: 910 target(m50), 903 target\n\nExample 1 will cast 413 then 903 on the target. Example 2 will cast 903 on the target twice. Example 3 will cast 903 on the target until the fight is over. Example 4 will cast 910 if mana is at least 50, otherwise it will cast 903. Separate all commands with commas.\n\nNew feature: 'and'.\nFor example: stance def and 1615 target, kill target(xx)"
            $OP_TOOLTIPS.set_tip($OP_ENTRY['hunting_commands'], commands_tip, "")
            $OP_TOOLTIPS.set_tip($OP_ENTRY['g_hunting_commands'], commands_tip, "")
            $OP_TOOLTIPS.set_tip($OP_ENTRY['g_disable_commands'], commands_tip, "")

            signs_tip = "Combat Movement - 9601\nCombat Focus - 9602\nShadow Mastery - 9603\nSurge of Strength - 9605\n\nSigil of Contact - 9703\nSigil of Resolve - 9704\nSigil of Minor Bane - 9705\nSigil of Defense - 9707\nSigil of Offense - 9708\nSigil of Minor Protection - 9710\nSigil of Focus - 9711\nSigil of Mending - 9713\nSigil of Concentration - 9714\nSigil of Major Bane - 9715\nSigil of Major Determination - 9716\nSigil of Major Protection - 9719\n\nSign of Warding - 9903\nSign of Striking - 9904\nSign of Thought - 9906\nSign of Defending - 9907\nSign of Smiting - 9908\nSign of Staunching - 9909\nSign of Deflection - 9910\nSign of Swords - 9912\nSign of Shields - 9913\nSign of Dissipation - 9914\nSign of Madness - 9916\n\nSymbol of Courage - 9805\nSymbol of Protection - 9806"
            $OP_TOOLTIPS.set_tip($OP_ENTRY['signs'], signs_tip, "")

            size = $OP_TABLE_SIZE[$OP_TABLE3]
            label = Gtk::Label.new
            label.set_markup("<i>Note: Big Shot will not enter boundary rooms. The goal is to pin yourself into a hunting area.</i>")
            align = Gtk::Alignment.new(1, 0, 0, 0)
            align.set_padding(75, 0, 0, 4)
            align.add(label)
            $OP_TABLE3.attach(align, 1, 2, size, size + 1)

            size = $OP_TABLE_SIZE[$OP_TABLE4]
            label = Gtk::Label.new
            label.set_markup("<i>Note: Use nouns for targets. Mouse over society abilities field for more info.</i>")
            align = Gtk::Alignment.new(1, 0, 0, 0)
            align.set_padding(0, 0, 0, 4)
            align.add(label)
            $OP_TABLE4.attach(align, 1, 2, size, size + 1)

            size = $OP_TABLE_SIZE[$OP_TABLE5]
            label = Gtk::Label.new
            label.set_markup("<i>Note: Use nouns for flee info. Mouse over some hunting commands field for more info.</i>")
            align = Gtk::Alignment.new(1, 0, 0, 0)
            align.set_padding(0, 0, 0, 4)
            align.add(label)
            $OP_TABLE5.attach(align, 1, 2, size, size + 1)

            $OP_WINDOW.show_all
        }
        
        $OP_SETUP_COMPLETED = false
        until($OP_SETUP_COMPLETED)
            sleep 1
        end
       
        UserVars.op ||= Hash.new
        $OP_ENTRY.keys.each { |key|
            if( $OP_ENTRY[key].class.to_s =~ /CheckButton/ )
                value = $OP_ENTRY[key].active?
                UserVars.op[key] = $OP_ENTRY[key].active?
            else
                if(key == 'wounded_eval')
                    UserVars.op[key] = $OP_ENTRY[key].text
                else
                    UserVars.op[key] = $OP_ENTRY[key].text.strip.downcase
                end
            end
        }
        UserVars.save()
        
        Gtk.queue {
            $OP_WINDOW.destroy
        }
    end
end

if( script.vars[1].nil? || script.vars[1] =~ /solo|(bounty)/i )
    bounty_mode = $1

    bs = Bigshot.new(bounty_mode)
    bs.croak('Requires Lich V4') unless defined?(Gtk.queue)
    bs.croak('Requires a mapped room.') if( Room.current.id.nil? || Room.current.id == 4 )
    bs.lead()

elsif( script.vars[1] =~ /setup/i )
    Bigshot.setup()

elsif( script.vars[1] =~ /display/i )
    echo "Version: #{BIGSHOT_VERSION}"
    UserVars.op.each_pair { |k, v|
        echo "#{k}: #{v}" unless v.nil? || v.class.to_s == 'Array' || v =~ /^\s*$/
    }

elsif( script.vars[1] =~ /head/i )
    # launch DRb server
    DRb.start_service( nil, Group.new )
    uri = DRb.uri
    Thread.new { DRb.thread.join }

    # launch DRb client
    DRb.start_service()
    bs = Bigshot.new()

    # set leader
    my_group = DRbObject.new( nil, uri )
    my_group.set_leader(bs)

    # announce/go
    (1..RALLY_TIME).each { |i| fput "whisper group Bigshot rallying at #{uri}"; sleep 1; }
    bs.lead(my_group)

elsif( script.vars[1] =~ /tail/i )
    # Watch for rally
    group = nil
    bs = nil
    while( group.nil? && bs.nil? )
        if( get =~ /rallying at (.*)\."$/ )

            # create group
            DRb.start_service()
            group = DRbObject.new( nil, $1 )

            # create Bigshot
            bs = Bigshot.new()
            group.add_member(bs)
            bs.keep_awake()
        end
    end

    # Participate
    bs.message("Joined group")
    leader = group.leader.name

    while(!dead?)
        begin
            bs.change_stance('defensive')
            bs.stand()
            sleep 0.25
            
            # grab event
            event = bs.event_stack.size == 0 ? nil : bs.grab_event
            next if event.nil?
            
            # kertwang!
            until( checkpcs.include?(leader) )
                start_script( 'go2', [ group.room_id, '_disable_confirm_' ] )
                wait_while { running?('go2') }
                fput "join #{leader}"
                sleep 1
            end
    
            # process event
            bs.message("event: " + event.type.to_s)
            if( event.type == :HUNTING_PREP_COMMANDS )
                bs.HUNTING_PREP_COMMANDS.each { |i| fput(i) }
    
            elsif( event.type == :CAST_SIGNS )
                bs.cast_signs()
    
            elsif( event.type == :HUNTING_SCRIPTS_START )
                bs.run_scripts( bs.HUNTING_SCRIPTS, false )
    
            elsif( event.type == :ATTACK )
                if( event.stale? ) # consider timestamp and room_id
                    bs.message("skipping attack because it's stale")
                    next
                end

                target = nil
                while( target = bs.find_target(target) )
					total_pcs = GameObj.pcs.count
					break if total_pcs > 0
                    break if event.room_id != Room.current.id # only consider room_id
                    bs.attack(target)
                end
    
            elsif( event.type == :HUNTING_SCRIPTS_STOP )
                bs.croak_scripts(bs.HUNTING_SCRIPTS)
    
            elsif( event.type == :RESTING_PREP_COMMANDS )
                $bigshot_should_rest = nil # need to reset this
                bs.RESTING_COMMANDS.each { |i| fput(i) }
    
            elsif( event.type == :RESTING_SCRIPTS_START )
                bs.run_scripts( bs.RESTING_SCRIPTS, true )
    
            elsif( event.type == :DISPLAY_WATCH )
                if( event.stale? )
                    bs.message("skipping display_watch because it's stale")
                    next
                end
                bs.message( "Bigshot last rested because: #{$rest_reason}" ) if $rest_reason
                bs.message( "Bigshot isn't hunting because: #{$not_hunting_reason}" ) if $not_hunting_reason
                sleep( REST_INTERVAL / 10 )
            end

        rescue
            fput 'leave group'
            if( bs.RESTING_ROOM_ID && bs.RESTING_ROOM_ID != 4 )
                start_script( 'go2', [ bs.RESTING_ROOM_ID, '_disable_confirm_' ] )
                wait_while { running?('go2') }
            end
            echo "Fatal exception!"
            echo $!.to_s
            echo $!.backtrace.join("\n")
            Script.self.kill
        end
    end
end