Custom Auxbox Creations

[LordMortiferus]

Last Update 9.6.2013

Kay, I throw this script into the pool for discussion.First part is a rewritten Str:Dex ratio by TheCrusher. Edit: See Ched's rad and awesome webpage for str:dex ratio script!

statistic.png

! = indicates that me:get_weapon_delay() is used to calculate the values (switches after 50 hits!)
sd = standard deviation
hps = hits/s
Med = Median
kpm = kill per minute
Total = last 500 hits

Code: Select all

auxbox_next_line = 0

function auxbox()
  auxbox_lm_dpscalc () -- has to be called always
  d:auxbox_clear();
  auxbox_next_line = 0
  auxbox_lm_time()           -- Total Time :       00:00:00
  auxbox_lm_hits()           -- Total Hits :            XXX
  auxbox_lm_kills()          -- Total Kills:            XXX
  auxbox_lm_xp_gained()      -- XP gained  :            XXX  
  auxbox_lm_xpps()           -- XP/sec     :            XXX
  auxbox_lm_xppm()           -- XP/min     :            XXX
  auxbox_lm_dmg()            -- Total dmg  :            XXX
  auxbox_lm_dps()            -- Dps from total Values:  XXX 
  auxbox_blank_line()
  auxbox_lm_mean_dmg()       -- mean:    XXX  dmg  YYY  dps
  auxbox_lm_sd_dmg()         -- sd  :    XXX  dmg  YYY  dps
  auxbox_lm_median_dmg()     -- med :    XXX  dmg  YYY  dps
  auxbox_lm_minmax_dmg()     -- min :    XXX  dmg  YYY  dps
                             -- max :    XXX  dmg  YYY  dps
  auxbox_lm_last4dmg()       -- dmg :    XXX  XXX  XXX  XXX
  auxbox_blank_line()
  auxbox_lm_mean_hps()       -- mean:              XXX  hps
  auxbox_lm_sd_hps()         -- sd  :              XXX  hps
  auxbox_lm_median_hps()     -- med :              XXX  hps
  auxbox_lm_minmax_hps()     -- min :              XXX  hps
                             -- max :              XXX  hps
  auxbox_lm_last4hps()       -- hps :    XXX  XXX  XXX  XXX
  auxbox_blank_line()
  auxbox_lm_mean_xp()        -- mean:    XXX   xp  YYY  xps
  auxbox_lm_sd_xp()          -- sd  :    XXX   xp  YYY  xps
  auxbox_lm_median_xp()      -- med :    XXX   xp  YYY  xps
  auxbox_lm_minmax_xp()      -- min :    XXX   xp  YYY  xps
                             -- max :    XXX   xp  YYY  xps
  auxbox_lm_last4xp()        -- xp  :    XXX  XXX  XXX  XXX
  auxbox_blank_line()
  auxbox_lm_mean_kpm()       -- mean:              XXX  kpm
  auxbox_lm_sd_kpm()         -- sd  :              XXX  kpm
  auxbox_lm_median_kpm()     -- med :              XXX  kpm
  auxbox_lm_minmax_kpm()     -- min :              XXX  kpm
                             -- max :              XXX  kpm
  auxbox_lm_last4kpm()       -- kpm :    XXX  XXX  XXX  XXX
end

function auxbox_prop_line(prop_name, prop_val)
  local filler = string.rep(" ", 25 - string.len(prop_name) - string.len(prop_val))
  auxbox_next_line = auxbox_next_line + 1
  d:auxbox_set_line(auxbox_next_line, string.format("%s %s %s", prop_name, filler, prop_val))
end

function auxbox_blank_line()
  auxbox_next_line = auxbox_next_line + 1
end


old_build = {me:get_float_str(),
		     me:get_float_dex(),
			 me:get_float_intel(),
             wl:get_full_name(me.weapon),
             wl:get_full_name(me.shield),
			 wl:get_full_name(me.armour),
			 wl:get_full_name(me.boots),
			 wl:get_full_name(me.gloves),
			 wl:get_full_name(me.hat),
			 wl:get_full_name(me.trousers),
			 wl:get_full_name(me.ring1),
			 wl:get_full_name(me.ring2),
			 wl:get_full_name(me.amulet),
			 wl:get_full_name(me.sigil1),
			 wl:get_full_name(me.sigil2),
			 wl:get_full_name(me.sigil3)}

lm_last_dpst = g_dpst		 
lm_dmg_log = {}
lm_dmgtime_log = {}
lm_hit_count = 0
lm_last_xp = me.xp
lm_xp_log = {}
lm_xptime_log = {}
lm_kill_count = 0

