def f():
s = script.Script()
x = random.randint(0, 316)
y = random.randint(0, 42)
print('CALLED WITH ' + str(x) + ' ' + str(y))
s.add_action(scumm.actions.Walk(id=id, pos=[x, y]))
return s
def init():
global s
if arm.c.board.is_open == False:
arm.c.connect() #Port will be opened if successful
robot.highArm.home = 2500
s = script.Script(test, call)
pass
def start(self, user):
if self.script == 0:
self.script = script.Script(user, self.contentFrame)
self.thread = threading.Thread(target=self.script.start)
self.thread.start()
def deserialize(self, elem):
"""Loads this class from an element tree representation"""
assert (elem.tag in ("stage", "sprite"))
# children
costumes_node = elem.find("costumes")
if costumes_node:
self.costumes = media.Costumes()
self.costumes.deserialize(costumes_node)
else:
self.costumes = None
self.sounds = elem.find("sounds")
self.variables.deserialize(elem.find("variables"))
self.blocks = get_blocks(elem)
self.scripts = []
event_loop = None
if self.project:
event_loop = self.project.event_loop
for item in elem.find("scripts"):
new_script = script.Script()
new_script.deserialize(item)
self.scripts.append(new_script)
if event_loop:
event_loop.queue(new_script, self)
def __init__(self, game, element):
RenderedNPC.__init__(self) #init the renderer class
self.id = element.getAttribute("id")
self.game = game
t = element.getAttribute("pos").split(",") #load tile position
self.tile_pos = [int(t[0].strip()), int(t[1].strip())]
self.game.set_obj_pos(self, self.tile_pos)
self.pos = [((self.tile_pos[0] - 1) * 16) + 8,
(self.tile_pos[1] - 1) * 16] #set real position
self.interacting = False #mark that we're not interacting
self.should_interact = False #and that we shouldn't be yet
self.interact_pos = 0 #position of current interaction
#load an animator
self.animator = animation.AnimationGroup(
game.g, self,
element.getElementsByTagName("anim")[0].getAttribute("file"))
self.animator.set_animation("stand_down") #set animation
self.animator.update() #update animation once
#and a movement manager
self.move_manager = MovementManager(self)
#load movement list
self.move_manager.load_move_dom(
element.getElementsByTagName("movement")[0])
self.script_manager = script.Script(self) #initialize script manager
self.interaction_script = element.getElementsByTagName("script")[
0] #load script
if len(element.getElementsByTagName(
"invisible")) == 1: #if there's an invisibility tag
self.visible = False #mark ourselves as invisible
def record_frida(self):
with open('scripts/recorder.js', 'r') as f:
self.script = script.Script(self.session, f.read())
self.script.set_on_message(self.on_message)
self.script.rpc.record_touch_and_key()
self.script.rpc.record_location()
self.script.rpc.record_sensor()
self.script.rpc.record_time_sync()
def m3(x: float, y: float):
a = entity.Sprite(model='sprites/01/score100',
pos=(x * vars.tile_size, (y + 1) * vars.tile_size, 0))
main = example.get('main')
id = main.add(a)
s = script.Script()
s.add_action(act.Move(speed=100, by=[0, 64], entity_id=id))
s.add_action(act.RemoveEntity(id))
example.play(s)
def __init__(self, raw: bool, session: frida.core.Session,
frida_device: frida.core.Device, pid, u2_device: u2.Device):
self.raw = raw
self.session = session
self.frida_device = frida_device
self.pid = pid
self.u2_device = u2_device
self.screen_width, self.screen_height = u2_device.window_size()
self.original_screen_width, self.original_screen_height = None, None
with open('scripts/replayer.js', 'r') as f:
s = script.Script(self.session, f.read())
s.set_on_message(self.on_message)
self.rpc = s.rpc
def m1(x: float, y: float):
a = None
if vars.state == 0:
a = monkey.engine.get_item_factory('moving_bonus')(
model='sprites/01/mushroom', tag=vars.tags.mushroom,
speed=30)(x, y, -1)
else:
a = monkey.engine.get_item_factory('moving_bonus')(
model='sprites/01/flower', tag=vars.tags.mushroom, speed=0)(x, y,
-1)
main = example.get('main')
id = main.add(a)
s = script.Script()
s.add_action(act.Move(entity_id=id, speed=10, by=[0, 16]))
s.add_action(act.SetState(entity_id=id, state='walk'))
example.play(s)
def execute_block_and_return_result(self, sprite, xml_for_block, client):
"""Runs a block and tells client the result"""
# We seem to get command blocks wrapped up in scripts
# and reporter blocks as blocks
print xml_for_block
obj = factory.deserialize_xml(xml_for_block)
if isinstance(obj, script.Script):
result = obj.run(sprite)
# result is almost certainly 'None'
else:
empty_script = script.Script()
result = obj.evaluate(sprite, empty_script)
if result is not None:
result_xml = factory.xml_for_object(result)
client.ws.send("execute_block_result %s" % result_xml)
def parse_script_file(self, script_file):
count = 1
blocks = open(script_file, 'r').read().split('%%%')
for b in blocks:
if len(b.split('%%')) == 2:
args = b.split('%%')[0].split('\n')
text = b.split('%%')[1]
tmp = script.Script()
tmp.text = text
for pair in args:
if pair is not None:
pair = pair.split(' ')
if len(pair) > 1:
tmp.__dict__[pair[0].lower()] = ' '.join(pair[1:])
self.scripts[str(count) + tmp.id] = tmp
count += 1
def m2(x: float, y: float):
def score():
m3(x, y + 1)
a = entity.Sprite(model='sprites/01/flyingcoin',
pos=(x * vars.tile_size, (y + 1) * vars.tile_size, 0))
main = example.get('main')
id = main.add(a)
s = script.Script()
s.add_action(
act.MoveAccelerated(v0=[0, 100],
a=[0, -100],
yStop=(y * vars.tile_size) + 16,
entity_id=id))
s.add_action(act.RemoveEntity(id))
s.add_action(act.CallFunc(score))
example.play(s)
def __init__(self, game, element):
self.id = element.getAttribute("id")
self.game = game
#get our position
t = element.getAttribute("pos").split(",")
self.tile_pos = (int(t[0].strip()), int(t[1].strip())) #store position
#get our size
t = element.getAttribute("size").split(",")
try:
self.size = (int(t[0].strip()), int(t[1].strip()))
except:
self.size = (1, 1) #default to a size of one
self.script = element.getElementsByTagName("script")[
0] #load our script
self.script_manager = script.Script(self) #and create a script manager
self.visible = False #we're not rendering anything
self.running = False #whether we're currently interacting
self.touched = False #whether the player is touching us
def setup(self, game):
self.symbols = symbols.Symbols(game, self)
self.script = None
self.result = False
self.currentCmd = 0
self.caller = None
self.waitingFor = None
#determine behaviour scripts
root = data.getTreeRoot(globs.BEHAVIOURS)
self.behaviours = {}
for behaviourNode in data.getChildren(root, "behaviour"):
i = data.getAttr(behaviourNode, "index", data.D_INT)
s = data.getChild(behaviourNode, "script")
self.behaviours[i] = script.Script(s, False)
def f(e, x, y):
new_model = vars.player_info[new_player]
if new_model == vars.current_player:
ui2 = example.get('ui2')
example.get('ui').setActive(True)
ui2.clear()
ui2.setActive(False)
else:
# save position of current player
player = example.get('player')
vars.items[vars.current_player]['pos'] = [player.x, player.y]
dir = player.anim[-1]
if dir == 'e' and player.flipx:
dir = 'w'
vars.items[vars.current_player]['dir'] = dir
# get next room
vars.current_player = new_model
s = script.Script()
s.add_action(
actions.ChangeRoom(room=vars.items[new_model]['room']))
example.play(s)
def on_enter(self):
"""Create the Theater"""
# The theater is the Sypral Group responsible for holding the
# backdrop, actors, and subtitler. It is held by the Script.
self.theater = spyral.sprite.Group(self.theaterCamera)
bg = spyral.util.new_surface(geom['screen'].size)
bg.fill(colors['bg'])
self.screenCamera.set_background(bg)
self.script = script.Script()
self.script.setTheater(self.theater)
self.script.setRecorder(self.recorder)
self.script.default()
self.gui = gui.App(theme=pgu['theme'])
self.guiContainer = gui.Container(align=-1, valign=-1)
if geom['frame'] != geom['screen']:
images['main-background'] = spyral.util.load_image(
images['main-background'])
croppedFrame = spyral.util.new_surface(geom['screen'].size)
croppedFrame.blit(images['main-background'],
geom['frame'],
area=geom['screen'])
images['main-background'] = croppedFrame
self.guiContainer.add(gui.Image(images['main-background']),
*geom['screen'].topleft)
self.guiContainer.add(gui.Image(images['main-tab']),
*geom['tab'].topleft)
# Tab is used to switch between the different panels
self.tab = tab.Tab(self.script)
# Add the tab and panel holder to the screen
self.guiContainer.add(self.tab, *geom['tab'].topleft)
self.guiContainer.add(self.tab.panelHolder, *geom['panel'].topleft)
self.script.gui = self.gui
self.gui.init(self.guiContainer)
def testPostScript():
reload(userchoices)
# Setup our fake '/bin/sh' executable that just checks its args.
def postBinSh(argv):
assert argv[0] == '/bin/sh'
assert argv[1] == '/tmp/ks-script'
postBinSh.ran = True
return 0
postBinSh.ran = False
fauxroot.EXEC_FUNCTIONS['/bin/sh'] = postBinSh
# setup a temporary directory for testing
tmproot = tempfile.mkdtemp(suffix='test_script')
try:
os.makedirs(os.path.join(tmproot, 'mnt/sysimage', 'tmp'))
os.chroot(tmproot)
# set a script to run.
userchoices.addPostScript(
script.Script(
'''#! /bin/sh
echo Hello, World!
''', '/bin/sh', True, 0, False))
context = applychoices.Context(applychoices.ProgressCallback())
script.hostActionPostScript(context)
assert postBinSh.ran, "the post script was not run?!"
assert not os.path.exists(os.path.join(
'mnt/sysimage', 'tmp', 'ks-script')), \
"post script was not generated?"
finally:
fauxroot.FAUXROOT = None # clear out our fake chroot
os.removedirs(os.path.join(tmproot, 'mnt/sysimage', 'tmp'))
del fauxroot.EXEC_FUNCTIONS['/bin/sh']
def add_scripts():
try:
saved = load_data()
except:
saved = {}
for each_file in os.listdir("./scripts/"):
file_name = os.path.splitext(os.path.basename(each_file))
if file_name[1] == ".py" \
and each_file != "__init__.py" \
and each_file != "template.py":
script_name = file_name[0]
if script_name not in script_list.keys():
script_list[script_name] = script.Script(script_name)
if script_name in saved: #then read in old values
#add back any settings
if script_list[script_name].get_trigger_type() != 'call':
saved_setting = saved[script_name]['trigger_settings']
for setting in saved_setting:
script_list[script_name].set_trigger_setting(setting, saved_setting[setting])
#set to last enabled state
if saved[script_name]['enabled']:
script_list[script_name].set_enabled()
def start(self):
"""Start the game."""
if self.game_state != GameState.STARTING:
if self.game_state == GameState.RUNNING:
print('Game already running.')
else:
print('Start game cancelled.')
return
self.game_state = GameState.RUNNING
print('Game started.')
# select a random dealer
occupied_seats = \
[i for i, p in enumerate(self.seats) if p and not p.sitting_out]
self.dealer = random.choice(occupied_seats)
# Let everyone off paying for the first hand!
# (Except the blinds)
for player in self.seats:
if player is not None and not player.sitting_out:
player.paid_state = player.PAID_SB_BB
# Start the actual game
scr = script.Script(self)
if self.handler:
self.handler.start(scr)
count = None
output = codecs.open(
os.path.split(current_file_path)[0] + "/output/output.html", "w",
"utf-8")
tng_actors = {
member: actor.Actor(all_tng_text, member, cast, 3)
for member in cast
}
html = "<html lang='en'>\n <head>\n <title>B-9 Indifference</title>\n " + \
"<meta charset='UTF-8'>\n " + \
"<link href='styles.css' rel='stylesheet'/>\n </head>\n <body>"
word_count = count
script = script.Script(1000, tng_actors)
while word_count > 0:
episode_text = script.generate_episode()
episode_length = len(
list(
filter(None,
re.split(r'\s+', re.sub(r'<(.*?)>+', '',
episode_text)))))
html += episode_text
word_count -= episode_length
html += "</body>\n</html>"
soup = Soup(html, 'html.parser')
print(soup.prettify(), file=output)
output.close()
except Exception, e:
ts.log_error('Test script exception: %s' % traceback.format_exc())
rc = 1
sys.exit(rc)
info = script.ScriptInfo(name=os.path.basename(__file__), run=run, version='1.0.0')
#Grid simulator
pvsim.params(info)
def script_info():
return info
if __name__ == "__main__":
# stand alone invocation
config_file = None
if len(sys.argv) > 1:
config_file = sys.argv[1]
test_script = script.Script(info=script_info(), config_file=config_file)
run(test_script)
def walkto(x, y):
s = script.Script(uid='_main')
s.add_action(scumm.actions.Walk(pos=[x, y], tag='player'))
example.play(s)
return self.v_max_param
def v_nom(self):
return self.v_nom_param
if __name__ == "__main__":
import script
d = {'gridsim.chroma.phases':'3',
'gridsim.chroma.v_nom':'120.0',
'gridsim.chroma.visa_path':'C:/Program Files (x86)/IVI Foundation/VISA/WinNT/agvisa/agbin/visa32.dll',
'gridsim.chroma.visa_device':'USB0::0x0A69::0x086C::662040000329::0::INSTR'}
'''
ts._param_value('phases')
self.v_nom_param = ts._param_value('v_nom')
self.v_max_param = ts._param_value('v_max')
self.i_max_param = ts._param_value('i_max')
self.freq_param = ts._param_value('freq')
self.comm = ts._param_value('comm')
self.visa_device = ts._param_value('visa_device')
self.visa_path = ts._param_value('visa_path')
'''
ts = script.Script(params = d)
GridSim(ts)
GridSim.config()
pass
import script from param import Par from au.gov.ansto.bragg.nbi.scripting import ScriptModel __model__ = ScriptModel.getModel(script.__script_model_id__) __script__ = script.Script(__model__) print 'manager imported'
def pane(id):
s = script.Script(loop=0)
s.add_action(actions.RunScript(func=random_move(id)), id=0)
example.play(s)
c.login(config["USERNAME"], config["PASSWORD"], config["SMTP_ADDRESS"],
config["IMAP_ADDRESS"], int(config["SMTP_PORT"]),
int(config["IMAP_PORT"]))
print("Logged In")
AllowedModules = [x.strip(" ") for x in config["ALLOWED_MODULES"].split(",")]
run = True
for m in c.getMail():
break
if m.subject.split(":")[0].strip(
" ") == "SERVICE INPUT" and m.subject.split(":")[1].strip(
" ") == ID:
c.delMail(m)
while run:
for m in c.getMail():
if m.subject.split(":")[0].strip(
" ") == "SERVICE INPUT" and m.subject.split(":")[1].strip(
" ") == ID:
cmd = Cmdlet(m)
s = script.Script(cmd, AllowedModules)
s.initialize(c)
s.execute()
c.delMail(m)
if m.subject.split(":")[0].strip(
" ") == "SERVICE SHUTDOWN" and m.subject.split(":")[1].strip(
" ") == ID:
run = False
c.delMail(m)
sleep(1)
c.disconnect()
print("Done")
from helper import little_endian_to_int, big_endian_to_int
from binascii import unhexlify, hexlify
import script
import helper
from tx import TxIn, TxOut, Tx
key_pairs = [x.split('/') for x in map(str.strip,raw.split('\n'))]
key_pairs = [(S256Point.parse(unhexlify(sec)), PrivateKey.parse(wif, compressed=False)) for sec, wif in key_pairs]
assert all(p == pk.point for p,pk in key_pairs)
pubkeys = [p for p, _ in key_pairs]
OP_n = lambda n: 0x51 + n - 1
n_required = 2
elements = [OP_n(n_required)] + [pk.sec(compressed=False) for pk in pubkeys] + [OP_n(len(pubkeys))] + [174]
redeemScript = script.Script(elements)
address=helper.h160_to_p2sh_address(helper.hash160(redeemScript.serialize()), testnet=False)
redeemScript=hexlify(redeemScript.serialize())
assert address=="3QJmV3qfvL9SuYo34YihAf3sRCW3qSinyC"
assert redeemScript=="52410491bba2510912a5bd37da1fb5b1673010e43d2c6d812c514e91bfa9f2eb129e1c183329db55bd868e209aac2fbc02cb33d98fe74bf23f0c235d6126b1d8334f864104865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac09ef122b1a986818a7cb624532f062c1d1f8722084861c5c3291ccffef4ec687441048d2455d2403e08708fc1f556002f1b6cd83f992d085097f9974ab08a28838f07896fbab08f39495e15fa6fad6edbfb1e754e35fa1c7844c41f322a1863d4621353ae".encode('ascii')
print(hexlify(helper.hash160(unhexlify(redeemScript))))
prev_tx = 'd6f72aab8ff86ff6289842a0424319bf2ddba85dc7c52757912297f948286389'
prev_index = 0
tx_in = TxIn(unhexlify(prev_tx), prev_index, b'')
h160 = helper.decode_base58_checksum(address)[1:]
tx_out = TxOut(int(0.01*100e6), script_pubkey=helper.p2sh_script(h160))
t = Tx(version=1, tx_ins=[tx_in], tx_outs=[tx_out], locktime=0, testnet=False)
raw_transaction = hexlify(t.serialize())
def run(self, args):
args = args.split()
args.insert(0, 'script.py')
return script.Script().run(args)
info = script.ScriptInfo(name=os.path.basename(__file__),
run=run,
version='1.0.0')
# DER
der.params(info)
info.logo('sunspec.gif')
def script_info():
return info
if __name__ == "__main__":
# stand alone invocation
config_file = None
if len(sys.argv) > 1:
config_file = sys.argv[1]
params = None
test_script = script.Script(info=script_info(),
config_file=config_file,
params=params)
run(test_script)
def parse(path):
f = open(path, 'r')
script = s.Script()
# Get characters!
for line in f:
if line.strip() == "CAST": break
print "Cast:"
for line in f:
if ("STAR TREK" in line):
break
line = line.strip()
if line == "": continue
chars = re.split("\s\s+", line)
for char in chars:
if char == "Non-Speaking": continue # Special case!!!
script.addCharacter(char)
print "Character:", char
# Get sets!
for line in f:
if line.strip() == "SETS": break
print "Sets:"
for line in f:
if ("STAR TREK" in line):
break
line = line.strip()
if line == "": continue
sets = re.split("\s\s+", line)
for setting in sets:
if script.addSetting(setting):
print "Set:", setting
# Get scenes!
scenetexts = []
curscene = []
for line in f:
if line.strip() == "THE END" or re.match("^\d+.*$", line):
if "CONTINUED" in line or "ANGLE" in line or \
not ("INT." in line or "EXT." in line or "OMITTED" in line):
print ":::", line
curscene[0] = scenetexts[-1][0]
scenetexts.append(curscene)
curscene = []
if line.strip() == "THE END":
break
curscene.append(line)
scenetexts = scenetexts[1:] # Remove some crap.
seenchars = set()
for text in scenetexts:
descr = text[0].strip()
setting = script.getSetting(descr)
print descr, "==>", setting.name
scene = s.Scene(text[0])
scene.setSetting(setting)
actuallines = []
lastline = (0, "")
for line in text[1:]:
tabs = 0
for rune in line:
if rune == "\t":
tabs += 1
else:
break
line = line.strip()
if tabs == 0 or line == "":
continue
if tabs == lastline[0]:
lastline = (tabs, lastline[1] + " " + line)
else:
actuallines.append(lastline)
lastline = (tabs, line)
if lastline[0] != 0:
actuallines.append(lastline)
curchar = None
for line in actuallines:
tabs, line = line
if tabs == 1: # Stage direction
direction = s.StageDirection(line)
scene.addDirection(direction)
sentences = line.split('.')
for sentence in sentences:
sentence = re.sub('[^\s\w]', '', sentence.upper())
words = sentence.split()
action = s.BACKGROUND
for act in [
keywords[k] for k in keywords if k in sentence
]:
action = act
break
chars = set()
for character in script.characters.values():
if character.name in words:
chars.add(character)
for char in chars:
direction.addAction(action, char)
print(action, char.name)
elif tabs == 3: # Dialog
scene.addDirection(s.Dialog(curchar, line))
elif tabs == 4: # Stage direction for character
scene.addDirection(s.StageDirection(line, character=curchar))
elif tabs == 5: # Character
curchar = script.getCharacter(line)
if not line in seenchars:
print line, "==>", curchar.name
seenchars.add(line)
else:
pass # Eh, this probably shouldn't happen. Whatever.
script.addScene(scene)
return script
