示例#1
0
    def feed_carnivore(cls, hungry_carnivores, player_state, list_of_player):
        """
        Feeds the largest hungry carnivore
        :param hungry_carnivores: list of hungry carnivores
        :param player_state: the current player state
        :param list_of_player: list of all player states
        :return:
        """
        sorted_carnivores = Species.sort_lex(hungry_carnivores)
        for carnivore in sorted_carnivores:
            targets = []
            for player in list_of_player:
                if player == player_state:
                    continue
                for i in range(0, len(player.species)):
                    defender = player.species[i]
                    left_neighbor = (False if i == 0 else player.species[i - 1])
                    right_neighbor = (False if i == len(player.species) - 1 else player.species[i + 1])
                    if defender.is_attackable(carnivore, left_neighbor, right_neighbor):
                        targets.append(defender)
            if targets:
                sorted_targets = Species.sort_lex(targets)
                target = sorted_targets[0]
                target_player = next(player for player in list_of_player if target in player.species)
                return [carnivore, target_player, target]

        return False
示例#2
0
    def sense(self, animal_base):
        surrounding_res = Surroundings()
        for spec in self.animals.keys():
            for animal2 in self.animals[spec]:
                animal2_dist = self.distanceToAgent(animal_base, animal2)
                if (animal2_dist < animal_base.genes.sense):
                    if Species.predator(
                            animal_base._species) == animal2._species:
                        surrounding_res.closest_predator = animal2
                        surrounding_res.closest_predator_dist = animal2_dist

                    elif Species.prey(
                            animal_base._species) == animal2._species:
                        surrounding_res.closest_prey = animal2
                        surrounding_res.closest_prey_dist = animal2_dist

        for spec in self.plants.keys():
            for plant in self.plants[spec]:
                plant_dist = self.distanceToAgent(animal_base, plant)
                if (plant_dist < animal_base.genes.sense):
                    if (surrounding_res.closest_plant is None or
                            plant_dist < surrounding_res.closest_plant_dist):
                        surrounding_res.closest_plant = plant
                        surrounding_res.closest_plant_dist = plant_dist

        return surrounding_res
 def feed_carnivore(cls, hungry_carnivores, player_state, list_of_player):
     """
     Feeds the largest hungry carnivore
     :param hungry_carnivores: list of hungry carnivores
     :param player_state: the current player state
     :param list_of_player: list of all player states
     :return:
     """
     sorted_carnivores = Species.sort_lex(hungry_carnivores)
     for carnivore in sorted_carnivores:
         targets = []
         for player in list_of_player:
             if player == player_state:
                 continue
             for i in range(0, len(player.species)):
                 defender = player.species[i]
                 left_neighbor = (False if i == 0 else player.species[i -
                                                                      1])
                 right_neighbor = (False if i == len(player.species) -
                                   1 else player.species[i + 1])
                 if defender.is_attackable(carnivore, left_neighbor,
                                           right_neighbor):
                     targets.append(defender)
         if targets:
             sorted_targets = Species.sort_lex(targets)
             target = sorted_targets[0]
             target_player = next(player for player in list_of_player
                                  if target in player.species)
             return [carnivore, target_player, target]
         else:
             return False
 def test_can_eat(self):
     self.assertFalse(self.species_1.can_eat())
     self.assertTrue(self.species_4.can_eat())
     fat_tissue = Species(4, 3, 4, [TraitCard("fat-tissue")], 3)
     self.assertTrue(fat_tissue.can_eat())
     fat_tissue.fat_storage = 4
     self.assertFalse(fat_tissue.can_eat())
示例#5
0
 def setUp(self):
     self.t1 = TraitCard("horns", 3)
     self.t2 = TraitCard("ambush", 1)
     self.t3 = TraitCard("carnivore", 2)
     self.t4 = TraitCard("fat-tissue", 0)
     self.t5 = TraitCard("foraging", 3)
     self.t6 = TraitCard("herding", 0)
     self.defSpec = Species(0, 0, 1, [], 0)
     self.specWGrownBody = Species(0, 1, 1, [], 0)
     self.specW3t = Species(0, 0, 1, [self.t3, self.t4, self.t5], 0)
     self.specWAll = Species(0, 1, 2, [self.t4], 0)
     self.playerWithManyCards = PlayerState(
         1, 0, [], [self.t1, self.t2, self.t3, self.t4, self.t5, self.t6])
     self.playerForAll = PlayerState(1, 0, [self.specWAll], [])
     self.playerFor3t = PlayerState(1, 0, [self.specW3t], [self.t6])
     self.playerForDefSpec = PlayerState(1, 0, [self.defSpec],
                                         [self.t5, self.t6])
     self.playerForBodyNewspec = PlayerState(
         1, 0, [self.specWGrownBody], [self.t3, self.t4, self.t5, self.t6])
     self.noAct = Action4(0, [], [], [], [])
     self.actGP = Action4(0, [GainPopulation(0, 1)], [], [], [])
     self.actGB = Action4(0, [], [GainBodySize(0, 1)], [], [])
     self.actRT = Action4(0, [], [], [ReplaceTrait(0, 1, 1)], [])
     self.actBT0t = Action4(0, [], [], [], [BuySpeciesBoard(1, [])])
     self.actBT1t = Action4(0, [], [], [], [BuySpeciesBoard(1, [2])])
     self.actBT2t = Action4(0, [], [], [], [BuySpeciesBoard(1, [2, 3])])
     self.actBT3t = Action4(0, [], [], [], [BuySpeciesBoard(1, [2, 3, 4])])
     self.actBT4t = Action4(0, [], [], [],
                            [BuySpeciesBoard(1, [2, 3, 4, 5])])
     self.addBodyToNewSpec = Action4(0, [GainPopulation(1, 1)], [], [],
                                     [BuySpeciesBoard(2, [3])])
     self.actAll = Action4(0, [GainPopulation(0, 1)], [GainBodySize(0, 2)],
                           [ReplaceTrait(0, 0, 3)],
                           [BuySpeciesBoard(4, [5])])
