class Rock(Sprite):
cell_x = export(int)
cell_y = export(int)
@export(int)
@property
def value(self):
return self._value
@value.setter
def value(self, val):
self._value = val
if val == WHITE:
self.set_modulate(Color(1.0, 1.0, 1.0, 1))
self.visible = True
elif val == BLACK:
self.set_modulate(Color(0.3, 0.3, 0.3, 1))
self.visible = True
elif val == UNKNOWN:
self.set_modulate(Color(0.1, 0.8, 0.8, 1))
self.visible = True
elif val == EMPTY:
self.visible = False
def _ready(self):
self.value = -1
class Paddle(Area2D):
left = export(bool, default=False)
action_prefix = export(str, default='')
def _ready(self):
self.motion = 0
self.can_move = True
self.screen_size = self.get_viewport_rect().size
self.set_process(True)
def _process(self, delta):
motion = 0
if (Input.is_action_pressed(self.action_prefix + "_move_up")):
motion -= 1
elif (Input.is_action_pressed(self.action_prefix + "_move_down")):
motion += 1
motion *= MOTION_SPEED
if self.can_move:
self.translate(Vector2(0, motion * delta))
# set screen limits
if self.position.y < 0:
self.position.y = 0
elif self.position.y > self.screen_size.y:
self.position.y = self.screen_size.y
def _on_paddle_area_enter(self, area):
# random for new direction generated on each peer
area.bounce(self.left, random())
class Pong(Node2D):
a = export(int)
b = export(str, default='foo')
game_finished = signal()
def _ready(self):
self.score_left = 0
self.score_right = 0
# let each paddle know which one is left, too
self.get_node("player1").left
self.get_node("player1").left = True
self.get_node("player2").left = False
self.get_node("player1").action_prefix = 'p1'
self.get_node("player2").action_prefix = 'p2'
def update_score(self, add_to_left):
if add_to_left:
self.score_left += 1
self.get_node("score_left").set_text(str(self.score_left))
else:
self.score_right += 1
self.get_node("score_right").set_text(str(self.score_right))
game_ended = False
if self.score_left == SCORE_TO_WIN:
self.get_node("winner_left").show()
game_ended = True
elif self.score_right == SCORE_TO_WIN:
self.get_node("winner_right").show()
game_ended = True
if game_ended:
self.get_node("ball").stop()
self.get_node("player1").can_move = False
self.get_node("player2").can_move = False
class global_py(Node):
accessors = export(Array, default=Array())
type = export(str, default="Python")
def set_accessed(self, name):
self.accessors.append(name)
class player(KinematicBody2D): # member variables here, example: a = export(int) b = export(str, default='foo') def _ready(self): """ Called every time the node is added to the scene. Initialization here. """ pass
class new_script(Node):
# member variables here, example:
a = export(int)
b = export(str, default='foo')
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
pass
class Main(Node):
# member variables here, example:
a = export(int)
b = export(str, default='foo')
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
array_np = np.arange(15).reshape(3, 5)
class CFGDownloader(HTTPRequest):
# member variables here, example:
a = export(int)
b = export(str, default='foo')
def _ready(self):
os.system("echo TESST")
"""
Called every time the node is added to the scene.
Initialization here.
"""
pass
class Mob(RigidBody2D):
min_speed = export(int, default=150) # Minimum speed range.
max_speed = export(int, default=250) # Maximum speed range.
def _ready(self):
animated_sprite = self.get_node("AnimatedSprite")
mob_types = animated_sprite.frames.get_animation_names()
animated_sprite.animation = mob_types[randrange(len(mob_types))]
def _on_VisibilityNotifier2D_screen_exited(self):
self.queue_free()
class MyExportedCls(Node2D):
# member variables here, example:
a = export(int)
b = export(str)
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
print("Hello World !")
print('OLD ROT:', self.get_rot())
self.rotate(1.5)
print('NEW ROT:', self.get_rot())
class Polygon2D(Polygon2D):
# member variables here, example:
a = export(int)
b = export(str, default='foo')
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
self.set_process(True)
def _process(self, delta):
self.translate(Vector2(10, 10) * delta)
class SkryptPython(gd.Polygon2D):
# member variables here, example:
a = gd.export(int, default=150)
b = gd.export(str, default='foo')
Pole = gd.export(int, default=333)
pole2 = gd.export(int, default=450)
x = 13
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
print(f"Oto python! {self.get_node('polygon2d')} {self.a} {self.b} {self.Pole} {self.pole2}")
class Node(Node):
# member variables here, example:
a = export(int)
b = export(str, default='foo')
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
print("Hello from python")
self.get_node("../DirectionalLight").queue_free()
self.get_node("../DirectionalLight2").queue_free()
print_formatted_text("Prompt toolkit alive and well!")
class PyNode(Node):
_ready_called = False
_overloaded_by_child_prop_value = None
def _ready(self):
self._ready_called = True
def is_ready_called(self):
return self._ready_called
def meth(self, attr):
return attr
def overloaded_by_child_meth(self, attr):
return attr
@staticmethod
def static_meth(attr):
return f"static:{attr}"
prop = export(int)
@export(str, default="default")
@property
def overloaded_by_child_prop(self):
return self._overloaded_by_child_prop_value
@overloaded_by_child_prop.setter
def overloaded_by_child_prop(self, value):
self._overloaded_by_child_prop_value = value
def print_tree(self):
# Overloaded native method
return """
class Player(Area2D):
speed = export(int, default=420)
screen_size = None
hit = signal()
def _ready(self):
self.screen_size = self.get_viewport_rect().size
self.hide()
def _process(self, delta):
velocity = Vector2()
if Input.is_action_pressed("ui_right"):
velocity.x += 1
if Input.is_action_pressed("ui_left"):
velocity.x -= 1
if Input.is_action_pressed("ui_down"):
velocity.y += 1
if Input.is_action_pressed("ui_up"):
velocity.y -= 1
animated_sprite = self.get_node("AnimatedSprite")
if velocity.length() > 0:
velocity = velocity.normalized() * self.speed
animated_sprite.play()
else:
animated_sprite.stop()
self.position += velocity * delta
# NOTE: It seems you can't set the self.position's x and y values
# so you'll need to assign a new vector instead.
self.position = Vector2(
clamp(self.position.x, 0, self.screen_size.x),
clamp(self.position.y, 0, self.screen_size.y),
)
if velocity.x != 0:
animated_sprite.animation = "walk"
animated_sprite.flip_v = False
animated_sprite.flip_h = velocity.x < 0
elif velocity.y != 0:
animated_sprite.animation = "up"
animated_sprite.flip_v = velocity.y > 0
def _on_Player_body_entered(self, body):
self.hide() # Player disappears after being hit.
self.call('emit_signal', 'hit')
# Ensures that the collission shape is not disabled while
# the Godot is still in the middle of collision processing.
self.get_node("CollisionShape2D").set_deferred("disabled", True)
def start(self, pos):
self.position = pos
self.show()
self.get_node("CollisionShape2D").disabled = False
class PythonTest(Node2D):
# member variables here, example:
a = export(int)
b = export(str, default='foo')
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
#print ('Hello World!')
pass
def _process(self, delta):
globals.hello = "Hello World!?!{}".format(numpy.zeros(3))
class Node(Node2D):
# member variables here, example:
a = export(int)
b = export(str, default='foo')
def _ready(self):
'''ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()
ts.plot()
plt.show()'''
data_file1 = pd.read_csv("Data/data11.csv")
data_file2 = pd.read_csv("Data/data12.csv")
data = pd.concat([data_file1.iloc[1:], data_file2[1:]],
axis=0,
ignore_index=True)
data.drop(columns=[
'Date', 'Time GMT -4', 'Latitude', 'Longitude', 'Unnamed: 16'
],
inplace=True)
data['Timestamp'] = pd.to_datetime(data.Timestamp, unit='ms')
data.set_index('Timestamp', inplace=True)
data.index = data.index.tz_localize('UTC').tz_convert('US/Eastern')
intervals = []
for i in range(1, len(data.index)):
intervals.append((data.index[i] - data.index[i - 1]).seconds)
cnt = collections.Counter(intervals)
df_cnt = pd.DataFrame(
sorted(cnt.items(), key=lambda x: x[1], reverse=True))
df_cnt.columns = ['Interval (s)', 'Counts']
print(df_cnt.head(5))
fig, ax = plt.subplots(figsize=(16, 6))
for col in data.columns:
data[col] = data[col].astype('float64')
data.plot(y=col, use_index=True, ax=ax)
plt.show()
def _draw(self):
self.draw_line(Vector2(10, 10), Vector2(50, 30), Color(1, 1, 0))
class access_from_python(Node):
outcome = export(str, default=None)
def _ready(self):
try:
self.do_test()
except Exception as exc:
self.outcome = f"Unexpected error: {exc!r}"
raise # Stacktrace will be displayed on stdout this way
self.outcome = self.outcome or "ok"
def do_test(self):
# Test accessing from `Node.get_node`
for name, type in (("global_py", "Python"), ("global_gd", "GDScript")):
path = f"/root/{name}"
node = self.get_node(path)
if not node:
self.outcome = f"Cannot retrieve node `{path}`"
return
if str(node.type) != type:
self.outcome = (
f"Invalid Node type for `{path}` (expected `{type}`, got `{node.type}`)"
)
return
node.set_accessed("Python")
# Also test accessing from `godot.globals` module
if global_import_outcome != "ok":
self.outcome = global_import_outcome
return
from godot import globals as godot_globals
godot_globals_dir = dir(godot_globals)
expected_godot_globals_dir = ["global_gd", "global_py"]
if godot_globals_dir != expected_godot_globals_dir:
self.outcome = f"Invalid `dir(godot.globals)` (expected: `{expected_godot_globals_dir}`, got `{godot_globals_dir}`)"
return
for name, type in (("global_py", "Python"), ("global_gd", "GDScript")):
node_from_globals = getattr(godot_globals, name)
if str(node_from_globals.type) != type:
self.outcome = (
f"Invalid Node type for `{path}` (expected `{type}`, got `{node.type}`)"
)
return
class MyExportedCls(Node2D):
initialized = False
_python_prop = None
def _ready(self):
self.initialized = True
def python_method(self, attr):
return attr
python_prop_static = export(str)
@export(int, default=42)
@property
def python_prop(self):
return self._python_prop
@python_prop.setter
def python_prop(self, value):
self._python_prop = value
class PromptToolkitApp(Node):
terminal_path = export(NodePath)
redirect_stdout = export(bool, default=True)
redirect_stderr = export(bool, default=False)
focused = export(bool, default=True)
app = None
def _enter_tree(self):
self.input = create_pipe_input()
def _ready(self):
self.terminal = self.get_node(self.terminal_path)
self.terminal.connect("data_sent", self, "_on_Terminal_data_sent")
self.terminal.connect("size_changed", self,
"_on_Terminal_size_changed")
if self.focused:
self.terminal.grab_focus()
self.stdout = Stdout(writefunc=self._terminal_write)
self.output = Vt100_Output(stdout=self.stdout,
get_size=self._get_terminal_size,
write_binary=False)
self.thread = Thread(target=self._main_wrapped)
self.thread.start()
def _main_wrapped(self):
asyncio.set_event_loop(asyncio.new_event_loop())
with create_app_session(input=self.input, output=self.output):
# Wait until here to redirect stdout and/or stderr otherwise errors
# and output from the previous code would be written to the Terminal
# node rather than editor Output.
if self.redirect_stdout:
sys.stdout = self.stdout
if self.redirect_stderr:
sys.stderr = self.stdout
self.main()
def main(self):
raise NotImplementedError
def _get_terminal_size(self) -> Size:
return Size(self.terminal.rows, self.terminal.cols)
def _on_Terminal_data_sent(self, data: PoolByteArray) -> None:
self.input.send_bytes(bytes(data))
def _on_Terminal_size_changed(self, _new_size: Vector2):
try:
self.app._on_resize()
except AttributeError:
pass
def _terminal_write(self, data):
self.terminal.write(data)
self.terminal.update()
def _exit_tree(self):
self.input.send_bytes(
b'\x04') # Sends EOF to input (i.e. typing ctrl+D)
try:
self.app.exit()
except AttributeError:
pass
self.thread.join()
class Main(gd.Node2D):
speed = gd.export(float, default=0.1)
def _ready(self):
pass
class Evolution(Object):
# member variables here, example:
#a = export(int)
#b = export(str, default='foo')
start = export(bool, default=True)
def _ready(self):
self.start = True
def scaler(self, value, min, max):
scaled_value = (value - min) / (max - min)
return scaled_value
def de_scaler(self, scaled_value, min, max):
value = (scaled_value * (max - min)) + min
return value
def move(self, angle_to_target, distance_to_target, value):
#print ("done")
if self.start:
number_hidden_layers = 5
number_output_values = 2 # move_angle + move_speed
#create input array for Multilayer Perceptron
X_array = numpy.zeros((1, 2))
X_array[0, 0] = angle_to_target
X_array[0, 1] = distance_to_target
# scaling input values
# scaling angles from radians between 0 and 2pi to between 0 and 1
X_array[0, 0] = self.scaler(X_array[0, 0], 0, 2 * numpy.pi)
# scaling speed from between 0 and 100 to between 0 and 1
X_array[0, 1] = self.scaler(X_array[0, 1], 0, 100)
#create output array for initial fit
y_array = numpy.zeros((1, 2))
y_array[0, 0] = angle_to_target
y_array[0, 1] = 55
mlp = MLPRegressor(hidden_layer_sizes=(number_hidden_layers,
number_output_values),
activation='logistic',
solver='lbfgs',
tol=1e-2,
max_iter=10,
random_state=0)
#‘lbfgs’ is an optimizer in the family of quasi-Newton methods.
mlp.fit(X_array, y_array)
#The attribute coefs_ contains a list of weight matrices for every layer.
#print(len(mlp.coefs_[0]))
#print(numpy.size(mlp.coefs_[0]))
#print(len(mlp.coefs_[1]))
#print(numpy.size(mlp.coefs_[1]))
#The weight matrix at index i holds the weights between the layer i and layer i + 1.
#mlp.coefs_[0] = numpy.random.rand(number_hidden_layers,number_output_values)
#mlp.coefs_[1] = numpy.random.rand(number_output_values,number_hidden_layers)
#y_array = numpy.random.rand(2)
y_array2 = mlp.predict(X_array)
#rescaling output values
y_array2[0, 0] = self.de_scaler(y_array2[0, 0], 0, numpy.pi / 4)
y_array2[0, 1] = self.de_scaler(y_array2[0, 1], 0, 100)
value[0] = y_array2[0, 0] #angle
value[1] = y_array2[0, 1] #speed
print(X_array, y_array2)
class Gameplay(Node):
job = None
turn = 0
is_white = export(bool, True)
is_quantum = export(bool, True)
def tick(self):
if self.board.is_cleared:
return
if self.turn != 0 and self.turn % 15 == 0:
self.board.collapse()
self.timer.start()
self.timer_timeout()
self.turn += 1
self.is_quantum = (self.turn % 3 == 0)
self.is_white = (self.turn % 2 == 1)
self.update_status_text()
def timer_timeout(self):
self.board.check_job()
if self.board.is_measuring:
self.get_node('WaitIndicator').set_visible(True)
print('Still waiting...')
def update_status_text(self):
if self.board.is_cleared:
return
if self.board.is_measuring:
self.status_text.text = 'Collapsing Quantum States...'
elif self.is_white:
if self.is_quantum:
self.status_text.text = 'White\'s Quantum Turn'
else:
self.status_text.text = 'White\'s Turn'
else:
if self.is_quantum:
self.status_text.text = 'Black\'s Quantum Turn'
else:
self.status_text.text = 'Black\'s Turn'
def game_over(self, winner):
self.status_text.text = '%s Wins!' % winner
self.get_node('Restart').visible = True
def restart_pressed(self):
self.get_tree().reload_current_scene()
def show_circuit(self, text):
self.circuit_text.set_text(text)
self.circuit_text.set_visible(True)
def job_cleanup(self):
self.circuit_text.set_visible(False)
self.get_node('WaitIndicator').set_visible(False)
self.timer.stop()
self.update_status_text()
def quantum_toggle(self, button_pressed):
if button_pressed:
self.get_node('DeviceName').set_text("Quantum Device:\n" +
real_name)
else:
self.get_node('DeviceName').set_text("Local Simulator")
def _ready(self):
self.timer = self.get_node('Timer')
self.board = self.get_node('Board')
self.status_text = self.get_node('GameStatus')
self.circuit_text = self.get_node('CircuitText')
self.board.connect('game_finished', self, 'game_over')
self.board.connect('circuit_finished', self, 'show_circuit')
self.board.connect('job_finished', self, 'job_cleanup')
self.tick()
class WiiBalanceBoard(Control):
# member variables here, example:
connected = export(bool, default=False)
connecting = export(bool, default=False)
error = export(str, default="")
com = Vector2()
_last_off_board_time = 0
_last_off_board_duration = 0
_com_mutex = threading.Lock()
_response_thread = None
_wiiboard_process = None
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
print("creating WiiBalanceBoard response thread")
self._response_thread = threading.Thread(target=self.response)
self._response_thread.start()
def restart(self):
print("recreating WiiBalanceBoard response thread")
self._response_thread = threading.Thread(target=self.response)
self._response_thread.start()
def shutdown(self):
self._wiiboard_process.kill()
def _process(self, delta):
#label = self.get_node("StatusLabel")
#if self.connected:
# label.text = "Balance board status:\n Connected!"
#else:
# label.text = "Balance board status:\n Disconnected."
pass
def response(self):
#self._wiiboard = WiiboardCOM()
#wiiboards = wiiboard.discover()
#print("Found wiiboards: %s", str(wiiboards))
#if not wiiboards:
# self.connected = False
# self.error = "Not paired!"
#address = wiiboards[0]
#with WiiboardCOM(address) as wiiprint:
# self.connected = True
#
# wiiprint.loop()
self._wiiboard_process = subprocess.Popen(
["/usr/bin/python", "wiiboard.py"])
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
time.sleep(2)
tcp_socket.connect(("127.0.0.1", 7375))
while True:
tcp_socket.send(b"ping")
data = tcp_socket.recv(1024).decode("ascii").split("_")
if len(data) < 3:
assert (len(data) > 1)
if data[0] == "connecting":
self.connecting = True
print("connecting...")
else:
print("searching...")
time.sleep(2)
continue
self.connected = True
self._com_mutex.acquire()
self.com.x = float(data[1])
self.com.y = float(data[2])
self._com_mutex.release()
if self.on_board():
self._last_off_board_duration = 0
else:
self._last_off_board_duration += time.monotonic() - \
self._last_off_board_time
self._last_off_board_time = time.monotonic()
tcp_socket.close()
@export(bool)
def on_board(self):
return self.com.y != -1
@export(Vector2)
def get_com(self):
self._com_mutex.acquire()
return_value = self.com
self._com_mutex.release()
return self.com
@export(bool)
def jumped(self):
return_value = \
(self.get_com().y != -1) and \
((time.monotonic() - self._last_off_board_time) < 1.5) and \
self._last_off_board_duration < 1.5
#if return_value:
#self._last_off_board_time = time.monotonic() - 1.5
#print("jumped")
return return_value
class Board(TileMap):
is_measuring = export(bool, False)
is_cleared = export(bool, False)
game_finished = signal()
circuit_finished = signal()
job_finished = signal()
gate_start_rock = None
current_gate = None
job = None
backend = sim_backend
def get_rock(self, x, y):
return self.rocks_array[TILE_COUNT * y + x]
def _unhandled_input(self, event):
if not self.is_measuring and not self.is_cleared:
if event.is_action_pressed('mouse_left_button'):
v = self.get_local_mouse_position()
x = int(v.x // TILE_SIZE)
y = int(v.y // TILE_SIZE)
cell = self.get_cell(x, y)
if cell != -1:
rock = self.get_rock(x, y)
if rock.value == EMPTY:
if self.gameplay.is_quantum:
rock.value = UNKNOWN
num = len(self.quantum_rocks)
self.quantum_rocks[rock.get_name()] = num
self.quantum_rocks_inv.append(rock)
if not self.gameplay.is_white:
self.quantum_operations.append(('x', num))
self.quantum_operations.append(('h', num))
elif self.gameplay.is_white:
rock.value = WHITE
self.check_cleared([(x, y)])
else:
rock.value = BLACK
self.check_cleared([(x, y)])
self.gameplay.tick()
elif event.is_action_pressed(
'mouse_right_button') and self.gameplay.is_quantum:
v = self.get_local_mouse_position()
x = int(v.x // TILE_SIZE)
y = int(v.y // TILE_SIZE)
cell = self.get_cell(x, y)
if cell != -1:
rock = self.get_rock(x, y)
if rock.value == UNKNOWN:
self.gate_start_rock = rock
gate = GateScene.instance()
gate.position = self.gate_start_rock.position
self.gates_node.add_child(gate)
self.current_gate = gate
elif event.is_action_released(
'mouse_right_button') and self.current_gate != None:
diff = self.get_local_mouse_position(
) - self.gate_start_rock.get_position()
cx, cy = self.gate_start_rock.cell_x, self.gate_start_rock.cell_y
nx, ny = cx, cy
if diff.x >= 0:
if diff.y >= 0:
if diff.x >= diff.y:
nx += 1
else:
ny += 1
else:
if diff.x >= -diff.y:
nx += 1
else:
ny -= 1
else:
if diff.y >= 0:
if -diff.x >= diff.y:
nx -= 1
else:
ny += 1
else:
if -diff.x >= -diff.y:
nx -= 1
else:
ny -= 1
if nx >= 0 and nx < TILE_COUNT and ny >= 0 and ny < TILE_COUNT:
next_rock = self.get_rock(nx, ny)
if next_rock.value != EMPTY:
a_num = self.quantum_rocks[
self.gate_start_rock.get_name()]
b_num = 0
if next_rock.value != UNKNOWN:
b_num = len(self.quantum_rocks)
self.quantum_rocks[next_rock.get_name()] = b_num
self.quantum_rocks_inv.append(next_rock)
if next_rock.value == BLACK:
self.quantum_operations.append(('x', b_num))
next_rock.value = UNKNOWN
else:
b_num = self.quantum_rocks[next_rock.get_name()]
self.quantum_operations.append(('gate', a_num, b_num))
self.quantum_gates.append(self.current_gate)
self.gameplay.tick()
else:
self.current_gate.queue_free()
else:
self.current_gate.queue_free()
self.gate_start_rock = None
self.current_gate = None
def collapse(self):
register_size = len(self.quantum_rocks)
circuit_builder = CircuitBuilder(register_size)
for op in self.quantum_operations:
circuit_builder.add_operation(op, self.backend)
qr, cr, circuit = circuit_builder.build()
circuit_text = circuit.draw(output='text', line_length=75)
self.emit_signal('circuit_finished', circuit_text.single_string())
qobj = assemble(transpile(circuit, self.backend, optimization_level=2),
self.backend,
memory=True,
shots=32)
self.job = self.backend.run(qobj)
self.is_measuring = True
def check_job(self):
if self.job != None:
status = self.job.status()
if status == JobStatus.DONE:
self.cleanup()
self.emit_signal('job_finished')
elif status == JobStatus.ERROR or status == JobStatus.CANCELLED:
raise QiskitError
def cleanup(self):
result = self.job.result()
memory_list = result.get_memory()
# counts = result.get_counts()
# memory_list = []
# for k,v in counts.items():
# for _ in range(v):
# memory_list.append(k)
pick = memory_list[0]
pick = pick[::-1]
arr = []
for i, v in enumerate(pick):
rock = self.quantum_rocks_inv[i]
if v == '0':
rock.value = WHITE
else:
rock.value = BLACK
arr.append((rock.cell_x, rock.cell_y))
self.quantum_rocks.clear()
self.quantum_rocks_inv.clear()
self.quantum_operations.clear()
for gate in self.quantum_gates:
gate.queue_free()
self.quantum_gates.clear()
self.job = None
self.is_measuring = False
self.check_cleared(arr)
def check_cleared(self, arr):
for v in arr:
x, y = v[0], v[1]
value = self.get_rock(x, y).value
count = 0
for i in range(-4, 5):
cx = x + i
if cx >= 0 and cx < TILE_COUNT and self.get_rock(
cx, y).value == value:
count += 1
if count == 5:
return self.cleared(value)
else:
count = 0
count = 0
for i in range(-4, 5):
cy = y + i
if cy >= 0 and cy < TILE_COUNT and self.get_rock(
x, cy).value == value:
count += 1
if count == 5:
return self.cleared(value)
else:
count = 0
count = 0
for i in range(-4, 5):
cx, cy = x + i, y + i
if cx >= 0 and cx < TILE_COUNT and cy >= 0 and cy < TILE_COUNT and self.get_rock(
cx, cy).value == value:
count += 1
if count == 5:
return self.cleared(value)
else:
count = 0
count = 0
for i in range(-4, 5):
cx, cy = x + i, y - i
if cx >= 0 and cx < TILE_COUNT and cy >= 0 and cy < TILE_COUNT and self.get_rock(
cx, cy).value == value:
count += 1
if count == 5:
return self.cleared(value)
else:
count = 0
def cleared(self, value):
self.is_cleared = True
winner = ''
if value == WHITE:
winner = 'White'
else:
winner = 'Black'
self.emit_signal('game_finished', winner)
def quantum_toggle(self, button_pressed):
if button_pressed:
self.backend = real_backend
else:
self.backend = sim_backend
def _process(self, dt):
if self.current_gate != None:
dv = self.current_gate.position - self.get_local_mouse_position()
if dv.x >= 0:
if dv.y >= 0:
if dv.x >= dv.y:
self.current_gate.rotation_degrees = 180.0
else:
self.current_gate.rotation_degrees = 270.0
else:
if dv.x >= -dv.y:
self.current_gate.rotation_degrees = 180.0
else:
self.current_gate.rotation_degrees = 90.0
else:
if dv.y >= 0:
if -dv.x >= dv.y:
self.current_gate.rotation_degrees = 0.0
else:
self.current_gate.rotation_degrees = 270.0
else:
if -dv.x >= -dv.y:
self.current_gate.rotation_degrees = 0.0
else:
self.current_gate.rotation_degrees = 90.0
def _ready(self):
self.gameplay = self.get_parent()
self.rocks_node = self.get_node('Rocks')
self.gates_node = self.get_node('Gates')
self.rocks_array = []
for iy in range(TILE_COUNT):
for ix in range(TILE_COUNT):
y = (iy + 0.5) * TILE_SIZE
x = (ix + 0.5) * TILE_SIZE
rock = RockScene.instance()
self.rocks_array.append(rock)
self.rocks_node.add_child(rock)
rock.position = Vector2(x, y)
rock.cell_x, rock.cell_y = ix, iy
self.quantum_rocks = {}
self.quantum_rocks_inv = []
self.quantum_gates = []
self.quantum_operations = []
self.set_process(True)
class python(Control):
# member variables here, example:
command_test = export(str, default="'Jupter Kernel Test: Good!'")
response = export(str)
response2 = export(Dictionary)
def _ready(self):
"""
Called every time the node is added to the scene.
Initialization here.
"""
#self.execute_command(self.command_test)
self.response = Array()
self.response2 = Dictionary()
print("Python3-Godot Loaded")
def execute_command(self, command):
import time
try:
from queue import Empty # Py 3
except ImportError:
from Queue import Empty # Py 2
km = KernelManager(kernel_name='python')
km.start_kernel()
print("Kernel Running: " + str(km.is_alive()))
try:
c = km.client()
msg_id = c.execute(command)
state = 'busy'
data = {}
content_printer = pprint.PrettyPrinter(indent=4)
content = {}
while state != 'idle' and c.is_alive():
try:
msg = c.get_iopub_msg(timeout=1)
if not 'content' in msg:
print("message has no content, moving on...")
continue
content = msg['content']
for info in content:
self.response2[info] = content[info]
#content_printer.pprint(content)
# if 'data' in content:
# data=content['data']
if 'execution_state' in content:
state = content['execution_state']
except Empty:
pass
#print(str(data))
except KeyboardInterrupt:
pass
finally:
km.shutdown_kernel()
#print('Kernel Running Final : ' + str(km.is_alive()))
#response = json.dumps(data, ensure_ascii=True)
#print(type(self.response2))
content_printer.pprint(self.response2)
return self.response2
def remove_ansi(self, line):
ansi_escape = re.compile(r'(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]')
return ansi_escape.sub('', line)
