예제 #1
0
    def __init__(self):
        """  """
        self.commands = {
            'a': self.addAbilities,
            'd': self.addDreamAbility,
            'p': self.addParameters,
            's': self.addStats,
            't': self.addTypes
        }

        self.vals = {
            'species': None,
            'dex': None,
            'HP': None,
            'ATK': None,
            'DEF': None,
            'SPD': None,
            'SATK': None,
            'SDEF': None
        }

        self.abilities = []
        self.types = []
        self.dreamAbilities = []

        self.connection = PkmnDBConnect()
        self.cursor = self.connection.cursor()
예제 #2
0
 def loadFromDB(name):
     """ Loads an attack from a Database """
     connection = PkmnDBConnect()
     cursor = connection.cursor()
     
     attack = AttackFactory.buildAttackFromDB(cursor, name)
     connection.close()
     return attack
예제 #3
0
 def __init__(self, id, connection = None, cursor = None):
     """  """
     self.delegateType = "Attack in Use"
     self.commands = {'p':self.addParameters}
     self.vals = {'pkmn_id':id, 
                       'attack_id':None}
     
     #self.pkmn_id = id
     if connection is None:
         self.connection = PkmnDBConnect()
         self.cursor = self.connection.cursor()
     else:
         self.connection = connection
         self.cursor = cursor
예제 #4
0
 def __init__(self):
     """  """
     self.commands = {'p':self.addParameters, 'h':self.addHit,
                                'd':self.addDamage, 'c':self.addCrit, 's':self.addSpeed,
                                'e':self.addEffect}
     self.vals = {'name':None, 'type_id':None,
                       'hit_type':None, 'hit_id':None,
                       'damage_type':None, 'damage_id':None,
                       'crit_type':None, 'crit_id':None,
                       'speed_type':None, 'speed_id':None,
                       'effects':[]}
     
     
     self.connection = PkmnDBConnect()
     self.cursor = self.connection.cursor()
예제 #5
0
class DBAddAttackInUse(DBAdder):
    """ Adds an Attack In Use to the Database """

    def __init__(self, id, connection=None, cursor=None):
        """  """
        self.delegateType = "Attack in Use"
        self.commands = {"p": self.addParameters}
        self.vals = {"pkmn_id": id, "attack_id": None}

        # self.pkmn_id = id
        if connection is None:
            self.connection = PkmnDBConnect()
            self.cursor = self.connection.cursor()
        else:
            self.connection = connection
            self.cursor = cursor

    def execute(self, params, close=True):
        """  """
        self.attack = params[0]
        self.cursor.execute("SELECT id from Attack where name = ?", (self.attack,))
        self.vals["attack_id"] = self.cursor.fetchone()[0]

        self.addAttackInUse()

        self.connection.commit()

        if close:
            self.connection.close()

    def addAttackInUse(self):
        """ Adds the attack to the database """
        params = []
        toAdd = []

        for key in self.vals.keys():
            if self.vals[key] is None:
                continue

            params += [key]
            toAdd += [self.vals[key]]

        paramStr = self.GetStrFromList(params)

        print "Adding Attack In Use:", self.attack
        self.insertIntoDB("AttackInUse", paramStr, toAdd)
예제 #6
0
class DBAddAttackInUse(DBAdder):
    """ Adds an Attack In Use to the Database """
    def __init__(self, id, connection = None, cursor = None):
        """  """
        self.delegateType = "Attack in Use"
        self.commands = {'p':self.addParameters}
        self.vals = {'pkmn_id':id, 
                          'attack_id':None}
        
        #self.pkmn_id = id
        if connection is None:
            self.connection = PkmnDBConnect()
            self.cursor = self.connection.cursor()
        else:
            self.connection = connection
            self.cursor = cursor
    
    def execute(self, params, close = True):
        """  """
        self.attack = params[0]
        self.cursor.execute("SELECT id from Attack where name = ?", (self.attack,))
        self.vals['attack_id'] = self.cursor.fetchone()[0]
            
        self.addAttackInUse()
            
        self.connection.commit()
        
        if (close):
            self.connection.close()
        
    def addAttackInUse(self):
        """ Adds the attack to the database """
        params = []
        toAdd = []
        
        for key in self.vals.keys():
            if self.vals[key] is None:
                continue 
                
            params += [key]
            toAdd += [self.vals[key]]
            
        paramStr = self.GetStrFromList(params)
        
        print "Adding Attack In Use:", self.attack
        self.insertIntoDB("AttackInUse", paramStr, toAdd)
