import matplotlib.pyplot as plt import matplotlib.colors import random as rand import numpy as np import math import exploding_dice as DRN from matplotlib.lines import Line2D import os import matplotlib.ticker as mtick #ceiling division: if a = qb + r when euclidian dividing by b, returns q+1 def ceildiv(a, b): return -(a // -b) # MORALE PROBLEMS ARE APPARENTLY RESET AT SOME POINT, NOT SURE WHEN, WAIT FOR LOGGY ANSWER # to-do list: # - THINK ABOUT how to show squad size in histograms; maybe check if it has an effect with a graph, and if not say that we can thus play with squads of arbitrary size, and we choose one that's not too big to help with CPU (if yes RIP, gonna have to be clever) # - do fear aura I guess as well, assuming line vs line # - add modelling of the loss of the bonus of 4 to morale check (i would need to make sure that routed units count as killed units) ---> DONE I THINK? TO BE RE_READ # - add modelling of the effect of blood rain on squad that go below size 5 ---> DONE I THINK? TO BE RE_READ # - try and calculate variance and show it in plots # - try and add back a simulation for run 2 (ww and ww+bloodrain) and compare to new ones # - make it 50/50 which of wailing winds or blood rain goes first # - DONE: check whether blood rain can rout commanders by itself; answer: yes # - DONE: check what happens if morale malus is above unit's morale; answer: looks like negative morale after maluses are taken into account # graphics suggestions: # - DONE: use % instead of proba for easier access by people # - DONE: alternate half and full lines # globals effects (values gotten by asking Loggy): # wailing winds: 3% of battlefield every 320 ticks, full fear effect if fail weird morale check (resists == openended 3d6 < current morale), max penalty -5 # blood rain 3% of battlefield every 320 ticks, frighten effect, max penalty -5, won't cause rout by itself for the squad scenario, but will for lone commanders ####################################################################### ########################### global settings ########################### ####################################################################### wailingHitRate = 3 rainHitRate = 3 fullFearMalusLimit = 5 # maximum morale malus from wailing winds frightenMalusLimit = 5 # maximum morale malus from blood rain DOM5_wailingHitRate = 5 ############################################################################## ########################### morale check functions ########################### ############################################################################## def moraleDomAverage(squadSize, unitMorale, moraleMalus): totalMorale = 0 for unitID in range(squadSize): totalMorale += unitMorale - moraleMalus[unitID] return ((squadSize // 2) + totalMorale) // squadSize #https://illwiki.com/dom5/user/loggy/morale def moraleCheckFailureStandard_commanders(unitMorale, moraleMalus): # note: the value of 5 is in fact the morale bonus 5*squadSize/squadSize; the "base morale bonus" is 0 because "The number of alive units in the squad is less than or equal to a closed d4, AND the highest number of morale problems is greater than or equal to half the number of alive units in the squad" (https://illwiki.com/dom5/user/loggy/morale) if (5 + unitMorale + DRN.DRN() < 14 + moraleMalus + DRN.DRN()): return True else: return False def moraleCheckFailureStandard_squad(averageMorale, squadSize, squadMoraleBonus): # note: the value 4 on the left-hand side is a bonus that becomes 0 if the squad becomes too beaten up (exact conditions in https://illwiki.com/dom5/user/loggy/morale); # loss of this bonus is not modelled here if (squadMoraleBonus + averageMorale + (squadSize // 2 + squadSize*5) // squadSize + DRN.DRN() < 14 + DRN.DRN()): return True else: return False def moraleCheckFailureIndividual(unitMorale, moraleMalus): if (unitMorale + DRN.DRN() < 6 + moraleMalus + DRN.DRN()): return True else: return False def moraleCheckFailureWailingWindsNegation(unitMorale, moraleMalus): if (DRN.DRN_triple() < max(unitMorale - moraleMalus, 0)): return False else: return True ################################################################################# ########################### single battle simulations ########################### ################################################################################# def wailingBattleSim_commanders(unitMorale = 10, bloodRainActive = 0, wailingWindsActive = 1, debug = 0): tickCount = 0 roundCountCurrent = 0 roundCountNew = 0 moraleCheckCount = 0 # one morale check per turn maximum - monitors this moraleCheckCount_easier = 0 # one morale check per turn maximum - monitors this unitHasRouted = False moraleMalus = 0 while unitHasRouted == False: tickCount += 320 roundCountNew = tickCount // 7500 # Blood Rain effect if active if bloodRainActive == 1: if rand.randrange(100) < rainHitRate: #chance for Blood rain to hit the commander square: rainHitRate% every 320 ticks if moraleMalus < frightenMalusLimit: moraleMalus += 1 if moraleCheckCount == 0 and moraleCheckFailureStandard_commanders(unitMorale, moraleMalus): unitHasRouted = True moraleCheckCount = 1 # Wailing Winds effect if wailingWindsActive == 1: if rand.randrange(100) < wailingHitRate: #chance for Wailing winds to hit the commander square: wailingHitRate% every 320 ticks if moraleCheckFailureWailingWindsNegation(unitMorale, moraleMalus): # units get a morale check to avoid being affected by wailing winds if moraleMalus < fullFearMalusLimit: moraleMalus += 1 if moraleCheckCount == 0 and moraleCheckFailureStandard_commanders(unitMorale, moraleMalus): unitHasRouted = True moraleCheckCount = 1 if moraleCheckCount_easier == 0 and moraleCheckFailureIndividual(unitMorale, moraleMalus): unitHasRouted = True moraleCheckCount_easier = 1 # new round, chance of morale malus to decay, and wailing winds will be able to try a rout one more time if roundCountNew > roundCountCurrent: if rand.randrange(100) < 50: # 50% chance of the morale malus being reduced by 1 every round moraleMalus = max(moraleMalus - 1, 0) moraleCheckCount = 0 moraleCheckCount_easier = 0 if debug == 1: print(moraleMalus) roundCountCurrent = tickCount // 7500 # end of battle, unit hasn't routed yet (this is dom5 number, gotta check new dom6 end of turn stuff) if roundCountCurrent > 100: # turn 100: battle enchantents end unitHasRouted = True roundCountCurrent = 130 #debug value return roundCountCurrent def wailingBattleSim_squad(unitMorale = 10, bloodRainActive = 0, wailingWindsActive = 1, squadSize = 1, unitDensity = 1, debug = 0): tickCount = 0 roundCountCurrent = 0 roundCountNew = 0 unitHasRouted = np.zeros(squadSize, dtype=bool) moraleMalus = np.zeros(squadSize) moraleCheckCount = 0 # one morale check per unit per turn maximum - monitors this ; this one is shared by whole squad moraleCheckCount_easier = np.zeros(squadSize) # one morale check per unit per turn maximum - monitors this unitMoraleProblems = np.zeros(squadSize) # see morale problems in https://illwiki.com/dom5/user/loggy/morale ; only counts the 1000 ones, not the finer details, should be enough squadSquareSize = ceildiv(squadSize, unitDensity) # how many squares deos the squad cover unitRoutRound = np.zeros(squadSize) # turn at which the unit routed unitRoutCount = 0 # how many units have routed so far squadMoraleBonus = 4 # is 4 by default, unless squad size is small while not np.all(unitHasRouted): tickCount += 320 roundCountNew = tickCount // 7500 for squadSquare_i in range(squadSquareSize): # Blood Rain effect if active if bloodRainActive == 1: if rand.randrange(100) < rainHitRate: #chance for Blood rain to hit the unit's square: rainHitRate% every 320 ticks for j in range(unitDensity): unitID = squadSquare_i*unitDensity + j if moraleMalus[unitID] < frightenMalusLimit: moraleMalus[unitID] += 1 # squad survival ratio check if ((unitRoutCount <= squadSize*80//100 and np.sum(unitMoraleProblems) > squadSize//2 and moraleDomAverage(squadSize, unitMorale, moraleMalus) <= 8) or (unitRoutCount <= squadSize*75//100 and np.sum(unitMoraleProblems) > squadSize//2 and moraleDomAverage(squadSize, unitMorale, moraleMalus) <= 10) or (unitRoutCount <= squadSize*70//100 and np.sum(unitMoraleProblems) > squadSize//2 and moraleDomAverage(squadSize, unitMorale, moraleMalus) <= 11) or (unitRoutCount <= squadSize*60//100 and np.sum(unitMoraleProblems) > squadSize//2) or (unitRoutCount <= squadSize*30//100 and np.sum(unitMoraleProblems) >= 0)): squadMoraleBonus = 0 unitMoraleProblems[:] = 10000 if np.max(unitMoraleProblems) >= 10000: squadAttemptsRout = True if squadAttemptsRout == True: if moraleCheckCount == 0 and unitHasRouted[unitID] == False and moraleCheckFailureStandard_squad(moraleDomAverage(squadSize, unitMorale, moraleMalus), squadSize, squadMoraleBonus): # This is not a true average, but in fact is rather %%((number of alive units in squad / 2) + total morale) / number of alive units (https://illwiki.com/dom5/user/loggy/morale) unitHasRouted[:] = True unitRoutRound[:] = roundCountNew if debug == 1: print("big fear routs whole squad at round "+str(roundCountNew)+"----------------") moraleCheckCount = 1 #resetting variables at end of iteration squadAttemptsRout = False squadmoralebonus = 4 # Wailing Winds effect if wailingWindsActive == 1: if rand.randrange(100) < wailingHitRate: #chance for Wailing winds to hit the unit's square: wailingHitRate% every 320 ticks for j in range(unitDensity): unitID = squadSquare_i*unitDensity + j if moraleCheckFailureWailingWindsNegation(unitMorale, moraleMalus[unitID]): # units get a morale check to avoid being affected by wailing winds if moraleMalus[unitID] < fullFearMalusLimit: moraleMalus[unitID] += 1 if moraleCheckCount_easier[unitID] == 0 and unitHasRouted[unitID] == False and moraleCheckFailureIndividual(unitMorale, moraleMalus[unitID]): unitHasRouted[unitID] = True unitRoutRound[unitID] = roundCountNew if debug == 1: print("big fear routs unit "+str(unitID)+" at round "+str(roundCountNew)) moraleCheckCount_easier[unitID] = 1 unitMoraleProblems[:] += 1000 unitMoraleProblems[unitID] += 1000 # squad survival ratio check if ((unitRoutCount <= squadSize*80//100 and np.sum(unitMoraleProblems) > squadSize//2 and moraleDomAverage(squadSize, unitMorale, moraleMalus) <= 8) or (unitRoutCount <= squadSize*75//100 and np.sum(unitMoraleProblems) > squadSize//2 and moraleDomAverage(squadSize, unitMorale, moraleMalus) <= 10) or (unitRoutCount <= squadSize*70//100 and np.sum(unitMoraleProblems) > squadSize//2 and moraleDomAverage(squadSize, unitMorale, moraleMalus) <= 11) or (unitRoutCount <= squadSize*60//100 and np.sum(unitMoraleProblems) > squadSize//2) or (unitRoutCount <= squadSize*30//100 and np.sum(unitMoraleProblems) >= 0)): squadMoraleBonus = 0 unitMoraleProblems[:] = 10000 if squadSize <= rand(4)+1 and np.sum(unitMoraleProblems) >= squadSize//2: squadMoraleBonus = 0 squadAttemptsRout = True if np.max(unitMoraleProblems) >= 10000: squadAttemptsRout = True if squadAttemptsRout == True: if moraleCheckCount == 0 and unitHasRouted[unitID] == False and moraleCheckFailureStandard_squad(moraleDomAverage(squadSize, unitMorale, moraleMalus), squadSize, squadMoraleBonus): # This is not a true average, but in fact is rather %%((number of alive units in squad / 2) + total morale) / number of alive units (https://illwiki.com/dom5/user/loggy/morale) unitHasRouted[:] = True unitRoutRound[:] = roundCountNew if debug == 1: print("big fear routs whole squad at round "+str(roundCountNew)+"----------------") moraleCheckCount = 1 #resetting variables at end of iteration squadAttemptsRout = False squadmoralebonus = 4 # new round, chance of morale malus to decay, and wailing winds will be able to try a rout one more time if roundCountNew > roundCountCurrent: for unitID in range(squadSize): if rand.randrange(100) < 50: # 50% chance of the morale malus being reduced by 1 every round moraleMalus[unitID] = max(moraleMalus[unitID] - 1, 0) moraleCheckCount = 0 moraleCheckCount_easier[:] = 0 unitMoraleProblems[:] = 0 if debug == 1: print(moraleMalus) roundCountCurrent = tickCount // 7500 # end of battle, unit hasn't routed yet (this is dom5 number, gotta check new dom6 end of turn stuff) if roundCountCurrent > 100: # turn 100: battle enchantents end roundCountCurrent = 130 #debug value # unitHasRouted = np.ones(squadSize, dtype=bool) for unitID in range(squadSize): if unitHasRouted[unitID] == False: unitHasRouted[unitID] = True unitRoutRound[unitID] = roundCountCurrent if debug == 1: print("sim ends at round "+str(roundCountCurrent)+" with unitRoutRound = "+str(unitRoutRound)) return unitRoutRound def FearMoraleMalusSim(unitMorale = 10, bloodRainActive = 0, wailingWindsActive = 1, debug = 0): battleHasEnded = False tickCount = 0 roundCountCurrent = 0 roundCountNew = 0 moraleMalus = 0 nRounds = 100 moraleMalusArray = np.zeros(nRounds) moraleMalusArray[0] = 0 while not battleHasEnded: tickCount += 320 roundCountNew = tickCount // 7500 # Blood Rain effect if active if bloodRainActive == 1: if rand.randrange(100) < rainHitRate: #chance for Blood rain to hit the unit's square: rainHitRate% every 320 ticks if moraleMalus < frightenMalusLimit: moraleMalus += 1 # Wailing Winds effect if wailingWindsActive == 1: if rand.randrange(100) < wailingHitRate: #chance for Wailing winds to hit the unit's square: wailingHitRate% every 320 ticks if moraleCheckFailureWailingWindsNegation(unitMorale, moraleMalus): # units get a morale check to avoid being affected by wailing winds if moraleMalus < fullFearMalusLimit: moraleMalus += 1 # new round, chance of morale malus to decay, and wailing winds will be able to try a rout one more time if roundCountNew > roundCountCurrent: moraleMalusArray[roundCountNew] = moraleMalus if rand.randrange(100) < 50: # 50% chance of the morale malus being reduced by 1 every round moraleMalus = max(moraleMalus - 1, 0) if debug == 1: print(moraleMalus) roundCountCurrent = tickCount // 7500 # end of battle, unit hasn't routed yet (this is dom5 number, gotta check new dom6 end of turn stuff) if roundCountCurrent > 98: # turn 100: battle enchantents end roundCountCurrent = 130 #debug value battleHasEnded = True if debug == 1: print("sim ends at round "+str(roundCountCurrent)+" with moraleMalus = "+str(moraleMalus)) return moraleMalusArray # FearMoraleMalusSim(10, 1, 1, debug = 1) # did I actually finish those DOM5 versions? to be checked def DOM5_wailingBattleSim_commanders(unitMorale = 10, bloodRainActive = 0, debug = 0): tickCount = 0 roundCountCurrent = 0 roundCountNew = 0 moraleCheckCount = 0 # one morale check per turn maximum - monitors this moraleCheckCount_easier = 0 # one morale check per turn maximum - monitors this unitHasRouted = False moraleMalus = 0 while unitHasRouted == False: tickCount += 320 roundCountNew = tickCount // 7500 # Blood Rain effect if active # if wailingWindsActive == 1: for DOM5 if wailing winds isn't active there is no rout check, so there would be no need for a simulation if rand.randrange(100) < DOM5_wailingHitRate: #chance for Blood rain to hit the commander square: rainHitRate% every 320 ticks if moraleMalus < frightenMalusLimit: # in DOM5 the morale malus caps at 5 moraleMalus += 1 if moraleCheckCount == 0 and moraleCheckFailureStandard_commanders(unitMorale, moraleMalus - (4 if bloodRainActive == 0 else 0)): unitHasRouted = True moraleCheckCount = 1 # new round, chance of morale malus to decay, and wailing winds will be able to try a rout one more time if roundCountNew > roundCountCurrent: moraleMalus = moraleMalus // 2 moraleCheckCount = 0 if debug == 1: print(moraleMalus) roundCountCurrent = tickCount // 7500 # end of battle, unit hasn't routed yet (this is dom5 number, gotta check new dom6 end of turn stuff) if roundCountCurrent > 100: # turn 100: battle enchantents end unitHasRouted = True roundCountCurrent = 130 #debug value return roundCountCurrent # did I actually finish those DOM5 versions? to be checked def DOM5_wailingBattleSim_squad(unitMorale = 10, bloodRainActive = 0, squadSize = 1, unitDensity = 1, debug = 0): tickCount = 0 roundCountCurrent = 0 roundCountNew = 0 unitHasRouted = np.zeros(squadSize, dtype=bool) moraleMalus = np.zeros(squadSize) moraleCheckCount = 0 # one morale check per unit per turn maximum - monitors this ; this one is shared by whole squad moraleCheckCount_easier = np.zeros(squadSize) # one morale check per unit per turn maximum - monitors this unitMoraleProblems = np.zeros(squadSize) # see morale problems in https://illwiki.com/dom5/user/loggy/morale ; only counts the 1000 ones, not the finer details, should be enough squadSquareSize = ceildiv(squadSize, unitDensity) # how many squares deos the squad cover unitRoutRound = np.zeros(squadSize) # turn at which the unit routed while not np.all(unitHasRouted): tickCount += 320 roundCountNew = tickCount // 7500 for squadSquare_i in range(squadSquareSize): # Wailing Winds effect # if wailingWindsActive == 1: for DOM5 if wailing winds isn't active there is no rout check, so there would be no need for a simulation if rand.randrange(100) < DOM5_wailingHitRate: #chance for Wailing winds to hit the commander square: DOM5_wailingHitRate% every 320 ticks for j in range(unitDensity): unitID = squadSquare_i*unitDensity + j # if moraleCheckFailureWailingWindsNegation(unitMorale, moraleMalus[unitID]): # in DOM5 units do not get a morale check to avoid being affected by wailing winds if moraleMalus[unitID] < frightenMalusLimit: # in DOM5 the morale malus caps at 5 moraleMalus[unitID] += 1 # in DOM5 there is no individual rout # if moraleCheckCount_easier[unitID] == 0 and unitHasRouted[unitID] == False and moraleCheckFailureIndividual(unitMorale, moraleMalus[unitID]): # unitHasRouted[unitID] = True # unitRoutRound[unitID] = roundCountNew # if debug == 1: # print("big fear routs unit "+str(unitID)+" at round "+str(roundCountNew)) moraleCheckCount_easier[unitID] = 1 unitMoraleProblems[:] += 1000 unitMoraleProblems[unitID] += 1000 if np.max(unitMoraleProblems) >= 10000: # or 5 cases depending on surviving number of squad members; issue is those cases look at whether the unit is alive, not routed. So it's hard to check in a sim without fighting; maybe ignore for now if moraleCheckCount == 0 and unitHasRouted[unitID] == False and moraleCheckFailureStandard_squad(moraleDomAverage(squadSize, unitMorale, moraleMalus), squadSize, squadMoraleBonus): # This should not be a true average, but in fact is rather %%((number of alive units in squad / 2) + total morale) / number of alive units (https://illwiki.com/dom5/user/loggy/morale) unitHasRouted[:] = True unitRoutRound[:] = roundCountNew if debug == 1: print("big fear routs whole squad at round "+str(roundCountNew)+"----------------") moraleCheckCount = 1 # new round, chance of morale malus to decay, and wailing winds will be able to try a rout one more time if roundCountNew > roundCountCurrent: for unitID in range(squadSize): moraleMalus[unitID] = moraleMalus[unitID] // 2 moraleCheckCount = 0 moraleCheckCount_easier[:] = 0 unitMoraleProblems[:] = 0 if debug == 1: print(moraleMalus) roundCountCurrent = tickCount // 7500 # end of battle, unit hasn't routed yet (this is dom5 number, gotta check new dom6 end of turn stuff) if roundCountCurrent > 100: # turn 100: battle enchantents end roundCountCurrent = 130 #debug value # unitHasRouted = np.ones(squadSize, dtype=bool) for unitID in range(squadSize): if unitHasRouted[unitID] == False: unitHasRouted[unitID] = True unitRoutRound[unitID] = roundCountCurrent if debug == 1: print("sim ends at round "+str(roundCountCurrent)+" with unitRoutRound = "+str(unitRoutRound)) return unitRoutRound ######################################################################################################################## ########################### Making distributions by running battle simulations several times ########################### ######################################################################################################################## def wailingExpectedRout_commanders(unitMorale = 10, bloodRainActive = 0, wailingWindsActive = 1, nIteration = 1000): roundExpectedRout = 0 for i in range(nIteration): if (i % 5000 == 0): print("nIteration done: " + str(i)) routRound = wailingBattleSim_commanders(unitMorale, bloodRainActive, wailingWindsActive) roundExpectedRout+=routRound return 1./nIteration * roundExpectedRout def makeWailingRoutDistrib_commanders(unitMorale = 10, bloodRainActive = 0, wailingWindsActive = 1, nIteration = 1000, isDOM5 = 0): routingTime = [] for i in range(nIteration): if (i % 5000 == 0): print("nIteration done: " + str(i)) if (isDOM5 == 0): routingTime = routingTime + [wailingBattleSim_commanders(unitMorale, bloodRainActive, wailingWindsActive)] else: routingTime = routingTime + [DOM5_wailingBattleSim_commanders(unitMorale, bloodRainActive, wailingWindsActive)] routingTime = np.array(routingTime) return routingTime def makeWailingRoutDistrib_squad(unitMorale = 10, bloodRainActive = 0, wailingWindsActive = 1, squadSize = 1, unitDensity = 1, nIteration = 1000, isDOM5 = 0): nRounds = 100 routedRatio = np.zeros(nRounds) for i in range(nIteration): if (i % 5000 == 0): print("nIteration done: " + str(i)) if (isDOM5 == 0): unitRoutRound = np.array(wailingBattleSim_squad(unitMorale, bloodRainActive, wailingWindsActive, squadSize, unitDensity)) else: unitRoutRound = np.array(DOM5_wailingBattleSim_squad(unitMorale, bloodRainActive, wailingWindsActive, squadSize, unitDensity)) for round in range(nRounds): routedRatio[round] += (unitRoutRound <= round).sum() * 1./squadSize # sum of array of booleans (unitRoutRound =< round), then division by squad size routedRatio = routedRatio * 1./nIteration return routedRatio def makeFearMoraleMalusAverageDistrib(unitMorale = 10, bloodRainActive = 0, wailingWindsActive = 1, nIteration = 1000): nRounds = 100 moraleMalusAverage = np.zeros(nRounds) for i in range(nIteration): if (i % 5000 == 0): print("nIteration done: " + str(i)) moraleMalusAverage += np.array(FearMoraleMalusSim(unitMorale, bloodRainActive, wailingWindsActive)) moraleMalusAverage = moraleMalusAverage * 1./nIteration return moraleMalusAverage # makeFearMoraleMalusAverageDistrib(10, 1, 0, 1000) ################################################################################################################ ########################### Functions to plot distributions into a .pdf or .png file ########################### ################################################################################################################ def plotHistograms_commanders(nDistribs, routingTimeDistrib_collection, collectionLegend, pltTitle, pdfName, option = ""): nBins = 140 fig, ax = plt.subplots() color1 = 'tab:red' ax.set_xlabel('Round number') ax.set_ylabel('Proba of being already routed (ie cumulative) in %') if option == "longCollection": colourMap = plt.get_cmap("viridis", nDistribs) else: colourMap = plt.get_cmap("copper", nDistribs) for i in range(nDistribs): if option == "longCollection": ax.hist(routingTimeDistrib_collection[i], nBins, label=collectionLegend[i], range=(0,nBins), density=True, cumulative=True, color=colourMap(i), histtype="step", linestyle=('solid' if i%2 == 0 else 'dashed')) else: ax.hist(routingTimeDistrib_collection[i], nBins, label=collectionLegend[i], range=(0,nBins), density=True, cumulative=True, color=colourMap(i), histtype="step") # Create new legend handles but use the colors from the existing ones handles, labels = ax.get_legend_handles_labels() if len(handles) != nDistribs: raise ValueError('handles list should have length of nDistribs, it is not the case') if option == "longCollection": new_handles = [Line2D([], [], c=handles[i].get_edgecolor(), linestyle=('solid' if i%2 == 0 else 'dashed')) for i in range(nDistribs)] else: new_handles = [Line2D([], [], c=handles[i].get_edgecolor()) for i in range(nDistribs)] # plt.legend(handles=new_handles, labels=labels) ax.legend(handles=new_handles, labels=labels, loc='center left', bbox_to_anchor=(1, 0.5)) ax.label_outer() plt.xlim(xmin=0, xmax = 100) plt.ylim(ymin=0, ymax = 1.05) plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter(xmax=1.0)) # transforms y-axis in % format plt.title(pltTitle) fig.tight_layout() # otherwise the right y-label is slightly clipped fig.tight_layout() # for some reason gotta call it twice for the top title to not be cropped # x-axis: major ticks every 20, minor ticks every 5 major_ticks_x = np.arange(0, 101, 20) minor_ticks_x = np.arange(0, 101, 5) # y-axis: major ticks every 0.2, minor ticks every 0.05 major_ticks_y = np.arange(0, 101, 20)*1./100 minor_ticks_y = np.arange(0, 101, 5)*1./100 ax.set_xticks(major_ticks_x) ax.set_xticks(minor_ticks_x, minor=True) ax.set_yticks(major_ticks_y) ax.set_yticks(minor_ticks_y, minor=True) ax.grid(which='both') ax.grid(which='minor', alpha=0.2) ax.grid(which='major', alpha=0.5) # save figure in ./WailingWindsPlots/ folder ; if it doesnt exist, create it script_dir = os.path.dirname(__file__) results_dir = os.path.join(script_dir, 'WailingWindsPlots/') results_dir_png = os.path.join(script_dir, 'WailingWindsPlots/pngPlots') if not os.path.isdir(results_dir): os.makedirs(results_dir) if not os.path.isdir(results_dir_png): os.makedirs(results_dir_png) if option == "debug": plt.show() plt.savefig(results_dir+pdfName+'.pdf') plt.savefig(results_dir_png+pdfName+'.png') def plotHistograms_squad(nDistribs, routedRatioDistrib_collection, collectionLegend, pltTitle, pdfName, option = ""): fig, ax = plt.subplots() color1 = 'tab:red' ax.set_xlabel('Round number') ax.set_ylabel('Proportion of squad already routed in %') if option == "longCollection": colourMap = plt.get_cmap("viridis", nDistribs) else: colourMap = plt.get_cmap("copper", nDistribs) nRounds = 100 # x-axis bin size for i in range(nDistribs): if option == "longCollection": ax.plot(np.array(range(nRounds)), routedRatioDistrib_collection[i], label=collectionLegend[i], color=colourMap(i), linestyle=('solid' if i%2 == 0 else 'dashed')) else: ax.plot(np.array(range(nRounds)), routedRatioDistrib_collection[i], label=collectionLegend[i], color=colourMap(i)) # Create new legend handles but use the colors from the existing ones handles, labels = ax.get_legend_handles_labels() if len(handles) != nDistribs: raise ValueError('handles list should have length of nDistribs, it is not the case') if option == "longCollection": new_handles = [Line2D([], [], c=handles[i].get_color(), linestyle=('solid' if i%2 == 0 else 'dashed')) for i in range(nDistribs)] else: new_handles = [Line2D([], [], c=handles[i].get_color()) for i in range(nDistribs)] ax.legend(handles=new_handles, labels=labels, loc='center left', bbox_to_anchor=(1, 0.5)) ax.label_outer() plt.xlim(xmin=0, xmax = 100) plt.ylim(ymin=0, ymax = 1.05) plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter(xmax=1.0)) # transforms y-axis in % format plt.title(pltTitle) fig.tight_layout() # otherwise the right y-label is slightly clipped fig.tight_layout() # for some reason gotta call it twice for the top title to not be cropped # setting up the grid and the ticks on the axes: # x-axis: major ticks every 20, minor ticks every 5 major_ticks_x = np.arange(0, 101, 20) minor_ticks_x = np.arange(0, 101, 5) # y-axis: major ticks every 0.2, minor ticks every 0.05 major_ticks_y = np.arange(0, 101, 20)*1./100 minor_ticks_y = np.arange(0, 101, 5)*1./100 ax.set_xticks(major_ticks_x) ax.set_xticks(minor_ticks_x, minor=True) ax.set_yticks(major_ticks_y) ax.set_yticks(minor_ticks_y, minor=True) ax.grid(which='both') ax.grid(which='minor', alpha=0.2) ax.grid(which='major', alpha=0.5) # save figure in ./WailingWindsPlots/ folder ; if it doesnt exist, create it script_dir = os.path.dirname(__file__) results_dir = os.path.join(script_dir, 'WailingWindsPlots/') results_dir_png = os.path.join(script_dir, 'WailingWindsPlots/pngPlots') if not os.path.isdir(results_dir): os.makedirs(results_dir) if not os.path.isdir(results_dir_png): os.makedirs(results_dir_png) if option == "debug": plt.show() plt.savefig(results_dir+pdfName+'.pdf') plt.savefig(results_dir_png+pdfName+'.png') def plotHistograms_fearMoraleMalus(nDistribs, fearMoraleMalusDistrib_collection, collectionLegend, pltTitle, pdfName, option = ""): nBins = 140 fig, ax = plt.subplots() color1 = 'tab:red' ax.set_xlabel('Round number') ax.set_ylabel('Morale malus') if option == "longCollection": colourMap = plt.get_cmap("viridis", nDistribs) else: colourMap = plt.get_cmap("copper", nDistribs) xRounds = np.arange(100) for i in range(nDistribs): if option == "longCollection": # ax.hist(fearMoraleMalusDistrib_collection[i], nBins, label=collectionLegend[i], range=(0,nBins), density=False, cumulative=False, color=colourMap(i), histtype="step", linestyle=('solid' if i%2 == 0 else 'dashed')) ax.plot(xRounds, fearMoraleMalusDistrib_collection[i], label=collectionLegend[i], color=colourMap(i), linestyle=('solid' if i%2 == 0 else 'dashed')) else: # ax.hist(fearMoraleMalusDistrib_collection[i], nBins, label=collectionLegend[i], range=(0,nBins), density=False, cumulative=False, color=colourMap(i), histtype="step") ax.plot(xRounds, fearMoraleMalusDistrib_collection[i], label=collectionLegend[i], color=colourMap(i)) # Create new legend handles but use the colors from the existing ones handles, labels = ax.get_legend_handles_labels() if len(handles) != nDistribs: raise ValueError('handles list should have length of nDistribs, it is not the case') if option == "longCollection": new_handles = [Line2D([], [], c=handles[i].get_color(), linestyle=('solid' if i%2 == 0 else 'dashed')) for i in range(nDistribs)] else: new_handles = [Line2D([], [], c=handles[i].get_color()) for i in range(nDistribs)] # plt.legend(handles=new_handles, labels=labels) ax.legend(handles=new_handles, labels=labels, loc='center left', bbox_to_anchor=(1, 0.5)) ax.label_outer() plt.xlim(xmin=0, xmax = 100) plt.ylim(ymin=0, ymax = 10) # plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter(xmax=1.0)) # transforms y-axis in % format plt.title(pltTitle) fig.tight_layout() # otherwise the right y-label is slightly clipped fig.tight_layout() # for some reason gotta call it twice for the top title to not be cropped # x-axis: major ticks every 20, minor ticks every 5 major_ticks_x = np.arange(0, 101, 20) minor_ticks_x = np.arange(0, 101, 5) # # y-axis: major ticks every 0.2, minor ticks every 0.05 # major_ticks_y = np.arange(0, 101, 20)*1./100 # minor_ticks_y = np.arange(0, 101, 5)*1./100 # y-axis: major ticks every 0.2, minor ticks every 0.05 major_ticks_y = np.arange(0, 10, 1 ) minor_ticks_y = np.arange(0, 10, 1./5) ax.set_xticks(major_ticks_x) ax.set_xticks(minor_ticks_x, minor=True) ax.set_yticks(major_ticks_y) ax.set_yticks(minor_ticks_y, minor=True) ax.grid(which='both') ax.grid(which='minor', alpha=0.2) ax.grid(which='major', alpha=0.5) # save figure in ./WailingWindsPlots/ folder ; if it doesnt exist, create it script_dir = os.path.dirname(__file__) results_dir = os.path.join(script_dir, 'WailingWindsPlots/') results_dir_png = os.path.join(script_dir, 'WailingWindsPlots/pngPlots') if not os.path.isdir(results_dir): os.makedirs(results_dir) if not os.path.isdir(results_dir_png): os.makedirs(results_dir_png) if option == "debug": plt.show() plt.savefig(results_dir+pdfName+'.pdf') plt.savefig(results_dir_png+pdfName+'.png') ################################################################################################################################ ########################### Main functions that call plotting functions for many different scenarios ########################### ################################################################################################################################ def plot_varyingMorale_setEnchantments_commandersRout(): unitMorale_collection = range(10,30,2) nIteration=100000 nDistribs = len(unitMorale_collection) for bloodRainActive in [0,1]: for wailingWindsActive in [0,1]: if (bloodRainActive, wailingWindsActive) != (0, 0): print("analysing: (bloodRainActive, wailingWindsActive) = " + str((bloodRainActive, wailingWindsActive))) bloodRain = "" if bloodRainActive == 1: bloodRain = "_withBloodRain" if bloodRainActive == 0: bloodRain = "_noBloodRain" wailingWinds = "" if wailingWindsActive == 1: wailingWinds = "_withWailingWinds" if wailingWindsActive == 0: wailingWinds = "_noWailingWinds" routingTimeDistrib_collection = [] collectionLegend = [] for unitMorale in unitMorale_collection: print("Morale "+str(unitMorale)) routingTimeDistrib_collection += [makeWailingRoutDistrib_commanders(unitMorale, bloodRainActive, wailingWindsActive, nIteration)] collectionLegend += ["morale " + str(unitMorale)] wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" rainStatus = "ON" if bloodRainActive == 1 else "OFF" pltTitle = "commanders - BloodRain" + rainStatus + ", WailingWinds " + wailingStatus pdfName = "MoralePlays_MoraleComparison_commanders___BloodRain_" + rainStatus + "_WailingWinds_" + wailingStatus plotHistograms_commanders(nDistribs, routingTimeDistrib_collection, collectionLegend, pltTitle, pdfName, "longCollection") def plot_setMorale_varyingEnchantments_commandersRout(): unitMorale_collection = range(10,30,2) # unitMorale_collection = [15] nIteration=100000 for unitMorale in unitMorale_collection: print("simulating unit morale "+str(unitMorale)) # for wailingWindsActive in [0,1]: # if (bloodRainActive, wailingWindsActive) != (0, 0): nDistribs = 3 # wailing,rain (on,on), (on,off), (off,on) routingTimeDistrib_collection = [] collectionLegend = [] for bloodRainActive in [0,1]: for wailingWindsActive in [0,1]: if (bloodRainActive, wailingWindsActive) != (0, 0): print("simulating (bloodRainActive, wailingWindsActive) = " + str((bloodRainActive, wailingWindsActive))) routingTimeDistrib_collection += [makeWailingRoutDistrib_commanders(unitMorale, bloodRainActive, wailingWindsActive, nIteration)] wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" rainStatus = "ON" if bloodRainActive == 1 else "OFF" collectionLegend += ["winds " + wailingStatus + "\nrain " + rainStatus] pltTitle = "commanders - morale " + str(unitMorale) pdfName = "MoralePlays_WailingRainComparison_commanders___morale_" + str(unitMorale) plotHistograms_commanders(nDistribs, routingTimeDistrib_collection, collectionLegend, pltTitle, pdfName) def plot_setMorale_varyingEnchantments_squadRout(): unitMorale_collection = range(10,30,2) # unitMorale_collection = range(16,30,2) nIteration=100000 squadSize = 10 unitDensity = 2 for unitMorale in unitMorale_collection: print("analysing: morale "+str(unitMorale)+":") nDistribs = 2 # wailing,rain (on,on), (on,off), (off,on) routedRatioDistrib_collection = [] collectionLegend = [] for bloodRainActive in [0,1]: for wailingWindsActive in [0,1]: if (bloodRainActive, wailingWindsActive) != (0, 0) and (bloodRainActive, wailingWindsActive) != (1, 0): #don't care about blood rain alone given it's not gonna rout squads by itself print("simulating (bloodRainActive, wailingWindsActive) = " + str((bloodRainActive, wailingWindsActive))) routedRatioDistrib_collection += [makeWailingRoutDistrib_squad(unitMorale, bloodRainActive, wailingWindsActive, squadSize, unitDensity, nIteration)] wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" rainStatus = "ON" if bloodRainActive == 1 else "OFF" collectionLegend += ["winds " + wailingStatus + "\nrain " + rainStatus] pltTitle = "squad morale " + str(unitMorale) pdfName = "MoralePlays_WailingRainComparison_squad___morale_" + str(unitMorale) plotHistograms_squad(nDistribs, routedRatioDistrib_collection, collectionLegend, pltTitle, pdfName, "") def plot_varyingMorale_setEnchantments_squadRout(): unitMorale_collection = range(10,30,2) nIteration=100000 squadSize = 10 unitDensity = 2 nDistribs = len(unitMorale_collection) for bloodRainActive in [0,1]: for wailingWindsActive in [0,1]: if (bloodRainActive, wailingWindsActive) != (0, 0) and (bloodRainActive, wailingWindsActive) != (1, 0): #don't care about blood rain alone given it's not gonna rout squads by itself print("analysing: (bloodRainActive, wailingWindsActive) = " + str((bloodRainActive, wailingWindsActive))) bloodRain = "" if bloodRainActive == 1: bloodRain = "_withBloodRain" if bloodRainActive == 0: bloodRain = "_noBloodRain" wailingWinds = "" if wailingWindsActive == 1: wailingWinds = "_withWailingWinds" if wailingWindsActive == 0: wailingWinds = "_noWailingWinds" routedRatioDistrib_collection = [] collectionLegend = [] for unitMorale in unitMorale_collection: print("Morale "+str(unitMorale)) routedRatioDistrib_collection += [makeWailingRoutDistrib_squad(unitMorale, bloodRainActive, wailingWindsActive, squadSize, unitDensity, nIteration)] collectionLegend += ["morale " + str(unitMorale)] wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" rainStatus = "ON" if bloodRainActive == 1 else "OFF" pltTitle = "squad - BloodRain" + rainStatus + ", WailingWinds " + wailingStatus pdfName = "MoralePlays_MoraleComparison_squad___BloodRain_" + rainStatus + "_WailingWinds_" + wailingStatus plotHistograms_squad(nDistribs, routedRatioDistrib_collection, collectionLegend, pltTitle, pdfName, "longCollection") def plot_varyingMorale_setEnchantments_moraleMalus(): unitMorale_collection = range(10,30,2) nIteration=10000 nDistribs = len(unitMorale_collection) for bloodRainActive in [0,1]: for wailingWindsActive in [0,1]: if (bloodRainActive, wailingWindsActive) != (0, 0): print("analysing: (bloodRainActive, wailingWindsActive) = " + str((bloodRainActive, wailingWindsActive))) bloodRain = "" if bloodRainActive == 1: bloodRain = "_withBloodRain" if bloodRainActive == 0: bloodRain = "_noBloodRain" wailingWinds = "" if wailingWindsActive == 1: wailingWinds = "_withWailingWinds" if wailingWindsActive == 0: wailingWinds = "_noWailingWinds" fearMoraleMalusDistrib_collection = [] collectionLegend = [] for unitMorale in unitMorale_collection: print("Morale "+str(unitMorale)) fearMoraleMalusDistrib_collection += [makeFearMoraleMalusAverageDistrib(unitMorale, bloodRainActive, wailingWindsActive, nIteration)] collectionLegend += ["morale " + str(unitMorale)] wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" rainStatus = "ON" if bloodRainActive == 1 else "OFF" pltTitle = "morale malus - BloodRain" + rainStatus + ", WailingWinds " + wailingStatus pdfName = "MoralePlays_MoraleComparison___BloodRain_" + rainStatus + "_WailingWinds_" + wailingStatus + "_moraleMalus" plotHistograms_fearMoraleMalus(nDistribs, fearMoraleMalusDistrib_collection, collectionLegend, pltTitle, pdfName, "longCollection") def plot_setMorale_varyingEnchantments_moraleMalus(): unitMorale_collection = range(10,30,2) # unitMorale_collection = [15] nIteration=10000 for unitMorale in unitMorale_collection: print("simulating unit morale "+str(unitMorale)) # for wailingWindsActive in [0,1]: # if (bloodRainActive, wailingWindsActive) != (0, 0): nDistribs = 3 # wailing,rain (on,on), (on,off), (off,on) fearMoraleMalusDistrib_collection = [] collectionLegend = [] for bloodRainActive in [0,1]: for wailingWindsActive in [0,1]: if (bloodRainActive, wailingWindsActive) != (0, 0): print("simulating (bloodRainActive, wailingWindsActive) = " + str((bloodRainActive, wailingWindsActive))) fearMoraleMalusDistrib_collection += [makeFearMoraleMalusAverageDistrib(unitMorale, bloodRainActive, wailingWindsActive, nIteration)] wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" rainStatus = "ON" if bloodRainActive == 1 else "OFF" collectionLegend += ["winds " + wailingStatus + "\nrain " + rainStatus] pltTitle = "morale malus - morale " + str(unitMorale) pdfName = "MoralePlays_WailingRainComparison___morale_" + str(unitMorale)+"_moraleMalus" plotHistograms_fearMoraleMalus(nDistribs, fearMoraleMalusDistrib_collection, collectionLegend, pltTitle, pdfName) def plot_all_commanders(): plot_varyingMorale_setEnchantments_commandersRout() plot_setMorale_varyingEnchantments_commandersRout() def plot_test(): unitMorale_collection = [10,15,20,25] nIteration=100000 # # commanders # for unitMorale in unitMorale_collection: # # for wailingWindsActive in [0,1]: # # if (bloodRainActive, wailingWindsActive) != (0, 0): # nDistribs = 3 # wailing,rain (on,on), (on,off), (off,on) # routingTimeDistrib_collection = [] # collectionLegend = [] # for bloodRainActive in [0,1]: # for wailingWindsActive in [0,1]: # if (bloodRainActive, wailingWindsActive) != (0, 0): # routingTimeDistrib_collection += [makeWailingRoutDistrib_commanders(unitMorale, bloodRainActive, wailingWindsActive, nIteration)] # wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" # rainStatus = "ON" if bloodRainActive == 1 else "OFF" # collectionLegend += ["winds " + wailingStatus + "\nrain " + rainStatus] # pltTitle = "commander morale " + str(unitMorale) # pdfName = "test_WailingRainComparison___morale_" + str(unitMorale)+"_commanders" # plotHistograms_commanders(nDistribs, routingTimeDistrib_collection, collectionLegend, pltTitle, pdfName, "debug") # squad for unitMorale in unitMorale_collection: print("simulating "+str(unitMorale)+":") # for wailingWindsActive in [0,1]: # if (bloodRainActive, wailingWindsActive) != (0, 0): nDistribs = 2 # wailing,rain (on,on), (on,off), (off,on) routedRatioDistrib_collection = [] collectionLegend = [] squadSize = 10 unitDensity = 2 for bloodRainActive in [0,1]: for wailingWindsActive in [0,1]: if (bloodRainActive, wailingWindsActive) != (0, 0) and (bloodRainActive, wailingWindsActive) != (1, 0): print("simulating (bloodRainActive, wailingWindsActive) = " + str((bloodRainActive, wailingWindsActive))) routedRatioDistrib_collection += [makeWailingRoutDistrib_squad(unitMorale, bloodRainActive, wailingWindsActive, squadSize, unitDensity, nIteration)] wailingStatus = "ON" if wailingWindsActive == 1 else "OFF" rainStatus = "ON" if bloodRainActive == 1 else "OFF" collectionLegend += ["winds " + wailingStatus + "\nrain " + rainStatus] pltTitle = "squad morale " + str(unitMorale) pdfName = "test_WailingRainComparison___morale_" + str(unitMorale)+"_squad" plotHistograms_squad(nDistribs, routedRatioDistrib_collection, collectionLegend, pltTitle, pdfName, "") # for units: # proba full squad gone # proba one unit gone # % of units in the squad gone # legacy error bars attempt # SumSquareDev = 0 # E = wailingExpectedRout(unitMorale, bloodRainActive, wailingWindsActive, nIteration) # n, bins, patches = plt.hist(RoutingTime, num_bins, range=(0,140), density=1, facecolor='blue', alpha=0.5) # y,binEdges = np.histogram(RoutingTime,range=(0,300),bins=num_bins) # bincenters = 0.5*(binEdges[1:]+binEdges[:-1]) # sigma = np.sqrt(y) # wrong error bar, check out https://stats.stackexchange.com/questions/368533/conditional-probability-for-consecutive-bernoulli-trials for an idea # width = 0.0 # # plt.bar(bincenters, y, width=width, color='r', yerr=sigma) # plt.errorbar( # bincenters, # y, # yerr = y**0.5, # marker = '.', # linestyle='', # drawstyle = 'steps-mid' # )