示例#6
0
class TestReaction(unittest.TestCase):

    def setUp(self):
        self._limiting = Species("Limiting", 100)
        self._limiting.set_n(0.001)
        self._reactant2 = Species("Reactant #1", 200)
        self._reactant3 = Species("Reactant #2", 300)
        self._product = Species("Product", 400)

    def test_add_get_limiting_reactant(self):
        reaction = Reaction()
        reaction.add_limiting_reactant(self._limiting)
        self.assertEqual(reaction.get_limiting_reactant().n(), 0.001)

    def test_add_get_reactant(self):
        reaction = Reaction()
        reaction.add_limiting_reactant(self._limiting)
        reaction.add_reactant(self._reactant2, 2)
        reaction.add_reactant(self._reactant3, 3)
        self.assertEqual(reaction.get_non_limiting_reactants()[0].n(), 0.002)
        self.assertEqual(reaction.get_non_limiting_reactants()[1].n(), 0.003)

    def test_add_get_product(self):
        reaction = Reaction()
        reaction.add_product(self._product, 0.4)
        self.assertEqual(reaction.get_product().n(), 0.001)

    def test_get_yield(self):
        reaction = Reaction()
        reaction.add_limiting_reactant(self._limiting)
        reaction.add_product(self._product, 0.3)
        self.assertEqual(reaction.get_yield(), 75)
 def test_sort_lex(self):
     sorted_list = [
         self.species_2, self.species_1, self.species_3, self.species_4,
         self.species_5
     ]
     self.assertEqual(Species.sort_lex(self.species_list), sorted_list)
     self.assertNotEqual(Species.sort_lex(self.species_list),
                         self.species_list)
示例#8
0
def initializeModels():
    model = newModel()
    board = [0 for x in range(10)]
    board = [list(board) for x in range(20)]
    species = Species(model,[board]*2,[[1,0,0,0,0,0,0,0],[0,0,0,0,0,0,1,0]],0)
    assert (len(species.intake) == len(species.output))
    species.create()
    return species
示例#9
0
 def validate_cards(self, total_deck):
     """
     Validates that the TraitCards in this PlayerState's hand and on its Species boards are all possible
     and unique
     :param total_deck: a list of TraitCards representing all valid card possibilities
     :raise ValueError if duplicate or invalid cards exist on this player
     """
     TraitCard.validate_all_unique(self.hand, total_deck)
     Species.validate_all_cards(self.species, total_deck)
 def initialize_species(X, Y, positive_examples, negative_examples,
                        minority_flag):
     # Positive Species
     species_a = Species(X, Y, positive_examples, negative_examples, 1, 100,
                         minority_flag)
     # Negative Species
     species_b = Species(X, Y, negative_examples, positive_examples, 0, 100,
                         not minority_flag)
     return [species_a, species_b]
示例#11
0
文件: tests.py 项目: skirklin/modopt
 def optimizer_test(self):
     target = np.array([5,1,2])
     def objective(a,b,c):
         arr = np.array([a,b,c])
         return np.average((arr - target)**2)**0.5
     genome = {'a':range(10), 'b':range(10), 'c':range(1)}
     genome = Genome(genome)
     spec = Species(genome, objective=objective)
     spec.evaluate()
     spec.evolve()
 def test_largest_fatty_need(self):
     self.species_1.traits = [TraitCard("fat-tissue")]
     self.species_2.traits = [TraitCard("fat-tissue")]
     self.species_4.traits = [TraitCard("fat-tissue")]
     self.assertEqual(
         Species.largest_fatty_need([self.species_1, self.species_4]),
         self.species_4)
     self.assertEqual(
         Species.largest_fatty_need([self.species_1, self.species_2]),
         self.species_1)
 def validate_attributes(self):
     """
     Validates the attributes of this PlayerState
     :raise AssertionError if any attributes are out of bounds
     """
     assert(isinstance(self.name, int) and self.name >= MIN_PLAYER_ID)
     assert(isinstance(self.food_bag, int) and self.food_bag >= MIN_FOOD_BAG)
     assert(isinstance(self.hand, list))
     TraitCard.validate_all_attributes(self.hand)
     assert(isinstance(self.species, list))
     Species.validate_all_attributes(self.species)
示例#14
0
	def situationFromJson(situation):    
		defend = JsonParsing.speciesFromJson(situation[0])
		attack = JsonParsing.speciesFromJson(situation[1])

		if not attack or not defend:
			quit()

		lNeighbor = JsonParsing.speciesFromJson(situation[2]) or Species(0, 0, 0, [], 0)
		rNeighbor = JsonParsing.speciesFromJson(situation[3]) or Species(0, 0, 0, [], 0)

		return defend, attack, lNeighbor, rNeighbor
示例#15
0
    def parse_choice(choice):
        """
        Parse a choice into a [PlayerState, listOf(Species), listOf(Species]
        :param choice: json list representing [playerstate, listof species, listof species]
        :return: [PlayerState, listOf(Species), listOf(Species)]
        """
        ps = PlayerState.convertPlayerState(choice[0])
        prev_species = [Species.convertSpecies(species) for species in [prev for prev in choice[1]]]
        later_species = [Species.convertSpecies(species) for species in [late for late in choice[2]]]

        return [ps, prev_species, later_species]
示例#16
0
文件: tests.py 项目: skirklin/modopt
    def organism_test(self):
        genome = Genome({
            'A':range(10),
            'B':'abcdefg',
            'C':np.linspace(0, 1, 100)})
        species = Species(genome)

        org1 = species.spawn_organism()
        org2 = species.spawn_organism()

        org3 = org1.mate(org2)
        org3.mutate()
示例#17
0
 def json_to_species(cls, json_species):
     assert(cls.validate_species_json(json_species))
     species_food = json_species[0][1]
     species_body = json_species[1][1]
     species_pop = json_species[2][1]
     species_traits = []
     for trait in json_species[3][1]:
         species_traits.append(cls.json_to_trait(trait))
     species_obj = Species(species_pop, species_food, species_body, species_traits)
     if len(json_species) == 5:
         species_obj.fat_storage = json_species[4][1]
     return species_obj
    def setUp(self):
        self.attacker = Species()
        self.attacker.traits = [TraitCard("carnivore")]
        self.defender = Species()
        self.left_neighbor = Species()
        self.right_neighbor = Species()

        self.species_1 = Species(4, 4, 4)
        self.species_2 = Species(4, 4, 4)
        self.species_3 = Species(4, 4, 3)
        self.species_4 = Species(4, 3, 3)
        self.species_5 = Species(3, 3, 3)
        self.species_list = [self.species_2, self.species_4, self.species_3, self.species_5, self.species_1]
