def updateTargetsView(self, analyzer):
totalDamage = sum([v['damage'] for v in analyzer.entityBreakdown.values()])
totalDamageTaken = sum([v['damageTaken'] for v in analyzer.entityBreakdown.values()])
totalHealing = sum([v['healing'] for v in analyzer.entityBreakdown.values()])
totalHealingReceived = sum([v['healingReceived'] for v in analyzer.entityBreakdown.values()])
totalThreatReceived = sum([v['threatReceived'] for v in analyzer.entityBreakdown.values()])
rows = []
itemMap = []
for entity, info in analyzer.entityBreakdown.iteritems():
if not entity.name:
continue
damage = info['damage']
damageTaken = info['damageTaken']
healing = info['healing']
healingReceived = info['healingReceived']
threatReceived = info['threatReceived']
rows.append([
entity.name,
locale.format("%d", damage, grouping=True) +
" (%.2f%%)"%(util.div(damage, totalDamage) * 100),
locale.format("%d", damageTaken, grouping=True) +
" (%.2f%%)"%(util.div(damage, totalDamageTaken) * 100),
locale.format("%d", healing, grouping=True) +
" (%.2f%%)"%(util.div(healing, totalHealing) * 100),
locale.format("%d", healingReceived, grouping=True) +
" (%.2f%%)"%(util.div(healing, totalHealingReceived) * 100),
locale.format("%d", threatReceived, grouping=True) +
" (%.2f%%)"%(util.div(threatReceived, totalThreatReceived) * 100),
])
itemMap.append([entity.name, damage, damageTaken, healing,
healingReceived, threatReceived])
self.targetsView.setRows(rows, itemMap)
def onMotion(self, evt): old_offset = self.offset_pos #fix for windows focus policy ( after treeCtrl grabs focus it wont let it back ) self.SetFocus() if not self.moving: return #if not self.moving_proved: # self.pushMotionEvent(evt) # return curPos = evt.GetPosition() dx,dy = util.div(util.sub(self.prevPos, curPos), float(self.cell_size)) if dx != 0 or dy != 0: x,y=self.offset_pos x+=dx y+=dy self.offset_pos=(x,y) #self.Refresh() self.prevPos = curPos self.shift(util.mul(util.sub(old_offset, self.offset_pos), self.cell_size)) #self.update() self.Refresh() self.Update()
def onAnalyzerTick(self, analyzer):
self.beginBatch()
self.clearList()
index = 0
raidTotalDamageTaken = 0
for player in raid.playerData:
raidTotalDamageTaken += player['totalDamageTaken']
for player in sorted(raid.playerData,
key=lambda x: x['totalDamageTaken'],
reverse=True):
if player['totalDamageTaken'] == 0:
continue
percent = util.div(player['totalDamageTaken'],
raidTotalDamageTaken)
color = self.getForegroundColor()
if player['name'] == analyzer.parser.me.rawName:
color = config.getColor("overlayListSelfColor")
self.addRow([
player['name'][1:],
locale.format("%d", player['totalDamageTaken'], grouping=True),
percent
], color)
index += 1
self.endBatch()
self.panel.Layout()
def adadelta(allparams,
nat_stepsize,
num_epochs,
seq_len,
num_seqs=None,
rho=0.95,
epsilon=1e-6,
num_samples=1,
permute=True):
natparams, params = allparams[:1], allparams[1:]
sum_gsq = zeros_like(params) # accumulated sq. grads
sum_usq = zeros_like(params) # accumulated sq. updates
accumulate = lambda a, b: add(scale(rho, a), scale(1 - rho, b))
for epoch in xrange(num_epochs):
vals = []
batches, num_batches = split_into_batches(data, seq_len, num_seqs)
for y in batches:
val, grad = scale(
1. / num_datapoints,
val_and_grad(y, num_batches, num_samples, *allparams))
natgrad, grad = grad[:1], grad[1:]
sum_gsq = accumulate(sum_gsq, square(grad))
diag_scaling = div(sqrt(add_scalar(epsilon, sum_usq)),
sqrt(add_scalar(epsilon, sum_gsq)))
update = mul(diag_scaling, grad)
sum_usq = accumulate(sum_usq, square(update))
natparams = add(natparams, scale(nat_stepsize, natgrad))
params = add(params, update)
allparams = concat(natparams, params)
vals.append(val)
if callback: callback(epoch, vals, natgrad, allparams)
return allparams
def onAnalyzerTick(self, analyzer):
self.beginBatch()
self.clearList()
index = 0
raidTotalThreat = 0
for player in raid.playerData:
if player['totalThreat'] < 0:
continue
raidTotalThreat += player['totalThreat']
for player in sorted(raid.playerData, key=lambda x:x['totalThreat'], reverse=True):
if player['totalThreat'] == 0:
continue
percent = 0
if player['totalThreat'] > 0:
percent = util.div(player['totalThreat'], raidTotalThreat)
color = self.getForegroundColor()
if player['name'] == analyzer.parser.me.rawName:
color = config.getColor("overlayListSelfColor")
self.addRow([player['name'][1:], locale.format("%d", player['totalThreat'], grouping=True), percent], color)
index += 1
self.endBatch()
self.panel.Layout()
def onAnalyzerTick(self, analyzer):
self.beginBatch()
self.clearList()
index = 0
raidTotalHealing = 0
for player in raid.playerData:
raidTotalHealing += player['totalHealing']
for player in sorted(raid.playerData, key=lambda x:x['totalHealing'], reverse=True):
if player['totalHealing'] == 0:
continue
if raidTotalHealing > 0:
percent = "%.2f"%((float(player['totalHealing']) / float(raidTotalHealing)) * 100.0)
else:
percent = "%.2f"%0
color = self.getForegroundColor()
if player['name'] == analyzer.parser.me.rawName:
color = config.getColor("overlayListSelfColor")
hps = player['avgHps']
percent = util.div(player['totalHealing'], raidTotalHealing)
color = self.getForegroundColor()
if player['name'] == analyzer.parser.me.rawName:
color = config.getColor("overlayListSelfColor")
self.addRow([player['name'][1:], locale.format("%.2f", hps, grouping=True), percent], color)
index += 1
self.endBatch()
self.panel.Layout()
def perform_action(self, move):
if move is None:
self.game_ended = True
return
origin, destination = move
figure = self.get_field(origin)
if figure == 0 and destination[0] == self.board_size - 1:
figure = 2
if figure == 1 and destination[0] == 0:
figure = 3
self.add_figure(figure, destination)
self.remove_figure(origin)
if abs(move[0][0] - move[1][0]) == 2:
self.pacifist_turns = 0
half_destination = div(add(origin, destination), 2)
self.remove_figure(half_destination)
move_type, _ = self.get_viable_moves_from_field(destination)
if move_type == 1:
self.only_viable_field = destination
else:
self.only_viable_field = None
self.player = 1 - self.player
else:
self.pacifist_turns += 1
self.player = 1 - self.player
def centerAt(self, logicPos): #print 'before centering offset is %s %s'%(self.offset_pos, logicPos) if logicPos == (0,0): print traceback.format_exc() self.offset_pos = util.sub(logicPos, util.div(self.screen_size, 2)) #print 'after centering offset is %s'%(self.offset_pos,) self.update()
def onLeftUp(self, evt): self.moving = False self.update() #if self.moving_proved: # return pos = util.add(self.offset_pos, util.div(evt.GetPosition(), float(self.cell_size))) wx.PostEvent(self.GetParent(), event.SelectObject(attr1=(int(round(pos[0])), int(round(pos[1]))), attr2=None))
def onAnalyzerTick(self, analyzer):
enrageTime = config.get("customEnrageTime")
if not enrageTime:
self.bar.SetValue(0)
self.bar.SetLabel("")
return
enrageTime = float(enrageTime)
self.bar.SetValue(1.0 - util.div(analyzer.combatDuration, enrageTime))
self.bar.SetLabel(util.formatDuration(enrageTime - analyzer.combatDuration))
def onScroll(self, evt): pos = evt.GetPosition() logicPos = util.div(pos, float(self.cell_size)) diff = 1 if evt.GetWheelRotation()>0 else -1 self.cell_size += diff if self.cell_size < 1: self.cell_size = 1 elif self.cell_size > 40: self.cell_size = 40 self.calcScreenSize() #make sure mouse is pointing on the centre of the scroll area ( just move the pos so that this _is_ the center ) newScreenPos = util.mul(logicPos, self.cell_size) newScreenDiff = util.sub(newScreenPos, pos) newLogicDiff = util.div(newScreenDiff, self.cell_size) self.offset_pos = util.add(self.offset_pos, newLogicDiff) self.update()
def updateAbilityView(self, analyzer):
totalDamage = sum([v['damage'] for v in analyzer.abilityBreakdown.values()])
totalHealing = sum([v['healing'] for v in analyzer.abilityBreakdown.values()])
totalThreat = sum([v['threat'] for v in analyzer.abilityBreakdown.values()])
rows = []
itemMap = []
for ability, info in analyzer.abilityBreakdown.iteritems():
damage = info['damage']
healing = info['healing']
threat = info['threat']
rows.append([
ability,
locale.format("%d", damage, grouping=True) +
" (%.2f%%)"%(util.div(damage, totalDamage) * 100),
locale.format("%d", healing, grouping=True) +
" (%.2f%%)"%(util.div(healing, totalHealing) * 100),
locale.format("%d", threat, grouping=True) +
" (%.2f%%)"%(util.div(threat, totalThreat) * 100)
])
itemMap.append([ability, damage, healing, threat])
self.abilityView.setRows(rows, itemMap)
def onAnalyzerTick(self, analyzer):
enrageTime = config.get("customEnrageTime")
if not enrageTime:
self.bar.SetValue(0)
self.bar.SetLabel("")
return
enrageTime = float(enrageTime)
self.bar.SetValue(1.0 - util.div(analyzer.combatDuration, enrageTime))
self.bar.SetLabel(
util.formatDuration(enrageTime - analyzer.combatDuration))
def adam(allparams,
nat_stepsize,
stepsize,
num_epochs,
seq_len,
num_seqs=None,
b1=0.9,
b2=0.999,
eps=1e-8,
num_samples=1):
natparams, params = allparams[:1], allparams[1:]
m = zeros_like(params)
v = zeros_like(params)
i = 0
accumulate = lambda rho, a, b: add(scale(1 - rho, a), scale(rho, b))
for epoch in xrange(num_epochs):
vals = []
batches, num_batches = split_into_batches(data, seq_len, num_seqs)
for y in batches:
val, grad = scale(
1. / num_datapoints,
val_and_grad(y, num_batches, num_samples, *allparams))
natgrad, grad = grad[:1], grad[1:]
m = accumulate(b1, grad, m) # first moment estimate
v = accumulate(b2, square(grad), v) # second moment estimate
mhat = scale(1. / (1 - b1**(i + 1)), m) # bias correction
vhat = scale(1. / (1 - b2**(i + 1)), v)
update = scale(stepsize, div(mhat, add_scalar(eps,
sqrt(vhat))))
natparams = add(natparams, scale(nat_stepsize, natgrad))
params = add(params, update)
allparams = concat(natparams, params)
vals.append(val)
i += 1
if callback: callback(epoch, vals, natgrad, allparams)
return allparams
def onAnalyzerTick(self, analyzer):
self.beginBatch()
self.clearList()
index = 0
raidTotalHealing = 0
for player in raid.playerData:
raidTotalHealing += player['totalHealing']
for player in sorted(raid.playerData,
key=lambda x: x['totalHealing'],
reverse=True):
if player['totalHealing'] == 0:
continue
if raidTotalHealing > 0:
percent = "%.2f" % (
(float(player['totalHealing']) / float(raidTotalHealing)) *
100.0)
else:
percent = "%.2f" % 0
color = self.getForegroundColor()
if player['name'] == analyzer.parser.me.rawName:
color = config.getColor("overlayListSelfColor")
hps = player['avgHps']
percent = util.div(player['totalHealing'], raidTotalHealing)
color = self.getForegroundColor()
if player['name'] == analyzer.parser.me.rawName:
color = config.getColor("overlayListSelfColor")
self.addRow([
player['name'][1:],
locale.format("%.2f", hps, grouping=True), percent
], color)
index += 1
self.endBatch()
self.panel.Layout()
def adam(gradfun, allparams, num_iters, step_size, b1=0.9, b2=0.999, eps=1e-8):
natparams, params = allparams[:1], allparams[1:]
m = zeros_like(params)
v = zeros_like(params)
i = 0
accumulate = lambda rho, a, b: add(scale(1-rho, a), scale(rho, b))
for i in xrange(num_iters):
grad = gradfun(allparams, i)
natgrad, grad = grad[:1], grad[1:]
m = accumulate(b1, grad, m) # first moment estimate
v = accumulate(b2, square(grad), v) # second moment estimate
mhat = scale(1./(1 - b1**(i+1)), m) # bias correction
vhat = scale(1./(1 - b2**(i+1)), v)
update = scale(step_size, div(mhat, add_scalar(eps, sqrt(vhat))))
natparams = sub(natparams, scale(step_size, natgrad))
params = sub(params, update)
allparams = concat(natparams, params)
return allparams
def analyzeFight(self, fight=-1, realtime=False):
analysis = FightAnalysis()
analysis.realtime = realtime
sampleDamage = 0
sampleHeal = 0
buffs = []
now = time.time()
if self.parser.fights:
if not isinstance(fight, Fight):
fight = self.parser.fights[fight]
events = fight.events
else:
events = []
if events:
analysis.combatStartTime = events[0].time
analysis.combatEndTime = events[-1].time
startWasRecent = events[0].recent
for ev in events:
if ev.actor == self.parser.me and (ev.type in (evt.DAMAGE, evt.HEAL)
or ev.threat):
if not ev.abilityName in analysis.abilityBreakdown:
analysis.abilityBreakdown[ev.abilityName] = {'damage': 0, 'healing': 0,
'threat': 0}
for entity in (ev.actor, ev.target):
if entity not in analysis.entityBreakdown:
analysis.entityBreakdown[entity] = {'damage': 0, 'damageTaken': 0,
'healing': 0, 'healingReceived': 0, 'threatReceived': 0}
# Damage Event
if ev.type == evt.DAMAGE:
# From Me
if ev.actor == self.parser.me:
analysis.totalDamage += ev.damage
if ev.readTime > now - ROLLING_SAMPLE and ev.recent:
sampleDamage += ev.damage
analysis.abilityBreakdown[ev.abilityName]['damage'] += ev.damage
# To Me
if ev.type == evt.DAMAGE and ev.target == self.parser.me:
analysis.totalDamageTaken += ev.damage
analysis.entityBreakdown[ev.actor]['damage'] += ev.damage
analysis.entityBreakdown[ev.target]['damageTaken'] += ev.damage
# Heal Event
if ev.type == evt.HEAL:
# From Me
if ev.actor == self.parser.me:
analysis.totalHealing += ev.healing
if ev.readTime > now - ROLLING_SAMPLE and ev.recent:
sampleHeal += ev.healing
analysis.abilityBreakdown[ev.abilityName]['healing'] += ev.healing
# To Me
if ev.target == self.parser.me:
analysis.totalHealingReceived += ev.healing
analysis.entityBreakdown[ev.actor]['healing'] += ev.healing
analysis.entityBreakdown[ev.target]['healingReceived'] += ev.healing
# Apply threat
if ev.actor == self.parser.me and ev.threat:
analysis.totalThreat += ev.threat
analysis.abilityBreakdown[ev.abilityName]['threat'] += ev.threat
analysis.entityBreakdown[ev.target]['threatReceived'] += ev.threat
# Handle buffs
if ev.type == evt.APPLY_BUFF:
buffs.append(ev.actionType)
elif ev.type == evt.REMOVE_BUFF:
if ev.actionType in buffs:
buffs.remove(ev.actionType)
eventTimeDelta = ev.time - ev.readTime
analysis.combatDuration = analysis.combatEndTime - analysis.combatStartTime
if len(events) > 0 and self.parser.inCombat and startWasRecent:
combatNow = time.time() + eventTimeDelta
analysis.combatDurationLinear = combatNow - analysis.combatStartTime
if analysis.combatDurationLinear < 0:
analysis.combatDurationLinear = analysis.combatDuration
else:
analysis.combatDurationLinear = analysis.combatDuration
# Avg DPS calculation
analysis.avgDps = util.div(analysis.totalDamage, analysis.combatDuration)
analysis.avgHps = util.div(analysis.totalHealing, analysis.combatDuration)
if realtime:
# Rolling calculations
analysis.dps = util.div(sampleDamage, min(analysis.combatDuration, ROLLING_SAMPLE))
analysis.hps = util.div(sampleHeal, min(analysis.combatDuration, ROLLING_SAMPLE))
# TFB HM Op-9 Colors
if '2957991221395456' in buffs: # Blue
analysis.tfbOrb = 1
elif '2958167315054592' in buffs: # Orange
analysis.tfbOrb = 2
elif '2958188789891072' in buffs: # Purple
analysis.tfbOrb = 3
elif '2958193084858368' in buffs: # Yellow
analysis.tfbOrb = 4
return analysis
def screenPosToLogic(self, pos): return util.add(self.offset_pos, util.div(pos, self.cell_size))
def analyzeFight(self, fight=-1, realtime=False):
analysis = FightAnalysis()
analysis.realtime = realtime
sampleDamage = 0
sampleHeal = 0
buffs = []
now = time.time()
if self.parser.fights:
if not isinstance(fight, Fight):
fight = self.parser.fights[fight]
events = fight.events
else:
events = []
if events:
analysis.combatStartTime = events[0].time
analysis.combatEndTime = events[-1].time
startWasRecent = events[0].recent
for ev in events:
if ev.actor == self.parser.me and (
ev.type in (evt.DAMAGE, evt.HEAL) or ev.threat):
if not ev.abilityName in analysis.abilityBreakdown:
analysis.abilityBreakdown[ev.abilityName] = {
'damage': 0,
'healing': 0,
'threat': 0
}
for entity in (ev.actor, ev.target):
if entity not in analysis.entityBreakdown:
analysis.entityBreakdown[entity] = {
'damage': 0,
'damageTaken': 0,
'healing': 0,
'healingReceived': 0,
'threatReceived': 0
}
# Damage Event
if ev.type == evt.DAMAGE:
# From Me
if ev.actor == self.parser.me:
analysis.totalDamage += ev.damage
if ev.readTime > now - ROLLING_SAMPLE and ev.recent:
sampleDamage += ev.damage
analysis.abilityBreakdown[
ev.abilityName]['damage'] += ev.damage
# To Me
if ev.type == evt.DAMAGE and ev.target == self.parser.me:
analysis.totalDamageTaken += ev.damage
analysis.entityBreakdown[ev.actor]['damage'] += ev.damage
analysis.entityBreakdown[ev.target]['damageTaken'] += ev.damage
# Heal Event
if ev.type == evt.HEAL:
# From Me
if ev.actor == self.parser.me:
analysis.totalHealing += ev.healing
if ev.readTime > now - ROLLING_SAMPLE and ev.recent:
sampleHeal += ev.healing
analysis.abilityBreakdown[
ev.abilityName]['healing'] += ev.healing
# To Me
if ev.target == self.parser.me:
analysis.totalHealingReceived += ev.healing
analysis.entityBreakdown[ev.actor]['healing'] += ev.healing
analysis.entityBreakdown[
ev.target]['healingReceived'] += ev.healing
# Apply threat
if ev.actor == self.parser.me and ev.threat:
analysis.totalThreat += ev.threat
analysis.abilityBreakdown[
ev.abilityName]['threat'] += ev.threat
analysis.entityBreakdown[
ev.target]['threatReceived'] += ev.threat
# Handle buffs
if ev.type == evt.APPLY_BUFF:
buffs.append(ev.actionType)
elif ev.type == evt.REMOVE_BUFF:
if ev.actionType in buffs:
buffs.remove(ev.actionType)
eventTimeDelta = ev.time - ev.readTime
analysis.combatDuration = analysis.combatEndTime - analysis.combatStartTime
if len(events) > 0 and self.parser.inCombat and startWasRecent:
combatNow = time.time() + eventTimeDelta
analysis.combatDurationLinear = combatNow - analysis.combatStartTime
if analysis.combatDurationLinear < 0:
analysis.combatDurationLinear = analysis.combatDuration
else:
analysis.combatDurationLinear = analysis.combatDuration
# Avg DPS calculation
analysis.avgDps = util.div(analysis.totalDamage,
analysis.combatDuration)
analysis.avgHps = util.div(analysis.totalHealing,
analysis.combatDuration)
if realtime:
# Rolling calculations
analysis.dps = util.div(
sampleDamage, min(analysis.combatDuration, ROLLING_SAMPLE))
analysis.hps = util.div(
sampleHeal, min(analysis.combatDuration, ROLLING_SAMPLE))
# TFB HM Op-9 Colors
if '2957991221395456' in buffs: # Blue
analysis.tfbOrb = 1
elif '2958167315054592' in buffs: # Orange
analysis.tfbOrb = 2
elif '2958188789891072' in buffs: # Purple
analysis.tfbOrb = 3
elif '2958193084858368' in buffs: # Yellow
analysis.tfbOrb = 4
return analysis
def rectFilter(self, rect): ps = self.screenPosToLogic(rect.GetPosition().Get()) ps = util.sub(ps, (1,1)) sz = util.div(rect.GetSize().Get(), self.cell_size) sz = util.add(sz, (1,1)) return ['x>=%d AND y>=%d AND x<=%d AND y<=%d'%(ps[0], ps[1], ps[0]+sz[0], ps[1]+sz[1])]
