def main():
root = os.path.dirname(sys.argv[0]) + '/assets/'
files = [
"balls.html", "barrel.png", "barrier.png", "bullet.png", "dome.png",
"numbers.png", "skull.png"
]
full_paths = list(map(lambda f: root + f, files))
data_map, names = resource.from_file_list(full_paths)
# make list of image URIs from names
urls = []
for i in range(1, len(full_paths)):
urls.append(names[full_paths[i]])
ui = Gempyre.Ui(data_map, names[full_paths[0]])
Gempyre.Element(ui, "game_over").set_attribute("style",
"visibility:hidden")
Gempyre.Element(ui, "wave_end").set_attribute("style", "visibility:hidden")
canvas = Gempyre.CanvasElement(ui, 'canvas')
images = canvas.add_images(urls, None)
game = Game(ui, canvas, zip(files[1:], images))
ui.on_open(lambda: game.init())
canvas.subscribe("click", lambda _: game.shoot(), [],
timedelta(milliseconds=200))
def get_property(event):
if event:
nonlocal game
x = float(event.properties["clientX"])
y = float(event.properties["clientY"])
mid_x = game.gun.x
return math.atan2((game.rect.height - y), mid_x - x) - math.pi / 2
return 0
canvas.subscribe('mousemove', lambda e: game.turret(get_property(e)),
["clientX", "clientY"], timedelta(milliseconds=100))
def key_listen(e):
code = int(float((e.properties['keyCode'])))
if code == 37: # left arrow
game.gun_move(-GUN_SPEED)
elif code == 39: # right arrow
game.gun_move(GUN_SPEED)
elif code == ord('Z'):
game.turret_turn(-TURRET_STEP)
elif code == ord('X'):
game.turret_turn(TURRET_STEP)
elif code == ord('C'):
game.shoot()
elif code == ord('A'):
game.start()
# canvas is not focusable therefore we listen whole app
ui.root().subscribe('keydown', key_listen, ['keyCode'])
ui.run()
def main(py_cpp_file, cpp_headers):
with open(py_cpp_file) as p:
py_tree = parse_py11_cpp(p)
cpp_functions = []
for cpp_header in cpp_headers:
with open(cpp_header) as c:
cpp_functions.extend(find_tagged(c))
ui_file = 'make_header.html'
file_map, names = resource.from_file(ui_file)
ui = Gempyre.Ui(file_map, '/make_header.html', Gempyre.os_browser())
input_element = Gempyre.Element(ui, 'input')
def get_input(e):
input_text = e.properties['value']
declarations = find(input_text, py_tree, cpp_functions)
output_element = Gempyre.Element(ui, 'output')
if len(declarations) > 0:
html = ""
for d in declarations:
html += decorate(d)
output_element.set_html(html)
else:
output_element.set_html("Not found '" + input_text + "'")
input_element.subscribe('change', get_input, ['value'])
ui.run()
def draw():
frame = Gempyre.FrameComposer()
frame.clear_rect(
Gempyre.Rect(swarm.x, swarm.y, swarm.width, swarm.height))
swarm.draw(frame)
frame.fill_rect(
Gempyre.Rect(swarm.fake_bee.x - 5, swarm.fake_bee.y - 5, 10, 10))
canvas.draw_frame(frame)
def draw_loop(self):
fc = Gempyre.FrameComposer()
fc.clear_rect(Gempyre.Rect(0, 0, self.width, self.height))
for bullet in self.bullets:
bullet.draw(fc, self.bullet)
for monster in self.monsters:
monster.draw(fc, self.skull)
self.gun.draw(fc, self.dome, self.barrel)
self.ammo.draw(fc, self.bullet)
self.canvas.draw_frame(fc)
def game_over(self):
self.ui.cancel(self.tick)
self.canvas.draw_completed(None)
self.tick = None
Gempyre.Element(self.ui,
"game_over").set_attribute("style",
"visibility:visible")
Gempyre.Element(self.ui,
"instructions").set_attribute("style",
"visibility:visible")
self.restart = True
self.draw_loop()
def main():
print(Gempyre.version())
#Gempyre.set_debug()
current_dir = os.path.dirname(sys.argv[0])
file_map, names = resource.from_file(current_dir + "/swarm.html")
ui = Gempyre.Ui(file_map, '/swarm.html', "Swarm", 800 + 15, 600 + 20)
canvas = Gempyre.CanvasElement(ui, "canvas")
swarm = Swarm(200)
canvas_rect = Gempyre.Rect()
def resize_handler(_):
nonlocal canvas_rect
canvas_rect = canvas.rect()
swarm.x = 0
swarm.y = 0
swarm.width = canvas_rect.width
swarm.height = canvas_rect.height
ui.root().subscribe("resize", resize_handler)
def draw():
frame = Gempyre.FrameComposer()
frame.clear_rect(
Gempyre.Rect(swarm.x, swarm.y, swarm.width, swarm.height))
swarm.draw(frame)
frame.fill_rect(
Gempyre.Rect(swarm.fake_bee.x - 5, swarm.fake_bee.y - 5, 10, 10))
canvas.draw_frame(frame)
def on_start():
resize_handler(None)
for b in swarm.bees:
b.x = random.randint(b.width + swarm.x, swarm.width)
b.y = random.randint(b.height + swarm.y, swarm.height)
draw()
ui.on_open(on_start)
ui.start_periodic(timedelta(milliseconds=40), lambda: swarm.move())
canvas.draw_completed(draw)
def make_move(event):
mouse_x = float(event.properties['clientX']) - canvas_rect.x
mouse_y = float(event.properties['clientY']) - canvas_rect.y
swarm.set_pos(mouse_x, mouse_y)
canvas.subscribe('mousemove', make_move, ["clientX", "clientY"],
timedelta(milliseconds=100))
ui.run()
def draw(self, g, dome_image, barrel_image):
g.draw_image_rect(
dome_image,
Gempyre.Rect(self.mx - GUN_WIDTH / 2, self.my - GUN_HEIGHT,
GUN_WIDTH, GUN_HEIGHT))
g.save()
g.translate(self.mx, self.my - 20)
g.rotate(self.angle)
g.translate(-self.mx, -(self.my - 20))
g.draw_image_rect(
barrel_image,
Gempyre.Rect(self.mx - BARREL_WIDTH / 2,
self.my - (GUN_WIDTH * 0.9), BARREL_WIDTH,
BARREL_HEIGHT))
g.restore()
def draw(self, g, image):
pos = (self.gap + BULLET_WIDTH) * (self.max - self.count)
for i in range(0, self.count):
g.draw_image_rect(
image,
Gempyre.Rect(pos, self.y_pos, BULLET_WIDTH, BULLET_HEIGHT))
pos += self.gap + BULLET_WIDTH
def draw(self, g, image):
g.draw_image_rect(
image, Gempyre.Rect(self.x, self.y, self.width, self.height))
f1 = int(self.endurance / 10)
f2 = self.endurance - (f1 * 10)
self.numbers.draw(g, self.x + 6, self.y + 6, 10, 10, f1)
self.numbers.draw(g, self.x + 24, self.y + 6, 10, 10, f2)
def on_start():
global eyes_rect
eyes_rect = eyes.rect()
print(ui.root().html())
ui.start_periodic(
timedelta(seconds=1), lambda: Gempyre.Element(ui, 'time').set_html(
datetime.now().strftime("%d/%m/%Y %H:%M:%S")))
def add_element(event):
global elementCount
new = Gempyre.Element(ui, "name_" + str(elementCount), "img", ui.root())
elementCount += 1
new.set_attribute(
"SRC",
"https://www.animatedimages.org/data/media/202/animated-dog-image-0931.gif"
)
def wave_end(self):
self.ui.cancel(self.tick)
self.canvas.draw_completed(None)
self.tick = None
Gempyre.Element(self.ui,
"wave_end").set_attribute("style",
"visibility:visible")
self.wave += 1
self.draw_loop()
def get_input(e):
input_text = e.properties['value']
declarations = find(input_text, py_tree, cpp_functions)
output_element = Gempyre.Element(ui, 'output')
if len(declarations) > 0:
html = ""
for d in declarations:
html += decorate(d)
output_element.set_html(html)
else:
output_element.set_html("Not found '" + input_text + "'")
def start(self):
if self.tick:
return
if self.restart:
self.hits = 0
self.wave = 0
self.game_speed = GAME_SPEED
self.restart = False
self.ammo.count = MAX_AMMO
self.wave_count = 3 + self.wave * 1.5
self.monsters = []
self.bullets = []
self.ammo.count = MAX_AMMO
Gempyre.Element(self.ui,
"game_over").set_attribute("style",
"visibility:hidden")
Gempyre.Element(self.ui,
"wave_end").set_attribute("style", "visibility:hidden")
Gempyre.Element(self.ui, "hits").set_html(str(self.hits))
Gempyre.Element(self.ui, "waves").set_html(str(self.wave + 1))
Gempyre.Element(self.ui,
"monsters").set_html(str(int(self.wave_count + 0.5)))
Gempyre.Element(self.ui,
"instructions").set_attribute("style",
"visibility:hidden")
self.tick = self.ui.start_periodic(timedelta(milliseconds=TICK_SPEED),
self.do_tick)
if self.game_speed > GAME_SPEED / 10:
self.game_speed -= 1
self.canvas.draw_completed(lambda: self.draw_completed())
self.draw_loop()
def move_eyes(x, y):
fc = Gempyre.FrameComposer()
fc.clear_rect(Gempyre.Rect(0, 0, 80, 80))
def draw_eye(fc, px, py, x, y):
fc.begin_path()
fc.arc(px, py, 20, 0, 2 * math.pi)
fc.stroke_style('black')
fc.stroke()
angle = math.atan2(x, y)
dx = math.fabs(x - px)
dy = math.fabs(y - py)
xx = math.sin(angle) * min(dx, 10)
yy = math.cos(angle) * min(dy, 10)
fc.begin_path()
fc.arc(px + xx, py + yy, 10, 0, 2 * math.pi)
fc.fill_style('black')
fc.fill()
draw_eye(fc, 20, 40, x, y)
draw_eye(fc, 60, 40, x, y)
eyes.draw_frame(fc)
def game_loop(self):
for bullet in self.bullets:
bullet.step()
to_delete = bullet.test_inside(0, 0, self.width, self.height)
if to_delete:
self.bullets.remove(bullet)
else:
bullet.step()
bullet.test_hit(self.gun)
for monster in self.monsters:
if bullet.test_hit(monster):
monster.endurance -= 1
self.hits += 1
Gempyre.Element(self.ui,
"hits").set_html(str(self.hits))
if monster.endurance <= 0:
bullet.hit_in = None
self.monsters.remove(monster)
if len(self.monsters) == 0:
self.wave_end()
return
if self.ammo.count < self.ammo.max:
self.ammo.count += 1
bullet.step()
gaps = []
for monster in self.monsters:
monster.step()
if monster.y < 0:
gaps.append(monster.x)
to_delete = monster.test_inside(0, 0, self.width, self.height)
if to_delete:
self.monsters.remove(monster)
if (monster.y + monster.height) > (self.height - BULLET_HEIGHT):
self.game_over()
return
if self.wave_count > 0:
if random.randint(0, self.game_speed) == 1:
x_pos = random.randint(0, self.width - MONSTER_WIDTH)
is_ok = True
for x in gaps:
if (x_pos > x) or (x_pos < x + MONSTER_WIDTH):
is_ok = False
break
if is_ok:
self.create_monster(x_pos)
self.wave_count -= 1
def draw_kitt():
global position
global direction
position += direction
if position >= 198:
direction = -1
if position <= 0:
direction = 1
g.draw_rect(Gempyre.Rect(0, 0, 200, 20), Gempyre.Graphics.Black)
for i in range(0, 20):
g.set_pixel(position - 1, i, Gempyre.Graphics.Red)
for i in range(0, 20):
g.set_pixel(position, i, Gempyre.Graphics.pix(0xFF, 0xFF, 0))
for i in range(0, 20):
g.set_pixel(position + 1, i, Gempyre.Graphics.Red)
g.update()
def main():
name = os.path.join(os.path.dirname(sys.argv[0]),
"python_dialog_test.html")
map, names = resource.from_file(name)
ui = Gempyre.Ui(map, names[name])
output = Gempyre.Element(ui, "output")
open_file_button = Gempyre.Element(ui, "open_file")
def open_file(_):
dlg = Gempyre.Dialog()
result = dlg.open_file_dialog("hop", str(Path.home()),
[("Text", ["*.txt", "*.text"])])
if result:
output.set_html(result)
open_file_button.subscribe("click", open_file)
open_files_button = Gempyre.Element(ui, "open_files")
def open_files(_):
result = Gempyre.Dialog().open_files_dialog("hop", str(Path.home()))
if result:
output.set_html(str(result))
open_files_button.subscribe("click", open_files)
open_dir_button = Gempyre.Element(ui, "open_dir")
def open_dir(_):
dialog = Gempyre.Dialog()
result = dialog.open_dir_dialog("hop", str(Path.home()))
if result:
output.set_html(result)
open_dir_button.subscribe("click", open_dir)
save_file_button = Gempyre.Element(ui, "save_file")
def save_file(_):
dialog = Gempyre.Dialog()
filter = [("Foo", ["*.foo", "*.bar"])]
result = dialog.save_file_dialog("hop", str(Path.home()), filter)
if result:
output.set_html(result)
save_file_button.subscribe("click", save_file)
ui.run()
def draw(self, drawer):
for b in self.bees:
b.draw(drawer)
drawer.fill_rect(
Gempyre.Rect(self.fake_bee.x - 5, self.fake_bee.y - 5, 10, 10))
def removeElement(event):
global elementCount
if elementCount <= 0:
return
elementCount -= 1
Gempyre.Element(ui, "name_" + str(elementCount)).remove()
import sys
import os
import math
import Gempyre
from datetime import datetime
from datetime import date
from datetime import timedelta
from Gempyre_utils import resource
Gempyre.set_debug()
name = sys.argv[1] if len(sys.argv) > 1 else os.path.join(
os.path.dirname(sys.argv[0]), "python_test_1.html")
map, names = resource.from_file(name)
print(names[name], name)
ui = Gempyre.Ui(map,
names[name]) if sys.platform != 'win32' or sys.version_info < (
3, 8) else Gempyre.Ui(map, names[name], "")
ver, major, minor = Gempyre.version()
Gempyre.Element(ui, 'ver').set_html("Gempyre Version: " + str(ver) + '.' +
str(major) + '.' + str(minor))
eyes = Gempyre.CanvasElement(ui, 'eyes')
eyes_rect = None
def on_start():
global eyes_rect
eyes_rect = eyes.rect()
def open_file(_):
dlg = Gempyre.Dialog()
result = dlg.open_file_dialog("hop", str(Path.home()),
[("Text", ["*.txt", "*.text"])])
if result:
output.set_html(result)
import sys
import os
import subprocess
import platform
import shlex
import psutil
import Gempyre
from Gempyre_utils import resource
name = os.path.join(os.path.dirname(sys.argv[0]), "python_test_2.html")
map, names = resource.from_file(name)
ui = Gempyre.Ui(map, names[name])
header = Gempyre.Element(ui, "header")
Gempyre.Element(ui, "th", header).set_html("Name")
Gempyre.Element(ui, "th", header).set_html("Info")
name = list()
name.append(["Architecture", platform.architecture()[0]])
name.append(["Machine", platform.machine()])
name.append(["Node", platform.node()])
name.append(["System", platform.system()])
info = Gempyre.Element(ui, "info")
for n in name:
h = Gempyre.Element(ui, "tr", info)
Gempyre.Element(ui, "td", h).set_html(n[0])
Gempyre.Element(ui, "td", h).set_html(n[1])
def open_files(_):
result = Gempyre.Dialog().open_files_dialog("hop", str(Path.home()))
if result:
output.set_html(str(result))
def open_dir(_):
dialog = Gempyre.Dialog()
result = dialog.open_dir_dialog("hop", str(Path.home()))
if result:
output.set_html(result)
def draw(self, g, x, y, width, height, value):
g.draw_image_clip(
self.images,
Gempyre.Rect(NUMBERS_WIDTH * value, 0, NUMBERS_WIDTH,
NUMBERS_HEIGHT), Gempyre.Rect(x, y, width, height))
def save_file(_):
dialog = Gempyre.Dialog()
filter = [("Foo", ["*.foo", "*.bar"])]
result = dialog.save_file_dialog("hop", str(Path.home()), filter)
if result:
output.set_html(result)
def draw(self, g, image):
g.draw_image_rect(
image, Gempyre.Rect(self.x, self.y, BULLET_WIDTH, BULLET_HEIGHT))