예제 #7
0
    def __init__(self, id, connection=None, cursor=None):
        """  """
        self.delegateType = "Attack in Use"
        self.commands = {"p": self.addParameters}
        self.vals = {"pkmn_id": id, "attack_id": None}

        # self.pkmn_id = id
        if connection is None:
            self.connection = PkmnDBConnect()
            self.cursor = self.connection.cursor()
        else:
            self.connection = connection
            self.cursor = cursor
예제 #8
0
 def __init__(self):
     """  """
     self.delegateType = "Ability"
     self.commands = {'p':self.addParameters, 
                                'a':self.addAbilityType}
     self.vals = {'name':None, 
                       'ability_type_id':None,
                       'ability_id':None,
                       'effects':[]}
                       
     self.getIDForType = {'ACC MOD':self.buildAccMod,
                                    'BOOST STAB':self.buildAbilityWithNone,
                                    'CANT LOWER STAT':self.buildCantLowerStat,
                                    'EFFECT AFTER TURN':self.buildAbilityWithEffects,
                                    'EFFECT ON CRIT':self.buildAbilityWithEffects,
                                    'EFFECT ON STAT MOD':self.buildAbilityWithEffects,
                                    'NO CRIT':self.buildAbilityWithNone,
                                    'SKIP TURN':self.buildAbilityWithNone,
                                    'SNIPER':self.buildAbilityWithNone,
                                    'STAT MOD ON STATUS':self.buildStatModOnStatus}
     
     
     self.connection = PkmnDBConnect()
     self.cursor = self.connection.cursor()
예제 #9
0
 def __init__(self):
     """  """
     self.commands = {'a':self.addAbilities,
                                'd':self.addDreamAbility,
                                'p':self.addParameters,
                                's':self.addStats,
                                't':self.addTypes}
                                
     self.vals = {'species':None,
                       'dex':None,
                       'HP':None,
                       'ATK':None,
                       'DEF':None,
                       'SPD':None,
                       'SATK':None,
                       'SDEF':None}
                       
     self.abilities = []
     self.types = []
     self.dreamAbilities = []
     
     self.connection = PkmnDBConnect()
     self.cursor = self.connection.cursor()
예제 #10
0
class DBAddPkmn(DBAdder):
    """ Adds a pkmn to the Database """
    def __init__(self), id, connection = None, cursor = None:
        """  """
        self.commands = {'a':self.addAttacks,
                                   'p':self.addParameters}
                                   
        self.vals = {'name':None,
                          'species_id':None,
                          'ability_id':None,
                          'level':None,
                          'currHP':None,
                          'trainer_id':id}
                          
        self.attacks = []
        
        self.trainer_id = id
        if connection is None:
            self.connection = PkmnDBConnect()
            self.cursor = self.connection.cursor()
        else:
            self.connection = connection
            self.cursor = cursor
예제 #11
0
class DBAddSpecies(DBAdder):
    """ Adds a species to the Database """
    def __init__(self):
        """  """
        self.commands = {'a':self.addAbilities,
                                   'd':self.addDreamAbility,
                                   'p':self.addParameters,
                                   's':self.addStats,
                                   't':self.addTypes}
                                   
        self.vals = {'species':None,
                          'dex':None,
                          'HP':None,
                          'ATK':None,
                          'DEF':None,
                          'SPD':None,
                          'SATK':None,
                          'SDEF':None}
                          
        self.abilities = []
        self.types = []
        self.dreamAbilities = []
        
        self.connection = PkmnDBConnect()
        self.cursor = self.connection.cursor()
    
    def execute(self, params, close = True):
        """  """
        for param in params:
            cmd = param[0]
            cmdParams = param[2:].split(':')
            
            self.commands[cmd](cmdParams)
            
        self.addSpecies()
            
        self.connection.commit()
        
        if (close):
            self.connection.close()
        
    def addSpecies(self):
        """ Adds the species to the database """
        params = []
        toAdd = []
        
        for key in self.vals.keys():
            if self.vals[key] is None:
                continue
                
            params += [key]
            toAdd += [self.vals[key]]
            
        paramStr = self.GetStrFromList(params)
        
        print "Adding Species:", self.vals['species']
        self.insertIntoDB("Species", paramStr, toAdd)
        
        self.cursor.execute("SELECT id from Species where species = ?", (self.vals['species'],))
        id = self.cursor.fetchone()[0]
        
        for type in self.types:
            self.insertIntoDB("SpeciesTypeJoin", "species_id, type_id", (id,)+(type,))
            
        for ability in self.abilities:
            self.insertIntoDB("SpeciesAbilityJoin", "species_id, ability_id", (id,)+(type,))
            
        for ability in self.dreamAbilities:
            self.insertIntoDB("SpeciesDreamAbilityJoin", "species_id, ability_id", (id,)+(type,))
            
    def addAbilities(self, vals):
        """ Adds Ability parameters """
        for ability in vals:
            if ability == "":
                continue
            ability = ability.strip()
            self.cursor.execute("SELECT id from Ability where name = ?", (ability,))
            self.abilities.append(self.cursor.fetchone()[0])
            
    def addDreamAbility(self, vals):
        """ Adds Dream Ability parameters """
        for dreamAbility in vals:
            dreamAbility = dreamAbility.strip()
            self.cursor.execute("SELECT id from Ability where name = ?", (dreamAbility,))
            self.dreamAbilities.append(self.cursor.fetchone()[0])
    
    def addParameters(self, vals):
        """ Adds Species specific parameters """
        self.vals['species'] = vals[0]
        self.vals['dex'] = vals[1]
        print "Building Species:", self.vals['species']
        
        self.checkForSpeciesAlready()
        
    def addStats(self, vals):
        """ Adds stats """
        self.vals['HP'] = vals[0]
        self.vals['ATK'] = vals[1]
        self.vals['DEF'] = vals[2]
        self.vals['SPD'] = vals[3]
        self.vals['SATK'] = vals[4]
        self.vals['SDEF'] = vals[5]
        
    def addTypes(self, vals):
        """ Adds types """
        for type in vals:
            type = type.strip()
            if type == "":
                continue
            
            self.cursor.execute("SELECT id from Type where name = ?", (type,))
            self.types.append(self.cursor.fetchone()[0])
        
    def checkForSpeciesAlready(self):
        """  """
        print "Checking for Species"
        self.cursor.execute("SELECT id from Species where species = ?", (self.vals['species'],))
        t = self.cursor.fetchone()
        
        if not t is None:
            print "Species %s already exists" % self.vals['species']
            raise Exception()
        print "Done checking Species"
