def before_try_to_get(entity, target, location, behavioured): if (random.randint(0, 1) == 0): entity.act("Infili una $hand tra i fili ma qualcosa ti punge e la ritiri subito di scatto.", TO.ENTITY, target) entity.act("Non appena $n infila una $hand tra i fili la ritira di scatto.", TO.OTHERS, target) return True oggetto = Item(random.choice(PROTO_CIANFUSAGLIE_CODES)) oggetto.inject(location) entity.act("Infili la $hand tra $N per prendere qualcosa.", TO.ENTITY, target) entity.act("Ti senti un po' deprezzat$O ogni volta $n t'indaga!", TO.TARGET, target) entity.act("$n infila la $hand tra $N per prendere qualcosa.", TO.OTHERS, target) numbered_keyword = oggetto.get_numbered_keyword(looker=entity) execution_result = command_get(entity, numbered_keyword) # Il peso dei fili viene diminuito man mano che se ne preleva. # Prima di farlo verifica che sia uscita una keyword quando ne resta # troppo poco viene eliminato if execution_result: if target.weight < oggetto.weight: target.act("Ed ora non ne trovi neanche uno, o così sembra.", TO.OTHERS, target) target.act("Ed ora non ne è rimasto neanche uno, o così sembra.", TO.ENTITY, target) target.extract(1) else: target.weight = target.weight - oggetto.weight return execution_result
def after_touch(entity, target, descr, detail, behavioured): if not entity.IS_PLAYER: return False if target.weight < 200: entity.act("$n pigia al pompetta di $N ma a vuoto.", TO.OTHERS, target) entity.act("Pigi la pompetta di $N ma a vuoto.", TO.ENTITY, target) return False else: target.weight = target.weight - PROFUMO_PROTO.weight for mode in PROFUMO_PROTO.wear_type.modes: for part in mode: already_weared_part, already_weared_possession = check_if_part_is_already_weared(entity, part) if already_weared_part: entity.act("[plum]$N si dissolve immediatamente nell'aria.[close]", TO.ENTITY, PROFUMO_PROTO) entity.act("[plum]$N si dissolve immediatamente nell'aria.[close]", TO.OTHERS, PROFUMO_PROTO) return profumo = Item(PROTO_PROFUMO_CODE) profumo.inject(entity) profumo.wear_mode += part part_descriptions = get_part_descriptions(mode, "wear") send_wear_messages(entity, profumo, "Indossi", "indossa", part_descriptions) break defer(10, profumo_cleaning, profumo, entity)
def blooming(pianta, room, age, fortuna): if pianta.code not in database["items"]: return fiore = Item("karpuram_item_mirtillo-rosso-04-fiore") if not fiore: log.bug("impossibile creare fiore: %r" % fiore) return location=pianta.location pianta.act("Nelle scorse ore $N ha aperto i fiori", TO.OTHERS, pianta) pianta.act("Nelle scorse ore $N ha aperto i fiori", TO.ENTITY, pianta) pianta.extract(1) fiore.inject(location) fiore.act("$N rifulge di tutto il suo splendore.", TO.OTHERS, fiore) fiore.act("$N rifulge di tutto il suo splendore.", TO.ENTITY, fiore) fortuna = fortuna -1 if random.randint(1, fortuna) == 1: reactor.callLater(random.randint( FLOWER_WAIT_MIN , FLOWER_WAIT_MAX ), desiccation, fiore, room, age ) return reactor.callLater(random.randint( FLOWER_WAIT_MIN , FLOWER_WAIT_MAX ),fructification , fiore, room, age, fortuna)
def before_try_to_get(entity, target, location, behavioured): manciata_torba = Item("karpuram_item_torba-manciata") laminetta_oro = Item("karpuram_item_laminetta-oro") if random.randint(1, 10) == 1: laminetta_oro.inject(location) entity.act( "Metti la $hand in $N ed un luccicore ti distrae dal tuo proponimento!", TO.ENTITY, target) entity.act( "tu che sei $N ti senti un po' deprezzato ogni volta $n ti indaga!", TO.TARGET, target) entity.act("$n affonda una mano in $N e si ferma sorpres$o.", TO.OTHERS, target) execution_result = command_get( entity, laminetta_oro.get_numbered_keyword(looker=entity)) else: manciata_torba.inject(location) execution_result = command_get( entity, manciata_torba.get_numbered_keyword(looker=entity)) # Se execution_result a True significa che è stato raccolta con successo # una manciata di torba e quindi ferma l'esecuzione del resto del comando get; # altrimenti è False e tornando False viene continuato il get del mucchio # di torba, che in futuro fallirà per motivi di peso return execution_result
def __init__(self, amount): Item.__init__( self, str(amount) + " Gold", "imgs/dungeon_crawl/item/gold/gold_pile_10.png", "Gold could be used to buy some items or other services", 0) self.amount = amount
def marciume(seed, room): if seed.code not in database["items"]: return frutto_marcio = Item("karpuram_item_mirtillo-rosso-00-frutto-marcio") if not frutto_marcio: log.bug("impossibile creare frutto_marcio: %r" % frutto_marcio) return if room != seed.location: # log da rimuovere log.bug("room di drop diversa da room attuale") return location=seed.location seed.act("$N appare tutto molliccio...", TO.OTHERS, seed) seed.act("$N appare tutto molliccio...", TO.ENTITY, seed) seed.extract() frutto_marcio.inject(location) frutto_marcio.act("... è $N buono solo come concime.", TO.OTHERS, frutto_marcio) frutto_marcio.act("... è $N buono solo come concime.", TO.ENTITY, frutto_marcio)
def renew(fruttificato, room, age, fortuna): if fruttificato.code not in database["items"]: return pianta = Item("karpuram_item_mirtillo-rosso-03-pianta") if not pianta: log.bug("impossibile creare pianta: %r" % pianta) return age = age +1 location=fruttificato.location fruttificato.act("quel che un tempo doveva esser $N, ora ...", TO.OTHERS, fruttificato) fruttificato.act("quel che un tempo doveva esser $N, ora ...", TO.ENTITY, fruttificato) fruttificato.extract(1) pianta.inject(location) pianta.act("... è $N che fruttificherà più avanti", TO.OTHERS, pianta) pianta.act("... è $N che fruttificherà più avanti", TO.ENTITY, pianta) fortuna = fortuna -1 if random.randint(1, fortuna) == 1: reactor.callLater(random.randint(10,20), desiccation, pianta, room, age ) return reactor.callLater(random.randint(10,20), blooming, pianta, room, age, fortuna)
def carica_regalo(player, location, rompicapo): price = Item(random.choice(PRICE_PROTO_CODES)) price.inject(location) player.act("\n[yellow]Hai appena concluso il rompicapo che dal nulla compare un premio![close]\n", TO.ENTITY, rompicapo) player.act("\n[yellow]$n fa uno scatto sorpreso all'apparire del premio per $N.[close]\n", TO.OTHERS, rompicapo) player.act("Gothcha!.", TO.TARGET, rompicapo) print "novizi2_item_rompicapo-colorato - YOU WIN"
def before_try_to_get(entity, target, location, behavioured): # Crea e inserisce il pizzico di polverina nella locazione da cui prenderlo pizzico = Item("carrozzone-zingaro_item_polverina-pizzico") pizzico.inject(location) entity.act("Infili le dita dentro $N.", TO.ENTITY, target) entity.act("$n allunga due dita dentro $N.", TO.OTHERS, target) entity.act("Ti senti un po' deprezzata ogni volta che $n ti indaga!", TO.TARGET, target) # Bisogna utilizzare la get_numbered_keyword perché non si sa se entity in quel # momento stia guardando la short diurna, notturna o il nome first_keyword = pizzico.get_numbered_keyword(looker=entity) if location.IS_ROOM: argument = first_keyword else: argument = "%s %s " % (first_keyword, location.get_numbered_keyword(looker=entity)) execution_result = command_get(entity, argument) # Questo è meglio farlo solo se il get è andato a buon fine, cioè quando # execution_result ha valore di verità positiva if execution_result: if target.weight < pizzico.weight: target.act("Quello era l'ultimo, ora sei vuot$o.", TO.ENTITY) target.act("Una volta c'era $n, ma ora è vuot$o.", TO.OTHERS) target.extract(1) else: target.weight = target.weight - pizzico.weight return execution_result
def __init__(self, settings): self.boardWidth = getSetting(settings, "boardWidth", 10) self.boardHeight = getSetting(settings, "boardHeight", 10) self.cellSize = getSetting(settings, "cellSize", 10) self.snake = Snake(settings, self.boardWidth / 2, self.boardHeight / 2) self.isDead = False self.item = Item(settings) self.reinitItem()
def handle_new_player(self, ident): self.players[ident] = Player(ident) # self.players[ident].profession = 'survivor' self.players[ident].position = self.find_spawn_point_for_new_player() self.worldmap.put_object_at_position(self.players[ident], self.players[ident].position) self.localmaps[ident] = self.worldmap.get_chunks_near_position(self.players[ident].position) # give the player their starting items by referencing the ProfessionManager. # print('profession items ') ''' ident : survivor _comment : A basic as it comes. I'll use this for the default profession. name : Survivor description : Some would say that there's nothing particularly notable about you. But you survived. That's more than most can say right now. skills : ["{'survival': 1}"] points : 0 items : {'equipped': [{'TORSO': 'backpack'}], 'in_containers': [{'backpack': 'cell_phone'}]} flags : [] CBMs : [] ''' #print(self.players[ident].profession) for key, value in self.ProfessionManager.PROFESSIONS[str(self.players[ident].profession)].items(): print(key, ':', value) # print(value.items()) # TODO: load the items into the player equipment slots as well as future things like CBMs and flags if(key == 'equipped_items'): for equip_location, item_ident in value.items(): print(equip_location, item_ident) for bodypart in self.players[ident].body_parts: if(bodypart.ident.split('_')[0] == equip_location): if(bodypart.slot0 is None): if('container_type' in self.ItemManager.ITEM_TYPES[item_ident]): bodypart.slot0 = Container(item_ident, self.ItemManager.ITEM_TYPES[item_ident]) # need to pass the reference to load the item with data. else: bodypart.slot0 = Item(item_ident, self.ItemManager.ITEM_TYPES[item_ident]) # need to pass the reference to load the item with data. break elif(bodypart.slot1 is None): if('container_type' in self.ItemManager.ITEM_TYPES[item_ident]): bodypart.slot1 = Container(item_ident, self.ItemManager.ITEM_TYPES[item_ident]) # need to pass the reference to load the item with data. else: bodypart.slot1 = Item(item_ident, self.ItemManager.ITEM_TYPES[item_ident]) # need to pass the reference to load the item with data. break else: print('player needed an item but no free slots found') elif(key == 'items_in_containers'): # load the items_in_containers into their containers we just created. print('LOADING ITEMS INTO CONTAINERS') for location_ident, item_ident in value.items(): print(location_ident, item_ident) # first find the location_ident so we can load a new item into it. for bodypart in self.players[ident].body_parts: if(bodypart.slot0 is not None): if(isinstance(bodypart.slot0, Container) and bodypart.slot0.ident == location_ident): # uses the first one it finds, maybe check if it's full? bodypart.slot0.add_item(Item(item_ident, self.ItemManager.ITEM_TYPES[item_ident])) if(isinstance(bodypart.slot1, Container) and bodypart.slot1.ident == location_ident): # uses the first one it finds, maybe check if it's full? bodypart.slot1.add_item(Item(item_ident, self.ItemManager.ITEM_TYPES[item_ident])) print('New player joined.', self.players[ident].name)
def test_item_functions(): name = "A shiny bauble" desc = "A tiny golden bauble, not good for much but very shiny" value = 5 item = Item(name=name, desc=desc, value=value) assert item.identify() == name assert item.describe() == desc assert item.appraise() == value
def test_basket_assignment_example(): baked_beans = Item(name='Baked Beans', price=0.99, discount_bogof=2) biscuits = Item(name='Biscuits', price=1.20) basket = Basket(items=[baked_beans] * 4 + [biscuits]) assert basket.get_subtotal() == 5.16 assert basket.get_discount() == 0.99 assert basket.get_total() == 4.17
def before_try_to_get(entity, target, location, behavioured): frutta_semi_db = ["flora_item_mirtillo-rosso-01-frutto", "flora_item_leccio-01-ghianda-viva", "flora_item_leccio-02-ghianda-morta", "flora_item_mirtillo-nero-01-frutto", "flora_item_mirtillo-rosso-00-frutto-marcio", "flora_item_mirtillo-rosso-00-frutto-sterile", "flora_item_farnia-01-ghianda-viva", "flora_item_farnia-02-ghianda-morta"] num_rand = random.randint(1, 100) if num_rand < 8: frutto_seme_code = frutta_semi_db[0] elif num_rand < 18: frutto_seme_code = frutta_semi_db[1] elif num_rand < 22: frutto_seme_code = frutta_semi_db[2] elif num_rand < 32: frutto_seme_code = frutta_semi_db[3] elif num_rand < 35: frutto_seme_code = frutta_semi_db[4] elif num_rand < 40: frutto_seme_code = frutta_semi_db[5] elif num_rand < 76: frutto_seme_code = frutta_semi_db[6] else: frutto_seme_code = frutta_semi_db[7] # Crea e inserisce il seme scelto nella locazione da cui prenderlo poi seed_founded = Item(frutto_seme_code) seed_founded.inject(location) # Attenzione che il get invierà i propri messaggi oltre a questi qui entity.act("Infili la $hand verso $N.", TO.ENTITY, target) entity.act("$n allunga una mano verso $N.", TO.OTHERS, target) entity.act("Ti senti un po' deprezzato ogni volta che $n ti indaga!", TO.TARGET, target) # Bisogna utilizzare la get_numbered_keyword perché non si sa se entity # in quel momento possa visualizzare la short diurna, notturna o il nome argument = seed_founded.get_numbered_keyword(looker=entity) if not location.IS_ROOM: argument += " %s " % location.get_numbered_keyword(looker=entity) execution_result = command_get(entity, argument) # La diminuzione del peso deve essere eseguita quando effettivamente sia # stato eseguito il comando di get, ovvero execution_result ha valore # di verità positiva if execution_result: if target.weight < seed_founded.weight: target.act("Dei $n che c'erano ora non resta nulla.", TO.ENTITY) target.act("Di te ormai ora non resta nulla.", TO.OTHERS) target.extract(1) else: target.weight = target.weight - seed_founded.weight return True
def carica_regalo(player, location, rompicapo): price = Item(random.choice(PRICE_PROTO_CODES)) price.inject(location) player.act( "\n[yellow]Hai appena concluso il rompicapo che dal nulla compare un premio![close]\n", TO.ENTITY, rompicapo) player.act( "\n[yellow]$n fa uno scatto sorpreso all'apparire del premio per $N.[close]\n", TO.OTHERS, rompicapo) player.act("Gothcha!.", TO.TARGET, rompicapo) print "novizi2_item_rompicapo-colorato - YOU WIN"
def test_initialize(self): item = Item([0, 'format'], 'id', 'prev-id') self.assertEqual(item.id, 'id') self.assertEqual(item.prev_id, 'prev-id') self.assertEqual(item.formats, [0, 'format']) format = TestFormatSubClass() format2 = TestFormatSubClass2() item = Item([format, format2]) self.assertEqual(item.formats, [format, format2]) item = Item(format) self.assertEqual(item.formats, [format])
def test_basket_bonus_discount(): shampoo_small = Item(name='Shampoo Small', price=2.00, discount_bonus=True) shampoo_medium = Item(name='Shampoo Medium', price=2.50, discount_bonus=True) shampoo_large = Item(name='Shampoo Large', price=3.50, discount_bonus=True) basket = Basket(items=[shampoo_large] * 3 + [shampoo_medium] + [shampoo_small] * 2) assert basket.get_subtotal() == 17.00 assert basket.get_discount() == 5.5 assert basket.get_total() == 11.5
def before_try_to_get(entity, target, location, behavioured): funghi_db = { 1: "villaggio-zingaro_item_fungo-01", 2: "villaggio-zingaro_item_fungo-02", 3: "villaggio-zingaro_item_fungo-03" } num_rand = random.randint(1, 100) if num_rand < 14: fungo_label = funghi_db[3] elif num_rand < 32: fungo_label = funghi_db[2] elif num_rand < 49: fungo_label = funghi_db[1] # in tutti gli altri casi esce dallo script con il return True # che esce dal flusso del get senza raccattare nulla else: entity.act( "Fai come per afferrarne uno ma questo ti sguscia tra le mani e si ritrae sotto terra.", TO.ENTITY, target) entity.act( "$n fa come per afferrare un fungo ma questo $gli sguscia tra le mani e si ritrae sotto terra.", TO.OTHERS, target) return True fungo = Item(fungo_label) fungo.inject(location) entity.act("Allunghi la $hand verso $N per raccoglierne uno.", TO.ENTITY, target) entity.act("$n allunga una $hand verso $N per raccoglierne uno.", TO.OTHERS, target) entity.act("Ti senti un po' deprezzat$O ogni volta $n ti indaga!", TO.TARGET, target) numbered_keyword = fungo.get_numbered_keyword(looker=entity) execution_result = command_get(entity, numbered_keyword) # Il peso del cerchio viene diminuito man mano che se ne preleva # prima di farlo verifica che sia uscita una keyword quando ne # resta troppo poco viene eliminato if execution_result: if target.weight < fungo.weight: target.act("Ed ora non ne trovi neanche uno, o così sembra.", TO.ENTITY, target) target.act("Ed ora non ne è rimasto neanche uno, o così sembra.", TO.OTHERS, target) target.extract(1) else: target.weight = target.weight - fungo.weight return execution_result
def gen_trash(room): casual_rotten = Item(random.choice(PROTO_VEGGY_CODES)) #if casual_rotten.max_global_quantity != 0 and casual_rotten.current_global_quantity >= casual_rotten.max_global_quantity: if casual_rotten.has_reached_max_global_quantity(): #log.bug("limit exceded") return casual_rotten.flags += FLAG.BURIED #log.bug("veggys injection") casual_rotten.inject(room)
class Board(): def __init__(self, settings): self.boardWidth = getSetting(settings, "boardWidth", 10) self.boardHeight = getSetting(settings, "boardHeight", 10) self.cellSize = getSetting(settings, "cellSize", 10) self.snake = Snake(settings, self.boardWidth / 2, self.boardHeight / 2) self.isDead = False self.item = Item(settings) self.reinitItem() def draw(self, screen): self.move() screen.fill(style.BoardFillColor) for row in range(0, self.boardWidth): for column in range(0, self.boardHeight): x = row * self.cellSize y = column * self.cellSize color = style.BoardFloorColor if self.isDead: color = style.BoardDeadColor pygame.draw.rect(screen, color, (x, y, self.cellSize, self.cellSize), 1) self.item.draw(screen) self.snake.draw(screen) def move(self): if self.snake.direction == Direction.Up: self.tryMove(self.snake.x, self.snake.y - 1) elif self.snake.direction == Direction.Right: self.tryMove(self.snake.x + 1, self.snake.y) elif self.snake.direction == Direction.Down: self.tryMove(self.snake.x, self.snake.y + 1) elif self.snake.direction == Direction.Left: self.tryMove(self.snake.x - 1, self.snake.y) def tryMove(self, x, y): self.isDead = ((x < 0) or (x >= self.boardWidth) or (y < 0) or (y >= self.boardHeight) or self.snake.isContains(x, y)) if self.isDead: return isItemEaten = (x == self.item.x) and (y == self.item.y) if isItemEaten: self.item.eatenUpCount = self.item.eatenUpCount + 1 self.reinitItem() self.snake.moveHead(x, y, isItemEaten) def reinitItem(self): self.item.x = random.randint(0, self.boardWidth - 1) self.item.y = random.randint(0, self.boardHeight - 1)
def turn_to_dust(player, cadavere, location): if not player.IS_PLAYER: return False polvere = Item(PROTO_DUST_CODE) polvere.inject(location) player.act("$N comincia a sgretolarsi fino a farsi polvere.", TO.ENTITY, cadavere) player.act("$N toccato da $n si decompone a vista d'occhio.", TO.OTHERS, cadavere) player.act("Ti sgretoli al tocco di $n!", TO.TARGET, cadavere) cadavere.extract(1) caterpillar_creation() return True
def on_sunrise(lupo): if not lupo: log.bug("lupo non è un parametro valido: %r" % lupo) return dosso = Item(PROTO_DOSSO_CODE) dosso.inject(lupo.location) dosso.act("Ti origini da $N e sei $n.", TO.ENTITY, lupo) dosso.act("Tra atroci ululati $N si trasforma in $n!", TO.OTHERS, lupo) dosso.act("$n si origina da te!", TO.TARGET, lupo) lupo.stop_repop() lupo.extract(1)
def marciume(seed, room): if seed.code not in database["items"]: return frutto_marcio = Item("karpuram_item_mirtillo-rosso-00-frutto-marcio") if not frutto_marcio: log.bug("impossibile creare frutto_marcio: %r" % frutto_marcio) return if room != seed.location: # log da rimuovere log.bug("room di drop diversa da room attuale") return location = seed.location seed.act("$N appare tutto molliccio...", TO.OTHERS, seed) seed.act("$N appare tutto molliccio...", TO.ENTITY, seed) seed.extract() frutto_marcio.inject(location) frutto_marcio.act("... è $N buono solo come concime.", TO.OTHERS, frutto_marcio) frutto_marcio.act("... è $N buono solo come concime.", TO.ENTITY, frutto_marcio)
def test_send_to_zmq(self): pc = PubControl() pc._zmq_pub_controller = ZmqPubControllerTestClass() pc._send_to_zmq('chan', Item(TestFormatSubClass())) fmt = TestFormatSubClass() pc._send_to_zmq('chan', Item(fmt)) self.assertEqual(pc._zmq_pub_controller.publish_channel, 'chan'.encode('utf-8')) is_encoded = False try: if not isinstance(pc._zmq_pub_controller.publish_channel, unicode): is_encoded = True except NameError: if not isinstance(pc._zmq_pub_controller.publish_channel, str): is_encoded = True
def after_move(entity, from_room, direction, to_room, running, behavioured): if not entity.IS_PLAYER: return for content in to_room.iter_contains(): if content.IS_PLAYER: continue if content.prototype.code == oggetti["chiave"]: return chiave = Item(oggetti["chiave"]) chiave.inject(to_room) defer(3, ambience_act_1, to_room) defer(5, ambience_act_2, to_room, chiave)
def after_move(entity, from_room, direction, to_room, running, behavioured): if not entity.IS_PLAYER: return for content in to_room.iter_contains(): if content.IS_PLAYER: continue if content.prototype.code == oggetti["chiave"]: return chiave = Item(oggetti["chiave"]) chiave.inject(to_room) defer(3, ambience_act_1, to_room) defer(5, ambience_act_2, to_room, chiave)
def turn_to_dust(player, cadavere, location): if not player.IS_PLAYER: return False polvere = Item(PROTO_DUST_CODE) polvere.inject(location) player.act("$N comincia a sgretolarsi fino a farsi polvere.", TO.ENTITY, cadavere) player.act("$N toccato da $n si decompone a vista d'occhio.", TO.OTHERS, cadavere) player.act("Ti sgretoli al tocco di $n!", TO.TARGET, cadavere) cadavere.extract(1) caterpillar_creation() return True
def gem_gen(unused_room): sum_relative_weight = 0 for gem_code in GEMS_WEIGHT_DICT: print "--> relative weight sum <--", sum_relative_weight sum_relative_weight += GEMS_WEIGHT_DICT[gem_code] print "--> final reative weight sum <--", sum_relative_weight area = database["areas"]["miniere-kezaf"] rooms = area.rooms.values() log.bug("start miniere kezaf", log_stack=False) rooms_to_fill = len(rooms) - 2 print "rooms_to_fill ", rooms_to_fill for room in random.sample(rooms, rooms_to_fill): for content in room.iter_contains(): if FLAG.BURIED in content.flags: log.bug("gem extraction: %s" % content.code, log_stack=False) content.extract(1) if random.randint(0, 1): casual_gem_code = random.chioce(PROTO_GEMS_CODES) if casual_gem_code.has_reached_max_global_quantity(): log.bug("extract causa excedeed of: %s" % casual_gem_code, log_stack=False) else: casual_gem = Item(casual_gem_code) casual_gem.flags += FLAG.BURIED log.bug("insertion of: %s" % casual_gem.code, log_stack=False) casual_gem.inject(room) # if not casual_gem: # log.bug("not casual gem: %s" % casual_gem, log_stack=False) # return # casual_gem.flags += FLAG.BURIED # # if casual_gem.has_reached_max_global_quantity(): # log.bug("extract causa excedeed of: %s" % casual_gem.code, log_stack=False) # casual_gem.extract(1) # else: # log.bug("insertion of: %s" % casual_gem.code, log_stack=False) # casual_gem.inject(room) # if casual_gem.max_global_quantity == 0 or casual_gem.current_global_quantity < casual_gem.max_global_quantity: # log.bug("insertion of: %s" % casual_gem.code, log_stack=False) # casual_gem.inject(room) # else: # log.bug("extract causa excedeed of: %s" % casual_gem.code, log_stack=False) # casual_gem.extract(1) return True
def cached_fitness(self, genes: "Genes") -> "Tuple[Result, Any]": '''Same as _fitnes_function but uses cached values if it can. For the given set of genes it checks if cache_data contains that record already. If it does not it creates a new tuple with _fitness_function and saves it to cache_data. Args: genes: An array of booleans (genes) whose cache_data record is to be returned Returns: A tuple[Result, Any] that was obtained from cache_data or calculated. ''' #print("Trying:", np.where(genes)) number = Item.to_number(genes) result = self.cache_data.get(number, None) self.cache_counter[number] += 1 if result is None: result = self._fitness_function(genes) self.cache_data[number] = result else: #print("Hitted", self.cache_counter) pass return result
def main(): items = [] random.seed(5345) number_of_items = int(input("Please enter number of items: ")) for i in range(number_of_items): item = Item(random.randint(1, 10), random.randint(0, 75)) items.append(item) print(items) weight = 0 for i in range(number_of_items): weight += items[i].weight print(weight) max_weight = round(weight / 2) population_size = int(input("Please enter population size: ")) population = generate_population(population_size, max_weight, items) number_of_generations = int(input("Please enter number of generations: ")) population = run_algorithm(population, number_of_generations) print_population(population) choice = input("Do you want to export results to textfile? (y/N) ") if choice == "y": parameters = { "Number of items": number_of_items, "Population size": population_size, "Number of generations": number_of_generations } filename = input("Please enter filename: ") if not path.isdir("exported_results"): mkdir("exported_results") export_results(population, parameters, filename)
def purge_item_with_information_gain(self, item: "Item") -> "EvalItem": '''Removes the worst gene from an item. Checks which gene adds the least to the score and removes it from the item. Args: item: An Item object to which we want to remove the worst gene. Returns: An EvalItem Object that is the same as the input object but with the worst gene removed. ''' base_result, model = self.fitness_function(item.genes) on_genes = np.where(item.genes)[0] changes = [(1.0, -1) for _ in on_genes] for change_ind, gene_ind in enumerate(on_genes): sh_result = self.evaluator(model, item.genes, [change_ind]) changes[change_ind] = (base_result.score - sh_result.score, gene_ind) changes.sort() # Sort them so that first cause the smallest change # print(base_result) # print("CHANGES:", changes) # And therefore seem a good fit for removal # Maybe some random selection? genes2 = item.genes.copy() # Unset the gene with the smallest change genes2[changes[0][1]] = False rt_item = Item(genes2, item.generation + 1, None, None).\ evaluate(self.fitness_function) return rt_item
def bash( self, object, position ): # catch-all for bash/smash (can probably use this for vehicle collisions aswell) object is object that is doing the bashing # since we bash in a direction we need to check what's in the tile and go from there. # both furniture and terrain can be bashed but we should assume that the player wants to bash the furniture first then terrain we will go in that order. tile = self.get_tile_by_position(position) terrain = tile["terrain"] # strength = creature strength. if tile["furniture"] is not None: furniture_type = self.FurnitureManager.FURNITURE_TYPES[ tile["furniture"].ident] for item in furniture_type["bash"]["items"]: self.put_object_at_position( Item( self.ItemManager.ITEM_TYPES[str( item["item"])]["ident"], self.ItemManager.ITEM_TYPES[str(item["item"])], ), position, ) # need to pass the reference to load the item with data. tile["furniture"] = None # get the 'bash' dict for this object from furniture.json # get 'str_min' # if player can break it then delete the furniture and add the bash items from it to the tile. return if terrain is not None: # get the 'bash' dict for this object from terrain.json if any # if dict is not None: # get 'str_min' # if player can break it then delete the terrain and add the bash terrain from it to the tile. return return
def gem_gen(unused_room): sum_relative_weight = 0 for gem_code in GEMS_WEIGHT_DICT: print "--> relative weight sum <--", sum_relative_weight sum_relative_weight += GEMS_WEIGHT_DICT[gem_code] print "--> final reative weight sum <--", sum_relative_weight area = database["areas"]["miniere-kezaf"] rooms = area.rooms.values() log.bug("start miniere kezaf", log_stack=False) rooms_to_fill = len(rooms) - 2 print "rooms_to_fill ", rooms_to_fill for room in random.sample(rooms, rooms_to_fill): for content in room.iter_contains(): if FLAG.BURIED in content.flags: log.bug("gem extraction: %s" % content.code, log_stack=False) content.extract(1) if random.randint(0,1): casual_gem_code = random.chioce(PROTO_GEMS_CODES) if casual_gem_code.has_reached_max_global_quantity(): log.bug("extract causa excedeed of: %s" % casual_gem_code, log_stack=False) else: casual_gem = Item(casual_gem_code) casual_gem.flags += FLAG.BURIED log.bug("insertion of: %s" % casual_gem.code, log_stack=False) casual_gem.inject(room) # if not casual_gem: # log.bug("not casual gem: %s" % casual_gem, log_stack=False) # return # casual_gem.flags += FLAG.BURIED # # if casual_gem.has_reached_max_global_quantity(): # log.bug("extract causa excedeed of: %s" % casual_gem.code, log_stack=False) # casual_gem.extract(1) # else: # log.bug("insertion of: %s" % casual_gem.code, log_stack=False) # casual_gem.inject(room) # if casual_gem.max_global_quantity == 0 or casual_gem.current_global_quantity < casual_gem.max_global_quantity: # log.bug("insertion of: %s" % casual_gem.code, log_stack=False) # casual_gem.inject(room) # else: # log.bug("extract causa excedeed of: %s" % casual_gem.code, log_stack=False) # casual_gem.extract(1) return True
def test_init_item(self): name = 'life_potion' sprite = 'imgs/dungeon_crawl/item/potion/magenta_new.png' description = 'This is a test description' item = Item(name, sprite, description) self.assertEqual(name, item.name) self.assertEqual(description, item.desc) self.assertEqual('Life Potion', str(item))
def generate_item(apprendista, player, choosed_material, room): # Normale che possa accadere visto che la funzione viene deferrata if not apprendista or not player or not room: return to_say = "Uhm... un golem di %s... Cominciamo un po'..." % choosed_material command_say(apprendista, to_say) proto_item_code = ITEM_PROTO_CODE[choosed_material] item = Item(proto_item_code) item.flags += FLAG.NO_GET item.inject(room) # (bb) perché funzioni al meglio il sistema di persistent act qui bisogna # che esista anche il messaggio a TO.ENTITY, da aggiungere quindi apprendista.act(PHRASES[choosed_material], TO.OTHERS, item) defer_random_time(12, 20, generate_golem, apprendista, player, choosed_material, room, item)
def load(self): ws = load_workbook(self.path)['Engineering'] values = ws.values headers = tuple(self.__column_name_to_item_field(header) for header in next(values)) dicts = [dict(zip(headers, row)) for row in values] for attrs in dicts: del attrs[None] return [Item(**attrs) for attrs in dicts if attrs['name']]
def on_sunrise(lupo): if not lupo: log.bug("lupo non è un parametro valido: %r" % lupo) return dosso = Item(PROTO_DOSSO_CODE) dosso.inject(lupo.location) dosso.act("Ti origini da $N e sei $n.", TO.ENTITY, lupo) dosso.act("Tra atroci ululati $N si trasforma in $n!", TO.OTHERS, lupo) dosso.act("$n si origina da te!", TO.TARGET, lupo) lupo.stop_repop() lupo.extract(1)
def medaglione_corruption(medaglione, player): # Normale perché la funzione è deferrata if not medaglione or not player: return old_medallion = Item("villaggio-zingaro_item_medaglione-rotto") old_medallion.inject(medaglione.location) medaglione.act("$n si consuma lentamente...", TO.ENTITY, send_to_location=player.location) medaglione.act("$n si consuma lentamente...", TO.OTHERS, send_to_location=player.location) medaglione.extract(1) defer(120, medaglione_remove, old_medallion, player) return False
def test_export(self): format = TestFormatSubClass() out = Item(format, 'id', 'prev-id').export() self.assertEqual(out['name'], {'body': 'bodyvalue'}) self.assertEqual(out['id'], 'id') self.assertEqual(out['prev-id'], 'prev-id') out = Item(format).export() self.assertFalse('id' in out) self.assertFalse('prev-id' in out) out = Item(format, 'id', 'prev-id').export(True) self.assertEqual(out['formats']['name'], {'body': 'bodyvalue'}) self.assertEqual(out['id'], 'id') self.assertEqual(out['prev-id'], 'prev-id') self.verify_unicode(out['id'], 'id') self.verify_unicode(out['prev-id'], 'prev-id') out = Item(format, 'id', 'prev-id').export(False, True) self.verify_utf8(out['id'.encode('utf-8')], 'id') self.verify_utf8(out['prev-id'.encode('utf-8')], 'prev-id')
def reset_fermaglio(): """ Cerca le copie di fermagli e le rimuove, ma se son in inventario dei player li sostituisce con la fuffa. """ for fermaglio in reversed(database["items"].values()): if fermaglio.prototype.code != FERMAGLIO_PROTO_CODE: continue if not fermaglio.location: fermaglio.extract(1) player_container = fermaglio.get_player_carrier() if player_container: location = fermaglio.location fermaglio.extract(1) dummy_fermaglio = Item(FAKE_FERMAGLIO_PROTO_CODE) dummy_fermaglio.inject(location) else: fermaglio.extract(1)
def generate_item(apprendista, player, choosed_material, room): # Normale che possa accadere visto che la funzione viene deferrata if not apprendista or not player or not room: return to_say = "Uhm... un golem di %s... Cominciamo un po'..." % choosed_material command_say(apprendista, to_say) proto_item_code = ITEM_PROTO_CODE[choosed_material] item = Item(proto_item_code) item.flags += FLAG.NO_GET item.inject(room) # (bb) perché funzioni al meglio il sistema di persistent act qui bisogna # che esista anche il messaggio a TO.ENTITY, da aggiungere quindi apprendista.act(PHRASES[choosed_material], TO.OTHERS, item) defer_random_time(12, 20, generate_golem, apprendista, player, choosed_material, room, item)
def before_try_to_get(entity, target, location, behavioured): matasse_db = { 1: "carrozzone-zingaro_item_canovaccio-01-macchiato", 2: "carrozzone-zingaro_item_canovaccio-01-pulito", 3: "carrozzone-zingaro_item_canovaccio-01-usurato", 4: "carrozzone-zingaro_item_canovaccio-02-macchiato", 5: "carrozzone-zingaro_item_canovaccio-02-pulito", 6: "carrozzone-zingaro_item_canovaccio-02-usurato" } num_rand = random.randint(1, 100) if num_rand < 17: matassa_label = matasse_db[1] elif num_rand < 34: matassa_label = matasse_db[2] elif num_rand < 50: matassa_label = matasse_db[3] elif num_rand < 67: matassa_label = matasse_db[4] elif num_rand < 84: matassa_label = matasse_db[5] else: matassa_label = matasse_db[6] matassa = Item(matassa_label) matassa.inject(location) entity.act("Affondi la $hand verso $N incurante.", TO.ENTITY, target) entity.act("Ti senti un po' deprezzato ogni volta $n ti indaga!", TO.TARGET, target) entity.act("Incurante $n allunga una $hand verso $N.", TO.OTHERS, target) execution_result = command_get(entity, "canovaccio") # Il peso del filo viene diminuito man mano che se ne preleva quando # ne resta troppo poco viene eliminato if target.weight < matassa.weight: target.act("E questo era il tuo ultimo pezzo di stoffa...", TO.ENTITY) target.act("E questo era l'ultimo pezzo di stoffa...", TO.OTHERS) target.extract(1) else: target.weight = target.weight - matassa.weight return execution_result
def before_try_to_get(entity, target, location, behavioured): funghi_db = {1: "villaggio-zingaro_item_fungo-01", 2: "villaggio-zingaro_item_fungo-02", 3: "villaggio-zingaro_item_fungo-03"} num_rand = random.randint(1, 100) if num_rand < 14: fungo_label = funghi_db[3] elif num_rand < 32: fungo_label = funghi_db[2] elif num_rand < 49: fungo_label = funghi_db[1] # in tutti gli altri casi esce dallo script con il return True # che esce dal flusso del get senza raccattare nulla else : entity.act("Fai come per afferrarne uno ma questo ti sguscia tra le mani e si ritrae sotto terra.", TO.ENTITY, target) entity.act("$n fa come per afferrare un fungo ma questo $gli sguscia tra le mani e si ritrae sotto terra.", TO.OTHERS, target) return True fungo = Item(fungo_label) fungo.inject(location) entity.act("Allunghi la $hand verso $N per raccoglierne uno.", TO.ENTITY, target) entity.act("$n allunga una $hand verso $N per raccoglierne uno.", TO.OTHERS, target) entity.act("Ti senti un po' deprezzat$O ogni volta $n ti indaga!", TO.TARGET, target) numbered_keyword = fungo.get_numbered_keyword(looker=entity) execution_result = command_get(entity, numbered_keyword) # Il peso del cerchio viene diminuito man mano che se ne preleva # prima di farlo verifica che sia uscita una keyword quando ne # resta troppo poco viene eliminato if execution_result: if target.weight < fungo.weight: target.act("Ed ora non ne trovi neanche uno, o così sembra.", TO.ENTITY, target) target.act("Ed ora non ne è rimasto neanche uno, o così sembra.", TO.OTHERS, target) target.extract(1) else: target.weight = target.weight - fungo.weight return execution_result
def before_try_to_get(entity, target, location, behavioured): matasse_db = {1: "carrozzone-zingaro_item_canovaccio-01-macchiato", 2: "carrozzone-zingaro_item_canovaccio-01-pulito", 3: "carrozzone-zingaro_item_canovaccio-01-usurato", 4: "carrozzone-zingaro_item_canovaccio-02-macchiato", 5: "carrozzone-zingaro_item_canovaccio-02-pulito", 6: "carrozzone-zingaro_item_canovaccio-02-usurato"} num_rand = random.randint(1,100) if num_rand < 17: matassa_label = matasse_db[1] elif num_rand < 34: matassa_label = matasse_db[2] elif num_rand < 50: matassa_label = matasse_db[3] elif num_rand < 67: matassa_label = matasse_db[4] elif num_rand < 84: matassa_label = matasse_db[5] else: matassa_label = matasse_db[6] matassa = Item(matassa_label) matassa.inject(location) entity.act("Affondi la $hand verso $N incurante.", TO.ENTITY, target) entity.act("Ti senti un po' deprezzato ogni volta $n ti indaga!", TO.TARGET, target) entity.act("Incurante $n allunga una $hand verso $N.", TO.OTHERS, target) execution_result = command_get(entity, "canovaccio") # Il peso del filo viene diminuito man mano che se ne preleva quando # ne resta troppo poco viene eliminato if target.weight < matassa.weight: target.act("E questo era il tuo ultimo pezzo di stoffa...", TO.ENTITY) target.act("E questo era l'ultimo pezzo di stoffa...", TO.OTHERS) target.extract(1) else: target.weight = target.weight - matassa.weight return execution_result
def quest_reward(player, item, tessi): if tessi.location != player.location: to_say = "a %s %s, ma dove scappi? Non vuoi la ricompensa dopo tanto affanno? Vabbè!" % (player.code, player.name) command_say(tessi, to_say) return # (GATTO) il valore forse è da tarare experience = 100 * max(1, player.level / 2) player.experience += experience player.send_output("Guadagni [white]%d[close] di esperienza!" % experience) tessi.specials["player_on_quest"] = "" #to_say = "Quest False" #command_say(tessi, to_say) to_say_1 = "a %s È proprio il mio fermacapelli! Dopo tanto affanno ecco a te un piccolo presente come ringraziamento." % player.code defer_if_possible(1, 1, tessi, player, command_say, tessi, to_say_1) # Poiché un'iniezione silenziosa di un oggetto ad un giocatore non è molto # friendly allora dà il medaglione alla tessitrice e quest'ultima lo dà # al giocatore tramite un give medaglione = Item(MEDAGLIONE_PROTO_CODE) unguento = Item(UNGUENTO_PROTO_CODE) medaglione.inject(tessi) unguento.inject(medaglione) defer_if_possible(2, 2, tessi, player, give_reward, tessi, medaglione, player) to_say_2 = "a %s Adoperalo con saggezza, solo quando saprai che farne perché potrai utilizzarlo una sola volta." % player.code defer_if_possible(3, 3, tessi, player, command_say, tessi, to_say_2) defer(4, reset_quest, tessi)
def gem_generation(unused_room): sum_relative_weight = 0 for gem_code in GEM_WEIGHTS: #print "--> relative weight sum <--", sum_relative_weight sum_relative_weight += GEM_WEIGHTS[gem_code] #print "--> final reative weight sum <--", sum_relative_weight area = database["areas"]["miniere-kezaf"] rooms = area.rooms.values() #log.bug("start miniere kezaf", log_stack=False) rooms_to_fill = len(rooms) - 2 #print "rooms_to_fill ", rooms_to_fill for room in random.sample(rooms, rooms_to_fill): for content in room.iter_contains(use_reversed=True): #maledetto, maledetto reversed! if FLAG.BURIED in content.flags: #log.bug("gem extraction: %s" % content.code, log_stack=False) content.extract(1) if random.randint(0, 1) == 0: #print gem_code_generator(sum_relative_weight) chosed_gem_code = gem_code_generator(sum_relative_weight) casual_gem = database["proto_items"][chosed_gem_code] if not casual_gem: log.bug("not casual gem: %s" % casual_gem, log_stack=False) return if casual_gem.has_reached_max_global_quantity(): log.bug("not inject causa maxquantity of: %s" % casual_gem.code, log_stack=False) else: casual_gem = Item(chosed_gem_code) casual_gem.flags += FLAG.BURIED casual_gem.max_vigour = random.randint(MIN_GEM_VIGOUR, MAX_GEM_VIGOUR) casual_gem.vigour = random.randint(1,casual_gem.max_vigour) casual_gem.max_life = random.randint(MIN_GEM_LIFE, MAX_GEM_LIFE) casual_gem.life = random.randint(1,casual_gem.max_life) casual_gem.inject(room) # #if casual_gem.max_global_quantity == 0 or casual_gem.current_global_quantity < casual_gem.max_global_quantity: # casual_gem = Item(chosed_gem_code) # casual_gem.flags += FLAG.BURIED # # casual_gem.max_vigour = random.randint(MIN_GEM_VIGOUR, MAX_GEM_VIGOUR) # casual_gem.vigour = random.randint(1,casual_gem.max_vigour) # casual_gem.max_life = random.randint(MIN_GEM_LIFE, MAX_GEM_LIFE) # casual_gem.life = random.randint(1,casual_gem.max_life) # # casual_gem.inject(room) # #log.bug("insertion of: %s" % casual_gem.code, log_stack=False) # else: # log.bug("not inject causa maxquantity of: %s" % casual_gem.code, log_stack=False) return True
def germinate(seed, room, age, fortuna): if seed.code not in database["items"]: return germoglio = Item("karpuram_item_mirtillo-rosso-02-germoglio") if not germoglio: log.bug("impossibile creare germoglio: %r" % germoglio) return #rudimentale contollo per vedere che il seme non sia stato spostato nel frattempo # 2 i problemi a cui si va incontro # aa) qualcuno lo droppa e poi lo raccatta e lo ridroppa 1ora dopo e comunque lui cresce (da evitare) # bb) la room stessa si resetta e anche se il seme non è stato spostato la room è cambiate e lui non cresce (da evitare) # forse il controllo con le coordinate xyz potrebbe risolvere b # (gatto dice che non si presenta il problema bb anche se la room resetta) # c'è da vedere perché al solito credo ci siam fraintesi ed io pensavo al reset di room diverse nelle stesse coordinate # per risolvere aa forse basta in qualche modo che un get interrompa lo script (come fare?) if room != seed.location: # log da rimuovere log.bug("room di drop diversa da room attuale") return location=seed.location seed.act("Di recente $N s'è schiuso...", TO.OTHERS, seed) seed.act("Di recente $N s'è schiuso...", TO.ENTITY, seed) seed.extract(1) germoglio.inject(location) germoglio.act("... in $N.", TO.OTHERS, germoglio) germoglio.act("... in $N.", TO.ENTITY, germoglio) fortuna = fortuna -1 if random.randint(1, fortuna) == 1: reactor.callLater(random.randint( GERM_WAIT_MIN , GERM_WAIT_MAX ), desiccation, germoglio, room, age) return reactor.callLater(random.randint( GERM_WAIT_MIN , GERM_WAIT_MAX ), growing, germoglio, room, age, fortuna)
def growing(germoglio, room, age, fortuna): if germoglio.code not in database["items"]: return pianta = Item("karpuram_item_mirtillo-rosso-03-pianta") if not pianta: log.bug("impossibile creare pianta: %r" % pianta) return location=germoglio.location germoglio.act("Quel che poco tempo fa era solo $N, ora ...", TO.OTHERS, germoglio) germoglio.act("Quel che poco tempo fa era solo $N, ora ...", TO.ENTITY, germoglio) germoglio.extract(1) pianta.inject(location) pianta.act("... è $N.", TO.OTHERS, pianta) fortuna = fortuna -1 if random.randint(1, fortuna) == 1: reactor.callLater(random.randint( PLANT_WAIT_MIN , PLANT_WAIT_MAX ), desiccation, pianta, room, age) return reactor.callLater(random.randint( PLANT_WAIT_MIN , PLANT_WAIT_MAX ), blooming, pianta, room, age, fortuna)
def before_try_to_get(entity, target, location, behavioured): manciata_torba = Item("karpuram_item_torba-manciata") laminetta_oro = Item("karpuram_item_laminetta-oro") if random.randint(1, 10) == 1: laminetta_oro.inject(location) entity.act("Metti la $hand in $N ed un luccicore ti distrae dal tuo proponimento!", TO.ENTITY, target) entity.act("tu che sei $N ti senti un po' deprezzato ogni volta $n ti indaga!", TO.TARGET, target) entity.act("$n affonda una mano in $N e si ferma sorpres$o.", TO.OTHERS, target) execution_result = command_get(entity, laminetta_oro.get_numbered_keyword(looker=entity)) else: manciata_torba.inject(location) execution_result = command_get(entity, manciata_torba.get_numbered_keyword(looker=entity)) # Se execution_result a True significa che è stato raccolta con successo # una manciata di torba e quindi ferma l'esecuzione del resto del comando get; # altrimenti è False e tornando False viene continuato il get del mucchio # di torba, che in futuro fallirà per motivi di peso return execution_result
def desiccation(generic_plant, room, age): if generic_plant.code not in database["items"]: return pianta_morta = Item("karpuram_item_mirtillo-rosso-06-pianta_morta") if not pianta_morta: # qui non dovrà uscire dallo script che sennò si frizza la pianta a questo stadio log.bug("impossibile creare pianta_morta: %r" % pianta_morta) return location=generic_plant.location generic_plant.act("Il rigoglio di $N ...", TO.OTHERS, generic_plant) generic_plant.act("Il rigoglio di $N ...", TO.ENTITY, generic_plant) generic_plant.extract() pianta_morta.inject(location) pianta_morta.descr_sixth = "una pianta che ha passato %r stagioni" % age pianta_morta.act("... è tramontato in $N.", TO.OTHERS, pianta_morta) pianta_morta.act("... è tramontato in $N.", TO.ENTITY, pianta_morta)
def after_buying(client, dealer, purchase, quantity, behavioured): item = Item(random.choice(PROTO_ITEM_CODES)) item.inject(purchase) purchase.value = 0
def after_touch(entity, room, descr, detail, behavioured): tessera = Item(PROTO_TESSERA_CODE) tessera.icon = icona_testo_002 tessera.inject(room)
def before_move(entity, from_room, direction, to_room, running, behavioured): if not entity.IS_PLAYER: return if direction != DIR.NORTHEAST: return for content in to_room.iter_contains(): if content.IS_PLAYER: continue if content.prototype.code == oggetti["contenitore_01"]: return funghi = Item(oggetti["funghi"]) contenitore_01 = Item(oggetti["contenitore_01"]) contenitore_02 = Item(oggetti["contenitore_02"]) contenitore_03 = Item(oggetti["contenitore_03"]) premio_01 = Item(oggetti["premio_01"]) premio_02 = Item(oggetti["premio_02"]) premio_03 = Item(oggetti["premio_03"]) funghi.inject(to_room) contenitore_01.inject(to_room) contenitore_02.inject(to_room) contenitore_03.inject(to_room) premio_01.inject(contenitore_01) premio_02.inject(contenitore_02) premio_03.inject(contenitore_03) to_room.act("\n[mediumturquoise]Una luce provieniente dal centro della cupola ti acceca per pochi attimi... qualcosa è cambiato attorno a te[close].") defer(3600, cleaning, to_room)
def after_inject(entity, room): # # Defer necessario per attendere il next stage precedente # defer(1, after_inject_deferred, seme, room) # #def after_inject_deferred(seme, room): print ">>> inserimento fiori via inject" if not entity.specials or not 'ancestors' in entity.specials or entity.specials['ancestors'] == False: # Qui genero un genotipo solo per fare dei contacci e passare il valore ai successivi genotipi # sistema da migliorare... entity.specials['ancestors'] = True numero_rose = random.randint(4,10) for i in range(0,numero_rose): genotipo = genera_genotipo() rosa = Item(PROTO_ROSA_CODE) rosa.inject(entity) rosa.specials['fiore'] = str(genotipo.fiore_2g) rosa.specials['calice'] = str(genotipo.calice_2g) rosa.specials['sepali'] = str(genotipo.sepali_2g) rosa.specials['colore'] = str(genotipo.head_color) rosa.specials['colore_calice'] = str(genotipo.color2_2g) rosa.specials['colore_sepali'] = str(genotipo.color3_2g) rosa.specials['fiore_prob'] = genotipo.fiore_prob rosa.specials['calice_prob'] = genotipo.calice_prob rosa.specials['sepali_prob'] = genotipo.sepali_prob rosa.specials['colore_prob'] = genotipo.colore_prob rosa.specials['colore2_prob'] = genotipo.colore2_prob rosa.specials['colore3_prob'] = genotipo.colore3_prob rosa.specials['prob'] = genotipo.prob rosa.specials['price'] = genotipo.price rosa.specials['ancestors'] = True rosa.short = genotipo.flower rosa.name = genotipo.flower rosa.value = int(max(1, round(genotipo.price))) # Temporaneo: alcuni dati dell'ultima rosa li metto sul cespuglio per verificare che # siano trasferiti sul next stage entity.descr += '\n' + genotipo.flower entity.specials['fiore'] = str(genotipo.fiore_2g) entity.specials['calice'] = str(genotipo.calice_2g) entity.specials['sepali'] = str(genotipo.sepali_2g) entity.specials['colore'] = str(genotipo.head_color) entity.specials['colore_calice'] = str(genotipo.color2_2g) entity.specials['colore_sepali'] = str(genotipo.color3_2g) entity.specials['fiore_prob'] = genotipo.fiore_prob entity.specials['calice_prob'] = genotipo.calice_prob entity.specials['sepali_prob'] = genotipo.sepali_prob entity.specials['colore_prob'] = genotipo.colore_prob entity.specials['colore2_prob'] = genotipo.colore2_prob entity.specials['colore3_prob'] = genotipo.colore3_prob entity.specials['prob'] = genotipo.prob entity.specials['price'] = genotipo.price entity.specials['ancestors'] = True #defer(1, set_special_after_next_stage, entity, rosa) return False
def popping_new_grappolo(room): new_grappolo = Item("torreelementi_item_grappolo-glicine-01") new_grappolo.inject(room)
def fructification(fiore, room, age, fortuna): if fiore.code not in database["items"]: return fruttificato = Item("karpuram_item_mirtillo-rosso-05-fruttificato") if not fruttificato: log.bug("impossibile creare fruttificato: %r" % fruttificato) return #l'istruzione Item è eseguita qui per il chk #poi però è ripetuta più volte nel loop #qui in qualche modo è codice sporco... bacca_buona = Item("karpuram_item_mirtillo-rosso-01-frutto") if not fruttificato: log.bug("impossibile creare fruttificato: %r" % bacca_buona) return bacca_cattiva = Item("karpuram_item_mirtillo-rosso-00-frutto-sterile") if not fruttificato: log.bug("impossibile creare fruttificato: %r" % bacca_cattiva) return location=fiore.location fiore.act("Dei fiori d'un tempo $N non ne ha più...", TO.OTHERS, fiore) fiore.act("Dei fiori d'un tempo $N non ne ha più...", TO.ENTITY, fiore) fiore.extract(1) fruttificato.inject(location) for q in xrange(MAX_FRUIT_QUANTITY + 2 * age + random.randint(1,4) - 2 ): bacca_buona = Item("karpuram_item_mirtillo-rosso-01-frutto") bacca_buona.inject(fruttificato) for q in xrange(MAX_FRUIT_QUANTITY + 2 * age + random.randint(1,4) - 2 ): bacca_cattiva = Item("karpuram_item_mirtillo-rosso-00-frutto-sterile") bacca_cattiva.inject(fruttificato) fruttificato.act("in compenso ora è $N.", TO.OTHERS, fruttificato) fortuna = fortuna -1 if random.randint(1, fortuna) == 1: reactor.callLater(random.randint(GROWED_WAIT_MIN,GROWED_WAIT_MAX), desiccation, fruttificato, room, age ) return reactor.callLater(random.randint(GROWED_WAIT_MIN,GROWED_WAIT_MAX), renew, fruttificato, room, age, fortuna )
def test_export_same_format_type(self): item = Item([TestFormatSubClass(), TestFormatSubClass()]) with self.assertRaises(ValueError): item.export()
def before_try_to_get(entity, target, location, behavioured): panzerotti_db = ["krablath_item_food-panzerotto-01", "krablath_item_food-panzerotto-02", "krablath_item_food-panzerotto-03"] num_rand = random.randint(1, 100) if num_rand < 33: panzerotto_code = panzerotti_db[0] elif num_rand < 66: panzerotto_code = panzerotti_db[1] else: panzerotto_code = panzerotti_db[2] # Alternativamente una soluzione che potrebbe essere considerata più # elegante del codice sopra potrebbe essere questa sotto. # Non hai la granularità del 100 ma chi se ne fre'.. e poi è più facilmente # percepibile anche solo ad occhio quali panzerotti verranno caricati di più # e quali meno #Se vuoi tenerla deve decommentare anche l'import del random in alto ed #eventualmente commentare quello del random.randint #panzerotti_db = ["karpuram_item_mirtillo-rosso-01-frutto", # "karpuram_item_mirtillo-rosso-01-frutto", # "karpuram_item_leccio-01-ghianda-viva", # "karpuram_item_leccio-01-ghianda-viva", # "karpuram_item_leccio-01-ghianda-viva", # "karpuram_item_leccio-02-ghianda-morta", # "karpuram_item_mirtillo-nero-01-frutto", # "karpuram_item_mirtillo-nero-01-frutto", # "karpuram_item_mirtillo-nero-01-frutto", # "karpuram_item_mirtillo-rosso-00-frutto-marcio", # "karpuram_item_mirtillo-rosso-00-frutto-marcio", # "karpuram_item_mirtillo-rosso-00-frutto-sterile", # "karpuram_item_mirtillo-rosso-00-frutto-sterile", # "karpuram_item_farnia-01-ghianda-viva", # "karpuram_item_farnia-01-ghianda-viva", # "karpuram_item_farnia-01-ghianda-viva", # "karpuram_item_farnia-01-ghianda-viva", # "karpuram_item_farnia-01-ghianda-viva", # "karpuram_item_farnia-02-ghianda-morta", # "karpuram_item_farnia-02-ghianda-morta", # "karpuram_item_farnia-02-ghianda-morta", # "karpuram_item_farnia-02-ghianda-morta"] #panzerotto_code = random.choice(panzerotti_db) # Crea e inserisce il panzerotto scelto nella locazione da cui prenderlo poi panzerotto_founded = Item(panzerotto_code) panzerotto_founded.inject(location) if random.randint(0, 1) == 1: panzerotto_founded.flags += FLAG.NO_LOOK_LIST # Attenzione che il get invierà i propri messaggi oltre a questi qua. entity.act("Infili la $hand verso $N.", TO.ENTITY, target) entity.act("$n allunga una mano verso $N.", TO.OTHERS, target) entity.act("Ti senti un po' deprezzato ogni volta che $n ti indaga!", TO.TARGET, target) # Bisogna utilizzare la get_numbered_keyword perché non si sa se entity # in quel momento stia guardando la short diurna, notturna o il nome numbered_keyword = panzerotto_founded.get_numbered_keyword(looker=entity) if location.IS_ROOM: argument = numbered_keyword else: argument = "%s %s " % (numbered_keyword, location.get_numbered_keyword(looker=entity)) execution_result = command_get(entity, argument) # Questo è meglio farlo solo se il get è andato a buon fine, cioè quando # execution_result ha valore di verità positiva if execution_result: if target.weight < panzerotto_founded.weight: target.act("Dei $n che c'erano ora non resta nulla.", TO.OTHERS) target.act("Non resta più molto di te.", TO.ENTITY) target.extract(1) else: target.weight = target.weight - panzerotto_founded.weight return execution_result