def readXYZ(xyz, bonds=None, cluster_bond=None, fixed_atoms=None):
    # extract molecule information from xyz
    mol = next(pb.readfile('xyz', xyz))
    reactant_atom = [a.OBAtom.GetAtomicNum() for a in mol]
    # Manually give bond information
    # (Because in metal system the bond information detect by openbabel usually have some problem)
    if bonds or cluster_bond:
        m = Molecule(pb.ob.OBMol())
        obmol = m.OBMol

        obmol.BeginModify()
        for atom in mol:
            coords = [coord for coord in atom.coords]
            atomno = atom.atomicnum
            obatom = ob.OBAtom()
            obatom.thisown = 0
            obatom.SetAtomicNum(atomno)
            obatom.SetVector(*coords)
            obmol.AddAtom(obatom)
            del obatom

        if cluster_bond:
            bonds = [(bond.GetBeginAtomIdx(), bond.GetEndAtomIdx(),
                      bond.GetBondOrder())
                     for bond in pb.ob.OBMolBondIter(mol.OBMol)]
            #bonds = imaginary_bond(bonds, reactant_atom, fixed_atoms)
            bonds.extend(cluster_bond)

        for bond in bonds:
            obmol.AddBond(bond[0], bond[1], bond[2])

        # obmol.ConnectTheDots()
        obmol.PerceiveBondOrders()
        # obmol.SetTotalSpinMultiplicity(1)
        obmol.SetTotalCharge(int(mol.charge))
        obmol.Center()
        obmol.EndModify()

        mol_obj = gen3D.Molecule(obmol)

        reactant_graph = Species(xyz_file_to_atoms(xyz))
        reactant_bonds = [(i[0] - 1, i[1] - 1) for i in bonds]
        make_graph(reactant_graph, bond_list=reactant_bonds)
    else:
        mol_obj = gen3D.Molecule(mol.OBMol)
        reactant_graph = Species(xyz_file_to_atoms(xyz))
        reactant_bonds = tuple(
            sorted([(bond.GetBeginAtomIdx() - 1, bond.GetEndAtomIdx() - 1)
                    for bond in pb.ob.OBMolBondIter(mol.OBMol)]))
        make_graph(reactant_graph, bond_list=reactant_bonds)
    return mol_obj, reactant_graph
示例#20
0
 def parse_cj_dj(json_cj_dj):
     """
     Parse a json cj_dj into a [listOf(listOf(Species)), listOf(listOf(Species))]
     :param json_cj_dj: json list representing [listof species, listof species]
                     - First list of species is each specieslist of all players acting before this player
                     - Second list of species is each specieslist of all players who's turns come after this player
     :return: (listOf(Species), listOf(Species))
     """
     prev_species, later_species = [], []
     for prev in json_cj_dj[0]:
         prev_species.append([Species.convertSpecies(species) for species in prev])
     for later in json_cj_dj[1]:
         later_species.append([Species.convertSpecies(species) for species in later])
     return prev_species, later_species
示例#21
0
  def setUp(self):
    self.species1 = Species(0, 1, 3, [])
    self.carni2 = Species(0, 2, 3, [Trait.carnivore])
    self.herbavore = Species(0, 1, 1, [])
    self.herbavore2 = Species(0, 1, 1, [])

    self.herbavore3 = Species(1, 1, 1, [])
    self.herbavore4 = Species(2, 1, 2, [])

    self.fat_tissue = Species(0, 1, 1, [])
    self.fat_tissue.setTraits([Trait.fat_tissue])
    self.fat_tissue2 = Species(0, 3, 1, [])
    self.fat_tissue2.setTraits([Trait.fat_tissue])

    self.opherb = Species(0, 1, 1, [])
    self.opfatherb = Species(0, 7, 1, [])

    self.fertileCard = TraitCard(Trait.fertile, 2)
    self.climbingCard = TraitCard(Trait.climbing, 0)
    self.cooperationCard = TraitCard(Trait.cooperation, 0)
    self.carnivoreCard = TraitCard(Trait.carnivore, 0)
    self.longNeckCard = TraitCard(Trait.long_neck, 0)
    self.ambushCard = TraitCard(Trait.ambush, 0)
    self.burrowingCard = TraitCard(Trait.burrowing, 0)
    self.cooperation2Card = TraitCard(Trait.cooperation, -1)

    self.player1 = Player(1, [], 0)
    self.player2 = Player(2, [], 0)
    self.player3 = Player(3, [], 0)

    self.validAction1 = [2, [[2, 6]], [[2, 3]], [[5, 4]], [[2, 0, 0]]]
    self.validAction2 = [2, [[2, 0]], [[2, 1]], [[4, 3]], []]
    self.validAction3 = [2, [[2, 1]], [], [[3, 0]], []]
    self.validAction4 = [2, [], [], [[0, 1]], []]
    self.validAction5 = [0, [], [], [], []]

    self.invalidAction1 = ["hi", 1, [], "so", False]
    self.invalidAction2 = ["hi", 1, []]
    self.invalidAction3 = [False, [["2", 6]], [[2, 3]], [[5, 4]], [[2, 0, 0]]]

    self.validFeeding1 = False
    self.validFeeding2 = 1
    self.validFeeding3 = [1, 9]
    self.validFeeding4 = [0, 0, 1]

    self.invalidFeeding1 = True
    self.invalidFeeding2 = [1, 2, 3, 3, ""]
    self.invalidFeeding3 = ["p", "i", "e"]
示例#22
0
    def breed_new_generation(self):
        self.calculate_genome_adjusted_fitness()

        self.remove_weak_genomes_from_species()
        self.remove_stale_species()

        survived_species: List[Species] = []
        children: List[Genome] = []

        total_adjusted_fitness: float = self.calculate_total_adjusted_fitness()

        carry_over: float = 0
        for species in self.species:
            fchild: float = self.population * (
                species.get_total_adjusted_fitness() / total_adjusted_fitness)
            nchild: int = int(fchild)
            carry_over += fchild - nchild
            if carry_over >= 1:
                carry_over -= 1
                nchild += 1

            if nchild < 1:
                continue

            new_species: Species = Species(species.get_top_genome())
            new_species.previous_top_fitness = species.previous_top_fitness
            new_species.staleness = species.staleness
            survived_species.append(new_species)
            for _ in range(1, nchild):
                children.append(species.breed_child())

        self.species: List[Species] = survived_species
        for child in children:
            self.add_to_species(child)
示例#23
0
    def speciate(self):
        for spec in self.population:
            spec.entities = []
        for entity in self.population:

            suitable_species = False

            for spec in self.species:
                if Species.are_compatible(spec.standard, entity.brain):
                    spec.add(entity)
                    suitable_species = True
                    break

            if not suitable_species:
                self.species.append(Species(entity, self.spec_innov))
                self.spec_innov += 1
示例#24
0
 def show_changes(self, other_player):
     """
     Creates a string representation of the changed attributes between a PlayerState before and after
     an imperative function is called on it.
     :param other_player: The PlayerState after it has been modified
     :return: String of attribute changes, or "" if unchanged.
     """
     changes = []
     if self.name != other_player.name:
         changes.append(CHANGE_TEMPLATE %
                        ("name", str(self.name), str(other_player.name)))
     if self.food_bag != other_player.food_bag:
         changes.append(
             CHANGE_TEMPLATE %
             ("food_bag", str(self.food_bag), str(other_player.food_bag)))
     hand_changes = TraitCard.show_all_changes(self.hand, other_player.hand)
     if hand_changes:
         changes.append(hand_changes)
     species_changes = Species.show_all_changes(self.species,
                                                other_player.species)
     if species_changes:
         changes.append(species_changes)
     if self.active != other_player.active:
         changes.append(CHANGE_TEMPLATE %
                        ("active", self.active, other_player.active))
     return ", ".join(changes)