예제 #12
0
class DBAddAbility(DBAdder):
    """ Adds an ability to the Database """
    def __init__(self):
        """  """
        self.delegateType = "Ability"
        self.commands = {'p':self.addParameters, 
                                   'a':self.addAbilityType}
        self.vals = {'name':None, 
                          'ability_type_id':None,
                          'ability_id':None,
                          'effects':[]}
                          
        self.getIDForType = {'ACC MOD':self.buildAccMod,
                                       'BOOST STAB':self.buildAbilityWithNone,
                                       'CANT LOWER STAT':self.buildCantLowerStat,
                                       'EFFECT AFTER TURN':self.buildAbilityWithEffects,
                                       'EFFECT ON CRIT':self.buildAbilityWithEffects,
                                       'EFFECT ON STAT MOD':self.buildAbilityWithEffects,
                                       'NO CRIT':self.buildAbilityWithNone,
                                       'SKIP TURN':self.buildAbilityWithNone,
                                       'SNIPER':self.buildAbilityWithNone,
                                       'STAT MOD ON STATUS':self.buildStatModOnStatus}
        
        
        self.connection = PkmnDBConnect()
        self.cursor = self.connection.cursor()
    
    def execute(self, params, close = True):
        """  """
        for param in params:
            cmd = param[0]
            cmdParams = param[2:].split(':')
            
            self.commands[cmd](cmdParams)
            
        self.addAbility()
            
        self.connection.commit()
        
        if (close):
            self.connection.close()
        
    def addAbility(self):
        """ Adds the attack to the database """
        params = []
        toAdd = []
        
        for key in self.vals.keys():
            if self.vals[key] is None:
                continue
                
            if key == 'effects':
                continue   
                
            params += [key]
            toAdd += [self.vals[key]]
            
        paramStr = self.GetStrFromList(params)
        
        print "Adding Ability:", self.vals['name']
        self.insertIntoDB("Ability", paramStr, toAdd)
        
        self.cursor.execute("SELECT id from Ability where name = ?", (self.vals['name'],))
        id = self.cursor.fetchone()[0]
        
        self.connectToExtraEffects(id)
            
    def addParameters(self, vals):
        """ Adds Attack specific parameters """
        self.vals['name'] = vals[0]
        print "Building Ability:", self.vals['name']
        self.checkForAbilityAlready()
        
    def addAbilityType(self, vals):
        """  """
        type = vals[0].strip()
        self.cursor.execute("SELECT id FROM AbilityVariants where type = ?", (type,))
        val = self.cursor.fetchone()
        if val is None:
            print "%s ability variant does not exist" % type
            raise Exception()
        
        self.vals['ability_type_id'] = val[0]
        self.vals['ability_id'] = self.getIDForType[type](type, vals[1:])
        
        
    def buildAbilityWithEffects(self, type, vals):
        """  """
        table = "AbilityEffectsJoin"
        effects = vals[0].split('_')[1:]
        
        for effect in effects:
            effectAdder = DBAddEffect(self.connection, self.cursor)
            effect_type_id, effect_id = effectAdder.execute(effect[2:].split('%'))
            self.vals['effects'].append((effect_type_id, effect_id,))
        
    def buildAbilityWithNone(self, type, vals):
        """  """
        return None
        
    def buildAccMod(self, type, vals):
        """  """
        table = "AccModAbility"
        mod = float(vals[0])
        
        toAdd = (mod,)
        where = "mod = ?"
        params = "mod"
        
        return self.buildDelegate(type, table, where, toAdd, params)
        
    def buildCantLowerStat(self, type, vals):
        """  """
        table = "CantLowerStatAbility"
        stat = vals[0]
        
        toAdd = (stat,)
        where = "stat = ?"
        params = "stat"
        
        return self.buildDelegate(type, table, where, toAdd, params)
        
    def buildStatModOnStatus(self, type, vals):
        """  """
        table = "StatModOnStatusAbility"
        status = vals[0]
        stat = vals[1]
        mod = float(vals[2])
        
        toAdd = (status, stat, mod,)
        where = "status = ? and stat = ? and mod = ?"
        params = "status, stat, mod"
        
        return self.buildDelegate(type, table, where, toAdd, params)
        
    def checkForAbilityAlready(self):
        """  """
        self.cursor.execute("SELECT id from Ability where name = ?", (self.vals['name'],))
        t = self.cursor.fetchone()
        
        if not t is None:
            print "Ability %s already exists" % self.vals['name']
            raise Exception()
            
    def connectToExtraEffects(self, id):
        """  """
        table = "AbilityEffectsJoin"
        paramStr = "ability_id, effect_type_id, effect_id"
        
        for effect in self.vals['effects']:
            self.insertIntoDB(table, paramStr, (id,)+effect)