function auxbox_lm_dpscalc ()

 local new_build = {me:get_float_str(),
     	            me:get_float_dex(),
			        me:get_float_intel(),
                    wl:get_full_name(me.weapon),
                    wl:get_full_name(me.shield),
			        wl:get_full_name(me.armour),
			        wl:get_full_name(me.boots),
			        wl:get_full_name(me.gloves),
			        wl:get_full_name(me.hat),
			        wl:get_full_name(me.trousers),
			        wl:get_full_name(me.ring1),
			        wl:get_full_name(me.ring2),
			        wl:get_full_name(me.amulet),
			        wl:get_full_name(me.sigil1),
			        wl:get_full_name(me.sigil2),
			        wl:get_full_name(me.sigil3)}
   
    for i=1,#old_build do
        if old_build[i] ~= new_build[i] then
	     
		 table.remove (old_build, i)
         table.insert (old_build, i, new_build[i])
		    for i,v in pairs(lm_dmg_log) do
             lm_dmg_log[i]=nil
	        end
            for i,v in pairs(lm_dmgtime_log) do
             lm_dmgtime_log[i]=nil
	        end
			for i,v in pairs(lm_xp_log) do
             lm_dmg_log[i]=nil
	        end
            for i,v in pairs(lm_xptime_log) do
             lm_dmgtime_log[i]=nil
	        end
		 lm_hit_count = 0
		 lm_kill_count = 0
		end  
    end

	if lm_hit_count == 0 then
     lm_hunt_start = os.clock()
	 lm_last_killtime = os.clock()
	 lm_dmg_start = g_dpst
	 lm_xp_start = me.xp
	end
 lm_hunt_time = os.clock() - lm_hunt_start  
 lm_total_dmg = g_dpst - lm_dmg_start
 lm_xp_gained = me.xp - lm_xp_start 
	
	local lm_dmgtime_dif
	local lm_dmg_dif
	if lm_last_dpst ~= g_dpst then
	    if lm_hit_count >= 1 then
   		 lm_dmgtime_dif = os.clock() - lm_last_hittime
         lm_dmg_dif = g_dpst - lm_last_dpst	     
		  
		 --if lm_dmgtime_dif > (me:get_weapon_delay() / 1000) * 0.5 then
		        if lm_dmgtime_dif < (me:get_weapon_delay() / 1000) * 1.5 then 
		         table.insert(lm_dmgtime_log, 1, lm_dmgtime_dif)
				 table.insert(lm_dmg_log, 1, lm_dmg_dif)
	            end
	        --end
        end
	 lm_last_hittime = os.clock()
	 lm_last_dpst = g_dpst
	 lm_hit_count = lm_hit_count + 1
	end
    
	local lm_xptime_dif
	local lm_xp_dif
	if lm_last_xp ~= me.xp and lm_hit_count >= 1 then
     lm_kill_count = lm_kill_count + 1
	 
	 lm_xptime_dif = os.clock() - lm_last_killtime
	 table.insert(lm_xptime_log, 1, lm_xptime_dif)
	 lm_last_killtime = os.clock()
	 
	 lm_xp_dif = me.xp - lm_last_xp
	 table.insert(lm_xp_log, 1, lm_xp_dif)
	 lm_last_xp = me.xp	
    end	 
 
 local temp_lm_dmgtime_log={} -- for median time
 local lm_dmgtime_count = 0
  lm_max_hps = -math.huge -- for max time
  lm_min_hps = math.huge -- for min time
  lm_dmgtime_sum = 0
  
    if lm_dmgtime_log[1] ~= nil then
        for i,v in pairs(lm_dmgtime_log) do
            if type(v) == 'number' then
             lm_dmgtime_sum = lm_dmgtime_sum + v
             lm_dmgtime_count = lm_dmgtime_count + 1
			 table.insert(temp_lm_dmgtime_log, v) -- for median time
			 lm_min_hps = 1 / (math.max(lm_max_hps, v)) 
             lm_max_hps = 1 / (math.min(lm_min_hps, v)) 
		  	    if lm_dmgtime_count >= 500 then
			     table.remove(lm_dmgtime_log, 500)
      	        end
            end
        end
     lm_mean_hps = 1 / ((lm_dmgtime_sum / lm_dmgtime_count))
     else
     lm_mean_hps = 0
	 lm_max_hps = 0
	 lm_min_hps = 0
    end
	
 -- standard deviation time
 local dmgtime_vm
 local lm_dmgtime_sum_sd = 0
 local lm_dmgtime_count_sd = 0
    if lm_dmgtime_log[2] ~= nil then
        for i,v in pairs(lm_dmgtime_log) do
            if type(v) == 'number' then
             dmgtime_vm = v - lm_mean_hps
             lm_dmgtime_sum_sd = lm_dmgtime_sum_sd + (dmgtime_vm * dmgtime_vm)
             lm_dmgtime_count_sd = lm_dmgtime_count_sd + 1
            end
        end
	 lm_sd_hps = 1 / (math.sqrt(lm_dmgtime_sum_sd / (lm_dmgtime_count_sd-1)))
	else
	 lm_sd_hps = 0
 end
 
 -- median time
    if temp_lm_dmgtime_log[50] ~= nil then
     table.sort(temp_lm_dmgtime_log)
     asterisk = " "
     -- If we have an even number of table elements or odd.
        if math.fmod(#temp_lm_dmgtime_log,2) == 0 then
         -- return mean value of middle two elements
         lm_median_hps = 1 / ((temp_lm_dmgtime_log[#temp_lm_dmgtime_log/2] + temp_lm_dmgtime_log[(#temp_lm_dmgtime_log/2)+1]) / 2)
         else
         -- return middle element
         lm_median_hps = 1 / (temp_lm_dmgtime_log[math.ceil(#temp_lm_dmgtime_log/2)])
        end
     else
        if wl:is_weapon(me.shield)==true then
	     lm_median_hps = 1 / ((me:get_weapon_delay()/1000)) * 1.6
		else
         lm_median_hps = 1 / (me:get_weapon_delay()/1000)
		end
	 asterisk = "!"
    end
	
 -- mean/max/min damage 
 local temp_lm_dmg_log={} -- for median dmg
  lm_dmg_sum = 0
  lm_dmg_count = 0
  lm_max_dmg = -math.huge -- for max dmg
  lm_min_dmg = math.huge -- for min dmg
 
    if lm_dmg_log[1] ~= nil then
        for i,v in pairs(lm_dmg_log) do
            if type(v) == 'number' then
             lm_dmg_sum = lm_dmg_sum + v
             lm_dmg_count = lm_dmg_count + 1
			 table.insert(temp_lm_dmg_log, v) -- for median dmg
			 lm_max_dmg = math.max(lm_max_dmg, v) 
             lm_min_dmg = math.min(lm_min_dmg, v) 
		  	    if lm_dmg_count >= 500 then
			     table.remove(lm_dmg_log, 500)
      	        end
            end
        end
     lm_mean_dmg = (lm_dmg_sum / lm_dmg_count)
    else
     lm_mean_dmg = 0
	 lm_max_dmg = 0
	 lm_min_dmg = 0
    end
	
 -- mean dps
 lm_mean_dps = lm_mean_dmg * lm_median_hps
  
 -- standard deviation damage
 local vm
 local sum_sd = 0
 local count_sd = 0
    if lm_dmg_log[2] ~= nil then
        for i,v in pairs(lm_dmg_log) do
            if type(v) == 'number' then
             vm = v - lm_mean_dmg
             sum_sd = sum_sd + (vm * vm)
             count_sd = count_sd + 1
            end
        end
     lm_sd_dmg = math.sqrt(sum_sd / (count_sd-1))
     else
	 lm_sd_dmg = 0
	end

 -- standard deviation dps
 lm_sd_dps = lm_sd_dmg * lm_median_hps
  
 -- median damage
    if temp_lm_dmg_log[1] ~= nil then
     table.sort(temp_lm_dmg_log)

     -- If we have an even number of table elements or odd.
        if math.fmod(#temp_lm_dmg_log,2) == 0 then
         -- return mean value of middle two elements
         lm_median_dmg = ( temp_lm_dmg_log[#temp_lm_dmg_log/2] + temp_lm_dmg_log[(#temp_lm_dmg_log/2)+1] ) / 2
         else
         -- return middle element
         lm_median_dmg = temp_lm_dmg_log[math.ceil(#temp_lm_dmg_log/2)]
        end
     else
     lm_median_dmg = 0
    end
  
 -- median dps  
 lm_median_dps = lm_median_dmg * lm_median_hps
  
 -- min dps
 lm_min_dps = lm_min_dmg * lm_median_hps
  
 -- max dps
 lm_max_dps = lm_max_dmg * lm_median_hps
--------------------------------------------------------------------------------

 local temp_lm_xptime_log={} -- for median time
 local lm_xptime_count = 0
  lm_max_kpm = -math.huge -- for max time
  lm_min_kpm = math.huge -- for min time
  lm_xptime_sum = 0
  
    if lm_xptime_log[1] ~= nil then
        for i,v in pairs(lm_xptime_log) do
            if type(v) == 'number' then
             lm_xptime_sum = lm_xptime_sum + v
             lm_xptime_count = lm_xptime_count + 1
			 table.insert(temp_lm_xptime_log, v) -- for median time
			 lm_min_kpm = 1 / (math.max(lm_max_kpm, v)) 
             lm_max_kpm = 1 / (math.min(lm_min_kpm, v)) 
		  	    if lm_xptime_count >= 500 then
			     table.remove(lm_xptime_log, 500)
      	        end
            end
        end
     lm_mean_kpm = (1 / ((lm_xptime_sum / lm_xptime_count))) * 60
     else
     lm_mean_kpm = 0
	 lm_max_kpm = 0
	 lm_min_kpm = 0
    end
	
 -- standard deviation time
 local xptime_vm
 local lm_xptime_sum_sd = 0
 local lm_xptime_count_sd = 0
    if lm_xptime_log[2] ~= nil then
        for i,v in pairs(lm_xptime_log) do
            if type(v) == 'number' then
             xptime_vm = v - lm_mean_kpm
             lm_xptime_sum_sd = lm_xptime_sum_sd + (xptime_vm * xptime_vm)
             lm_xptime_count_sd = lm_xptime_count_sd + 1
            end
        end
	 lm_sd_kpm = (1 / (math.sqrt(lm_xptime_sum_sd / (lm_xptime_count_sd-1)))) * 60
	else
	 lm_sd_kpm = 0
 end
 
 -- median time
    if temp_lm_xptime_log[2] ~= nil then
     table.sort(temp_lm_xptime_log)
     -- If we have an even number of table elements or odd.
        if math.fmod(#temp_lm_xptime_log,2) == 0 then
         -- return mean value of middle two elements
         lm_median_kpm = (1 / ((temp_lm_xptime_log[#temp_lm_xptime_log/2] + temp_lm_xptime_log[(#temp_lm_xptime_log/2)+1]) / 2)) * 60
         else
         -- return middle element
         lm_median_kpm = (1 / (temp_lm_xptime_log[math.ceil(#temp_lm_xptime_log/2)])) * 60
        end
     else
	 lm_median_kpm = 0
	end
	
 -- mean/max/min xp
 local temp_lm_xp_log={} -- for median xp
  lm_xp_sum = 0
  lm_xp_count = 0
  lm_max_xp = -math.huge -- for max xp
  lm_min_xp = math.huge -- for min xp
 
    if lm_xp_log[1] ~= nil then
        for i,v in pairs(lm_xp_log) do
            if type(v) == 'number' then
             lm_xp_sum = lm_xp_sum + v
             lm_xp_count = lm_xp_count + 1
			 table.insert(temp_lm_xp_log, v) -- for median xp
			 lm_max_xp = math.max(lm_max_xp, v) 
             lm_min_xp = math.min(lm_min_xp, v) 
		  	    if lm_xp_count >= 500 then
			     table.remove(lm_xp_log, 500)
      	        end
            end
        end
     lm_mean_xp = (lm_xp_sum / lm_xp_count)
    else
     lm_mean_xp = 0
	 lm_max_xp = 0
	 lm_min_xp = 0
    end
	
 -- mean, min, max kpm
 lm_mean_xps = lm_mean_xp * (lm_median_kpm / 60)
 lm_min_xps = lm_min_xp * (lm_median_kpm / 60)
 lm_max_xps = lm_max_xp * (lm_median_kpm / 60)
  
 -- standard deviation xp
 local xpvm
 local xpsum_sd = 0
 local xpcount_sd = 0
    if lm_xp_log[2] ~= nil then
        for i,v in pairs(lm_xp_log) do
            if type(v) == 'number' then
             xpvm = v - lm_mean_xp
             xpsum_sd = xpsum_sd + (xpvm * xpvm)
             xpcount_sd = xpcount_sd + 1
            end
        end
     lm_sd_xp = math.sqrt(xpsum_sd / (xpcount_sd-1))
     else
	 lm_sd_xp = 0
	end

 -- standard deviation kpm
 lm_sd_xps = lm_sd_xp * (lm_median_kpm / 60)
  
 -- median xp
    if temp_lm_xp_log[1] ~= nil then
     table.sort(temp_lm_xp_log)

     -- If we have an even number of table elements or odd.
        if math.fmod(#temp_lm_xp_log,2) == 0 then
         -- return mean value of middle two elements
         lm_median_xp = ( temp_lm_xp_log[#temp_lm_xp_log/2] + temp_lm_xp_log[(#temp_lm_xp_log/2)+1] ) / 2
         else
         -- return middle element
         lm_median_xp = temp_lm_xp_log[math.ceil(#temp_lm_xp_log/2)]
        end
     else
     lm_median_xp = 0
    end
  
 -- median kpm  
 lm_median_xps = lm_median_xp * (lm_median_kpm / 60)
 		
end

function auxbox_lm_hits()
 auxbox_prop_line("Total Hits  :", string.format("%d",lm_hit_count))
end

function auxbox_lm_time()
 h = math.floor(lm_hunt_time / 60 / 60)
 m = math.floor((lm_hunt_time / 60 / 60 - h) * 60)
 s = math.floor(((lm_hunt_time / 60 / 60 - h) * 60 - m) * 60)
 --ms = ((((lm_hunt_time / 60 / 60 - h) * 60 - m) * 60) - s) * 1000
 auxbox_prop_line("Total Time  :", string.format("%02.f:%02.f:%02.f", h, m, s))
end

function auxbox_lm_dmg()
 auxbox_prop_line("Total Dmg   :", string.format("%d",lm_total_dmg))
end

function auxbox_lm_dps()
 auxbox_prop_line("Total Dps   :", string.format("%d",lm_total_dmg/lm_hunt_time))
end

function auxbox_lm_mean_dmg()
 auxbox_prop_line("Mean :", string.format("%4.f  dmg %4.f%s dps", lm_mean_dmg, lm_mean_dps, asterisk))
end

function auxbox_lm_sd_dmg()
 auxbox_prop_line("Sd   :", string.format("%4.f  dmg %4.f%s dps", lm_sd_dmg, lm_sd_dps, asterisk))
end

function auxbox_lm_median_dmg()
 auxbox_prop_line("Med  :", string.format("%4.f  dmg %4.f%s dps", lm_median_dmg, lm_median_dps, asterisk))
end

function auxbox_lm_minmax_dmg()
 auxbox_prop_line("Min  :", string.format("%4.f  dmg %4.f%s dps", lm_min_dmg, lm_min_dps, asterisk))
 auxbox_prop_line("Max  :", string.format("%4.f  dmg %4.f%s dps", lm_max_dmg, lm_max_dps, asterisk))
end

function auxbox_lm_last4dmg()
 local hit1, hit2, hit3, hit4
 if lm_dmg_log[1] ~= nill then hit1 = lm_dmg_log[1] else hit1 = 0 end
 if lm_dmg_log[2] ~= nill then hit2 = lm_dmg_log[2] else hit2 = 0 end
 if lm_dmg_log[3] ~= nill then hit3 = lm_dmg_log[3] else hit3 = 0 end
 if lm_dmg_log[4] ~= nill then hit4 = lm_dmg_log[4] else hit4 = 0 end
 auxbox_prop_line("dmg  :", string.format("%4.f %4.f %4.f %4.f", hit4, hit3, hit2, hit1))
end

function auxbox_lm_mean_hps()
 auxbox_prop_line("Mean :", string.format("%.2f  hps", lm_mean_hps))
end

function auxbox_lm_sd_hps()
 auxbox_prop_line("Sd   :", string.format("%.2f  hps", lm_sd_hps))
end

function auxbox_lm_median_hps()
 auxbox_prop_line("Med  :", string.format("%.2f%s hps", lm_median_hps, asterisk))
end

function auxbox_lm_minmax_hps()
 auxbox_prop_line("Min  :", string.format("%4.2f  hps", lm_min_hps))
 auxbox_prop_line("Max  :", string.format("%4.2f  hps", lm_max_hps))
end

function auxbox_lm_last4hps()
 local hit1, hit2, hit3, hit4
 if lm_dmgtime_log[1] ~= nill then hit1 = 1 / lm_dmgtime_log[1] else hit1 = 0 end
 if lm_dmgtime_log[2] ~= nill then hit2 = 1 / lm_dmgtime_log[2] else hit2 = 0 end
 if lm_dmgtime_log[3] ~= nill then hit3 = 1 / lm_dmgtime_log[3] else hit3 = 0 end
 if lm_dmgtime_log[4] ~= nill then hit4 = 1 / lm_dmgtime_log[4] else hit4 = 0 end
 auxbox_prop_line("hps  :", string.format("%4.2f %4.2f %4.2f %4.2f", hit4, hit3, hit2, hit1))
end

function auxbox_lm_kills()
 auxbox_prop_line("Total Kills :", string.format("%d", lm_kill_count))
end

function auxbox_lm_xp_gained()
 auxbox_prop_line("Total XP    :", string.format("%d", lm_xp_gained))
end

function auxbox_lm_xpps()
 auxbox_prop_line("Total XP/s  :", string.format("%d", lm_xp_gained / lm_hunt_time))
end 

function auxbox_lm_xppm()
 auxbox_prop_line("Total XP/min:", string.format("%d", lm_xp_gained / lm_hunt_time * 60))
end 

function auxbox_lm_mean_xp()
 auxbox_prop_line("Mean :", string.format("%4.f   xp %4.f  xps", lm_mean_xp, lm_mean_xps))
end

function auxbox_lm_sd_xp()
 auxbox_prop_line("Sd   :", string.format("%4.f   xp %4.f  xps", lm_sd_xp, lm_sd_xps))
end

function auxbox_lm_median_xp()
 auxbox_prop_line("Med  :", string.format("%4.f   xp %4.f  xps", lm_median_xp, lm_median_xps))
end

function auxbox_lm_minmax_xp()
 auxbox_prop_line("Min  :", string.format("%4.f   xp %4.f  xps", lm_min_xp, lm_min_xps))
 auxbox_prop_line("Max  :", string.format("%4.f   xp %4.f  xps", lm_max_xp, lm_max_xps))
end

function auxbox_lm_last4xp()
 local kill1, kill2, kill3, kill4
 if lm_xp_log[1] ~= nill then kill1 = lm_xp_log[1] else kill1 = 0 end
 if lm_xp_log[2] ~= nill then kill2 = lm_xp_log[2] else kill2 = 0 end
 if lm_xp_log[3] ~= nill then kill3 = lm_xp_log[3] else kill3 = 0 end
 if lm_xp_log[4] ~= nill then kill4 = lm_xp_log[4] else kill4 = 0 end
 auxbox_prop_line("xp   :", string.format("%4.f %4.f %4.f %4.f", kill4, kill3, kill2, kill1))
end

function auxbox_lm_mean_kpm()
 auxbox_prop_line("Mean :", string.format("%d  kpm", lm_mean_kpm))
end

function auxbox_lm_sd_kpm()
 auxbox_prop_line("Sd   :", string.format("%d  kpm", lm_sd_kpm))
end

function auxbox_lm_median_kpm()
 auxbox_prop_line("Med  :", string.format("%d  kpm", lm_median_kpm))
end

function auxbox_lm_minmax_kpm()
 auxbox_prop_line("Min  :", string.format("%d  kpm", lm_min_kpm))
 auxbox_prop_line("Max  :", string.format("%d  kpm", lm_max_kpm))
end

function auxbox_lm_last4kpm()
 local kill1, hit2, hit3, hit4
 if lm_xptime_log[1] ~= nill then kill1 = 1 / lm_xptime_log[1] * 60 else kill1 = 0 end
 if lm_xptime_log[2] ~= nill then kill2 = 1 / lm_xptime_log[2] * 60 else kill2 = 0 end
 if lm_xptime_log[3] ~= nill then kill3 = 1 / lm_xptime_log[3] * 60 else kill3 = 0 end
 if lm_xptime_log[4] ~= nill then kill4 = 1 / lm_xptime_log[4] * 60 else kill4 = 0 end
 auxbox_prop_line("kpm  :", string.format("%4.0f %4.0f %4.0f %4.0f", kill4, kill3, kill2, kill1))
end

Edit: added min and max dmg/dps
P.S.: Script resets on weapon change and collects 500 data points for damage to do statistics - I guess you can increase the amount without performance issues.
P.P.S.: Never trust any statistics you haven't cheesed yourself!
Edit: now with last 5 hits
Edit: hits after 150% of weapon delay will be neglected in time statistics
Edit: hits under 50% of weapon delay will be added to the next hit - experimental (dual wielding gives me a headache)

[Keighn]

Cool. I totally forgot about ratio.

[CIAassassin]

Id like to see something that shows DPS (not last five) in and out, with a calculation that shows % of DPS to show if you have a negative DPS or positive. DPS should include sun dmg.

[Loughf]

so far, this is my favorite setup!

auxbox2.png

Code: Select all

session_start = os.time() - 1
auxbox_next_line = 0

function auxbox()
	
	d:auxbox_clear();
	auxbox_next_line = 0 
		
	--auxbox_real_world_time()	
	--auxbox_moon_info()	
	--auxbox_blank_line()
		
	--auxbox_damage_per_second()
	--auxbox_blank_line()
	
	--auxbox_ratio()	
	--auxbox_blank_line()	
	
	auxbox_xp()
	auxbox_blank_line()	
	
	update_skill_experience()
	--auxbox_all_skill_levels()
	auxbox_class_skill_levels()	
	--auxbox_recent_crafting_skill_levels()
	--auxbox_recent_skill_levels()	
	--auxbox_current_equipment()
	auxbox_blank_line()

	auxbox_ratio()
	auxbox_blank_line()

	auxbox_damage_per_second()
	auxbox_blank_line()
	auxbox_f5_message()
	--forums_message()
	--website_message()
		
end

function auxbox_prop_line(prop_name, prop_val)
    local filler = string.rep(" ", 25 - string.len(prop_name) - string.len(prop_val))
	auxbox_next_line = auxbox_next_line + 1
	d:auxbox_set_line(auxbox_next_line, string.format("%s %s %s", prop_name, filler, prop_val))
end

function auxbox_blank_line()
	auxbox_next_line = auxbox_next_line + 1
end

function auxbox_ratio()
  strpct = (me:get_str()/(me:get_str()+me:get_dex())*100)
  dexpct = (me:get_dex()/(me:get_str()+me:get_dex())*100)
  auxbox_prop_line("Str : Dex", string.format("%.2f : %.2f",strpct,dexpct))
end


-- Real World Time - Duncan (PD) / Zen (Reg) / Brentoboy (forums)
function auxbox_real_world_time()
	auxbox_prop_line("Real World Time:", string.format(os.date("%I:%M%p")))
end



-- Moon Info - Duncan (PD) / Zen (Reg) / Brentoboy (forums)
function auxbox_moon_info()
	if world_time < 9 * 60 -- if its night time
	or world_time > 21 * 60 
	then
		auxbox_prop_line("Moon Phase:", string.format("%d", moon_phase))
		-- if moon_phase = full and is_night = true say "FULL MOON"
		-- if moon_phase = new ... "New Moon"
	end
	if world_time < 60 then -- between 12am and 1am
		auxbox_prop_line("ITS MIDNIGHT", "(*)")
	end
end



-- Equipment Summary  - Duncan (PD) / Zen (Reg) / Brentoboy (forums)
function auxbox_current_equipment()
    auxbox_prop_line("---- Current Equipment -----", "")
	auxbox_prop_line(wl:get_full_name(me.weapon), "")
	--auxbox_prop_line("  Damage", string.format("%dd%d", me:get_dmg_dice(), me:get_dmg_sides()))
	auxbox_prop_line(wl:get_full_name(me.shield), "")
	auxbox_prop_line(wl:get_full_name(me.hat), "")
	auxbox_prop_line(wl:get_full_name(me.armour), "")
	auxbox_prop_line(wl:get_full_name(me.gloves), "")
	auxbox_prop_line(wl:get_full_name(me.trousers), "")
	auxbox_prop_line(wl:get_full_name(me.boots), "")
	auxbox_prop_line(wl:get_full_name(me.ring1), "")
	auxbox_prop_line(wl:get_full_name(me.ring2), "")
	auxbox_prop_line(wl:get_full_name(me.amulet), "")
	auxbox_prop_line(wl:get_full_name(me.sigil1), "")
	auxbox_prop_line(wl:get_full_name(me.sigil2), "")
	auxbox_prop_line(wl:get_full_name(me.sigil3), "")
end



-- Skill level stuff - Duncan (PD) / Zen (Reg) / Brentoboy (forums)
skill_count = 40 

auxbox_class_skills = 
{	0, 1, 2, 3, 26 --fighter
,	17, 18, 13, 14, 15, 9	--thief
,	7, 33 -- mage
,	34, 38, 36  -- priest
,   10, 40 -- monk
}

auxbox_crafting_skills = 
{	4
,   5
, 	6
,	8
,	11
,	12
,	16
,   19
,	20
,	21, 22, 23, 24, 25
,	27, 28
,	29
,	30
,	31, 32
,	35, 37
,	39
}

auxbox_prev_skill_values = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}
auxbox_skill_last_updated = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}
auxbox_prev_skill_values[0] = -1
auxbox_skill_last_updated[0] = -1

auxbox_skill_names = 
{ 	"polearms" -- 1
,	"maces" -- 2
,	"tactics" -- 3
,	"woodcrafting" --4
,	"mining" -- 5
,	"weaponsmith" -- 6
,	"magery" -- 7
,	"fishing" -- 8
,	"locks" --9
,	"unarmed" --10
,	"meditation" -- 11
,	"alchemy" --12
,	"ranged" --13
,	"stealth" --14
,	"traps" --15
,	"item lore" --16
,	"shortswords" --17
,	"foils" -- 18
,	"Skill 19"
,	"tailoring" --20
,	"tinkering" -- 21
,	"Skill 22"
,	"Skill 23"
,	"Skill 24"
,	"Skill 25"
,	"block" --26
,	"cartography" --27
,	"healing" --28
,	"enchanting"  --29
,	"armourer" -- 30
,	"inscription" --31
,	"taming" --32
,	"sorcery" --33
,	"piety" --34
,	"Skill 35"
,	"blessed maces" --36
,	"staves" -- 37
,	"divinity" --38
,	"cooking" --39
,	"sanctity" --40
}
auxbox_skill_names[0] = "longswords"

function auxbox_skill_line(skill_index)
	if me:get_skill(skill_index) > 0 then
		auxbox_prop_line(auxbox_skill_names[skill_index], string.format("%f%%", me:get_skill(skill_index)))
	end	
end

-- I used this for debugging, its pretty similar to the skill tab, so kind of pointless, but why delete it, now that it works
function auxbox_all_skill_levels()
	for i = 0, skill_count do
		auxbox_skill_line(i)
	end
end

-- shows level for all of your class related skills 
-- regardless of how long it has been since you got experience in that skill
function auxbox_class_skill_levels()
	for i = 1, #auxbox_class_skills do
		auxbox_skill_line(auxbox_class_skills[i])
	end
end

-- you have to call this before either of the two functions below it or they wont know what has recently changed
function update_skill_experience()
	for i = 0, skill_count do
		if auxbox_prev_skill_values[i] < me:get_skill(i) then
			auxbox_skill_last_updated[i] = auxboxcnt
			auxbox_prev_skill_values[i] = me:get_skill(i)
		end
	end
end

-- shows level of any skill that has recently received experience
-- you should really either use THIS or auxbox_class_skill_levels + auxbox_recent_craft_skill_levels
-- the advantage of this function is that it doesnt show class skills if you arent currently working on them (saves space)
function auxbox_recent_skill_levels()
	for i = 0, skill_count do
		if auxbox_skill_last_updated[i] > auxboxcnt - 300 
		and auxbox_skill_last_updated[i] > 1
		then
			auxbox_skill_line(i)
		end
	end
end

-- shows level of any non-class skill that has recently received experience
function auxbox_recent_crafting_skill_levels()
	for i = 1, #auxbox_crafting_skills do
		if auxbox_skill_last_updated[auxbox_crafting_skills[i]] > auxboxcnt - 300 
		and auxbox_skill_last_updated[auxbox_crafting_skills[i]] > 1
		then
			auxbox_skill_line(auxbox_crafting_skills[i])
		end
	end
end




-- Bound Item Quantities  - Duncan (PD) / Zen (Reg) / Brentoboy (forums)
function auxbox_bound_item_qtys()
	local item
	local name
	for i = 1, 50 do	
		item = me.item_binds[i]
		name = wl:get_full_name(item)
		
		if item 
		and not wl:is_tool(item)
		and name ~= "NOTHING" 
		then		
			auxbox_prop_line(name, items:get_qty(item))
		end
	end
end



--- Damage Per Second -- original script proveded by LordMortiferus
last_session_seconds = 0
last_4_dpst = { g_dpst, g_dpst, g_dpst, g_dpst }
last_4_dtpst = { g_dtpst, g_dtpst, g_dtpst, g_dtpst }
last_dpst = g_dpst
recent_dmg = { 0, 0, 0, 0 }

function auxbox_damage_per_second() 
	local session_seconds = os.time() - session_start
	
	if session_seconds > last_session_seconds then
		last_session_seconds = session_seconds
		last_4_dpst[4] = last_4_dpst[3] 
		last_4_dpst[3] = last_4_dpst[2] 
		last_4_dpst[2] = last_4_dpst[1] 
		last_4_dpst[1] = g_dpst	

		last_4_dtpst[4] = last_4_dtpst[3] 
		last_4_dtpst[3] = last_4_dtpst[2] 
		last_4_dtpst[2] = last_4_dtpst[1] 
		last_4_dtpst[1] = g_dtpst	
	end
	
	if last_dpst ~= g_dpst then
		recent_dmg[4] = recent_dmg[3]
		recent_dmg[3] = recent_dmg[2]
		recent_dmg[2] = recent_dmg[1]
		recent_dmg[1] = g_dpst - last_dpst
		last_dpst = g_dpst
	end
	
	--auxbox_prop_line("Dmg Dealt / Sec", string.format("%d", (last_4_dpst[1] - last_4_dpst[4])  / 4))
	--auxbox_prop_line("Dmg Taken / Sec", string.format("%d", (last_4_dtpst[1] - last_4_dtpst[4])  / 4))
	--auxbox_prop_line("Recent Dmg Dealt", "")
	auxbox_prop_line("Last 4 Hits:", string.format("%d  %d  %d  %d", recent_dmg[4], recent_dmg[3], recent_dmg[2], recent_dmg[1]))
end

function auxbox_f5_message()
	auxbox_prop_line("Press alt-F5 to Reset", "")
end

function forums_message()
	auxbox_prop_line("http://forums.swut.net", "")
end

function website_message()
	auxbox_prop_line("http://www.euotopia.com", "")
end

-- XP by LordMortiferus 2013/01/28, rehashed by Brentoboy

session_start_xp = me.xp -- var to calculate xp gain per session
session_start_age = me.age -- var to calculate time played per session
session_time = 0
current_level = 0

-- beginning of XP-array
req_xp = {}
req_xp[1] = 0 -- fixed XP value
req_xp[2] = 200 -- fixed XP value
req_xp[26] = 93000 -- fixed XP value

for i=3,25 do -- adds XP for lvl 3 to 25 to array
  req_xp[i] = math.floor(req_xp[i-1]+1.2*(req_xp[i-1]-req_xp[i-2]))
end

for i=27,1000 do -- adds XP for lvl 27 to 1000 to array
  req_xp[i] = req_xp[i-1]+(i-26)*1000*4+15000
end

if me.xp >= req_xp[1000] then
	current_level = 1000
else
	for i = 1,999 do -- getting current player level based on array 
		if req_xp[i] <= me.xp 
		and req_xp[i + 1] > me.xp 
		then
			current_level = i
			break
		end
	end
end

-- end of XP-array

function auxbox_xp()
	if current_level <= 1000 then
		local xptolvl_float = ((me.xp - req_xp[current_level]))/(req_xp[current_level+1]-req_xp[current_level]) -- % needed for next level
		local lvl_float = current_level + me.remort_level * 75 + xptolvl_float -- combines actual lvl with the % needed for next lvl

		 -- checks if player leveled or remorted
		if xptolvl_float >= 1 or xptolvl_float < 0 then
			for i = 1,999 do
				if req_xp[i] <= me.xp 
				and req_xp[i + 1] > me.xp 
				then
					current_level = i
					break
				end
			end
		end
		
		if os.difftime(os.time(), session_start) > session_time then -- just to reduce the script to every second
			session_time = os.difftime(os.time(), session_start)
			session_d_float = session_time / 60 / 60 / 24
			session_d = math.floor(session_d_float)
			session_h = math.floor((session_d_float - session_d)*24)
			session_m = math.floor(((session_d_float - session_d)*24 - session_h) * 60)
			session_s = math.floor((((session_d_float - session_d)*24 - session_h) * 60 - session_m) * 60)

			xpgain = me.xp - session_start_xp  
			xps = xpgain/session_time

			if me.age-session_start_age > 0  then
			  xpmin = xpgain/(me.age-session_start_age)
			else 
			  xpmin = 0
			end

			xptolvl = req_xp[current_level + 1] - me.xp
			xpto1k = req_xp[1000] - me.xp

			if xps > 0 then
			  timetolvl = xptolvl / xps 
			  timeto1k = xpto1k / xps
			else 
			  timetolvl = 0
			  timeto1k = 0
			end

			timetolvl_d_float = timetolvl / 60 / 60 / 24
			timetolvl_d = math.floor(timetolvl_d_float)
			timetolvl_h = math.floor((timetolvl_d_float - timetolvl_d)*24)
			timetolvl_m = math.floor(((timetolvl_d_float - timetolvl_d)*24 - timetolvl_h) * 60)
			timetolvl_s = math.floor((((timetolvl_d_float - timetolvl_d)*24 - timetolvl_h) * 60 - timetolvl_m) * 60)

			timeto1k_d_float = timeto1k / 60 / 60 / 24
			timeto1k_d = math.floor(timeto1k_d_float)
			timeto1k_h = math.floor((timeto1k_d_float - timeto1k_d)*24)
			timeto1k_m = math.floor(((timeto1k_d_float - timeto1k_d)*24 - timeto1k_h) * 60)
			timeto1k_s = math.floor((((timeto1k_d_float - timeto1k_d)*24 - timeto1k_h) * 60 - timeto1k_m) * 60)
		end
		
		
		auxbox_prop_line("Level" ,string.format("%f",lvl_float))
		--auxbox_prop_line("Time" ,string.format("%02.f:%02.f:%02.f:%02.f", session_d, session_h, session_m, session_s))
  
		auxbox_prop_line("Current XP", string.format("%d", me.xp))
		auxbox_prop_line("Before Level", string.format("%d", xptolvl))
		auxbox_prop_line("XP/s" ,string.format("%d", xps))
		auxbox_prop_line("XP/min" ,string.format("%d", xpmin))
  
	end
end

[CIAassassin]

it severely upsets me that you have 92 locks...

[Loughf]

why??? LAUGHING OUT LOUD LIKE A MORON

[Chedich]

Got an idea for the accessibility issue with auxbox lua scripts.
You can check it out at URL REMOVED. If it goes down I'm probably sleeping.

If you want your script added/removed/changed you can PM me.

[Loughf]

that's awesome

[eggmceye]

This is the current default auxbox.lua in the installer
It does not patch so as not to over write your mods

Code: Select all

filterTextLines=[[w: weapons
W: wearables
p: potions
s: shields
u: usable
j: jewellry
f: food
U: unidentified
h: slot-head
t: slot-torso
l: slot-legs
b: slot-boots
g: slot-gloves
r: slot-rings
n: slot-neck
S: spells & scrolls
G: gems
R: reagants, etc
A: cancel filtering
v: cancel filtering]]

auxbox_next_line = 0
session_time = 0
sessionstart = os.time()

shiftkeys={"Shift","Alt","Ctrl+Shift","Shift+Alt","Ctrl+Alt","Ctrl+Alt+Shift","RMB","Ctrl+RMB"}


function auxbox()
   
  local w=d:auxbox_get_width()
  local h=d:auxbox_get_height()
 
  d:auxbox_clear()
  auxbox_next_line = 0 
  if not d:ok_to_draw_play_window() then return; end
      
  local cd=d:get_curr_display()
  local mode=d:get_statbox_mode()
  local lineNr=0
  
  if cd==1 then
  
    if mode==SELECT_ABILITY then
    	auxbox_prop_line("Hit F-key to bind currently")
    	auxbox_prop_line("selected spell")
    	auxbox_blank_line()
    	auxbox_ability_binds()
    else
  
      local txta=explode("\n", filterTextLines)
      local autofilter=options:get(OPT_INV_START_WITH_SEARCH)
      if autofilter then
      	auxbox_prop_line("Hit CTRL + following keys")
      else
      	auxbox_prop_line("Hit the following keys")
      end
			auxbox_prop_line("to filter item types:")
			auxbox_blank_line()
	  	for i=1,#txta do
	  	 auxbox_prop_line(txta[i])
	  	end
	  	auxbox_blank_line()
	  	if autofilter then
	  		auxbox_prop_line("Seach by typing ...")
	  	else
	  	auxbox_prop_line("Search with /")
	  	end
	  	if mode==SELECT_READY then
	  		auxbox_prop_line("Press ENTER to equip")
	    elseif mode==SELECT_BUY then  		
	    	auxbox_prop_line("Press ENTER to buy")
	    elseif mode==SELECT_BANK then
	    	auxbox_prop_line("Press ENTER to transfer one")
	    	auxbox_prop_line("Press Shift+ENTER for 10")
	    	auxbox_prop_line("Press TAB for whole stack")
	    end
	  end
    
  else
  			
			auxbox_time()	
			auxbox_blank_line()
			--auxbox_damage_per_second()
			--auxbox_blank_line()
						
			auxbox_prop_line("Spell & ability binds:")
      local cnt=auxbox_ability_binds()
		  if cnt==0 then 
		  	auxbox_prop_line("None!")
		  	auxbox_blank_line()
		  	auxbox_prop_line("Hit shift-c then F keys")
		  	auxbox_prop_line("to bind.") 
		  end
		  auxbox_blank_line()		  
		  auxbox_prop_line("Forums: forums.swut.net")
		  auxbox_prop_line("Manual: euotopia.com/manual")
		  
		  if d:numlock() then
		  	auxbox_blank_line()
		  	auxbox_prop_line("Please turn numlock off!")
		  end
		  auxbox_blank_line()
		  auxbox_prop_line("F12 for main menu.")
		  --auxbox_blank_line()
			--auxbox_f5_message()			  		 
  end
   
      
end

-- explode(seperator, string)
-- from http://lua-users.org/wiki/SplitJoin
function explode(d,p)
  local t, ll
  t={}
  ll=0
  if(#p == 1) then return p end
    while true do
      l=string.find(p,d,ll+1,true) -- find the next d in the string
      if l~=nil then -- if "not not" found then..
        table.insert(t, string.sub(p,ll,l-1)) -- Save it in our array.
        ll=l+1 -- save just after where we found it for searching next time.
      else
        table.insert(t, string.sub(p,ll)) -- Save what's left in our array.
        break -- Break at end, as it should be, according to the lua manual.
      end
    end
  return t
end

-- Real World Time - Duncan (PD) / Zen (Reg) / Brentoboy (forums)
function auxbox_time()

	auxbox_prop_line("Real World Time:", string.format(os.date("%I:%M%p")))
	
 
  
   if os.difftime(os.time(), sessionstart) > session_time then -- just to reduce the script to every second
  
    session_time = os.difftime(os.time(), sessionstart)
    session_d_float = session_time / 60 / 60 / 24
    session_d = math.floor(session_d_float)
    session_h = math.floor((session_d_float - session_d)*24)
    session_m = math.floor(((session_d_float - session_d)*24 - session_h) * 60)
    session_s = math.floor((((session_d_float - session_d)*24 - session_h) * 60 - session_m) * 60)
  end    
  
   if session_d~=nil then
     auxbox_prop_line("Session time:", string.format("%02.f:%02.f:%02.f:%02.f", session_d, session_h, session_m, session_s))	
   end 
end


function auxbox_f5_message()
	auxbox_prop_line("Press Alt-F5 to Reset", "")
end

function auxbox_prop_line(prop_name, prop_val)
  
  local pvl=0
  if prop_name==nil then prop_name="" end
  if prop_val==nil then prop_val="" end
  local filler = string.rep(" ", 25 - string.len(prop_name) - string.len(prop_val))
	auxbox_next_line = auxbox_next_line + 1
	d:auxbox_set_line(auxbox_next_line, string.format("%s %s %s", prop_name, filler, prop_val))
end

function auxbox_blank_line()
	auxbox_next_line = auxbox_next_line + 1
end

function auxbox_ability_binds() 
	local cnt=0			
	for i=10,17 do
		if me.spell_binds[i]~=-1 then
	   auxbox_prop_line(shiftkeys[i-9],spells:get_full_spell_name(me.spell_binds[i]))
	   cnt=cnt+1
	  end
  end
  return cnt
end

--- Damage Per Second -- original script proveded by LordMortiferus
last_session_seconds = 0
last_4_dpst = { g_dpst, g_dpst, g_dpst, g_dpst }
last_4_dtpst = { g_dtpst, g_dtpst, g_dtpst, g_dtpst }
last_dpst = g_dpst
recent_dmg = { 0, 0, 0, 0 }

function auxbox_damage_per_second() 
	local session_seconds = os.time() - sessionstart
	
	if session_seconds > last_session_seconds then
		last_session_seconds = session_seconds
		last_4_dpst[4] = last_4_dpst[3] 
		last_4_dpst[3] = last_4_dpst[2] 
		last_4_dpst[2] = last_4_dpst[1] 
		last_4_dpst[1] = g_dpst	

		last_4_dtpst[4] = last_4_dtpst[3] 
		last_4_dtpst[3] = last_4_dtpst[2] 
		last_4_dtpst[2] = last_4_dtpst[1] 
		last_4_dtpst[1] = g_dtpst	
	end
	
	if last_dpst ~= g_dpst then
		recent_dmg[4] = recent_dmg[3]
		recent_dmg[3] = recent_dmg[2]
		recent_dmg[2] = recent_dmg[1]
		recent_dmg[1] = g_dpst - last_dpst
		last_dpst = g_dpst
	end
	
	auxbox_prop_line("Dmg Dealt / Sec", string.format("%d", (last_4_dpst[1] - last_4_dpst[4])  / 4))
	auxbox_prop_line("Dmg Taken / Sec", string.format("%d", (last_4_dtpst[1] - last_4_dtpst[4])  / 4))
	auxbox_prop_line("Recent Dmg Dealt", "")
	auxbox_prop_line("", string.format("%d  %d  %d  %d", recent_dmg[4], recent_dmg[3], recent_dmg[2], recent_dmg[1]))
end

[Loughf]

hey, egg. if you look at CinisterD's post about the bar, you see how long his auxbox is? is there a way to make it longer like that? I don't think mind is that tall.

[brentoboy]

@loughf

the auxbox size is determined by your screen resolution.
the normal stats area (right above the auxbox) is a fixed size.

Whatever is left over, is auxbox.

so at 800x600, the auxbox is only several lines tall
at 1600x1200, the auxbox is several dozen lines tall.

@egg...
what are the chances that you will use the color logic that what talked about back on the first page ... using \# commands in order to color the rest of a row.

I'd love to dig in on tweaking up the scripts to make better use of color.

@turtle...
did you ever get the recent skills section to work. if not, post what you have, and I'll compare it with the original, and get it working for you.

[brentoboy]

Got an idea for the accessibility issue with auxbox lua scripts.
You can check it out at http://212.85.90.16/. If it goes down I'm probably sleeping.

If you want your script added/removed/changed you can PM me.

k, that's awesome.

I'd be happy to post up snippets that you can add to the list, just tell me what all info you want on it...

like ... I assume you need a name for each new section
and a snipped of code that will produce the section
and a sample blob of text of what it would look like for the preview

Also, can I recommend asking them up top what screen res they play at, so you can resize the sample area to be as tall as their auxbox will actually be...

[brentoboy]

I've been trying to figure out a simple way to have a different script for each of my characters.

My ranger cares how much ammo he has, but my fighter could care less.
And they each carry around different pots, etc.

It turns out that the "short list" of stuff I want to see varies from character to character.


I'm thinking I could do it with something like this...

in my script folder, I would have a file for each character named after the character.
Zen.aux
Duncan.aux
Jesse.aux

and when the script loads, it looks for a file by that name, and reads in the list of sections that should appear for that character.

so the actual auxbox.lua would be capable of displaying every known section. And we could all just contribute snippets of code for the various things that could be added to an auxbox.

and then, each section would have a name.
and your character's config file would just have a list of section names.

for instance, Zen's config file might look like this...


REAL_WORLD_TIME
MOON_PHASE
-
XP_LEVEL
RECENT_HITS
-
POT_YELLOW_MEGA
SCROLL_GREATHER_HEALTH
SCROLL_PROTECTION
SCROLL_S
SCROLL_VL
SCROLL_SL
-
MONK_SKILL_LEVELS




And, Jesse's config could look like this...
REAL_WORLD_TIME
-
XP_LEVEL
-
POT_BLUE
BANDAGES
SCROLL_SL
-
MAGE_SKILL_LEVELS
PRIEST_SKILL_LEVELS
RECENT_SKILL_LEVELS



Any thoughts on something like that before I start crunching on making it happen?

[Loughf]

I would really like to have different looks for alts like that. Have one alt set up for greater yellows and HP scrolls and cyan's (that's not a priest) and have another alt set up for ore, ingots, certain other items (like a crafter) so I know what all I have.

[Chedich]

@Brentoboy:
Check out http://www.lua.org/manual/5.1/manual.html#luaL_dostring and http://www.lua.org/manual/5.1/manual.ht ... loadstring.

Good idea about giving the option to change the preview size depending on your resolution.

As for a preferred format of the scripts you want added(probably best if you PM me to avoid cluttering this thread):
Name:
Author:
Group: If you don't have a good idea, leave it empty and I'll figure it out
Preview: 25 characters per line. Lines seperated with '<br/>'
callfunction: Function called within auxbox()
lua: The rest of the lua that is outside of the main function

To save people from a possible headache I suggest adding a prefix to your function names and global variables as well as defining as many variables as possible as local.

[eggmceye]

diff scripts for diff chars:

give each char's auxbox a different func name
then in the auxbox function name just call the func name of the char depending on your own player name


all of these funcs can be in different files as all files in client scripts are loaded

Code: Select all

-- these can go in separate files if you want
function auxbox_brent()
 -- etc
end

function auxbox_natasha()
 -- etc
end

function auxbox()

  if me.name=="brent"
   auxbox_brent()
  elseif me.name=="natasha"
   auxbox_natasha()
  end

end

[Loughf]

does that really work???

[brentoboy]

auxbox.png

here is my first attempt at making a per-character config file for the auxbox.

here's how it works. You put this exact script file in your clientscritps folder.
by default, it will show the same thing that the default auxbox script shows for a new character.

if you create an "aux" file for your character, it will show the sections listed in your aux file.
The list of available sections is down at the bottom of the auxbox.lua file.

You'll have to rename the auxbox.txt file to be auxbox.lua
and you'll have to remove the existing lua script in your clientscripts folder
I attached a sample config file Zen.txt which must be renamed YourCharName.aux

You can use Ctrl+F5 to refresh your script if you tweak your config file while playing the game

my goal is that the auxbox.lua file will be universally usable, and not need to be edited by end users. only the config file should need to be edited.

[brentoboy]

Oh? That was credited to you in one of the scripts I was sent. Oh well, the owner can step up if they want to.

The 5 hit counter was a tweak I made in the middle of the DPS script.
Actually, I believe it was a 4 hit counter when I did it.

We are getting to a point where many of the scripts as they are being circulated have multiple authors.

[brentoboy]

@CIA ... I think

the first post you made had the quantities for several items.
How did you go about figuring out a code for an item you want info about?