def _extract_objects(expression: str) -> dict: ''' Returns dictionary of characters in expression and their corresponding Logic objects. ''' object_dict = defaultdict(str) for i in expression: if i.isalpha(): object_dict[i] = logic.Logic() return object_dict
def calculate(self): yb = int(self.y_b.text()) ye = int(self.y_e.text()) log = logic.Logic(yb, ye) self.result = log.run() for line in self.result: self.res.append(line)
def __init__(self, options, *, seed=None): self.seed = seed if self.seed is None: self.seed = os.urandom(16) self.rnd = random.Random(self.seed) if options.race: self.rnd.random() # Just pull 1 random number so race seeds are different then from normal seeds but still stable. if options.multiworld: self.__logic = logic.MultiworldLogic(options, self.rnd) else: self.__logic = logic.Logic(options, self.rnd) if not options.keysanity or options.forwardfactor: item_placer = ForwardItemPlacer(self.__logic, options.forwardfactor) else: item_placer = RandomItemPlacer(self.__logic) if options.plan: assert options.multiworld is None self.readPlan(options.plan) for item, count in self.readItemPool(options, item_placer).items(): if count > 0: item_placer.addItem(item, count) item_placer.run(self.rnd) if options.goal == "random": options.goal = self.rnd.randint(-1, 8) if options.multiworld: z = None if options.output_filename is not None: z = zipfile.ZipFile(options.output_filename, "w") for n in range(options.multiworld): rom = generator.generateRom(options.multiworld_options[n], self.seed, self.__logic, multiworld=n) fname = "LADXR_Multiworld_%d_%d.gbc" % (options.multiworld, n + 1) if z: handle = z.open(fname, "w") rom.save(handle, name="LADXR") handle.close() else: rom.save(fname, name="LADXR") if options.spoilerformat != "none" and not options.race: extension = "json" if options.spoilerformat == "json" else "txt" sfname = "LADXR_Multiworld_%d_%d.%s" % (options.multiworld, n + 1, extension) log = spoilerLog.SpoilerLog(options, rom) log.output(sfname, z) else: rom = generator.generateRom(options, self.seed, self.__logic) filename = options.output_filename if filename is None: filename = "LADXR_%s.gbc" % (binascii.hexlify(self.seed).decode("ascii").upper()) rom.save(filename, name="LADXR") if options.spoilerformat != "none" and not options.race: log = spoilerLog.SpoilerLog(options, rom) log.output(options.spoiler_filename)
def __init__(self, width, height): # init vars self.uiobj = ui.UI(width, height) self.userinputobj = userinput.UserInput() self.gameobj = entity.Game(entity.Player(), entity.Player()) self.logicobj = logic.Logic() # update ui at start self.uiobj.update(self.gameobj, userinput)
def __init__(self): self.logger = log.get_logger("Server") asyncore.dispatcher.__init__(self) self.create_socket(socket.AF_INET, socket.SOCK_STREAM) host, port = '', 13579 addr = (host, port) self.bind(addr) self.listen(100) self.client_set = set() self.logic = logic.Logic()
def regist_dmmjp(): print 'regist_dmmjp.......................................' lg = logic.Logic() lg._autoRun() gameURL = lg._getGame() final_mail = 'empty' if not (gameURL == ''): final_mail = lg._getMail() return contrustHTML(final_mail, gameURL)
def __init__(self, master=None, title="<application>", **kwargs): self.logic = logic.Logic() super().__init__(master, **kwargs) self.master.title(title) self.master.columnconfigure(0, weight=1) self.master.rowconfigure(0, weight=1) self.grid(sticky="NEWS") self.create_widgets() for column in range(self.grid_size()[0]): for row in range(self.grid_size()[1]): self.columnconfigure(column, weight=1) self.rowconfigure(row, weight=1)
def runLogic(): tmpDir = 'tmp_out' if os.path.exists(tmpDir): shutil.rmtree(tmpDir, ignore_errors=True) os.makedirs(tmpDir) l = logic.Logic(logicConfig) l.createGraph(588, tmpDir + '/data.json', masterBranches=['zaap/devel'], additionalBranches=[]) dir_util.copy_tree(tmpDir, destinationOutDir, update=True)
def nowa_runda(self, lista_dzialan): if self.login == None: messagebox.showinfo('Brak użytkownika', 'Zaloguj sie. Plik->Login') else: self.logic = logic.Logic(self.login) self.logic.nowa_runda(lista_dzialan, self.login) messagebox.showinfo('Nowa runda', 'Czas rozpoczac nowa runde') self.logic.dodaj_przyklady_do_listy() self.logic.wczytaj_przyklad_z_listy() self.wyczysc_wynik() self.wyswietl_label_top(self.logic.komunikat()) self.wyswietl_label_l(self.logic.pytanie_dzialanie()) self.logic.set_start_time()
def fill_source(geometry_name, words_name): parser = CrossParser() parser.know_geometry(geometry_name) parser.know_words(words_name) dictionary_hor = parser.words_place_hor() dictionary_vert = parser.words_place_vert() parser.form_word_place(dictionary_vert, dictionary_hor) parser.new_view() logical_source = logic.Logic(parser) mat_source = logical_source.fill() if mat_source is not None: return str(mat_source) else: return ''
def regist_nutaku(): lg = logic.Logic() lg._autoRun() mail = lg._getMail() url = lg._getGame() #print mail #print url if url: return (mail, url) return ('', '')
def init(self): pygame.init() pygame.display.set_caption(constant.WINDOW_NAME) self._display_surf = pygame.display.set_mode( (constant.WINDOW_WIDTH, constant.WINDOW_HEIGHT)) self._running = True self._except_new_game = False self._background = pygame.image.load( constant.FILE_BACKGROUND).convert() self._logic = logic.Logic() self._logic.start() self._sound = sound.Sound() self._sound.play() self._font = pygame.font.SysFont("Arial", 20) self._end_font = pygame.font.SysFont("Arial", 30)
async def reload(self, ctx, *, module: str): if ctx.message.author.id in config.superusers: if module == 'webserver': await config.modules['webserver'].stop() webserver = importlib.reload(config.modules[module]) config.modules['webserver'] = webserver await webserver.start() await ctx.channel.send("reloaded `" + module + "` succesfully!") elif module == 'config': config.reload() await ctx.channel.send("reloaded `" + module + "` succesfully!") elif module == 'logic': bot.remove_cog('Logic') logic = importlib.reload(config.modules['logic']) gameclass = logic.Logic(bot) bot.add_cog(gameclass) elif module == admin: bot.remove_cog('Admin') admin = importlib.reload(config.modules['admin']) adminclass = admin.Admin(bot) bot.add_cog(adminclass) elif module in config.modules and config.modules[module]: try: bot.remove_cog(module.capitalize()) loadedmodule = importlib.reload(config.modules[module]) bot.add_cog( getattr(loadedmodule, module.capitalize())(bot)) await ctx.channel.send("reloaded `" + module + "` succesfully!") except AttributeError: importlib.reload(config.modules[module]) await ctx.channel.send("reloaded `" + module + "` succesfully?") except Exception as e: print(e) await ctx.channel.send("reloading `" + module + "` failed.") else: await ctx.channel.send('`' + module + "` isn't available for reloading.") else: await emformat.genericmsg(ctx.channel, "this command is restricted.", "error", "reload")
def _loadItems(self, args, rom): my_logic = logic.Logic(args, world_setup=self.world_setup) remainingItems = set(my_logic.iteminfo_list) currentSphere = 0 lastAccessibleLocations = set() itemContents = {} for ii in my_logic.iteminfo_list: itemContents[ii] = ii.read(rom) # Feed the logic items one sphere at a time while remainingItems: e = explorer.Explorer() e.visit(my_logic.start) newLocations = e.getAccessableLocations() - lastAccessibleLocations if not newLocations: # Some locations must be inaccessible, stop counting spheres break for location in newLocations: for ii in location.items: ii.metadata.sphere = currentSphere ii.item = itemContents[ii] if ii in remainingItems: remainingItems.remove(ii) lastAccessibleLocations = e.getAccessableLocations() currentSphere += 1 for ii in remainingItems: ii.item = itemContents[ii] for location in e.getAccessableLocations(): for ii in location.items: self.accessibleItems.append( SpoilerItemInfo(ii, rom, args.multiworld)) if len(e.getAccessableLocations()) != len(my_logic.location_list): self.inaccessibleItems = [] for loc in my_logic.location_list: if loc not in e.getAccessableLocations(): for ii in loc.items: self.inaccessibleItems.append( SpoilerItemInfo(ii, rom, args.multiworld))
def _calculate(self, c=0): ''' Eavaluates the LogicFunction for all possible variable values and returns a list with all the input/output combinations. ''' result_list = [] if c == len(self.logic_dict): row_list = [] for i in self.variable_list: row_list.append(int(self.logic_dict[i])) row_list.append(int(eval(self.parsed_expression))) return row_list else: n = 0 while n != 2: self.logic_dict[self.variable_list[c]] = logic.Logic(n) result_list.extend(self._calculate(c + 1)) n += 1 return result_list
def start(): global main_window geometry_file = ex.geo_name words_file = ex.wr_name parser = CrossParser() parser.know_geometry(geometry_file) parser.know_words(words_file) horizontal_dictionary = parser.words_place_hor() vertical_dictionary = parser.words_place_vert() parser.form_word_place(vertical_dictionary, horizontal_dictionary) parser.new_view() logicall = logic.Logic(parser) matrix = logicall.fill() # matrix = [['m', '_', 's'], ['o', '_', 'i'], ['r', '_', 's'], # ['e', '_', 'k'], ['_', '_', 'a']] # print(matrix) choose_size_dialog.close() main_window = MainWindow(matrix) main_window.show()
def __init__(self, args, roms): for rom in roms: if rom.banks[0][7] == 0x01: raise RaceRomException() self.seed = roms[0].readHexSeed() self.testOnly = args.test self.accessibleItems = [] self.inaccessibleItems = None self.outputFormat = args.spoilerformat self.args = vars(args) # Assume the broadest settings if we're dumping a seed we didn't just create if args.dump: # The witch flag causes trouble if we blindly turn it on if patches.witch.witchIsPatched(roms[0]): args.witch = True args.boomerang = "gift" args.heartpiece = True args.seashells = True args.heartcontainers = True args.owlstatues = "both" if len(roms) > 1: args.multiworld = len(roms) if not hasattr(args, "multiworld_options"): args.multiworld_options = [args] * args.multiworld world_setups = [] for rom in roms: world_setup = WorldSetup() world_setup.loadFromRom(rom) world_setups.append(world_setup) if len(world_setups) == 1: self.logic = logic.Logic(args, world_setup=world_setups[0]) else: self.logic = logic.MultiworldLogic(args, world_setups=world_setups) self._loadItems(args, roms)
def start(): qman = queue.QueueManager() threadLogic = logic.Logic(qman) threadLogic.start() threadPotPut = potentioReadRoter.PotentioReader(qman) threadPotPut.start() threadPotGet = fanRotate.FanRotate(qman) threadPotGet.start() threadTempPut = tempReadVal.TempReadVal(qman) threadTempPut.start() threadTempGet = fanOn.FanOn(qman) threadTempGet.start() threadSpeedPut = potentioReadSpeed.PotentioSpeedReader(qman) threadSpeedPut.start() threadSpeedGet = fanSpeed.FanSpeed(qman) threadSpeedGet.start()
def new_game(self): self._logic = logic.Logic() self._logic.start() self._except_new_game = False
import tkinter as tk import buttons as Bt import logic as Lg root = tk.Tk() root.geometry("514x490") logic = Lg.Logic() board = Bt.Buttons(root, logic) root.mainloop()
def main(mainargs=None): import argparse import sys parser = argparse.ArgumentParser(description='Randomize!') parser.add_argument('input_filename', metavar='input rom', type=str, help="Rom file to use as input.") parser.add_argument( '-o', '--output', dest="output_filename", metavar='output rom', type=str, required=False, help="Output filename to use. If not specified [seed].gbc is used.") parser.add_argument('--dump', dest="dump", type=str, nargs="*", help="Dump the logic of the given rom (spoilers!)") parser.add_argument( '--spoilerformat', dest="spoilerformat", choices=["none", "console", "text", "json"], default="none", help="Sets the output format for the generated seed's spoiler log") parser.add_argument( '--spoilerfilename', dest="spoiler_filename", type=str, required=False, help= "Output filename to use for the spoiler log. If not specified, LADXR_[seed].txt/json is used." ) parser.add_argument( '--test', dest="test", action="store_true", help="Test the logic of the given rom, without showing anything.") parser.add_argument('-s', '--seed', dest="seed", type=str, required=False, help="Generate the specified seed") parser.add_argument( '--romdebugmode', dest="romdebugmode", action="store_true", help= "Patch the rom so that debug mode is enabled, this creates a default save with most items and unlocks some debug features." ) parser.add_argument('--exportmap', dest="exportmap", action="store_true", help="Export the map (many graphical mistakes)") parser.add_argument('--emptyplan', dest="emptyplan", type=str, required=False, help="Write an unfilled plan file") parser.add_argument( '--timeout', type=float, required=False, help="Timeout generating the seed after the specified number of seconds" ) parser.add_argument( '--logdirectory', dest="log_directory", type=str, required=False, help= "Directory to write the JSON log file. Generated independently from the spoiler log and omitted by default." ) # Flags that effect gameplay parser.add_argument('--plan', dest="plan", metavar='plandomizer', type=str, required=False, help="Read an item placement plan") parser.add_argument( '--race', dest="race", nargs="?", default=False, const=True, help= "Enable race mode. This generates a rom from which the spoiler log cannot be dumped and the seed cannot be extracted." ) parser.add_argument( '--logic', dest="logic", choices=["casual", "normal", "hard", "glitched", "hell"], help="Which level of logic is required.") parser.add_argument('--multiworld', dest="multiworld", type=int, required=False, help="Generates multiple roms for a multiworld setup.") parser.add_argument( '--multiworld-config', dest="multiworld_config", action="append", required=False, help= "Set configuration for a multiworld player, supply multiple times for settings per player" ) parser.add_argument( '--forwardfactor', dest="forwardfactor", type=float, required=False, help= "Forward item weight adjustment factor, lower values generate more rear heavy seeds while higher values generate front heavy seeds. Default is 0.5." ) parser.add_argument('--heartpiece', dest="heartpiece", action="store_true", help="Enables randomization of heart pieces.") parser.add_argument( '--seashells', dest="seashells", action="store_true", help= "Enables seashells mode, which randomizes the secret sea shells hiding in the ground/trees. (chest are always randomized)" ) parser.add_argument( '--heartcontainers', dest="heartcontainers", action="store_true", help= "Enables heartcontainer mode, which randomizes the heart containers dropped by bosses." ) parser.add_argument('--instruments', dest="instruments", action="store_true", help="Shuffle the instruments in the item pool.") parser.add_argument( '--owlstatues', dest="owlstatues", choices=['none', 'dungeon', 'overworld', 'both'], default='none', help= "Give the owl statues in dungeons or on the overworld items as well, instead of showing the normal hints" ) parser.add_argument( '--dungeon-items', dest="dungeon_items", choices=['standard', 'localkeys', 'localnightmarekey', 'keysanity'], default='standard', help= "Sets what gets done with dungeon items, if they are in their own dungeon or not." ) parser.add_argument('--randomstartlocation', dest="randomstartlocation", action="store_true", help="Place your starting house at a random location.") parser.add_argument( '--dungeonshuffle', dest="dungeonshuffle", action="store_true", help="Enable dungeon shuffle, puts dungeons on different spots.") parser.add_argument( '--entranceshuffle', dest="entranceshuffle", choices=["none", "simple", "advanced", "expert", "insanity"], default="none", help="Enable entrance shuffle, shuffles around overworld entrances.") parser.add_argument( '--boss', dest="boss", choices=["default", "shuffle", "random"], default="default", help="Enable boss shuffle, swaps around dungeon bosses.") parser.add_argument('--miniboss', dest="miniboss", choices=["default", "shuffle", "random"], default="default", help="Shuffle the minibosses or just randomize them.") parser.add_argument('--doubletrouble', dest="doubletrouble", action="store_true", help="...") parser.add_argument('--witch', dest="witch", action="store_true", help="Enables witch and toadstool in the item pool.") parser.add_argument( '--hpmode', dest="hpmode", choices=['default', 'inverted', '1'], default='default', help= "Set the HP gamplay mode. Inverted causes health containers to take HP instead of give it and you start with more health. 1 sets your starting health to just 1 hearth." ) parser.add_argument( '--boomerang', dest="boomerang", choices=['default', 'trade', 'gift'], default='default', help= "Put the boomerang and the trade with the boomerang in the item pool") parser.add_argument('--steal', dest="steal", choices=['never', 'always', 'default'], default='always', help="Configure when to allow stealing from the shop.") parser.add_argument( '--hard-mode', dest="hardMode", action="store_true", help= "Make the game a bit harder, less health from drops, bombs damage yourself, and less iframes." ) parser.add_argument( '--goal', dest="goal", type=goal, default='8', help= "Configure the instrument goal for this rom: any number between -1 (open egg) and 8, a range (e.g. 4-7), 'random', or 'raft' / 'seashells' for special goals." ) parser.add_argument( '--accessibility', dest="accessibility_rule", choices=['all', 'goal'], help= "Switches between making sure all locations are reachable or only the goal is reachable" ) parser.add_argument( '--bowwow', dest="bowwow", choices=['normal', 'always', 'swordless'], default='normal', help= "Enables 'good boy mode', where BowWow is allowed on all screens and can damage bosses and more enemies." ) parser.add_argument( '--pool', dest="itempool", choices=['normal', 'casual', 'pain', 'keyup'], default='normal', help="Sets up different item pools, for easier or harder gameplay.") parser.add_argument( '--overworld', dest="overworld", choices=['normal', 'dungeondive'], default='normal', help= "Allows switching to the dungeondive overworld, where there are only dungeons." ) parser.add_argument('--pymod', dest="pymod", action='append', help="Load python code mods.") # Just aestetic flags parser.add_argument('--gfxmod', dest="gfxmod", action='append', help="Load graphical mods.") parser.add_argument( '--remove-flashing-lights', dest="removeFlashingLights", action="store_true", help= "Remove the flashing light effects from mamu, the shopkeeper and madbatter." ) parser.add_argument( '--quickswap', dest="quickswap", choices=['none', 'a', 'b'], default='none', help= "Configure quickswap for A or B button (select key swaps, no longer opens map)" ) parser.add_argument( '--textmode', dest="textmode", choices=['default', 'fast', 'none'], default='default', help= "Default just keeps text normal, fast makes text appear twice as fast, and none removes all text from the game." ) parser.add_argument( '--nag-messages', dest="removeNagMessages", action="store_false", help= "Enable the nag messages on touching stones and crystals. By default they are removed." ) parser.add_argument('--lowhpbeep', dest="lowhpbeep", choices=['default', 'slow', 'none'], default='slow', help="Slows or disables the low health beeping sound") parser.add_argument('--linkspalette', dest="linkspalette", type=int, default=None, help="Force the palette of link") parser.add_argument('--music', dest="music", choices=['default', 'random', 'off'], default='default', help="Randomizes or disable the music") args = parser.parse_args(mainargs) if args.multiworld is not None: args.multiworld_options = [args] * args.multiworld if args.multiworld_config is not None: for index, settings_string in enumerate(args.multiworld_config): args.multiworld_options[index] = parser.parse_args( [args.input_filename] + shlex.split(settings_string), namespace=argparse.Namespace(**vars(args))) if args.timeout is not None: import threading import time import os def timeoutFunction(): time.sleep(args.timeout) print("TIMEOUT") sys.stdout.flush() os._exit(1) threading.Thread(target=timeoutFunction, daemon=True).start() if args.exportmap: import mapexport print("Loading: %s" % (args.input_filename)) rom = ROMWithTables(args.input_filename) mapexport.MapExport(rom) sys.exit(0) if args.emptyplan: import locations.items f = open(args.emptyplan, "wt") f.write(";Plandomizer data\n;Items: %s\n" % (", ".join( map(lambda n: getattr(locations.items, n), filter(lambda n: not n.startswith("__"), dir( locations.items)))))) f.write(";Modify the item pool:\n") f.write(";Pool:SWORD:+5\n") f.write(";Pool:RUPEES_50:-5\n") import worldSetup iteminfo_list = logic.Logic( args, world_setup=worldSetup.WorldSetup()).iteminfo_list for ii in sorted(iteminfo_list, key=lambda n: (n.location.dungeon if n.location.dungeon else -1, repr(n.metadata))): if len(ii.OPTIONS) > 1: f.write(";%r\n" % (ii.metadata)) f.write("Location:%s: \n" % (ii.nameId)) sys.exit(0) if args.dump is not None or args.test: print("Loading: %s" % (args.input_filename)) roms = [ROMWithTables(f) for f in [args.input_filename] + args.dump] if args.spoilerformat == "none": args.spoilerformat = "console" try: log = spoilerLog.SpoilerLog(args, roms) log.output(args.spoiler_filename) sys.exit(0) except spoilerLog.RaceRomException: print("Cannot read spoiler log for race rom") sys.exit(1) if args.seed: try: args.seed = binascii.unhexlify(args.seed) except binascii.Error: args.seed = args.seed.encode("ascii") retry_count = 0 while True: try: r = randomizer.Randomizer(args, seed=args.seed) seed = binascii.hexlify(r.seed).decode("ascii").upper() break except randomizer.Error: if args.seed is not None: print("Specified seed does not produce a valid result.") sys.exit(1) retry_count += 1 if retry_count > 100: print("Randomization keeps failing, abort!") sys.exit(1) print("Failed, trying again: %d" % (retry_count)) print("Seed: %s" % (seed))
def score_edit(): logic = lc.Logic() return render_template("score_edit.html", data=logic.get_table_editable())
import logic import os from datetime import datetime import time fileList = [f for f in os.listdir() if f.endswith(".db_meta")] for f in fileList: os.remove(f) log = logic.Logic("Testing.vdb") time_list = [] def test_index(): log.query("CREATE TABLE FIRST (id int, name str);", 1) for i in range(50): request = 'INSERT INTO FIRST VALUES (' + str(i) + ', "first");' log.query(request, 1) log.query(request, 1) begin_first_time = datetime.now() temp1 = log.query("SELECT id FROM FIRST WHERE id = 49;", 1) end_first_time = datetime.now() first_time = end_first_time - begin_first_time log.query("CREATE INDEX ind1 ON FIRST (id);", 1) begin_second_time = datetime.now() temp2 = log.query("SELECT id FROM FIRST WHERE id = 49;", 1) end_second_time = datetime.now()
def messages_view(): logic = lc.Logic() return render_template("messages.html", messages=logic.get_messages())
import tornado.template import logic import sys from tornado.ioloop import IOLoop import serial ser = None try: ser = serial.Serial("/dev/cu.usbmodem1421", 9600, timeout=1) except: pass gui = None console = None logic = logic.Logic() class MainHandler(tornado.web.RequestHandler): def get(self): loader = tornado.template.Loader(".") self.write(loader.load("index.html").generate()) class WSHandler(tornado.websocket.WebSocketHandler): def check_origin(self, origin): return True def open(self): print 'connection opened...' self.write_message(
def edit(): logic = lc.Logic() logic.process_edit(request.args.getlist("id")[0], request.args.getlist("value")[0]) return ""
def __init__(self): self.logic = logic.Logic() self.queryParser = queryparser.QueryParser()
def main(): rospy.init_node('hcr_state_node') sm_hcr = smach.StateMachine(outcomes=['succeeded', 'aborted', 'preempted']) """ Initialize userdata """ # target and current positions pose_init = geometry_msgs.msg.PoseStamped() pose_init.pose.position.x = 0 pose_init.pose.position.y = 0 pose_init.pose.position.z = 0 pose_init.pose.orientation.x = 0 pose_init.pose.orientation.y = 0 pose_init.pose.orientation.z = 0 pose_init.pose.orientation.w = 1 sm_hcr.userdata.pose_base_cur = geometry_msgs.msg.PoseStamped() sm_hcr.userdata.pose_base_tar = geometry_msgs.msg.PoseStamped() sm_hcr.userdata.pose_object_cur = geometry_msgs.msg.PoseStamped() sm_hcr.userdata.pose_object_tar = geometry_msgs.msg.PoseStamped() sm_hcr.userdata.pose_base_cur = pose_init sm_hcr.userdata.pose_base_cur.header.frame_id = "map" sm_hcr.userdata.pose_base_tar = pose_init sm_hcr.userdata.pose_base_tar.header.frame_id = "map" sm_hcr.userdata.pose_object_cur = pose_init sm_hcr.userdata.pose_object_tar = pose_init # Flags (flg) sm_hcr.userdata.flg_move_detect_done = False sm_hcr.userdata.flg_move_search_done = False sm_hcr.userdata.flg_object_grasp_done = False sm_hcr.userdata.flg_object_place_done = False sm_hcr.userdata.flg_move_new_goal = False # List of detected frames (type class Frame) for each run sm_hcr.userdata.list_detected_frames_tmp = [] sm_hcr.userdata.list_detected_frames_1 = [] sm_hcr.userdata.list_detected_frames_2 = [] sm_hcr.userdata.list_detected_frames_3 = [] """ Initialize subscribers """ def _move_base_goal_cb(pose): sm_hcr.userdata.pose_base_tar = pose sm_hcr.userdata.flg_move_new_goal = True rospy.Subscriber('/move_base_simple/goal', geometry_msgs.msg.PoseStamped, _move_base_goal_cb) """ Initialize thread """ def thread_tf_target_object_pose(): while 1: br = tf2_ros.TransformBroadcaster() t = geometry_msgs.msg.TransformStamped() t.header.stamp = rospy.Time.now() t.header.frame_id = sm_hcr.userdata.pose_object_tar.header.frame_id t.child_frame_id = "target_object" t.transform.translation = sm_hcr.userdata.pose_object_tar.pose.position t.transform.rotation = sm_hcr.userdata.pose_object_tar.pose.orientation try: br.sendTransform(t) except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException): rospy.loginfo( "ERROR: thread_tf_target_object_pose: tf-exeption") with sm_hcr: ### LOGIC ### smach.StateMachine.add('LOGIC', logic.Logic(), transitions={ 'aborted': 'aborted', 'reset': 'RESET', 'move_detect': 'MOVE_DETECT', 'move_search': 'MOVE_SEARCH', 'object_grasp': 'OBJECT_GRASP', 'object_place': 'OBJECT_PLACE' }, remapping={ 'flg_reset': 'flg_reset', 'flg_score': 'flg_score', 'flg_move_detect_done': 'flg_move_detect_done', 'flg_move_search_done': 'flg_move_search_done', 'flg_object_grasp_done': 'flg_object_grasp_done', 'flg_object_place_done': 'flg_object_place_done' }) ### RESET ### smach.StateMachine.add('RESET', logic.Reset(), transitions={'succeeded': 'LOGIC'}, remapping={ 'flg_move_detect_done': 'flg_move_detect_done', 'flg_move_search_done': 'flg_move_search_done', 'flg_move_new_goal': 'flg_move_new_goal', 'flg_object_grasp_done': 'flg_object_grasp_done', 'flg_object_place_done': 'flg_object_place_done', 'pose_base_tar': 'pose_base_tar', 'list_detected_frames_tmp': 'list_detected_frames_tmp', 'list_detected_frames_1': 'list_detected_frames_1', 'list_detected_frames_2': 'list_detected_frames_2', 'list_detected_frames_3': 'list_detected_frames_3' }) ### SCORE ### smach.StateMachine.add('SCORE', logic.Score(), transitions={ 'succeeded': 'LOGIC', 'aborted': 'RESET' }, remapping={ 'list_detected_frames_1': 'list_detected_frames_1', 'list_detected_frames_2': 'list_detected_frames_2', 'list_detected_frames_3': 'list_detected_frames_3' }) ### MOVE_DETECT ### sm_MoveDetect = smach.StateMachine( outcomes=['succeeded', 'aborted'], input_keys=['pose_base_cur', 'list_detected_frames_tmp'], output_keys=[ 'pose_base_cur', 'list_detected_frames_tmp', 'list_detected_frames_1', 'flg_move_detect_done' ]) # sub Detect smach.StateMachine.add('MOVE_DETECT', sm_MoveDetect, { 'succeeded': 'SCORE', 'aborted': 'RESET' }) with sm_MoveDetect: smach.StateMachine.add('DETECT', measure.Detect(), transitions={'succeeded': 'STOP'}) smach.StateMachine.add( 'STOP', move.Stop(), transitions={'succeeded': 'MEASURE'}, remapping={'pose_base_cur': 'pose_base_cur'}) smach.StateMachine.add( 'MEASURE', measure.Measure(), transitions={'succeeded': 'MOVE_DETECT_EXIT'}, remapping={ 'pose_base_cur': 'pose_base_cur', 'list_detected_frames_tmp': 'list_detected_frames_tmp' }) smach.StateMachine.add('MOVE_DETECT_EXIT', logic.MoveDetectExit(), transitions={'succeeded': 'succeeded'}, remapping={ 'list_detected_frames_tmp': 'list_detected_frames_tmp', 'list_detected_frames_1': 'list_detected_frames_1', 'flg_move_detect_done': 'flg_move_detect_done' }) ### MOVE_SEARCH ### sm_MoveSearch = smach.StateMachine( outcomes=['succeeded', 'aborted'], input_keys=[ 'pose_base_tar', 'pose_base_cur', 'pose_object_tar', 'list_detected_frames_tmp' ], output_keys=[ 'pose_base_tar', 'pose_base_cur', 'list_detected_frames_tmp', 'list_detected_frames_2', 'flg_move_search_done' ]) smach.StateMachine.add('MOVE_SEARCH', sm_MoveSearch, { 'succeeded': 'SCORE', 'aborted': 'RESET' }) with sm_MoveSearch: smach.StateMachine.add( 'BASEPOSE_FINDER', logic.BasePoseFinder(), transitions={'succeeded': 'MOVE'}, # transitions={'succeeded':'MEASURE'}, remapping={ 'pose_object_tar': 'pose_object_tar', 'pose_base_tar': 'pose_base_tar' }) smach.StateMachine.add('MOVE', move.Move(), transitions={'succeeded': 'MEASURE'}, remapping={ 'pose_base_tar': 'pose_base_tar', 'pose_base_cur': 'pose_base_cur' }) smach.StateMachine.add( 'MEASURE', measure.Measure(), transitions={'succeeded': 'MOVE_SEARCH_EXIT'}, remapping={ 'pose_base_cur': 'pose_base_cur', 'list_detected_frames_tmp': 'list_detected_frames_tmp' }) smach.StateMachine.add('MOVE_SEARCH_EXIT', logic.MoveSearchExit(), transitions={'succeeded': 'succeeded'}, remapping={ 'list_detected_frames_tmp': 'list_detected_frames_tmp', 'list_detected_frames_2': 'list_detected_frames_2', 'flg_move_search_done': 'flg_move_search_done' }) ### OBJECT_GRASP ### sm_ObjectGrasp = smach.StateMachine( outcomes=['succeeded', 'aborted'], input_keys=['flg_object_grasp_done', 'pose_object_tar'], output_keys=['flg_object_grasp_done']) smach.StateMachine.add('OBJECT_GRASP', sm_ObjectGrasp, { 'succeeded': 'LOGIC', 'aborted': 'RESET' }) with sm_ObjectGrasp: smach.StateMachine.add( 'PICK', grasp.Pick(), transitions={'succeeded': 'OBJECT_GRASP_EXIT'}, remapping={'pose_object_tar': 'pose_object_tar'}) smach.StateMachine.add( 'OBJECT_GRASP_EXIT', logic.ObjectGraspExit(), transitions={'succeeded': 'succeeded'}, remapping={'flg_object_grasp_done': 'flg_object_grasp_done'}) ### OBJECT_PLACE ### sm_ObjectPlace = smach.StateMachine( outcomes=['succeeded', 'aborted'], input_keys=[ 'pose_base_cur', 'pose_base_tar', 'flg_object_place_done' ], output_keys=['pose_base_cur', 'flg_object_place_done']) smach.StateMachine.add('OBJECT_PLACE', sm_ObjectPlace, { 'succeeded': 'LOGIC', 'aborted': 'RESET' }) with sm_ObjectPlace: smach.StateMachine.add('MOVE', move.Move(), transitions={'succeeded': 'PLACE'}, remapping={ 'pose_base_tar': 'pose_base_tar', 'pose_base_cur': 'pose_base_cur' }) smach.StateMachine.add( 'PLACE', grasp.Place(), transitions={'succeeded': 'OBJECT_PLACE_EXIT'}) smach.StateMachine.add( 'OBJECT_PLACE_EXIT', logic.ObjectPlaceExit(), transitions={'succeeded': 'succeeded'}, remapping={'flg_object_place_done': 'flg_object_place_done'}) # # attach a SMACH introspection server sis = smach_ros.IntrospectionServer('hcr_state_machine', sm_hcr, '/HCR_State_Machine') sis.start() # set preempt handler smach_ros.set_preempt_handler(sm_hcr) # Execute SMACH tree in a separate thread so that we can ctrl-c the script thread_tf_tarBasePose = threading.Thread( target=thread_tf_target_object_pose) thread_tf_tarBasePose.start() thread_smach = threading.Thread(target=sm_hcr.execute) thread_smach.start() # signal handler rospy.spin()
help_attrs={'enabled': False}, case_insensitive=True) bot.remove_command('help') print('configuring webserver...') import webserver config.modules['webserver'] = webserver import admin config.modules['admin'] = admin adminclass = admin.Admin(bot) bot.add_cog(adminclass) import logic config.modules['logic'] = logic gameclass = logic.Logic(bot) bot.add_cog(gameclass) class Reload(commands.Cog): def __init__(self, bot): self.bot = bot @commands.command(pass_context=True, no_pm=False) async def reload(self, ctx, *, module: str): if ctx.message.author.id in config.superusers: if module == 'webserver': await config.modules['webserver'].stop() webserver = importlib.reload(config.modules[module]) config.modules['webserver'] = webserver await webserver.start()
def main(): #Initialize Everything sound_controler = Sound() db = database.Database('localhost', 27017) pygame.init() if sys.version_info[0] < 3: pygame.display.set_caption((u'武将大乱斗').encode('utf-8')) else: pygame.display.set_caption(u'武将大乱斗') hero.initiate_hero_pool(db) current_map = Map(name='map-1',team_count=3) sprite.Sprite.current_map = current_map screen = pygame.display.set_mode((current_map.map_width + 256, current_map.map_height)) current_map.init_terrain_mask() skill.load_skill_images() gui_controller = gui.Gui(current_map, screen) current_mission = mission.test_mission #yun = pawn.Pawn((9,6) ,pawn.DIRECTION_RIGHT , pawn.ARM_MELEE , pawn.MOBILE_MOUNT, hero.hero_pool[0] , 0 , True , False) #lvbu = pawn.Pawn((6,5) , pawn.DIRECTION_LEFT , pawn.ARM_MELEE , pawn.MOBILE_MOUNT, hero.hero_pool[1] , 1 , False , True) #zhouyu = pawn.Pawn((6,6) , pawn.DIRECTION_LEFT , pawn.ARM_MELEE , pawn.MOBILE_WALK, hero.hero_pool[2] , 1 , False , True) #guanyu = pawn.Pawn((8,9) , pawn.DIRECTION_LEFT , pawn.ARM_MELEE , pawn.MOBILE_MOUNT, hero.hero_pool[3] , 0 , True , False) #weiwen = pawn.Pawn((10,9) , pawn.DIRECTION_LEFT , pawn.ARM_MELEE , pawn.MOBILE_WALK, hero.hero_pool[4] , 0 , True , False) #yun.action_turn = 0 #lvbu.action_turn = 1 #zhouyu.action_turn = 1 #guanyu.action_turn = 0 # #pawn_list = [yun , lvbu , zhouyu , guanyu , weiwen] pawn_list = [] for roster in current_mission.player_roster: p = pawn.Pawn(roster[1], roster[2], roster[3], roster[4], hero.hero_pool[roster[0]], roster[5], 0, roster[6], roster[7]) pawn_list.append(p) for roster in current_mission.friend_roster: h = copy.copy(hero.hero_pool[roster[0]]) p = pawn.Pawn(roster[1], roster[2], roster[3], roster[4], h, roster[5], 1, roster[6], roster[7]) p.ai_group = roster[9][0] p.is_leader = roster[9][1] p.ai_strategy = roster[10] pawn_list.append(p) for roster in current_mission.enemy_roster: h = copy.copy(hero.hero_pool[roster[0]]) p = pawn.Pawn(roster[1], roster[2], roster[3], roster[4], h, roster[5], 2, roster[6], roster[7]) p.persuade = roster[8] p.ai_group = roster[9][0] p.is_leader = roster[9][1] p.ai_strategy = roster[10] pawn_list.append(p) selected_pawn = None control = Control(current_map) gui_controller.side_menu(selected_pawn) logic_controller = logic.Logic(current_map, pawn_list) fight_logic_controller = fight_logic.FightLogic(current_map, pawn_list) skill.fight_logic_controller = fight_logic_controller logic_controller.process_action_queue() logic_controller.turn_team = 0 logic.control = control logic.fight_logic_controller = fight_logic_controller ai.logic_controller = logic_controller gui.logic_controller = logic_controller info_before_move = (None, None, None) ai_controller = ai.AI(pawn_list) logic_controller.new_turn() current_round = 1 last_turn_team = 0 while True: config.clock = pygame.time.Clock().tick(config.FPS) current_map.render() logic_controller.update_terrain_mask() skill.fight_logic_controller.trigger_passive_skills_realtime() logic_controller.update_pawn_status() for p in logic_controller.pawn_list: if p.hero.alive: p.render() else: pawn_list.remove(p) #FOR ENEMY AI if logic_controller.turn_team != 0: for event in pygame.event.get(): if event.type == QUIT: return flag = False for p in ai_controller.pawn_list: if p.turn_team != logic_controller.turn_team: continue if not p.turn_finished and p.has_ai: if control.status == control.CONTROL_STATUS_IDlE: ai_controller.take_action(p) if p and p.next_move: top = p.next_move[0] action_type = top[0] action_target = top[1] if action_type == ai.AI_ACTION_MOVE: logic_controller.process_player_action(p, action_target) control.status = control.CONTROL_STATUS_PROCESSING_PLAYER_ACTION elif action_type == ai.AI_ACTION_ATTACK: logic_controller.process_player_action(p, action_target , MENU_ORDER_ATTACK) control.status = control.CONTROL_STATUS_PROCESSING_PLAYER_ACTION #print p.hero.name.encode('utf-8'), ' not finished', p.next_move, 'control status: ', control.status , logic_controller.turn_team , p.turn_team flag = True break elif control.status == control.CONTROL_STATUS_PAWN_MOVED: control.status = control.CONTROL_STATUS_PROCESSING_PLAYER_ACTION flag = True if not flag: control.status = control.CONTROL_STATUS_TURN_FINISHING if control.status == control.CONTROL_STATUS_PROCESSING_PLAYER_ACTION: if not logic_controller.process_action_queue(): control.status = control.CONTROL_STATUS_IDlE else: for event in pygame.event.get(): if event.type == QUIT: return if event.type == pygame.KEYDOWN: if event.key == pygame.K_p: if debug and selected_pawn: logger( selected_pawn.status_info() ) if control.status == control.CONTROL_STATUS_MENU_ATTACK_CHOOSE: target = gui_controller.get_grid_on_mouse() target_type = logic_controller.is_valid_target(selected_pawn, target, pawn.ACTION_ATTACK, ) elif control.status == control.CONTROL_STATUS_MENU_OPENED: target_type = gui_controller.is_mouse_on_menu() else: target = gui_controller.get_grid_on_mouse() target_type = logic_controller.get_target_type(0, target) if event.type == KEYDOWN or event.type == MOUSEBUTTONDOWN or event.type == MOUSEBUTTONUP: control.event_queue.append((event, target_type)) if control.status == control.CONTROL_STATUS_MENU_OPENED: #当鼠标在地图上右键, 打开菜单 if gui_controller.menu is None: gui_controller.build_menu(None) gui_controller.menu.display() elif control.status == control.CONTROL_STATUS_MENU_ITEM_SELECTING: gui_controller.menu.display(1) elif control.status == control.CONTROL_STATUS_PAWN_MOVED or control.status == control.CONTROL_STATUS_MENU_ATTACK_CHOOSE_CANCELED: gui_controller.build_menu(selected_pawn) control.status = control.CONTROL_STATUS_MENU_OPENED elif control.status == control.CONTROL_STATUS_MENU_CANCEL: #战斗菜单被取消后, 单位回到操作前的状态(包括位置,方向) gui_controller.menu = None if selected_pawn: logic_controller.current_map.map_collision_info[selected_pawn.position[0]][ selected_pawn.position[1]] = battle_map.COLLISION_INFO_EMPTY selected_pawn.position = info_before_move[0] selected_pawn.direction = info_before_move[1] selected_pawn.move_count = info_before_move[2] selected_pawn.render_position = selected_pawn.get_render_position(selected_pawn.position) logic_controller.current_map.map_collision_info[selected_pawn.position[0]][ selected_pawn.position[1]] = battle_map.COLLISION_INFO_OCCUPIED control.status = control.CONTROL_STATUS_IDlE elif control.status == control.CONTROL_STATUS_MENU_ITEM_SELECTED: control.status = control.get_control_status_by_menu_order(gui_controller.selected_menu_item) logic_controller.process_menu_order(selected_pawn, gui_controller.selected_menu_item) elif control.status == Control.CONTROL_STATUS_PROCESS_PLAYER_ACTION: if target and selected_pawn: order = None if gui_controller.selected_menu_item: order = gui_controller.selected_menu_item.order logic_controller.process_player_action(selected_pawn, target , order) control.status = Control.CONTROL_STATUS_PROCESSING_PLAYER_ACTION elif control.status == control.CONTROL_STATUS_PAWN_SELECTED: if selected_pawn: info_before_move = (selected_pawn.position, selected_pawn.direction , selected_pawn.move_count) valid_move = logic_controller.get_valid_move(selected_pawn) gui_controller.highlight_valid_move(valid_move, selected_pawn.controllable) attack_range = logic_controller.get_attack_range_grids(selected_pawn) gui_controller.draw_attack_frame_on_target(attack_range) elif control.status == control.CONTROL_STATUS_PROCESSING_PLAYER_ACTION: if not logic_controller.process_action_queue(): control.status = control.CONTROL_STATUS_IDlE elif control.status == control.CONTROL_STATUS_MENU_ATTACK_CHOOSE: valid_target = logic_controller.get_valid_target(selected_pawn) gui_controller.highlight_valid_target(valid_target) attack_range = logic_controller.get_attack_range_grids(selected_pawn) gui_controller.draw_attack_frame_on_target(attack_range) if selected_pawn.taunted_to: gui_controller.highlight_taunting_target(valid_target) elif control.status == control.CONTROL_STATUS_MENU_PERSUADE_CHOOSE: valid_target = logic_controller.get_persuade_target(selected_pawn) gui_controller.highlight_valid_target(valid_target) else: selected_pawn = gui_controller.get_selected_pawn(pawn_list) if control.status == control.CONTROL_STATUS_TURN_FINISHING: if (gui_controller.switch_turn(logic_controller.turn_team)): logic_controller.end_turn() control.status = control.CONTROL_STATUS_IDlE else: control.process_event() if control.status not in ( control.CONTROL_STATUS_MENU_OPENED, control.CONTROL_STATUS_MENU_BUILD, control.CONTROL_STATUS_MENU_ITEM_SELECTING ): gui_controller.menu = None gui_controller.draw_selection_frame() gui_controller.side_menu(selected_pawn) render_queue.sort(key=lambda surface:surface[0]) while render_queue: top = render_queue.pop() if top[1] and top[2]: screen.blit(top[1], top[2]) gui_controller.draw_border() pygame.display.update()