예제 #13
0
class DBAddAttack(DBAdder):
    """ Adds an attack to the Database """
    def __init__(self):
        """  """
        self.commands = {'p':self.addParameters, 'h':self.addHit,
                                   'd':self.addDamage, 'c':self.addCrit, 's':self.addSpeed,
                                   'e':self.addEffect}
        self.vals = {'name':None, 'type_id':None,
                          'hit_type':None, 'hit_id':None,
                          'damage_type':None, 'damage_id':None,
                          'crit_type':None, 'crit_id':None,
                          'speed_type':None, 'speed_id':None,
                          'effects':[]}
        
        
        self.connection = PkmnDBConnect()
        self.cursor = self.connection.cursor()
    
    def execute(self, params, close = True):
        """  """
        for param in params:
            cmd = param[0]
            cmdParams = param[2:].split(':')
            
            self.commands[cmd](cmdParams)
            
        self.addAttack()
            
        self.connection.commit()
        
        if (close):
            self.connection.close()
        
    def addAttack(self):
        """ Adds the attack to the database """
        params = []
        toAdd = []
        
        for key in self.vals.keys():
            if self.vals[key] is None:
                continue
                
            if key == 'effects':
                continue
                
            params += [key]
            toAdd += [self.vals[key]]
            
        paramStr = self.GetStrFromList(params)
        
        print "Adding Attack:", self.vals['name']
        self.insertIntoDB("Attack", paramStr, toAdd)
        
        self.cursor.execute("SELECT id from Attack where name = ?", (self.vals['name'],))
        id = self.cursor.fetchone()[0]
        
        for effect in self.vals['effects']:
            self.insertIntoDB("AttackEffectsJoin", "attack_id, effect_type, effect_id", (id,)+effect)
            
    def addParameters(self, vals):
        """ Adds Attack specific parameters """
        self.vals['name'] = vals[0]
        type = vals[1].strip()
        print "Building Attack:", self.vals['name']
        self.cursor.execute("SELECT id FROM Type where name = ?", (type,))
        
        val = self.cursor.fetchone()
        if val is None:
            print "%s type does not exist" % type
            raise Exception()
        
        self.vals['type_id'] = val[0]
        
        self.checkForAttackAlready()
        
    def addHit(self, vals):
        """  """
        hit = DBAddHit(self.connection, self.cursor)
        self.vals['hit_type'], self.vals['hit_id'] = hit.execute(vals)
        
    def addDamage(self, vals):
        """  """
        damage = DBAddDamage(self.connection, self.cursor)
        self.vals['damage_type'], self.vals['damage_id'] = damage.execute(vals)
        
    def addCrit(self, vals):
        """  """
        crit = DBAddCrit(self.connection, self.cursor)
        self.vals['crit_type'], self.vals['crit_id'] = crit.execute(vals)
        
    def addSpeed(self, vals):
        """  """
        speed = DBAddSpeed(self.connection, self.cursor)
        self.vals['speed_type'], self.vals['speed_id'] = speed.execute(vals)
        
    def addEffect(self, vals):
        """  """
        effect = DBAddEffect(self.connection, self.cursor)
        effect_type, effect_id = effect.execute(vals)
        self.vals['effects'].append((effect_type, effect_id,))
        
    def checkForAttackAlready(self):
        """  """
        self.cursor.execute("SELECT id from Attack where name = ?", (self.vals['name'],))
        t = self.cursor.fetchone()
        
        if not t is None:
            print "Attack %s already exists" % self.vals['name']
            raise Exception()