示例#25
0
    def __init__(self, db_name):
        """db_name: and Emsembl database name"""
        if isinstance(db_name, EnsemblDbName):
            db_name = db_name.Name
        self.Name = db_name
        self.Type = get_dbtype_from_name(db_name)
        self.Prefix = get_db_prefix(db_name)

        release, build = get_version_from_name(db_name)
        self.Release = release
        self.GeneralRelease = self.Release

        if len(build) == 1:
            if self.Type != 'compara':
                self.Build = build[0]
            else:
                self.Build = None
                self.GeneralRelease = build[0]
        elif build:
            self.Build = build[1]
            self.GeneralRelease = build[0]
        else:
            self.Build = None

        self.Species = None
        self.Species = Species.getSpeciesName(self.Prefix)
示例#26
0
 def getSpecies(self):
     self.category = 'species'
     self.callServiceThread()
     self.species = Species(self.result_d['name'],
                            self.result_d['classification'])
     print("Name: {} Classification: {}".format(
         self.species.name, self.species.classification))
示例#27
0
    def reproduction(self, fitness_array):
        def check_species(g):
            for s in self.species:
                if s.check_if_member(g):
                    return True
            return False

        for i, g in enumerate(self.genoms):
            g.fitness = fitness_array[i]
            if not check_species(g):
                self.species.append(Species(g))

        n_extint = 0
        new_species = []
        for s in self.species:
            s.sort()
            extinct = s.kill()
            if extinct:
                n_extint += 1
            else:
                new_species.append(s.reproduce())

        self.species = new_species

        n_extra = self.clients - len(self.genoms)
        for i in range(n_extra):
            random.choice(self.genoms).reproduce_extra()
示例#28
0
 def feed_herbivores(cls, hungry_herbivores):
     """
     Feeds a herbivore species
     :param hungry_herbivores: list of hungry herbivores
     :return: the Species to feed
     """
     return Species.sort_lex(hungry_herbivores)[0]
示例#29
0
 def feed_herbivores(cls, hungry_herbivores):
     """
     Feeds a herbivore species
     :param hungry_herbivores: list of hungry herbivores
     :return: the Species to feed
     """
     return Species.sort_lex(hungry_herbivores)[0]
示例#30
0
文件: name.py 项目: a1ultima/pycogent
 def __init__(self, db_name):
     """db_name: and Emsembl database name"""
     if isinstance(db_name, EnsemblDbName):
         db_name = db_name.Name
     self.Name = db_name
     self.Type = get_dbtype_from_name(db_name)
     self.Prefix = get_db_prefix(db_name)
     
     release, build = get_version_from_name(db_name)
     self.Release = release
     self.GeneralRelease = self.Release
     
     if len(build) == 1:
         if self.Type != 'compara':
             self.Build = build[0]
         else:
             self.Build = None
             self.GeneralRelease = build[0]
     elif build:
         self.Build = build[1]
         self.GeneralRelease = build[0]
     else:
         self.Build  = None
     
     self.Species = None
     self.Species = Species.getSpeciesName(self.Prefix)
示例#31
0
    def __init__(self):
        self.species_list = [Species("Blob")]
        self.biome_list = []  #todo: make a graph
        self.id_to_player = {}

        #placeholder, set up empty player
        self.add_player(Player("placeholder"))
示例#32
0
 def getSpecies(self):
     self.category = 'species'
     result_d = json.loads(
         SwapiService.getSwapi(self.category, self.getId()))
     self.species = Species(result_d['name'], result_d['classification'])
     print("Name: {} Classification: {}".format(
         self.species.name, self.species.classification))
示例#33
0
	def speciesFromJson(jsonSpecies):    
		# If the if statement errors out, the input is ill shaped
		try:
			if jsonSpecies is False:
				return False

			if jsonSpecies[0][0] == "food" and jsonSpecies[1][0] == "body" and jsonSpecies[2][0] == "population" and jsonSpecies[3][0] == "traits":
				food = jsonSpecies[0][1]
				body = jsonSpecies[1][1]
				population = jsonSpecies[2][1]
				traits = []
				hasFatTissue = False

				for trait in jsonSpecies[3][1] :
					if JsonParsing.checkTrait(trait):
						traits.append(trait)
					if trait == "fat-tissue":
						hasFatTissue = True

				if len(jsonSpecies) == 5 and hasFatTissue and jsonSpecies[4][0] == "fat-food":
					fatFood = jsonSpecies[4][1]
				else:
					fatFood = 0

				return Species(food, body, population, traits, fatFood)
			else:
				pass
				# TODO: what should actually happen when the labels for an array are wrong?

		except Exception as e:
			raise e
示例#34
0
	def setUp(self):
		self.player1 = Player(1, [], 0, info = "j")
		self.player2 = Player(2, [], 0, info = "j")
		self.player3 = Player(3, [], 0, info = "j")
		self.player4 = Player(4, [], 0, info = "j")
		self.player5 = Player(5, [], 0, info = "j")
		self.player6 = Player(6, [], 0, info = "j")
		self.player7 = Player(7, [], 0, info = "j")
		self.player8 = Player(8, [], 0, info = "j")

		self.players = [self.player1, self.player2, self.player3]
		self.players8 = [self.player1, self.player2, self.player3, self.player4, self.player5, self.player6, self.player7, self.player8]

		self.species1 = Species(0, 3, 3, [])
		self.species2 = Species(0, 2, 1, [])
		self.speciesscavenger = Species(0, 3, 3, [Trait.scavenger])
		self.speciesforaging = Species(0, 3, 3, [Trait.foraging])
		self.speciescoop = Species(0, 3, 3, [Trait.cooperation])
		self.speciesfull = Species(2, 2, 2, [])
		self.speciesfull1 = Species(3, 2, 3, [])
		self.speciesfull2 = Species(4, 2, 4, [])
		self.speciesfat= Species(0, 3, 3, [Trait.fat_tissue])
		self.speciesfat.setFatFood(1)
		self.specieshorns = Species(0, 3, 3, [Trait.horns])
		self.speciescarni = Species(0, 3, 3, [Trait.carnivore])
		self.specieshorns1 = Species(0, 3, 1, [Trait.horns])
		self.speciescarni1 = Species(0, 3, 1, [Trait.carnivore])
		self.speciesLongFertile = Species(0, 3, 1, [Trait.long_neck, Trait.fertile])
		self.speciesFertile = Species(0, 3, 1, [Trait.fertile])
		self.speciesLongNeck = Species(0, 3, 1, [Trait.long_neck])

		self.watering_hole = WateringHole(0)

		self.dealer = Dealer(self.watering_hole, self.players)

		self.warning_call_card = TraitCard(Trait.warning_call, 0)
		self.warning_call_card2 = TraitCard(Trait.warning_call, 1)
		self.climbing_card = TraitCard(Trait.climbing, 3)
		self.carnivore_card = TraitCard(Trait.carnivore, -8)

		self.fertileCard = TraitCard(Trait.fertile, 2)
		self.climbingCard = TraitCard(Trait.climbing, 0)
		self.cooperationCard = TraitCard(Trait.cooperation, 0)
		self.carnivoreCard = TraitCard(Trait.carnivore, 0)
		self.longNeckCard = TraitCard(Trait.long_neck, 0)
		self.fertileCard1 = TraitCard(Trait.fertile, 2)
		self.climbingCard1 = TraitCard(Trait.climbing, 1)
		self.cooperationCard1 = TraitCard(Trait.cooperation, 1)
		self.carnivoreCard1 = TraitCard(Trait.carnivore, 1)
		self.longNeckCard1 = TraitCard(Trait.long_neck, 1)
		self.ambushCard = TraitCard(Trait.ambush, 1)


		self.deck = [self.warning_call_card, self.climbing_card, self.carnivore_card]

		self.deck2 = deck.generateDeck()[:12]

		self.dealer.setDeck(self.deck)
		self.dealer.setWateringHole(20)
