from my_file import ENUM_1

NtotheTC fucked around with this message at 22:15 on Jul 19, 2018

• you are misusing the verb "call": a function is called with some arguments. A function may access some variable or attribute. You appear to be referring to both of these scenarios as the function "calling" something else, and it's not.
  
• (minor) Python doesn't have arrays, you are probably referring to lists
  
• (major) you are using raw values (apparently characters in strings) to represent different kinds of objects (factions, units, equipment). As we are finding out, this makes it hard to reason about your program and maintain/expand it, because you have to constantly translate in your head what each array of strings means
  

import random


class Equipment(object):
    def __init__(self, name, value):
	""" (this method creates an Equipment object every time you call Equipment()"""
        self.name = name
        self.value = value

    def __repr__(self):
	""" (Python calls this method to get strings representing your object) """
        return f'<{self.name}>'


sword = Equipment('sword', 3)
shield = Equipment('shield', 1)
bow = Equipment('bow', 3)

class Unit(object):
    def __init__(self, name, max_number_items, allowed_items, base_value):
        self.name = name
        self.max_number_items = max_number_items
        self.allowed_items = allowed_items
        self.items = []
        self.base_value = base_value

        self.select_random_equipment()
        self.total_value = self.base_value + self.calculate_items_value()

    def select_random_equipment(self):
        """ gives the unit up to max_number_items of random items """
        number_items = random.randint(0, self.max_number_items)
        for _ in range(number_items):
            self.items.append(random.choice(self.allowed_items))

    def calculate_items_value(self):
        result = 0
        for item in self.items:
            result += item.value
        return result

    def __repr__(self):
        return f'<{self.name}, value: {self.total_value}, items: {self.items}>'


class Swordsman(Unit):
    def __init__(self):
        super().__init__('swordsman', 2, [sword, shield], 10)


class Archer(Unit):
    def __init__(self):
        super().__init__('archer', 1, [bow], 6)

my_army = [Swordsman(), Swordsman(), Archer()]
print(my_army)

Daviclond fucked around with this message at 22:27 on Jul 23, 2018

• You have a bunch of units, each with a different number of slots
  
• You have a bunch of factions, each allowing a different set of units
  
• You have a bunch of equipment, each taking up a certain number of slots, and having a cost
  

units = {
    "Car": 1,
    "Boat": 2,
    "Big Boat": 3
}

factions = {
    "Good guys": ("Car", "Boat"),
    "Baddies": ("Car", "Boat"), 
    "Pirates": ("Boat", "Big Boat")
}

equipment_by_size = {
    1: ("Pew pew gun", "Bucket seat", "Parrot"),
    2: ("Water cannon", "Large parrot")
    3: ("Parrot King")
}

from collections import namedtuple
Item = namedtuple('Item', ['name', 'cost', 'size'])

equipment = {
    "PEW PEW" = Item("Pew Pew Gun", 100, size=1), # you can use named arguments if it's clearer, like this
    "BUCKET SEAT" = Item("Bucket seat", 50, 1),
    "PARROT" = Item("Parrot", 1000000, 1),
    "PARROT KING" = Item("Parrot King", 666, 3)
    ...
}

Unit = namedtuple('Unit', ['name', 'cost', 'slots'])
units = {
    "CAR": Unit("Car", 100, 1),
    "BOAT": Unit("Boat", 200, 2)
}

Faction = namedtuple('Faction', ['name', 'allowed_units'])
factions = {
    "GOOD GUYS": Faction("Good guys", set("CAR", "BOAT")),
    "PIRATES": Faction("Pirates", set("BOAT", "BIG BOAT"))
}

• I'm using sets for each faction's unit types, since you don't want repeats like you could have with lists. Using the right data structure for the job basically
  
• In those sets, it's just storing the lookup keys for different unit types - you'd need to look up the actual unit object each time. It would be more efficient to have a set like set(units["CAR"], units["BOAT"]) where it's looking them up at definition time, and adding the actual unit object to the set. Then you can just work with them instead of doing lookups every time. This is a design decision though
  
• Unit defines the number of slots on each unit, since that's info you'd like to access when you have the unit object itself. But if you want to e.g. find all the 2-slot units, you'd need to iterate over the whole units dictionary, filtering on the ones with slots=2. To make this faster, you might want to build a lookup dictionary when your program starts - just using the info you've defined here, building a dictionary of num_slots -> list_of_units, iterating over all the units and popping each one in the appropriate list. Since this runs automatically, if you ever make changes you just work on the definitions, and they'll end up in the right place in the lookup. Don't define things in multiple places if you can help it
  
• You'd probably want to do the same for your equipment too, lookup by number of slots
  

standard_equipment = { gun, bigger_gun, funny_hat }
good_guys_equipment = standard_equipment | { power_halo }
bad_guys_equipment = standard_equipment | { evil_hat, normal_hat }
# the | is the union operator - basically it combines two sets and gives you a -new- one containing everything 

baka kaba fucked around with this message at 01:42 on Jul 24, 2018

mr_package fucked around with this message at 18:36 on Jul 27, 2018