예제 #14
0
class DBAddSpecies(DBAdder):
    """ Adds a species to the Database """
    def __init__(self):
        """  """
        self.commands = {
            'a': self.addAbilities,
            'd': self.addDreamAbility,
            'p': self.addParameters,
            's': self.addStats,
            't': self.addTypes
        }

        self.vals = {
            'species': None,
            'dex': None,
            'HP': None,
            'ATK': None,
            'DEF': None,
            'SPD': None,
            'SATK': None,
            'SDEF': None
        }

        self.abilities = []
        self.types = []
        self.dreamAbilities = []

        self.connection = PkmnDBConnect()
        self.cursor = self.connection.cursor()

    def execute(self, params, close=True):
        """  """
        for param in params:
            cmd = param[0]
            cmdParams = param[2:].split(':')

            self.commands[cmd](cmdParams)

        self.addSpecies()

        self.connection.commit()

        if (close):
            self.connection.close()

    def addSpecies(self):
        """ Adds the species to the database """
        params = []
        toAdd = []

        for key in self.vals.keys():
            if self.vals[key] is None:
                continue

            params += [key]
            toAdd += [self.vals[key]]

        paramStr = self.GetStrFromList(params)

        print "Adding Species:", self.vals['species']
        self.insertIntoDB("Species", paramStr, toAdd)

        self.cursor.execute("SELECT id from Species where species = ?",
                            (self.vals['species'], ))
        id = self.cursor.fetchone()[0]

        for type in self.types:
            self.insertIntoDB("SpeciesTypeJoin", "species_id, type_id",
                              (id, ) + (type, ))

        for ability in self.abilities:
            self.insertIntoDB("SpeciesAbilityJoin", "species_id, ability_id",
                              (id, ) + (type, ))

        for ability in self.dreamAbilities:
            self.insertIntoDB("SpeciesDreamAbilityJoin",
                              "species_id, ability_id", (id, ) + (type, ))

    def addAbilities(self, vals):
        """ Adds Ability parameters """
        for ability in vals:
            if ability == "":
                continue
            ability = ability.strip()
            self.cursor.execute("SELECT id from Ability where name = ?",
                                (ability, ))
            self.abilities.append(self.cursor.fetchone()[0])

    def addDreamAbility(self, vals):
        """ Adds Dream Ability parameters """
        for dreamAbility in vals:
            dreamAbility = dreamAbility.strip()
            self.cursor.execute("SELECT id from Ability where name = ?",
                                (dreamAbility, ))
            self.dreamAbilities.append(self.cursor.fetchone()[0])

    def addParameters(self, vals):
        """ Adds Species specific parameters """
        self.vals['species'] = vals[0]
        self.vals['dex'] = vals[1]
        print "Building Species:", self.vals['species']

        self.checkForSpeciesAlready()

    def addStats(self, vals):
        """ Adds stats """
        self.vals['HP'] = vals[0]
        self.vals['ATK'] = vals[1]
        self.vals['DEF'] = vals[2]
        self.vals['SPD'] = vals[3]
        self.vals['SATK'] = vals[4]
        self.vals['SDEF'] = vals[5]

    def addTypes(self, vals):
        """ Adds types """
        for type in vals:
            type = type.strip()
            if type == "":
                continue

            self.cursor.execute("SELECT id from Type where name = ?", (type, ))
            self.types.append(self.cursor.fetchone()[0])

    def checkForSpeciesAlready(self):
        """  """
        print "Checking for Species"
        self.cursor.execute("SELECT id from Species where species = ?",
                            (self.vals['species'], ))
        t = self.cursor.fetchone()

        if not t is None:
            print "Species %s already exists" % self.vals['species']
            raise Exception()
        print "Done checking Species"