示例#35
0
 def add_species(self, add_card_list):
     """
     :effect Adds a new species to the right of this Player State's current species
     :param add_card_list: List of Nat representing indicies of Trait Cards in this Player State's hand to add to the
                           new species.
     """
     trait_list = [self.hand[i] for i in add_card_list]
     self.species.append(Species(traits=trait_list))
示例#36
0
    def species(self):
        map = self._readmap('classes')
        results = []

        for id in map:
            results.append(Species(id=int(id), name=map[id]))

        return sorted(results, key=lambda x: x.id)
示例#37
0
 def add_to_species(self, genome: Genome):
     for species in self.species:
         if Genome.is_same_species(species.genomes[0], genome):
             species.genomes.append(genome)
             species.previous_top_fitness = max(
                 species.previous_top_fitness, genome.fitness)
             return
     self.species.append(Species(genome))
示例#38
0
 def setUp(self):
     self.carnivore = TraitCard(CARNIVORE, 3)
     self.burrowing = TraitCard(BURROWING, 2)
     self.fattissue = TraitCard(FATTISSUE, 4)
     self.foraging = TraitCard(FORAGING, 2)
     self.horns = TraitCard(HORNS, 6)
     self.cooperation = TraitCard(COOPERATION, 1)
     self.scavenger = TraitCard(SCAVENGER, 2)
     self.species_1 = Species(4, 4, 4, [])
     self.species_2 = Species(4, 4, 4)
     self.species_3 = Species(4, 4, 3)
     self.species_4 = Species(4, 3, 3)
     self.species_5 = Species(3, 1, 3)
     self.species_6 = Species(4, 3, 3)
     self.species_7 = Species(4, 4, 4)
     self.species_list = [
         self.species_2, self.species_4, self.species_3, self.species_5,
         self.species_1
     ]
     self.player_1 = PlayerState(
         species=[self.species_4, self.species_5, self.species_6],
         hand=[self.carnivore])
     self.player_2 = PlayerState(species=[self.species_1],
                                 hand=[self.carnivore, self.fattissue])
     self.player_3 = PlayerState(
         species=[self.species_2, self.species_3, self.species_7],
         hand=[self.foraging])
示例#39
0
    def feed_carnivore(cls, hungry_carnivores, player, opponents):
        """
        Feeds the largest hungry carnivore
        :param hungry_carnivores: list of hungry carnivores
        :param player: the current player's state
        :param opponents: list of all other player's states
        :return:
        """
        sorted_carnivores = Species.sort_lex(hungry_carnivores)
        for carnivore in sorted_carnivores:
            targets = Dealer.carnivore_targets(carnivore, opponents)
            if targets:
                sorted_targets = Species.sort_lex(targets)
                target = sorted_targets[0]
                target_player = next(player for player in opponents if target in player.species)
                return [carnivore, target_player, target]

        return False
示例#40
0
 def mutation_step(self):
     """Mutates a random node."""
     # pick a random node in the graph, i.e. an integer
     node = random.randint(0, self.N - 1)
     # get the species currently living on that node
     species = self.State[node]
     # mutate the species and add it to the node in question.
     new_genome = species.mutated_genome()
     self.State[node] = Species(new_genome, self.fitness(new_genome))
示例#41
0
 def start(self, player):
     """
     Handles the start of a turn by dealing cards and a new Species (if necessary) to the given PlayerState
     :param player: the PlayerState being dealt to
     :effect: Updates given PlayerState with additional TraitCards and possible Species
     """
     new_cards = self.cards_to_deal(player)
     opt_species = (False if player.species else Species())
     player.start(opt_species, new_cards)
