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()
