def __init__(self, name='Stick', description='', damage=10, weapon_type='', cost=0, condition='sturdy', attacks=[Attack(), Attack(), Attack()]): self.name = name # a weapon's name consists of it's condition and regular name, e.g. 'Sturdy Sword' self.description = description self.condition = condition # condition effects the weapon's damage and other attributes, condition is defaulted to sturdy self.default_damage = damage self.damage = int( self.default_damage * condition_dictionary[self.condition]['damage_multiplier']) # damage changes depending on condition, but it is defaulted at the default damage # weapon's default damage is set by the parameter damage self.weapon_type = weapon_type self.cost = cost # how much it costs to purchase the weapon self.attacks = attacks # list of attacks that the weapon can perform self.critical_chance = condition_dictionary[ self.condition]['critical_chance'] self.critical_multiplier = condition_dictionary[ self.condition]['critical_multiplier']
def __init__(self, args, model, dataloarder): self.args = args # Basic # self.cuda = (args.cuda and torch.cuda.is_available()) # setting device if args.cuda and torch.cuda.is_available(): """ if argument is given and cuda is available """ self.device = torch.device('cuda') else: self.device = torch.device('cpu') self.epoch = args.epoch self.batch_size = args.batch_size self.eps = args.eps self.lr = args.lr self.y_dim = args.y_dim self.target = args.target self.dataset = args.dataset self.data_loader = dataloarder # dict self.global_epoch = 0 self.global_iter = 0 self.print_ = not args.silent self.net = model #need the model to be initialized here self.env_name = args.env_name self.tensorboard = args.tensorboard self.visdom = args.visdom self.ckpt_dir = Path(args.ckpt_dir).joinpath(args.env_name) if not self.ckpt_dir.exists(): self.ckpt_dir.mkdir(parents=True, exist_ok=True) self.output_dir = Path(args.output_dir).joinpath(args.env_name) if not self.output_dir.exists(): self.output_dir.mkdir(parents=True, exist_ok=True) # Visualization Tools self.visualization_init(args) # Histories self.history = dict() self.history['acc'] = 0. self.history['epoch'] = 0 self.history['iter'] = 0 # Models & Optimizers # self.model_init(args) self.load_ckpt = args.load_ckpt if self.load_ckpt != '': self.load_checkpoint(self.load_ckpt) # Adversarial Perturbation Generator #criterion = cuda(torch.nn.CrossEntropyLoss(), self.cuda) criterion = F.cross_entropy self.attack = Attack(self.net, criterion=criterion)
def unpack_attacks_into_objects(buff_output_dictionary): """unpacks attack attributes into objects within a dictionary""" attack_output_dictionary = {} for attack_group_key in attack_attribute_dictionary: attack_list = [] for attack_attributes in attack_attribute_dictionary[attack_group_key]: if attack_attributes['buff'] in buff_object_dictionary: attack_buff = buff_output_dictionary[attack_attributes['buff']] else: attack_buff = "" attack_list.append( Attack(attack_attributes['name'], attack_attributes['multiplier'], attack_attributes['variance'], attack_buff)) attack_output_dictionary[attack_group_key] = attack_list return attack_output_dictionary
def askUser(): print("==========================================") print("\n Please select an attack type:") print("\n 1. UDP Flood") print("\n 2. Ping of death") print("\n=========================================") try: valid = [1,2] answer = int(input("Choice [1-2]: ")) if answer not in valid: print("Please enter a valid number.") askUser() else: if answer == 1: host = input('Host: ') port = int(input('Post: ')) att = Attack('udpflood', host, port) isUp = att.checkTargetAlive() print(isUp) if isUp: att.attack() else: print("Could not check if target is up.") keepGoing = input("Do you still want to attack target? (y/n)") if keepGoing == 'y' or keepGoing == 'Y': att.attack() elif answer == 'n' or answer == 'N': askUser() else: pass else: pass finally: print("Done.")
def choose(arg): attack = str(accueil(arg)) if attack == "1": print("\n\t\t\t ***** Wiener Attack *****") args = input( "\n\t\t[*] Arguments ([-h] -n modulus -e exponent):\n\n\t\t\t" ).split() parser = argparse.ArgumentParser( description='This program allows to carry out a Wiener Attack') parser.add_argument('-n', dest='n', type=int, help='RSA public key modulus', required=True) parser.add_argument('-e', dest='e', type=int, help='RSA public key exponent', required=True) params = parser.parse_args(args) attack_object = Attack(params) attack_object.wiener() elif attack == "2": print("\n\t\t\t ***** Hastad Attack *****") try: args = input( "\n\t\t[*] Arguments ([-h] -n0 modulus_key0 -n1 modulus_key1 -n2 modulus_key2 -e public_exponent -c0 cipher1 -c1 cipher2 -c2 cipher3):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description='This program allows to carry out an Hastad Attack') parser.add_argument( '-n0', dest='n0', type=int, help='Modulus of the first RSA pulic key (decimal)', required=True) parser.add_argument( '-n1', dest='n1', type=int, help='Modulus of the second RSA pulic key (decimal)', required=True) parser.add_argument( '-n2', dest='n2', type=int, help='Modulus of the third RSA pulic key (decimal)', required=True) parser.add_argument('-e', dest='e', type=int, help='Common public exponent (decimal)', required=True) parser.add_argument('-c0', dest='c0', type=int, help='first ciphertext (decimal)', required=True) parser.add_argument('-c1', dest='c1', type=int, help='second ciphertext (decimal)', required=True) parser.add_argument('-c2', dest='c2', type=int, help='third ciphertext (decimal)', required=True) params = parser.parse_args(args) attack_object = Attack(params) attack_object.hastad() elif attack == "3": print("\n\t\t\t ***** Fermat Attack *****") try: args = input( "\n\t\t[*] Arguments ([-h] -n modulus -e exponent):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This program allows to carry out a Fermat Factorization') parser.add_argument('-n', dest='n', type=int, help='RSA public key modulus', required=True) parser.add_argument('-e', dest='e', type=int, help='RSA public key exponent', required=True) params = parser.parse_args(args) attack_object = Attack(params) attack_object.fermat() elif attack == "4": print("\n\t\t\t ***** Bleichenbacher Attack *****") try: args = input( "\n\t\t[*] Arguments ([-h] -n modulus -e exponent -c ciphertext --host hostname -p port --error error padding message):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This program allows to carry out a Bleichenbacher Attack') parser.add_argument('-n', dest='n', type=int, help='RSA public key modulus (int)', required=True) parser.add_argument('-e', dest='e', type=int, help='RSA public key exponent (int)', required=True) parser.add_argument('-c', dest='c', type=int, help='ciphertext (int)', required=True) parser.add_argument('--host', dest='host', type=str, help='hostname', required=True) parser.add_argument('-p', dest='port', type=int, help='port', required=True) parser.add_argument('--error', dest='error', type=str, help='Oracle Padding Error', required=True) params = parser.parse_args(args) attack_object = Attack(params) attack_object.bleichenbacher() elif attack == "5": print("\n\t\t\t ***** Common Modulus Attack *****") try: args = input( "\n\t\t[*] Arguments [-h] -n common modulus -e1 first exponent -e2 second exponent -c1 first cipher -c2 second cipher:\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This program allows to carry out a Common Modulus Attack') parser.add_argument('-n', dest='n', type=int, help='RSA public key modulus', required=True) parser.add_argument('-e1', dest='e1', type=int, help='First RSA public key exponent', required=True) parser.add_argument('-e2', dest='e2', type=int, help='Second RSA public key exponent', required=True) parser.add_argument('-c1', dest='c1', type=int, help='First ciphered text', required=True) parser.add_argument('-c2', dest='c2', type=int, help='Second ciphered text', required=True) params = parser.parse_args(args) attack_object = Attack(params) attack_object.comod() elif attack == "6": print("\n\t\t\t ***** Chosen Plaintext Attack *****") try: args = input( "\n\t\t[*] Arguments ([-h] -n modulus -e public_exponent -c ciphertext):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This program allows to carry out a Chosen Plaintext Attack') parser.add_argument('-n', dest='n', type=int, help='RSA public key modulus', required=True) parser.add_argument('-e', dest='e', type=int, help='first RSA public key exponent', required=True) parser.add_argument('-c', dest='c', type=int, help='ciphertext', required=True) params = parser.parse_args(args) params = parser.parse_args(args) attack_object = Attack(params) attack_object.chopla() elif attack == "a": print("\n\t\t\t ***** RSA Public Key parameters extraction *****") try: args = input("\n\t\t[*] Argument ([-h] -k K):\n\n\t\t\t").split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() if args[0] == '-k' and args[1] != '/': args[1] = getcwd() + "/" + args[1] parser = argparse.ArgumentParser( description= 'This program allows to extract the modulus and the exponent of an RSA public key (PEM)' ) parser.add_argument('-k', dest='k', type=str, help='path of the RSA public key', required=True) params = parser.parse_args(args) tool_object = Tool(params) tool_object.pubex() elif attack == "b": print("\n\t\t\t ***** RSA Private Key paramters extraction *****") try: args = input("\n\t\t[*] Argument ([-h] -k K):\n\n\t\t\t").split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() if args[0] == '-k' and args[1] != '/': args[1] = getcwd() + "/" + args[1] parser = argparse.ArgumentParser( description= 'This program allows to extract the parameters of an RSA private key (PEM)' ) parser.add_argument('-k', dest='k', type=str, help='path of the RSA private key', required=True) params = parser.parse_args(args) tool_object = Tool(params) tool_object.privex() elif attack == "c": print("\n\t\t\t ***** RSA Private Key constructor *****") try: args = input( "\n\t\t[*] Argument ([-h] -p first_factorization_element -q second_factorization_element -e public_exponent [-o output_file]):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This program allows to construct an RSA Private Key with its parameters' ) parser.add_argument('-p', dest='p', type=int, help='first element of the modulus factorization', required=True) parser.add_argument('-q', dest='q', type=int, help='second element of the modulus factorization', required=True) parser.add_argument('-e', dest='e', type=int, help='public exponent', required=True) parser.add_argument('-o', dest='o', type=str, help='output file') params = parser.parse_args(args) tool_object = Tool(params) tool_object.privkeyconstruct() elif attack == "d": print("\n\t\t\t ***** RSA Public Key constructor *****") try: args = input( "\n\t\t[*] Argument ([-h] -n modulus -e public_exponent [-o output_file]):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This program allows to construct an RSA Public Key with its parameters' ) parser.add_argument('-n', dest='n', type=int, help='modulus', required=True) parser.add_argument('-e', dest='e', type=int, help='public exponent', required=True) parser.add_argument('-o', dest='o', type=str, help='output file') params = parser.parse_args(args) tool_object = Tool(params) tool_object.pubkeyconstruct() elif attack == "e": print("\n\t\t\t ***** RSA Decipher *****") try: args = input( "\n\t\t[*] Argument ([-h] -n modulus -d private_exponent -c ciphertext):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This simple program allows to decipher a message using RSA') parser.add_argument('-n', dest='n', type=int, help='RSA public key modulus', required=True) parser.add_argument('-d', dest='d', type=int, help='RSA private key exponent', required=True) parser.add_argument('-c', dest='c', type=int, help='ciphertext', required=True) params = parser.parse_args(args) tool_object = Tool(params) tool_object.decipher() elif attack == "f": print("\n\t\t\t ***** RSA Encipher *****") try: args = input( "\n\t\t[*] Argument ([-h] -n modulus -e public_exponent -p plaintext):\n\n\t\t\t" ).split() except: print("\n\t\t\t[-] Argument Error: Please verify your inputs\n") exit() parser = argparse.ArgumentParser( description= 'This simple program allows to encipher a message using RSA') parser.add_argument('-n', dest='n', type=int, help='RSA public key modulus', required=True) parser.add_argument('-e', dest='e', type=int, help='RSA public key exponent', required=True) parser.add_argument('-p', dest='p', type=int, help='plaintext', required=True) params = parser.parse_args(args) tool_object = Tool(params) tool_object.encipher() else: choose("again")
class Solver(object): def __init__(self, args, model, dataloarder): self.args = args # Basic # self.cuda = (args.cuda and torch.cuda.is_available()) # setting device if args.cuda and torch.cuda.is_available(): """ if argument is given and cuda is available """ self.device = torch.device('cuda') else: self.device = torch.device('cpu') self.epoch = args.epoch self.batch_size = args.batch_size self.eps = args.eps self.lr = args.lr self.y_dim = args.y_dim self.target = args.target self.dataset = args.dataset self.data_loader = dataloarder # dict self.global_epoch = 0 self.global_iter = 0 self.print_ = not args.silent self.net = model #need the model to be initialized here self.env_name = args.env_name self.tensorboard = args.tensorboard self.visdom = args.visdom self.ckpt_dir = Path(args.ckpt_dir).joinpath(args.env_name) if not self.ckpt_dir.exists(): self.ckpt_dir.mkdir(parents=True, exist_ok=True) self.output_dir = Path(args.output_dir).joinpath(args.env_name) if not self.output_dir.exists(): self.output_dir.mkdir(parents=True, exist_ok=True) # Visualization Tools self.visualization_init(args) # Histories self.history = dict() self.history['acc'] = 0. self.history['epoch'] = 0 self.history['iter'] = 0 # Models & Optimizers # self.model_init(args) self.load_ckpt = args.load_ckpt if self.load_ckpt != '': self.load_checkpoint(self.load_ckpt) # Adversarial Perturbation Generator #criterion = cuda(torch.nn.CrossEntropyLoss(), self.cuda) criterion = F.cross_entropy self.attack = Attack(self.net, criterion=criterion) def visualization_init(self, args): # Visdom if self.visdom: from utils.visdom_utils import VisFunc self.port = args.visdom_port self.vf = VisFunc(enval=self.env_name, port=self.port) # TensorboardX if self.tensorboard: from tensorboardX import SummaryWriter self.summary_dir = Path(args.summary_dir).joinpath(args.env_name) if not self.summary_dir.exists(): self.summary_dir.mkdir(parents=True, exist_ok=True) self.tf = SummaryWriter(log_dir=str(self.summary_dir)) self.tf.add_text(tag='argument', text_string=str(args), global_step=self.global_epoch) # def model_init(self, args): # # Network # self.net = cuda(ToyNet(y_dim=self.y_dim), self.cuda) # self.net.weight_init(_type='kaiming') # # Optimizers # self.optim = optim.Adam([{'params':self.net.parameters(), 'lr':self.lr}], # betas=(0.5, 0.999)) def train(self): self.set_mode('train') for e in range(self.epoch): self.global_epoch += 1 correct = 0. cost = 0. total = 0. for batch_idx, (images, labels) in enumerate(self.data_loader['train']): self.global_iter += 1 x = Variable(images).to(self.device) y = Variable(labels).to(self.device) logit = self.net(x) prediction = logit.max(1)[1] correct = torch.eq(prediction, y).float().mean().data[0] cost = F.cross_entropy(logit, y) self.optim.zero_grad() cost.backward() self.optim.step() if batch_idx % 100 == 0: if self.print_: print() print(self.env_name) print('[{:03d}:{:03d}]'.format(self.global_epoch, batch_idx)) print('acc:{:.3f} loss:{:.3f}'.format( correct, cost.data[0])) if self.tensorboard: self.tf.add_scalars(main_tag='performance/acc', tag_scalar_dict={'train': correct}, global_step=self.global_iter) self.tf.add_scalars( main_tag='performance/error', tag_scalar_dict={'train': 1 - correct}, global_step=self.global_iter) self.tf.add_scalars( main_tag='performance/cost', tag_scalar_dict={'train': cost.data[0]}, global_step=self.global_iter) self.test() if self.tensorboard: self.tf.add_scalars(main_tag='performance/best/acc', tag_scalar_dict={'test': self.history['acc']}, global_step=self.history['iter']) print(" [*] Training Finished!") def test(self): self.set_mode('eval') correct = 0. cost = 0. total = 0. data_loader = self.data_loader['test'] for batch_idx, (images, labels) in enumerate(data_loader): x = Variable(images).to(self.device) y = Variable(labels).to(self.device) logit = self.net(x) prediction = logit.max(1)[1] correct += torch.eq(prediction, y).float().sum().data[0] cost += F.cross_entropy(logit, y, size_average=False).data[0] total += x.size(0) accuracy = correct / total cost /= total if self.print_: print() print('[{:03d}]\nTEST RESULT'.format(self.global_epoch)) print('ACC:{:.4f}'.format(accuracy)) print('*TOP* ACC:{:.4f} at e:{:03d}'.format( accuracy, self.global_epoch, )) print() if self.tensorboard: self.tf.add_scalars(main_tag='performance/acc', tag_scalar_dict={'test': accuracy}, global_step=self.global_iter) self.tf.add_scalars(main_tag='performance/error', tag_scalar_dict={'test': (1 - accuracy)}, global_step=self.global_iter) self.tf.add_scalars(main_tag='performance/cost', tag_scalar_dict={'test': cost}, global_step=self.global_iter) if self.history['acc'] < accuracy: self.history['acc'] = accuracy self.history['epoch'] = self.global_epoch self.history['iter'] = self.global_iter self.save_checkpoint('best_acc.tar') self.set_mode('train') def generate(self, num_sample=100, target=-1, epsilon=0.03, alpha=2 / 255, iteration=1): self.set_mode('eval') x_true, y_true = self.sample_data(num_sample) if isinstance(target, int) and (target in range(self.y_dim)): y_target = torch.LongTensor(y_true.size()).fill_(target) else: y_target = None x_adv, changed, values = self.FGSM(x_true, y_true, y_target, epsilon, alpha, iteration) accuracy, cost, accuracy_adv, cost_adv = values save_image(x_true, self.output_dir.joinpath( 'legitimate(t:{},e:{},i:{}).jpg'.format( target, epsilon, iteration)), nrow=10, padding=2, pad_value=0.5) save_image(x_adv, self.output_dir.joinpath( 'perturbed(t:{},e:{},i:{}).jpg'.format( target, epsilon, iteration)), nrow=10, padding=2, pad_value=0.5) save_image(changed, self.output_dir.joinpath( 'changed(t:{},e:{},i:{}).jpg'.format( target, epsilon, iteration)), nrow=10, padding=3, pad_value=0.5) if self.visdom: self.vf.imshow_multi(x_true.cpu(), title='legitimate', factor=1.5) self.vf.imshow_multi(x_adv.cpu(), title='perturbed(e:{},i:{})'.format( epsilon, iteration), factor=1.5) self.vf.imshow_multi(changed.cpu(), title='changed(white)'.format(epsilon), factor=1.5) print('[BEFORE] accuracy : {:.2f} cost : {:.3f}'.format( accuracy, cost)) print('[AFTER] accuracy : {:.2f} cost : {:.3f}'.format( accuracy_adv, cost_adv)) self.set_mode('train') def sample_data(self, num_sample=100): total = len(self.data_loader['test'].dataset) # seed = torch.FloatTensor(num_sample).uniform_(1, total).long()#if dataset is in tensor format #otherwise indexing is not supported for ndarray[torch seed] seed = np.random.random_integers(1, total, size=num_sample) # print(seed) x = torch.from_numpy(self.data_loader['test'].dataset.test_data[seed]) x = x.type(torch.cuda.FloatTensor) x = Variable(x, requires_grad=True).to(self.device) x = self.scale(x.float().unsqueeze(1).div(255)) print(type(self.data_loader['test'].dataset.test_data), self.data_loader['test'].dataset.test_data[0].shape) y = self.data_loader['test'].dataset.test_data[seed] #y = Variable(torch.from_numpy(self.data_loader['test'].dataset.test_labels[seed]),requires_grad = False).to(self.device) return x, y def FGSM(self, x, y_true, y_target=None, eps=0.03, alpha=2 / 255, iteration=1): self.set_mode('eval') if type(x) == np.ndarray: x = torch.from_numpy(x) if type(y_true) == np.ndarray: y_true = torch.from_numpy(y_true) x = Variable(x, requires_grad=True).to(self.device) y_true = Variable(y_true, requires_grad=False).to(self.device) if y_target is not None: targeted = True y_target = Variable(y_target, requires_grad=False).to(self.device) else: targeted = False h = self.net(x) prediction = h.max(1)[1] accuracy = torch.eq(prediction, y_true).float().mean() cost = F.cross_entropy(h, y_true) if iteration == 1: if targeted: x_adv, h_adv, h = self.attack.fgsm(x, y_target, True, eps) else: x_adv, h_adv, h = self.attack.fgsm(x, y_true, False, eps) else: if targeted: x_adv, h_adv, h = self.attack.i_fgsm(x, y_target, True, eps, alpha, iteration) else: x_adv, h_adv, h = self.attack.i_fgsm(x, y_true, False, eps, alpha, iteration) prediction_adv = h_adv.max(1)[1] accuracy_adv = torch.eq(prediction_adv, y_true).float().mean() cost_adv = F.cross_entropy(h_adv, y_true) # make indication of perturbed images that changed predictions of the classifier if targeted: changed = torch.eq(y_target, prediction_adv) else: changed = torch.eq(prediction, prediction_adv) changed = torch.eq(changed, 0) changed = changed.float().view(-1, 1, 1, 1).repeat(1, 3, 28, 28) changed[:, 0, :, :] = where(changed[:, 0, :, :] == 1, 252, 91) changed[:, 1, :, :] = where(changed[:, 1, :, :] == 1, 39, 252) changed[:, 2, :, :] = where(changed[:, 2, :, :] == 1, 25, 25) changed = self.scale(changed / 255) changed[:, :, 3:-2, 3:-2] = x_adv.repeat(1, 3, 1, 1)[:, :, 3:-2, 3:-2] self.set_mode('train') return x_adv.data, changed.data,\ (accuracy.data[0], cost.data[0], accuracy_adv.data[0], cost_adv.data[0]) def save_checkpoint(self, filename='ckpt.tar'): model_states = { 'net': self.net.state_dict(), } optim_states = { 'optim': self.optim.state_dict(), } states = { 'iter': self.global_iter, 'epoch': self.global_epoch, 'history': self.history, 'args': self.args, 'model_states': model_states, 'optim_states': optim_states, } file_path = self.ckpt_dir / filename torch.save(states, file_path.open('wb+')) print("=> saved checkpoint '{}' (iter {})".format( file_path, self.global_iter)) def load_checkpoint(self, filename='best_acc.tar'): file_path = self.ckpt_dir / filename if file_path.is_file(): print("=> loading checkpoint '{}'".format(file_path)) checkpoint = torch.load(file_path.open('rb')) self.global_epoch = checkpoint['epoch'] self.global_iter = checkpoint['iter'] self.history = checkpoint['history'] self.net.load_state_dict(checkpoint['model_states']['net']) self.optim.load_state_dict(checkpoint['optim_states']['optim']) print("=> loaded checkpoint '{} (iter {})'".format( file_path, self.global_iter)) else: print("=> no checkpoint found at '{}'".format(file_path)) def set_mode(self, mode='train'): if mode == 'train': self.net.train() elif mode == 'eval': self.net.eval() else: raise ('mode error. It should be either train or eval') def scale(self, image): return image.mul(2).add(-1) def unscale(self, image): return image.add(1).mul(0.5) def summary_flush(self, silent=True): rm_dir(self.summary_dir, silent) def checkpoint_flush(self, silent=True): rm_dir(self.ckpt_dir, silent)
from attacks import Attack # Initialize all attacks # ----------------------------------------------------------------------------------------- # # Fire type--------------------------- #new moves added blastburn = Attack(name='blast burn', attCategory='fire', baseDamage=150, pokemonLevel=0, baseCount=5, recoil=15, heal=0, accuracy=0.9) blazekick = Attack(name='blaze kick', attCategory='fire', baseDamage=85, pokemonLevel=0, baseCount=10, recoil=0, heal=0, accuracy=0.9) fierydance = Attack(name='fiery dance', attCategory='fire', baseDamage=80, pokemonLevel=0, baseCount=10, recoil=0, heal=0,
def main(): graph = graph_loader(graph_type='water', seed=1) params = { 'runs': 1, 'steps': 30, 'seed': 1, 'attack': 'rb_node', 'attack_approx': int(0.1 * len(graph)), 'plot_transition': True, 'gif_animation': True, 'gif_snaps': True, 'edge_style': None, 'node_style': None, 'fa_iter': 20 } print("Creating example visualization") a = Attack(graph, **params) a.run_simulation() node_attacks = ['rnd_node', 'id_node', 'rd_node', 'ib_node', 'rb_node'] edge_attacks = ['rnd_edge', 'id_edge', 'rd_edge', 'ib_edge', 'rb_edge'] params['runs'] = 10 params['steps'] = len(graph) - 1 params['plot_transition'] = False params['gif_animation'] = False params['gif_snaps'] = False print("Running node attacks") results = defaultdict(str) for attack in node_attacks: params['attack'] = attack if 'rb' in attack or 'ib' in attack: params['attack_approx'] = int(0.1 * len(graph)) else: params['attack_approx'] = None a = Attack(graph, **params) results[attack] = a.run_simulation() plot_results(graph, params['steps'], results, title='water:node-attacks_runs={}'.format(params['runs'])) print("Running edge attacks") results = defaultdict(str) for attack in edge_attacks: params['attack'] = attack if 'rb' in attack or 'ib' in attack: params['attack_approx'] = int(0.1 * len(graph)) else: params['attack_approx'] = None a = Attack(graph, **params) results[attack] = a.run_simulation() plot_results(graph, params['steps'], results, title='water:edge-attacks_runs={}'.format(params['runs']))