示例#42
0
    def setUp(self):
        # Traits (Trait, Food-value)
        self.carnivore = TraitCard(CARNIVORE, 3)
        self.burrowing = TraitCard(BURROWING, 2)
        self.fattissue = TraitCard(FATTISSUE, 4)
        self.foraging = TraitCard(FORAGING, 2)
        self.horns = TraitCard(HORNS, 6)
        self.cooperation = TraitCard(COOPERATION, 1)
        self.scavenger = TraitCard(SCAVENGER, 2)

        # Species (Population, Food, Body, Traits, Fat-Storage)
        self.species1 = Species(1, 0, 2, [self.cooperation])
        self.species2 = Species(6, 2, 1, [self.carnivore])
        self.species3 = Species(3, 3, 3, [self.fattissue], 0)
        self.species4 = Species(5, 5, 5, [self.burrowing])
        self.species5 = Species(5, 3, 4, [self.foraging])
        self.species6 = Species(
            2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
        self.species7 = Species(7, 1, 6, [self.horns])

        self.player1_species = [self.species1, self.species2]
        self.player2_species = [self.species3, self.species4, self.species5]
        self.player3_species = [self.species6, self.species7]

        # Players (Name, Bag, Hand, Species)
        self.player1 = PlayerState(1, 0, [self.fattissue],
                                   self.player1_species)
        self.player2 = PlayerState(2, 3, [self.fattissue, self.carnivore],
                                   self.player2_species)
        self.player3 = PlayerState(3, 6, [self.burrowing],
                                   self.player3_species)

        self.public_player1 = PlayerState(1, False, False,
                                          self.player1_species)
        self.public_player2 = PlayerState(2, False, False,
                                          self.player2_species)
        self.public_player3 = PlayerState(3, False, False,
                                          self.player3_species)

        self.list_of_players = [self.player1, self.player2, self.player3]

        # Dealer (List of Players, Watering Hole, Deck)
        self.dealer1 = Dealer(self.list_of_players, 10, [])

        # Actions
        self.food_card_action1 = FoodCardAction(0)
        self.food_card_action2 = FoodCardAction(1)
        self.grow_action_pop = GrowAction(POPULATION, 0, 0)
        self.grow_action_body = GrowAction(BODY, 1, 1)
        self.add_species_action1 = AddSpeciesAction(0, [1])
        self.add_species_action2 = AddSpeciesAction(0, [])
        self.replace_trait_action1 = ReplaceTraitAction(0, 0, 0)
        self.replace_trait_action2 = ReplaceTraitAction(2, 0, 1)
        self.replace_trait_action3 = ReplaceTraitAction(0, 2, 0)

        # Action4
        self.action4_1 = Action4(self.player1, [self.food_card_action1])
        self.action4_2 = Action4(
            self.player2, [self.food_card_action2, self.grow_action_pop])
示例#43
0
 def from_json_state(json_state):
     """
     Takes in a json 'state' of a Player, converting it into a new PlayerState object
     :param json_state: JSON List -  [Natural, [Species+, ..., Species+], Cards]
     :return: PlayerState - the new PlayerState object created from the json representation
     """
     food_bag = json_state[0]
     species_list = [Species.convertSpecies(species) for species in json_state[1]]
     trait_cards = [TraitCard.from_json(trait) for trait in json_state[2]]
     return PlayerState(bag=food_bag, speciesList=species_list, trait_cards=trait_cards)
示例#44
0
 def feed_fatty(cls, fat_tissue_species, food_available):
     """
     Feeds a species with the fat-tissue trait
     :param fat_tissue_species: species with a fat-tissue trait
     :param food_available: food on the watering_hole_board
     :return: list of [Species, int] where Species is the fat_tissue_species and int is the requested food
     """
     fatty = Species.largest_fatty_need(fat_tissue_species)
     food_requested = (fatty.body if fatty.body < food_available else food_available)
     return [fatty, food_requested]
    def setUp(self):
        # Traits (Trait, Food-value)
        self.carnivore = TraitCard(CARNIVORE, 3)
        self.burrowing = TraitCard(BURROWING, 2)
        self.fattissue = TraitCard(FATTISSUE, 2)
        self.foraging = TraitCard(FORAGING, 2)
        self.horns = TraitCard(HORNS, 0)
        self.cooperation = TraitCard(COOPERATION, 1)
        self.scavenger = TraitCard(SCAVENGER, 2)

        # Species (Population, Food, Body, Traits, Fat-Storage)
        self.species1 = Species(1, 0, 2, [self.cooperation])
        self.species2 = Species(6, 2, 1, [self.carnivore])
        self.species3 = Species(3, 3, 3, [self.fattissue], 0)
        self.species4 = Species(5, 5, 5, [self.burrowing])
        self.species5 = Species(5, 3, 4, [self.foraging])
        self.species6 = Species(
            2, 1, 7, [self.carnivore, self.fattissue, self.scavenger], 0)
        self.species7 = Species(7, 1, 6, [self.horns])

        self.player1_species = [self.species1, self.species2]
        self.player2_species = [self.species3, self.species4, self.species5]
        self.player3_species = [self.species6, self.species7]

        # Players (Name, Bag, Hand, Species)
        self.player1 = PlayerState(1,
                                   0, [self.horns, self.foraging],
                                   self.player1_species,
                                   ext_player=Player())
        self.player2 = PlayerState(2,
                                   3, [self.carnivore, self.fattissue],
                                   self.player2_species,
                                   ext_player=Player())
        self.player3 = PlayerState(3,
                                   6, [self.burrowing],
                                   self.player3_species,
                                   ext_player=Player())

        self.public_player1 = PlayerState(1, False, False,
                                          self.player1_species)
        self.public_player2 = PlayerState(2, False, False,
                                          self.player2_species)
        self.public_player3 = PlayerState(3, False, False,
                                          self.player3_species)

        self.list_of_players = [self.player1, self.player2, self.player3]

        # Dealer (List of Players, Watering Hole, Deck)
        self.dealer1 = Dealer(self.list_of_players, 10, [])

        # Action
        self.action4_1 = Action4(FoodCardAction(1),
                                 [GrowAction(POPULATION, 0, 0)], [], [], [])
        self.action4_2 = Action4(FoodCardAction(0), [], [], [],
                                 [ReplaceTraitAction(1, 0, 1)])
        self.action4_3 = Action4(FoodCardAction(0), [], [], [], [])
        self.action4_list = [self.action4_1, self.action4_2, self.action4_3]
示例#46
0
 def __init__(self, Graph: nx.Graph, mutation_ratio: int,
              uncertainty: float, surrender_option_on: bool):
     self.Graph = Graph
     self.N = Graph.number_of_nodes()
     self.State = [
         Species([])
     ] * self.N  # The state will contain a mapping of nodes to the species that currently lives on it.
     self.mutation_ratio = mutation_ratio
     self.uncertainty = uncertainty
     self.surrender_option_on = surrender_option_on
     self.surrender_fight_ratio = None
示例#47
0
def parse_species(species_json):
	"""
	converts from a json representation of species to a species representation
	:param species_json: Species+
	:return: Species
	"""
	try:
		if (len(species_json) == 5):
			[[f, food], [b, body], [p, population], [t, lot], [fb, fat_food]] = species_json
			if (f == "food" and b == "body" and p == "population" and t == "traits" and fb == "fat-food"):
				species = Species(food, body, population, parse_lot(lot))
				if fat_food == 0:
					return species
				species.setFatFood(fat_food)
				return species
		else:
			[[f, food], [b, body], [p, population], [t, lot]] = species_json
			if (f == "food" and b == "body" and p == "population" and t == "traits"):
				return Species(food, body, population, parse_lot(lot))
	except ValueError:
		raise ValueError("invalid species")
示例#48
0
 def from_json_gamestate(json_state):
     """
     Takes in a json game state, converting it into a list that contains the PlayerState, WateringHole, and other species
     :param json_state: JSON List - [Natural, [Species+, ..., Species+], Cards, Natural+, LOB]
     :return: [PlayerState, Nat, List of Species]
     """
     ps = PlayerState.from_json_state(json_state[:3])
     watering_hole = json_state[3]
     all_species = []
     for species_list in json_state[4]:
         all_species.append([Species.convertSpecies(species) for species in species_list])
     return [ps, watering_hole, all_species]
示例#49
0
    def speciate(self):
        comporg = None
        counter = 0

        #//Step through all existing organisms
        for curorg in self.organisms:
            
            #//For each organism, search for a species it is compatible to
            cur_species_i = 0
            found = False
            while (cur_species_i < len(self.species)) and (not found):
                comporg = self.species[cur_species_i].first()
                if comporg is None:
                    #//Keep searching for a matching species
                    cur_species_i += 1
                elif curorg.gnome.compatibility(comporg.gnome) < neat.compat_threshold:
                    #//Found compatible species, so add this organism to it
                    self.species[cur_species_i].add_Organism(curorg)
                    curorg.species = self.species[cur_species_i]
                    found = True
                else:
                    #//Keep searching for a matching species
                    cur_species_i += 1

            #//If we didn't find a match, create a new species
            if not found:
                newspecies = Species()
                counter += 1
                newspecies.SetFromId(counter)
                self.species.append(newspecies)
                newspecies.add_Organism(curorg)
                curorg.species = newspecies
            # end species search conditions

        # end organism loop
        self.last_species = counter
        return True
示例#50
0
    def is_larger_attack_option(self, defend_player, def_spec_index, attacker, largest_def_species):
        """
        Checks if the attacker -> def_species_index is a larger attack option than attacker -> largest_def_species
        :param defend_player: PlayerState - the defending playerState containing the defending species to compare
        :param def_spec_index: Nat - the index of the species to compare against largest_def_species
        :param attacker: Species - the attacking species
        :param largest_def_species: Species - the current largest defending species to compare against
        :return: One of: - Tuple(Nat, Species) - the new larger option found
                         - False (if not a larger option)
        """
        lNeighbor, rNeighbor = defend_player.get_neighbors(def_spec_index)

        def_species = defend_player.species[def_spec_index]

        if Species.isAttackable(def_species, attacker, lNeighbor, rNeighbor) and def_species.isLarger(largest_def_species):
            return def_spec_index, defend_player.species[def_spec_index]
        return False
示例#51
0
    def convertPlayerState(state):
        """
        Creates a PlayerState from from the given JSON representation
        :param state: JSON list - represents the playerState
        :return: PlayerState - with attributes contained in 'state'
        """
        playerTraitCards = []

        if state[0][0] == ID_LABEL and state[1][0] == SPECIES_LABEL and state[2][0] == BAG_LABEL:
            id = state[0][1]
            speciesList = [Species.convertSpecies(species) for species in state[1][1]]
            bag = state[2][1]
            if len(state) == 4 and state[3][0] == CARDS_LABEL:
                playerTraitCards = [TraitCard.from_json(card) for card in state[3][1]]
            if id < 1 or bag < 0:
                raise Exception("Bad JSON PlayerState Data")

            return PlayerState(id, bag, speciesList, playerTraitCards)

        else:
            raise Exception("Bad JSON PlayerState input")
 def test_is_larger(self):
     # Population different
     self.defender.population = 2
     self.attacker.population = 1
     self.assertEqual(Species.is_larger(self.defender, self.attacker), 1)
     self.assertEqual(Species.is_larger(self.attacker, self.defender), -1)
     # Same population different food
     self.attacker.population = 2
     self.defender.food = 2
     self.attacker.food = 1
     self.assertEqual(Species.is_larger(self.defender, self.attacker), 1)
     self.assertEqual(Species.is_larger(self.attacker, self.defender), -1)
     # Same population and food different body
     self.attacker.food = 2
     self.defender.body = 4
     self.attacker.body = 3
     self.assertEqual(Species.is_larger(self.defender, self.attacker), 1)
     self.assertEqual(Species.is_larger(self.attacker, self.defender), -1)
     # Equal population, food, and body
     self.attacker.body = 4
     self.assertEqual(Species.is_larger(self.defender, self.attacker), 0)
示例#53
0
  def setUp(self):
    self.pDealer = ProxyDealer()

    self.card1 = TraitCard(Trait.ambush, -2)
    self.card2 = TraitCard(Trait.carnivore, -8)
    self.card3 = TraitCard(Trait.ambush, 0)

    self.species1 = Species(0, 3, 3, [])
    self.species2 = Species(0, 2, 1, [])
    self.speciesscavenger = Species(0, 3, 3, [Trait.scavenger])
    self.speciesforaging = Species(0, 3, 3, [Trait.foraging])
    self.speciescoop = Species(0, 3, 3, [Trait.cooperation])
    self.speciesfull = Species(2, 2, 2, [])
    self.speciesfull1 = Species(3, 2, 3, [])
    self.speciesfull2 = Species(4, 2, 4, [])
    self.speciesfat= Species(0, 3, 3, [Trait.fat_tissue])
    self.speciesfat.setFatFood(1)
    self.specieshorns = Species(0, 3, 3, [Trait.horns])
    self.speciescarni = Species(0, 3, 3, [Trait.carnivore])
    self.specieshorns1 = Species(0, 3, 1, [Trait.horns])
    self.speciescarni1 = Species(0, 3, 1, [Trait.carnivore])
    self.speciesLongFertile = Species(0, 3, 1, [Trait.long_neck, Trait.fertile])
    self.speciesFertile = Species(0, 3, 1, [Trait.fertile])
    self.speciesLongNeck = Species(0, 3, 1, [Trait.long_neck])
示例#54
0
    def setUp(self):
        self.dealer = Dealer([Player(), Player(), Player(), Player()])
        self.dealer.watering_hole = 10
        self.dealer.player_sets[0]['state'].name = 0;
        self.dealer.player_sets[1]['state'].name = 1;
        self.dealer.player_sets[2]['state'].name = 2;
        self.dealer.player_sets[3]['state'].name = 3;
        self.dealer.current_player_index = 2

        self.species_1 = Species(4, 4, 4)
        self.species_2 = Species(4, 4, 4)
        self.species_3 = Species(4, 3, 3)
        self.species_4 = Species(4, 3, 3)
        self.species_5 = Species(3, 3, 3)
        self.species_list = [self.species_1,
                             self.species_2,
                             self.species_3,
                             self.species_4,
                             self.species_5]

        self.dealer.player_sets[0]['state'].species = [self.species_1]
        self.dealer.player_sets[1]['state'].species = [self.species_2]
        self.dealer.player_sets[2]['state'].species = [self.species_3]
        self.dealer.player_sets[3]['state'].species = [self.species_4, self.species_5]
示例#55
0
    def feed_result_carnivore(self, attSpecIndex, defPlayerIndex, defSpecIndex):
        """
        Effect: Attacking species will get food, decrease population if attacking horns.
                Defending species of defPlayerIndex will reduce in population if attack succeeds
                Food is taken from the wateringHole for successful attacks
                Extinction will cause extinct species owners to get cards, which are removed from this dealers hand
        :param attSpecIndex: Nat - the index of the carnivore species in the player that is attacking
        :param defPlayerIndex: Nat - the index of the player to attack
        :param defSpecIndex: Nat - the index of the species in the defending player to attack
        :return: Void
        """
        attPlayerState = self.playerStates[0]
        attSpecies = attPlayerState.get_species_at(attSpecIndex)

        defPlayerState = self.playerStates[defPlayerIndex]
        defSpecies = defPlayerState.get_species_at(defSpecIndex)

        leftSpecies = defPlayerState.getLeftNeighbor(defSpecIndex)
        rightSpecies = defPlayerState.getRightNeighbor(defSpecIndex)

        if Species.isAttackable(defSpecies, attSpecies, leftSpecies, rightSpecies):
            self.execute_attack(attSpecies, defSpecies, attPlayerState, defPlayerState, attSpecIndex, defSpecIndex)
        else:
            raise Exception("Bad Attack")
示例#56
0
 def setUp(self):
     self._limiting = Species("Limiting", 100)
     self._limiting.set_n(0.001)
     self._reactant2 = Species("Reactant #1", 200)
     self._reactant3 = Species("Reactant #2", 300)
     self._product = Species("Product", 400)
class TestSpecies(unittest.TestCase):

    def setUp(self):
        self.attacker = Species()
        self.attacker.traits = [TraitCard("carnivore")]
        self.defender = Species()
        self.left_neighbor = Species()
        self.right_neighbor = Species()

        self.species_1 = Species(4, 4, 4)
        self.species_2 = Species(4, 4, 4)
        self.species_3 = Species(4, 4, 3)
        self.species_4 = Species(4, 3, 3)
        self.species_5 = Species(3, 3, 3)
        self.species_list = [self.species_2, self.species_4, self.species_3, self.species_5, self.species_1]


    def test_can_eat(self):
        self.assertFalse(self.species_1.can_eat())
        self.assertTrue(self.species_4.can_eat())
        fat_tissue = Species(4, 3, 4, [TraitCard("fat-tissue")], 3)
        self.assertTrue(fat_tissue.can_eat())
        fat_tissue.fat_storage = 4
        self.assertFalse(fat_tissue.can_eat())

    def test_trait_names(self):
        self.assertEqual(self.defender.trait_names(), [])
        self.assertEqual(self.attacker.trait_names(), ["carnivore"])

    def test_attackable(self):
        self.assertTrue(self.defender.is_attackable(self.attacker))

    def test_no_carnivore(self):
        self.attacker.traits = []
        self.assertFalse(self.defender.is_attackable(self.attacker))

    def test_burrowing(self):
        self.defender.traits = [TraitCard("burrowing")]
        self.defender.population, self.defender.food = (4, 4)
        self.assertFalse(self.defender.is_attackable(self.attacker))
        self.defender.food = 3
        self.assertTrue(self.defender.is_attackable(self.attacker))

    def test_climbing(self):
        self.defender.traits = [TraitCard("climbing")]
        self.assertFalse(self.defender.is_attackable(self.attacker))
        self.attacker.traits.append(TraitCard("climbing"))
        self.assertTrue(self.defender.is_attackable(self.attacker))

    def test_hard_shell(self):
        self.defender.traits = [TraitCard("hard-shell")]
        self.defender.body = 3
        self.attacker.body = 6
        self.assertFalse(self.defender.is_attackable(self.attacker))
        self.attacker.body = 7
        self.assertTrue(self.defender.is_attackable(self.attacker))

    def test_herding(self):
        self.defender.traits = [TraitCard("herding")]
        self.defender.population = 4
        self.attacker.population = 3
        self.assertFalse(self.defender.is_attackable(self.attacker))
        self.attacker.population = 5
        self.assertTrue(self.defender.is_attackable(self.attacker))

    def test_symbiosis(self):
        self.defender.traits = [TraitCard("symbiosis")]
        self.defender.body = 3
        self.right_neighbor.body = 5
        self.assertFalse(self.defender.is_attackable(self.attacker, right_neighbor=self.right_neighbor))
        self.right_neighbor.body = 2
        self.assertTrue(self.defender.is_attackable(self.attacker, right_neighbor=self.right_neighbor))

    def test_warning_call(self):
        self.left_neighbor.traits = [TraitCard("warning-call")]
        self.right_neighbor.traits = [TraitCard("warning-call")]
        self.assertFalse(self.defender.is_attackable(self.attacker, left_neighbor=self.left_neighbor))
        self.assertFalse(self.defender.is_attackable(self.attacker, right_neighbor=self.right_neighbor))
        self.attacker.traits.append(TraitCard("ambush"))
        self.assertTrue(self.defender.is_attackable(self.attacker, left_neighbor=self.left_neighbor))

    def test_is_larger(self):
        # Population different
        self.defender.population = 2
        self.attacker.population = 1
        self.assertEqual(Species.is_larger(self.defender, self.attacker), 1)
        self.assertEqual(Species.is_larger(self.attacker, self.defender), -1)
        # Same population different food
        self.attacker.population = 2
        self.defender.food = 2
        self.attacker.food = 1
        self.assertEqual(Species.is_larger(self.defender, self.attacker), 1)
        self.assertEqual(Species.is_larger(self.attacker, self.defender), -1)
        # Same population and food different body
        self.attacker.food = 2
        self.defender.body = 4
        self.attacker.body = 3
        self.assertEqual(Species.is_larger(self.defender, self.attacker), 1)
        self.assertEqual(Species.is_larger(self.attacker, self.defender), -1)
        # Equal population, food, and body
        self.attacker.body = 4
        self.assertEqual(Species.is_larger(self.defender, self.attacker), 0)

    def test_sort_lex(self):
        sorted_list = [self.species_2, self.species_1, self.species_3, self.species_4, self.species_5]
        self.assertEqual(Species.sort_lex(self.species_list), sorted_list)
        self.assertNotEqual(Species.sort_lex(self.species_list), self.species_list)

    def test_largest_tied_species(self):
        tied_species = [self.species_2, self.species_1]
        self.assertEqual(Species.largest_tied_species(self.species_list), tied_species)

    def test_largest_fatty_need(self):
        self.species_1.traits = [TraitCard("fat-tissue")]
        self.species_2.traits = [TraitCard("fat-tissue")]
        self.species_4.traits = [TraitCard("fat-tissue")]
        self.assertEqual(Species.largest_fatty_need([self.species_1, self.species_4]), self.species_4)
        self.assertEqual(Species.largest_fatty_need([self.species_1, self.species_2]), self.species_1)
 def test_largest_fatty_need(self):
     self.species_1.traits = [TraitCard("fat-tissue")]
     self.species_2.traits = [TraitCard("fat-tissue")]
     self.species_4.traits = [TraitCard("fat-tissue")]
     self.assertEqual(Species.largest_fatty_need([self.species_1, self.species_4]), self.species_4)
     self.assertEqual(Species.largest_fatty_need([self.species_1, self.species_2]), self.species_1)
 def test_largest_tied_species(self):
     tied_species = [self.species_2, self.species_1]
     self.assertEqual(Species.largest_tied_species(self.species_list), tied_species)
 def test_sort_lex(self):
     sorted_list = [self.species_2, self.species_1, self.species_3, self.species_4, self.species_5]
     self.assertEqual(Species.sort_lex(self.species_list), sorted_list)
     self.assertNotEqual(Species.sort_lex(self.species_list), self.species_list)