def activate(self, activator=None): if CountUpTile.activate(self, activator): xu = self.map.size.x // 4 yu = self.map.size.y // 4 b = Menu(Position(xu, yu), Position(xu * 2, yu * 2), title="Camera Control") b.add('1', "View cameras") b.add( '2', "Switch %s cameras" % (CameraConsole.cameras_on and 'off' or 'on')) b.add('x', "Exit") c = b.get_key() del b cams = self.map.find_all(StaticCamera, Monster) if c == '1': for cam in cams: self.map.prepare_fov(cam.pos, reset=False) self.map.player.handle_keys() elif c == '2': if CameraConsole.cameras_on: for cam in cams: cam.add_effect(StatusEffect.BLIND) else: for cam in cams: cam.remove_effect(StatusEffect.BLIND) CameraConsole.cameras_on = not CameraConsole.cameras_on return True return False
def pickup(self, i): """returns True if i picked up successfully""" # TODO: move all this into HasInventory interface assert isinstance(i, Item), "Can't pick up a %s" % i if isinstance(i, Evidence): self.evidence.append(i) if not i.pos is None: # found it in a locker self.map.remove(i) return Player.ITEM_PICKUP_COST item_index = None items = self.items if isinstance(i, SlotItem): items = [self.slot_items[i.valid_slot]] if not None in items: # prompt to drop something; drop it xu = self.map.size.x // 4 yu = self.map.size.y // 4 b = Menu(Position(xu, yu), Position(xu * 2, yu * 2), title="Pick Up") b.add('x', str(i)) b.add_spacer() for idx in range(len(items)): v = items[idx] b.add('%d' % (idx + 1), str(v)) c = b.get_key() if isinstance(c, str) and c.isnumeric(): item_index = int(c) - 1 self.redraw_screen() del b if item_index is None or item_index >= len(items): return 0.0 items[item_index].drop_at(self.pos) self.map.add(items[item_index]) else: item_index = items.index(None) if isinstance(i, SlotItem): self.slot_items[i.valid_slot] = i else: self.items[item_index] = i if not i.pos is None: # if taken from locker or other bonus self.map.remove(i) i.take_by(self) return Player.ITEM_PICKUP_COST
def drop(self): # prompt to drop something; drop it xu = self.map.size.x // 4 yu = self.map.size.y // 4 b = Menu(Position(xu, yu), Position(xu * 2, yu * 2), title="Drop") b.add('x', 'Do nothing') b.add_spacer() for idx in range(len(self.items)): v = self.items[idx] if not v is None: b.add('%d' % (idx + 1), str(v)) b.add_spacer() idx += 1 for k in self.slot_keys: idx += 1 if not self.slot_items[k] is None: b.add('%d' % idx, str(self.slot_items[k])) c = b.get_key() item_index = None if isinstance(c, str) and c.isnumeric(): item_index = int(c) - 1 self.redraw_screen() del b if item_index is None: return 0.0 i = None if item_index < len(self.items): i = self.items[item_index] self.items[item_index] = None elif item_index < len(self.items) + len(self.slot_keys): k = self.slot_keys[item_index - len(self.items)] i = self.slot_items[k] self.slot_items[k] = None if not i is None: i.drop_at(self.pos) self.map.add(i) return self.ITEM_DROP_COST return 0.0
def apply_to(self, map_array): r = [] kw2 = len(self.masks[0]) // 2 kh2 = len(self.masks[0][0]) // 2 for mci in range(kw2, len(map_array) - kw2): for mri in range(kh2, len(map_array[mci]) - kh2): for mask in self.masks: ok = True for kci in range(-kw2, kw2 + 1): for kri in range(-kh2, kh2 + 1): #print("%2x&%2x "%(map_array[mci+kci][mri+kri], mask[kci+kw2][kri+kh2]), end="") if not (map_array[mci + kci][mri + kri] & mask[kci + kw2][kri + kh2]) and not ( map_array[mci + kci][mri + kri] == 0 and mask[kci + kw2][kri + kh2] & MapPattern.WALL): #print("!", end="") ok = False #break #print() if not ok: break #print("-----------------") if ok: #print("WOOOOOO") r.append(Position(mci, mri)) #return r return r
def __init__(self, pos): Tile.__init__(self, pos, Door.CLOSED['symbol'], Door.CLOSED['colour'], Door.CLOSED['walkcost'], Door.CLOSED['transparency']) CountUp.__init__(self, Door.CLOSED['timer']) TurnTaker.__init__(self, 5) self.unseen_symbol = Door.CLOSED[ 'symbol'] # always shows as closed when can't be seen self.state = Door.CLOSED self.bar = HBar(Position(pos.x - 1, pos.y - 1), 3, Door.CLOSED['barcolour'], libtcod.darkest_grey) self.bar.max_value = self.count_to - 1 self.bar.timeout = 5.0 self._trying_to_open = False
def activate(self, activator=None): if CountUpTile.activate(self, activator): xu = self.map.size.x // 4 yu = self.map.size.y // 4 b = Menu(Position(xu, yu), Position(xu * 2, yu * 2), title="Trap Control") b.add('1', "View traps") b.add( '2', "%s traps" % (TrapConsole.traps_on and 'Disable' or 'Enable')) b.add('3', "Set off traps") b.add('x', "Exit") c = b.get_key() del b traps = self.map.find_all(Trap, Tile) if c == '1': for t in traps: t.visible_to_player = True self.map.player.handle_keys() elif c == '2': for trap in traps: trap.enabled = TrapConsole.traps_on TrapConsole.traps_on = not TrapConsole.traps_on elif c == '3': for trap in traps: trap.trip() return True return False
def redraw_screen(self, t=0): # draw and flush screen if not UI.need_update(t): # clearly one of the libtcod functions here causes the wait for the next frame sleep(1.0 / Player.LIMIT_FPS) return self.map.draw() self.draw_ui(Position(0, Player.SCREEN_SIZE.y - 3)) UI.draw_all(t) libtcod.console_flush() # clear screen libtcod.console_clear(0)
def __init__(self, pos, symbol, colour, walk_cost=0.0, transparency=0.0, may_block_movement=False, count_up=10): Tile.__init__(self, pos, symbol, colour, walk_cost, transparency, may_block_movement) CountUp.__init__(self, count_up + 1) #TurnTaker.__init__(self, 0) Activatable.__init__(self) self.bar = HBar(Position(pos.x - 2, pos.y - 1), 5, libtcod.light_blue, libtcod.darkest_grey) self.bar.max_value = self.count_to - 1 self.bar.timeout = 5.0
# system imports import os import sys # libtcod import libtcodpy as libtcod # our imports from interfaces import Position, TurnTaker from ui import UI from maps import Map from player import Player from errors import GameOverError, LevelWinError SCREEN_SIZE = Position(80, 50) LIMIT_FPS = 10 RANDOM_SEED = 1999 MAP = None PLAYER = None # for now if len(sys.argv) > 1 and sys.argv[0].startswith('DalekRL') and len( sys.argv[1]) > 0: RANDOM_SEED = int(sys.argv[1]) - 1 def init(): # init window font = os.path.join(b'resources', b'consolas10x10_gs_tc.png') libtcod.console_set_custom_font(
def sync_positions(date_since,date_now,countryLookup,rest): field_list = "id,externalID,address,title,status,clientCorporation,dateLastModified,dateAdded,description,isOpen" position_list_query = "search/JobOrder?query=dateLastModified:[{0} TO {1}] AND isDeleted:0&sort=dateLastModified&fields={2}&count=100".format(date_since,date_now,field_list) url = position_list_query print(url) jres = make_list_request(url,rest) positions=[] if jres != None: position_list=jres["Results"] total_records=jres["TotalRecords"] for pos in position_list: #print(pos) position=Position() position.id="p" + str(pos["id"]) if "title" in pos: if pos["title"] != None: position.job_title=pos["title"].encode("utf-8").strip() if "address" in pos: addr = pos["address"] if "countryID" in addr: if addr["countryID"] != None: if addr["countryID"] in countryLookup : position.position_location=countryLookup[addr["countryID"]].encode("utf-8") if "city" in addr: if addr["city"] != None: position.city=addr["city"].encode("utf-8").strip() if "state" in addr: if addr["state"] != None: position.state=addr["state"].encode("utf-8").strip() if "zip" in addr: if addr["zip"] != None: position.postal_code=addr["zip"].encode("utf-8").strip() if "clientCorporation" in pos: company = pos["clientCorporation"] if "name" in company: if company["name"] != None: position.company_name=company["name"].encode("utf-8").strip() if "externalID" in pos: if pos["externalID"] != None: position.position_id=pos["externalID"].encode("utf-8").strip() if "status" in pos: if pos["status"] != None: position.status=pos["status"].encode("utf-8").strip() if "isOpen" in pos: if pos["isOpen"] != None: if pos["isOpen"] == True: position.open_closed="Open" else: position.open_closed="Closed" if "dateAdded" in pos: if pos["dateAdded"] != None: date_added = datetime.fromtimestamp(int(pos["dateAdded"])/1000).strftime('%Y-%m-%dT%H:%M:%S') position.date_entered=date_added if "dateLastModified" in pos: if pos["dateLastModified"] != None: date_last_modified = datetime.fromtimestamp(int(pos["dateLastModified"])/1000).strftime('%Y-%m-%dT%H:%M:%S') position.last_modified=date_last_modified if "description" in pos: if pos["description"] != None: position.job_description_words=cleanup_text(strip_html_bs(pos["description"].encode("utf-8"))) positions.append(position) return positions
def sync_positions(date_since, date_now, rest): #salesforce is limited to 2000 records returned but will return the total number of rows #we iterate through 2000 at a time updating the query criteria with the LastModifiedDate of #the last processed record keep_processing = True work_done = False while keep_processing: results = rest.make_rest_call( "query?q=SELECT+Id,Name,TR1__Account_Name__c,TR1__City__c,TR1__Client_Job_Description__c,LastModifiedDate,CreatedDate+FROM+TR1__Job__c+WHERE+LastModifiedDate+>+{0}+ORDER+BY+LastModifiedDate+asc" .format(date_since)) result_rows = len(results["records"]) if result_rows > 0: total_result_rows = results["totalSize"] print(results["totalSize"], len(results["records"])) positions = [] for pos in results["records"]: position = Position() position.id = "p" + str(pos["Id"]) if "Name" in pos: if pos["Name"] != None: position.job_title = pos["Name"].encode( "utf-8").strip() if "TR1__Account_Name__c" in pos: if pos["TR1__Account_Name__c"] != None: position.company_name = pos[ "TR1__Account_Name__c"].encode("utf-8").strip() if "TR1__City__c" in pos: if pos["TR1__City__c"] != None: position.position_location = pos[ "TR1__City__c"].encode("utf-8").strip() if "TR1__Client_Job_Description__c" in pos: if pos["TR1__Client_Job_Description__c"] != None: position.description = cleanup_text( strip_html_bs( pos["TR1__Client_Job_Description__c"].encode( "utf-8").strip())) if "CreatedDate" in pos: if pos["CreatedDate"] != None: date_added = pos["CreatedDate"] position.date_entered = date_added if "LastModifiedDate" in pos: if pos["LastModifiedDate"] != None: date_last_modified = pos["LastModifiedDate"] position.last_modified = date_last_modified positions.append(position) write_position_data(positions) work_done = True if total_result_rows > 2000: date_since = results["records"][-1][ "LastModifiedDate"].replace(".000+0000", "Z") else: keep_processing = False else: keep_processing = False return work_done
class Player(Activator, TurnTaker, StatusEffect, HasInventory, LightSource, Mappable): # these don't really belong here SCREEN_SIZE = Position(80, 50) LIMIT_FPS = 15 MAX_TIMEOUT = 5 # these do though ITEM_ACTIVATE_COST = 0.6 ITEM_PICKUP_COST = 1.0 ITEM_DROP_COST = 1.0 def __init__(self, pos=None): Mappable.__init__(self, pos, '@', libtcod.white) StatusEffect.__init__(self) TurnTaker.__init__(self, 1) HasInventory.__init__( self, 3, (SlotItem.HEAD_SLOT, SlotItem.BODY_SLOT, SlotItem.FEET_SLOT)) LightSource.__init__(self, 2, 0.1) self.items = [None, None, None] self.slot_items = { SlotItem.HEAD_SLOT: None, SlotItem.BODY_SLOT: None, SlotItem.FEET_SLOT: None, } self.turns = 0 self.evidence = [] self.levels_seen = 1 # init items (must be done this way to invoke any pickup triggers) # - inv items self.pickup(Item.random(None, self, 2, 1.5)) self.pickup(Item.random(None, self, 1)) # - slot items self.pickup(NightVisionGoggles(self)) self.pickup(NinjaSuit(self)) self.pickup(RunningShoes(self)) self.KEYMAP = { 'k': self.move_n, 'j': self.move_s, 'h': self.move_w, 'l': self.move_e, 'y': self.move_nw, 'u': self.move_ne, 'b': self.move_sw, 'n': self.move_se, '.': self.do_nothing, '1': self.use_item1, '2': self.use_item2, '3': self.use_item3, '4': self.use_head, '5': self.use_body, '6': self.use_feet, 'Q': sys.exit, 'R': self.reset_game, ' ': self.interact, 'd': self.drop, 'L': self.debug_lighting, } #@property #def light_level(self): # # cap min light level # l = self.map.light_level(self.pos) # if libtcod.color_get_hsv(l)[2] < 0.2: # return libtcod.dark_grey # return l def __str__(self): return "Player at %s" % self.pos def use_item(self, slot): assert slot in self.slot_items.keys() or slot < len( self.items), "Using undefined item slot" item = None if slot in self.slot_items.keys(): item = self.slot_items[slot] elif isinstance(slot, int): item = self.items[slot] if item is None: return 0.0 assert isinstance(item, Activatable) if item.activate(self): return Player.ITEM_ACTIVATE_COST else: return 0.0 def draw_ui(self, pos, max_size=80): # UI constants TODO: move them COL_W = 24 C_MARGIN_W = 1 # print inventory items for i in range(len(self.items)): libtcod.console_print(0, pos.x, pos.y + i, "%d." % (i + 1)) if self.items[i] is None: libtcod.console_print(0, pos.x + 3, pos.y + i, "--- Nothing ---") else: self.items[i].draw_ui(pos + (3, i), COL_W) # print slot items i = 4 for s in self.slot_keys: libtcod.console_print(0, pos.x + COL_W + 3 + C_MARGIN_W, pos.y + i - 4, "%d." % (i)) if self.slot_items[s] is None: libtcod.console_print(0, pos.x + COL_W + 3 + C_MARGIN_W + 3, pos.y + i - 4, "--- Nothing ---") else: self.slot_items[s].draw_ui( pos + (COL_W + 3 + C_MARGIN_W + 3, i - 4), COL_W) i += 1 # print info libtcod.console_print(0, pos.x + COL_W * 2 + C_MARGIN_W * 2 + 3 + 3, pos.y, "Level: %5d" % self.levels_seen) libtcod.console_print(0, pos.x + COL_W * 2 + C_MARGIN_W * 2 + 3 + 3, pos.y + 1, "Evidence: %5d" % len(self.evidence)) libtcod.console_print(0, pos.x + COL_W * 2 + C_MARGIN_W * 2 + 3 + 3, pos.y + 2, "Turns: %5d" % self.turns) def reset_fov(self): if self.has_effect(StatusEffect.BLIND): return self.map.prepare_fov(self.pos, 4) elif self.has_effect(StatusEffect.X_RAY_VISION): return self.map.prepare_fov(self.pos, 10) else: return self.map.prepare_fov(self.pos, 0) def pickup(self, i): """returns True if i picked up successfully""" # TODO: move all this into HasInventory interface assert isinstance(i, Item), "Can't pick up a %s" % i if isinstance(i, Evidence): self.evidence.append(i) if not i.pos is None: # found it in a locker self.map.remove(i) return Player.ITEM_PICKUP_COST item_index = None items = self.items if isinstance(i, SlotItem): items = [self.slot_items[i.valid_slot]] if not None in items: # prompt to drop something; drop it xu = self.map.size.x // 4 yu = self.map.size.y // 4 b = Menu(Position(xu, yu), Position(xu * 2, yu * 2), title="Pick Up") b.add('x', str(i)) b.add_spacer() for idx in range(len(items)): v = items[idx] b.add('%d' % (idx + 1), str(v)) c = b.get_key() if isinstance(c, str) and c.isnumeric(): item_index = int(c) - 1 self.redraw_screen() del b if item_index is None or item_index >= len(items): return 0.0 items[item_index].drop_at(self.pos) self.map.add(items[item_index]) else: item_index = items.index(None) if isinstance(i, SlotItem): self.slot_items[i.valid_slot] = i else: self.items[item_index] = i if not i.pos is None: # if taken from locker or other bonus self.map.remove(i) i.take_by(self) return Player.ITEM_PICKUP_COST def do_nothing(self): return self.move((0, 0)) # triggers try_movement on current square def reset_game(self): raise GameOverError def debug_lighting(self): if not self.map is None: self.map.debug_lighting() return 0.0 def move_n(self): return self.move((0, -1)) def move_s(self): return self.move((0, 1)) def move_w(self): return self.move((-1, 0)) def move_e(self): return self.move((1, 0)) def move_ne(self): return self.move((1, -1)) def move_nw(self): return self.move((-1, -1)) def move_se(self): return self.move((1, 1)) def move_sw(self): return self.move((-1, 1)) def use_item1(self): return self.use_item(0) def use_item2(self): return self.use_item(1) def use_item3(self): return self.use_item(2) def use_head(self): return self.use_item(SlotItem.HEAD_SLOT) def use_body(self): return self.use_item(SlotItem.BODY_SLOT) def use_feet(self): return self.use_item(SlotItem.FEET_SLOT) def interact(self): # TODO: manage situation where multiple items are on same tile gracefully r = 0.0 i = self.map.find_at_pos(self.pos, Item) if not i is None: r += self.pickup(i) for i in self.map.find_all_at_pos(self.pos, Tile): if isinstance(i, Activatable): if i.activate(self): r += 1.0 #return r # whilst we can calculate cumulative cost of all this stuff; actually want to end turn regardless return 1.0 def drop(self): # prompt to drop something; drop it xu = self.map.size.x // 4 yu = self.map.size.y // 4 b = Menu(Position(xu, yu), Position(xu * 2, yu * 2), title="Drop") b.add('x', 'Do nothing') b.add_spacer() for idx in range(len(self.items)): v = self.items[idx] if not v is None: b.add('%d' % (idx + 1), str(v)) b.add_spacer() idx += 1 for k in self.slot_keys: idx += 1 if not self.slot_items[k] is None: b.add('%d' % idx, str(self.slot_items[k])) c = b.get_key() item_index = None if isinstance(c, str) and c.isnumeric(): item_index = int(c) - 1 self.redraw_screen() del b if item_index is None: return 0.0 i = None if item_index < len(self.items): i = self.items[item_index] self.items[item_index] = None elif item_index < len(self.items) + len(self.slot_keys): k = self.slot_keys[item_index - len(self.items)] i = self.slot_items[k] self.slot_items[k] = None if not i is None: i.drop_at(self.pos) self.map.add(i) return self.ITEM_DROP_COST return 0.0 def take_turn(self): # runs just before handle_keys, so expensive ops run whilst player chooses what to do Talker.stop_all_talk() self.reset_fov() #self.map.recalculate_lighting() self.turns += 1 t_remaining = 1.0 # TODO: weight this based on passive buffs have_used_item = False while t_remaining > 0.0: self.map.recalculate_dirty() try: # handle player input (and redraw screen) f = self.handle_keys() # TODO: fix this monstrous way of detecting item use if f.__name__.startswith('use_'): if not have_used_item: have_used_item = True else: # TODO: this is wrong! two consecutive item uses should # register as two valid keypresses raise InvalidMoveError t_remaining -= f() except InvalidMoveContinueError: print("You can't move like that") except InvalidMoveError: # this is ok, like teleporting t_remaining = 0.0 def handle_keys(self): """returns pointer to function to call""" k = libtcod.Key() m = libtcod.Mouse() for t in range(Player.LIMIT_FPS * Player.MAX_TIMEOUT): if t % 5 == 0: self.redraw_screen(t / Player.LIMIT_FPS) ev = libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, k, m) if ev and k and k.pressed and chr(k.c) in self.KEYMAP: return self.KEYMAP.get(chr(k.c)) # redraw screen after first second after keypress self.redraw_screen(Player.MAX_TIMEOUT) # call this before going into while loop to make sure no keypresses get dropped ev = libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, k, m) while True: if k and k.pressed and chr(k.c) in self.KEYMAP: return self.KEYMAP.get(chr(k.c)) k = libtcod.console_wait_for_keypress(True) def redraw_screen(self, t=0): # draw and flush screen if not UI.need_update(t): # clearly one of the libtcod functions here causes the wait for the next frame sleep(1.0 / Player.LIMIT_FPS) return self.map.draw() self.draw_ui(Position(0, Player.SCREEN_SIZE.y - 3)) UI.draw_all(t) libtcod.console_flush() # clear screen libtcod.console_clear(0) def refresh_turntaker(self): TurnTaker.refresh_turntaker(self) for i in self.items + list(self.slot_items.values()): # switch off active rundownitem items before level transition if isinstance(i, RunDownItem) and i.is_active: print("switching off %s" % i) i.activate() elif isinstance(i, TurnTaker): i.refresh_turntaker() # TODO: this isn't great :( if hasattr(i, 'bar') and isinstance(i.bar, UI): i.bar.refresh_ui_list()