def _config_fbo(self):
# set shader file here
self.fbo.shader.source = self.shader_file or \
os.path.join(kivy3_path, "default.glsl")
with self.fbo:
Callback(self._setup_gl_context)
PushMatrix()
# instructions set for all instructions
self._instructions = InstructionGroup()
PopMatrix()
Callback(self._reset_gl_context)
def on_press(self):
if self.__shape_down__ == None:
self.__shape_down__ = InstructionGroup(grup="__shape_down__")
else:
self.canvas.remove(self.__shape_down__)
self.__shape_down__.clear()
color = Color(0, 0, 0, .4)
self.__shape_down__.add(color)
self.__shape_down__.add(Ellipse(pos=self.pos, size=self.size))
self.canvas.add(self.__shape_down__)
super(FloatButtonWidget, self).on_press()
def __init__(self, speed):
super(ParallaxLayer, self).__init__()
self.speed = speed
self.translator = Translate(0, 0)
self.add(self.translator)
self.objects = InstructionGroup()
self.add(self.objects)
self.rev_translator = Translate(0, 0)
self.add(self.rev_translator)
def _paint_divided_square(self):
instruction_group = InstructionGroup()
bottom_left_x = self._x - self._cell_width / 2
bottom_left_y = self._y - self._cell_height / 2
instruction_group.add(self._bottom_color)
instruction_group.add(
Rectangle(
pos=(bottom_left_x, bottom_left_y),
size=(self._cell_width, self._cell_height / 2),
))
self.instruction_groups.append(instruction_group)
instruction_group2 = InstructionGroup()
middle_left_y = self._y
instruction_group2.add(self._top_color)
instruction_group2.add(
Rectangle(
pos=(bottom_left_x, middle_left_y),
size=(self._cell_width, self._cell_height / 2),
))
self.instruction_groups.append(instruction_group2)
def _add_pause_sign(self):
self.pause_sign = InstructionGroup()
self.pause_sign.add(Color(1, 1, 1, 1))
self.pause_sign.add(
Rectangle(pos=(self.x + self.width * 0.35,
self.y + self.height * 0.25),
size=(self.width * 0.1, self.height * 0.5)))
self.pause_sign.add(
Rectangle(pos=(self.x + self.width * 0.55,
self.y + self.height * 0.25),
size=(self.width * 0.1, self.height * 0.5)))
self.canvas.after.add(self.pause_sign)
def __init__(self, elements=[], z=0, color=None, musical=False, tag=""):
self.elements = elements
self.musical = musical
self.z = z
self.tag = tag
self.color = color
if color == None:
self.color = Color(1, 1, 1)
self.shape = InstructionGroup()
for element in self.elements:
self.shape.add(element)
def on_bgColor(self, root, val):
if self.shape_up == None:
self.shape_up = InstructionGroup(grup="shape_up")
else:
self.shape.canvas.remove(self.shape_up)
self.shape_up.clear()
color = Color()
color.rgb = get_color_from_hex(val)
self.shape_up.add(color)
self.shape_up.add(Ellipse(pos=self.shape.pos, size=self.shape.size))
self.shape.canvas.before.add(self.shape_up)
self.shape_up.clear()
def __init__(self, **kwargs):
Widget.__init__(self, **kwargs)
# create keyboard
self.keyboard = Window.request_keyboard(self.keyboard_closed, self)
self.keyboard.bind(on_key_down=self.on_keyboard_down)
# custom events
self.register_event_type('on_land')
self.bind(on_land=self.check_landing)
# canvas core labels
self.lose_label = CoreLabel(text='', font_size=40)
self.lose_label.refresh()
self.lose_instruction = Rectangle(texture=self.lose_label.texture,
pos=(85, 430),
size=self.lose_label.texture.size)
self.aim_label = CoreLabel(text='', font_size=20)
self.aim_label.refresh()
self.aim_instruction = Rectangle(texture=self.aim_label.texture,
pos=(415, 300),
size=self.aim_label.texture.size)
self.score_label = CoreLabel(text='Score: 0', font_size=20)
self.score_label.refresh()
self.score_instruction = Rectangle(texture=self.score_label.texture,
pos=(400, 530),
size=self.score_label.texture.size)
self.speed_label = CoreLabel(text='Speed: 1.0', font_size=20)
self.speed_label.refresh()
self.speed_instruction = Rectangle(texture=self.speed_label.texture,
pos=(400, 485),
size=self.speed_label.texture.size)
self.canvas.add(self.lose_instruction)
self.canvas.add(self.score_instruction)
self.canvas.add(self.aim_instruction)
self.canvas.add(self.speed_instruction)
# graphics
line_instruction = InstructionGroup()
line_instruction.add(Color(1, 1, 1, 1))
line_instruction.add(Line(points=[0, 518, 500, 518], width=2))
self.canvas.add(line_instruction)
self.canvas.add(self.next_block.instruction)
# run these functions continuously
Clock.schedule_interval(self.move_tower, 0.02)
Clock.schedule_interval(self.move_block, 0.04)
Clock.schedule_interval(self.drop_block, 0)
Clock.schedule_interval(self.check_tower, 0)
def clicked(self):
group_of_drawings = InstructionGroup()
if self.id not in self.button_objects:
self.button_objects.append(self.id)
if not self.color_state:
"""Call ScreenOne and update the sequence"""
self.parent.parent.update_sequence(self.id)
"""Call ScreenOne and update the sequence"""
self.color_state = True
if "11" in self.id:
group_of_drawings.add(Color(rgba=(255, 0, 0, 1)))
elif "1" in self.id and "0" not in self.id:
group_of_drawings.add(Color(rgba=(0, 255, 0, 1)))
else:
group_of_drawings.add(Color(rgba=(0, 0, 255, 1)))
group_of_drawings.add(
Line(width=2.,
ellipse=(self.x + 5, self.y + 5, self.width - 10,
self.height - 10)))
if len(self.objects) == 0:
self.parent.last_hold_coordinates = [
self.x + 5 + (self.width - 10) / 2,
self.y + 5 + (self.height - 10) / 2
]
else:
self.parent.draw_line([
self.x + 5 + (self.width - 10) / 2,
self.y + 5 + (self.height - 10) / 2
])
self.parent.last_hold_coordinates = [
self.x + 5 + (self.width - 10) / 2,
self.y + 5 + (self.height - 10) / 2
]
self.objects.append(group_of_drawings)
self.canvas.add(group_of_drawings)
self.parent.all_hold_coordinates.append([
self.x + 5 + (self.width - 10) / 2,
self.y + 5 + (self.height - 10) / 2
])
else:
""" Remove selected ellipse"""
index = self.button_objects.index(self.id)
self.color_state = False
self.canvas.remove(self.objects[index])
self.objects.pop(index)
self.button_objects.pop(index)
""" Remove the last added element in sequence """
self.parent.parent.delete_sequence()
""" Remove last drawn line """
self.parent.remove_line_single()
def on_press(self):
size = self.__container__.size
if self.__shape_down__ == None:
self.__shape_down__ = InstructionGroup(group="__shape_down__")
else:
self.__container__.canvas.before.remove(self.__shape_down__)
self.__shape_down__.clear()
color = Color(0, 0, 0, .4)
self.__shape_down__.add(color)
self.__shape_down__.add(
Rectangle(pos=self.__container__.pos, size=size))
self.__container__.canvas.before.add(self.__shape_down__)
super(ButtonBase, self).on_press()
def __init__(self, **kwargs):
super(AltLabel, self).__init__(**kwargs)
self.onColor = (1, 0, 0, 1)
self.offColor = (0, 1, 0, 1)
self.bold = False
self.font_size = 14
self.active = False
self.instr = InstructionGroup()
self.canvas.before.add(self.instr)
def __init__(self, rows: int):
super(GridWidget, self).__init__()
self.rows = rows
self.grid_properties = GridProperties(self.width, self.height,
self.rows)
self.bind(size=self._resize)
self.gridlines = InstructionGroup()
self.paths: List[InstructionGroup] = []
self.factories: List[InstructionGroup] = []
self.touch_down_callback = lambda x_index, y_index: None
self.touch_move_callback = lambda x_index, y_index: None
self.touch_up_callback = lambda: None
self.double_tap_callback = lambda x_index, y_index: None
def __init__(self, size=20, pos=(100, 100), color=Color(50 / 255, 1, 0)):
super(Mute, self).__init__()
x1 = pos[0] - size / 2
x2 = pos[0] + size / 2
y1 = pos[1] - size / 2
y2 = pos[1] + size / 2
self.x = InstructionGroup()
self.x.add(color)
line1 = Line(points=[x1, y2, x2, y1], width=size * .15, cap='square')
line2 = Line(points=[x1, y1, x2, y2], width=size * .15, cap='square')
self.x.add(line1)
self.x.add(line2)
self.add(self.x)
def start(self):
"""Initialize function."""
try:
self.process_list = Process.list()
self.process_list.reverse()
except:
message("エラーが発生しました。管理者権限でこのゲームを実行してみてください。")
return
self.cells = InstructionGroup()
self.overwrap = InstructionGroup()
self.lebels = InstructionGroup()
i = 0
pid_of_this_program = os.getpid()
for proc in self.process_list:
# calculate position
posx, posy = self.index_to_pos(i)
# draw squares
if proc["pid"] == pid_of_this_program:
self.cells.add(Color(0.8, 0.8, 0.8))
else:
self.cells.add(Color(1, 1, 1))
self.cells.add(Rectangle(pos=(posx, posy), size=self.cell_size))
# draw text
self.lebels.add(Color(0, 0, 0))
self.lebels.add(
draw_text_on_canvas(str(proc["pid"]), pos=(posx, posy)))
i += 1
self.canvas.add(self.cells)
self.canvas.add(self.overwrap)
self.canvas.add(self.lebels)
def dessinerFond(case):
dessin_fond = InstructionGroup()
dessin_fond.add(blanc)
dessin_fond.add(Rectangle(pos=case.pos, size=case.size))
label = Label(text=str(case.X) + ',' + str(case.Y),
font_size=int(case.largeur / 5),
color=gris_clair.rgba)
label.texture_update()
texture = label.texture
dessin_fond.add(
Rectangle(texture=texture,
pos=[case.x, case.y],
size=label.texture.size))
def on_enter(self, *args):
if not hasattr(self.app.root, "error_message"):
return None
self.clear_widgets()
menu_background = InstructionGroup()
menu_background.add(Color(*GlobalStyle.error_screen_background_color))
menu_background.add(Rectangle(pos=self.pos, size=self.size))
self.canvas.add(menu_background)
v_layout = BoxLayout(orientation="vertical")
label = Label(text="Error",
font_name=GlobalStyle.extrabold_caption_font,
font_size=GlobalStyle.huge_caption_font_size,
text_size=self.size,
halign="center",
valign="middle",
size_hint_y=40)
v_layout.add_widget(label)
label = Label(text=self.app.root.error_message,
font_name=GlobalStyle.semibold_caption_font,
font_size=GlobalStyle.big_caption_font_size,
text_size=self.size,
halign="center",
valign="middle",
size_hint_y=40)
v_layout.add_widget(label)
h_layout = BoxLayout(orientation="horizontal",
size_hint_y=20,
padding=[0, 0, 0, 20],
spacing=40)
dummy = Label(size_hint_x=1)
h_layout.add_widget(dummy)
menu_button = Button(size_hint=(None, None),
size=GlobalStyle.standard_button_size,
border=(0, 0, 0, 0),
background_normal=image('menu'),
background_down=image('menu_pressed'))
menu_button.bind(on_release=self.menu_button_callback)
h_layout.add_widget(menu_button)
dummy = Label(size_hint_x=1)
h_layout.add_widget(dummy)
v_layout.add_widget(h_layout)
self.add_widget(v_layout)
def on_touch_move(self,touch): self.canvas.clear() if self.cir1==None: return l=touch.pos cir=circle(point(l[0],l[1]),5) cir=self.limitpos(cir) cir.c.set_local(self.cir1.c) path=InstructionGroup() if get_dis_pnt(self.cir1.c,cir.c)>35: self.makepath(path,cir) frill_s=arc(self.cir1,8,135-cir.c.local_t,45-cir.c.local_t) frill_s.draw(path) self.make(path)
def update_values(self, *args):
if not self._ready:
# Not fully initialized
return
for i, value in enumerate(self.values):
try:
if self._previous_values[i] == value:
continue
except:
self._previous_values.append(value)
self._needles.append(InstructionGroup())
color = Color((i % 3) * .5, ((i + 1) % 3) * .5,
((i + 2) % 3 * .5))
length = 1.0
width = 2.0
self._needles_props.append({
'color': color,
'width': width,
'length': length
})
self._previous_values[i] = value
self.canvas.remove(self._needles[i])
needle_props = self._needles_props[i]
x1, y1 = ellipse(self._x0, self._y0,
(self._e_width - 20) * needle_props['length'],
(self._e_height - 20) * needle_props['length'],
self.begin - (self._scale * (value - self.mini)))
self._needles[i] = InstructionGroup()
self._needles[i].add(needle_props['color'])
self._needles[i].add(
Line(points=(x1, y1, self._x0, self._y0),
width=needle_props['width'],
cap='round',
close=False))
self.canvas.add(self._needles[i])
def on_data(self, *args):
self.clear_widgets()
instance, data = args
# TODO: move to draw_static
menu_background = InstructionGroup()
menu_background.add(Color(*GlobalStyle.menu_background_color))
menu_background.add(Rectangle(pos=self.pos, size=self.size))
self.canvas.add(menu_background)
v_layout = BoxLayout(orientation="vertical")
label = Label(text=data['text'],
halign='center',
font_name=GlobalStyle.standard_caption_font,
font_size=GlobalStyle.big_caption_font_size,
size_hint_y=80)
v_layout.add_widget(label)
h_layout = BoxLayout(orientation="horizontal",
size_hint_y=20,
padding=[0, 0, 0, 20],
spacing=40)
dummy = Label(size_hint_x=1)
h_layout.add_widget(dummy)
ok_button = Button(size_hint=(None, None),
size=GlobalStyle.standard_button_size,
border=(0, 0, 0, 0),
background_normal=image('ok'),
background_down=image('ok_pressed'))
ok_button.bind(on_release=data['ok_callback'])
h_layout.add_widget(ok_button)
cancel_button = Button(size_hint=(None, None),
size=GlobalStyle.standard_button_size,
border=(0, 0, 0, 0),
background_normal=image('x'),
background_down=image('x_pressed'))
cancel_button.bind(on_release=data['cancel_callback'])
h_layout.add_widget(cancel_button)
dummy = Label(size_hint_x=1)
h_layout.add_widget(dummy)
v_layout.add_widget(h_layout)
self.add_widget(v_layout)
def on_touch_down(self, touch, *args):
super(FloatButton, self).on_touch_down(touch)
if self.collide_point(touch.x, touch.y):
if self.shape_down == None:
self.shape_down = InstructionGroup(grup="shape_down")
else:
self.shape.canvas.before.remove(self.shape_down)
self.shape_down.clear()
color = Color(0, 0, 0, .4)
self.shape_down.add(color)
self.shape_down.add(
Ellipse(pos=self.shape.pos, size=self.shape.size))
self.shape.canvas.before.add(self.shape_down)
Clock.schedule_once(self.remove_shape_down, .05)
return True
def __init__(self, **kwargs): super(MenuIcon,self).__init__(**kwargs) self.local_c=[0,0] self.r=30 if kwargs is not None: for key, value in kwargs.items(): if(key=='pos'): self.local_c=value self.icon=InstructionGroup() self.icon.add(Color(1,1,1)) self.icon.add(Ellipse(size=(2*self.r,2*self.r),pos=(self.local_c[0]-self.r,self.local_c[1]-self.r))) self.icon.add(SmoothLine(circle=(self.local_c[0],self.local_c[1],self.r+4),width=3)) self.icon.add(Color(.3,.3,.3)) self.icon.add(SmoothLine(circle=(self.local_c[0],self.local_c[1],self.r),width=3)) for group in [self.icon]: self.canvas.add(group)
def build(self):
# window size / position
Window.size = (1280, 600)
Window.left, Window.top = 3100, 30
# members
self.layout = BoxLayout()
test = InstructionGroup()
a = PrTracks()
a.add(PrTrack('', True))
self.layout.canvas.add(Rectangle(pos=(100, 100), size=(100, 100)))
PrClock.schedule_once(trigger, 0)
# return
return self.layout
def on_touch_down(self, touch, *args):
super(ButtonBase, self).on_touch_down(touch)
if self.collide_point(touch.x, touch.y):
size = self.container.size
if self.shape_down == None:
self.shape_down = InstructionGroup(group="shape_down")
else:
self.container.canvas.before.remove(self.shape_down)
self.shape_down.clear()
color = Color(0, 0, 0, .4)
self.shape_down.add(color)
self.shape_down.add(Rectangle(pos=self.container.pos, size=size))
self.container.canvas.before.add(self.shape_down)
Clock.schedule_once(self.remove_shape_down, .1)
return True
def __init__(self, target, following):
super(EntityFollow, self).__init__(target)
self.following = following
self.cells = []
self.moving = False
self.instructions = InstructionGroup()
targeted = self.target.map.layers.by_name['below'].get_at(
*self.following.pos)
# targeted = self.target.map.layers.by_name['below'].get_neighbor_cells(following_cell)[0]
origin_cell = self.target.map.layers.by_name['below'].get_at(
*self.target.pos)
if targeted is not None and targeted.tile.is_passable():
cells = targeted.layer.a_star_search(origin_cell, targeted)
# if there's only two cells selected, and goal is not origin neighbor... then run away, RUN AWAY!
if len(cells
) == 2 and targeted not in self.target.map.layers.by_name[
'below'].get_neighbor_cells(origin_cell):
return
if len(cells) > 1:
cells.reverse()
# self.instructions.clear()
self.instructions = InstructionGroup()
# self.highlight_tiles(cells)
self.cells = cells
self.moving = False
if not self.cells:
print('no cells here dawg')
self.target.state = EntityIdle(self.target)
self.end()
return
# self.highlight_tiles(self.cells)
self.foreshadowed = None
self.velocity = [0, 0]
self.target.anim_delay = .2
self.task = Clock.schedule_interval(self.slow_update, .6)
def makeicon(self,r): self.r=r global inuse inuse.append([self.local_c[0],self.local_c[1],self.r]) self.canvas.clear() self.icon=InstructionGroup() self.icon.add(Color(.3,.3,.3)) self.icon.add(Color(1,1,1)) self.icon.add(Ellipse(size=(2*self.r,2*self.r),pos=(self.local_c[0]-self.r,self.local_c[1]-self.r))) self.icon.add(SmoothLine(circle=(self.local_c[0],self.local_c[1],self.r+4),width=3)) self.icon.add(Color(.3,.3,.3)) self.icon.add(SmoothLine(circle=(self.local_c[0],self.local_c[1],self.r),width=3)) for group in [self.icon]: self.canvas.add(group)
def __init__(self, pos: Tuple[float, float]):
self.world_group = InstructionGroup()
self.top_group = InstructionGroup()
chunk_pos = World.get_chunk_coords_from_pos(pos)
self.loaded_center = chunk_pos
self.seed = random.randint(0, 2**32 - 1)
self.chunks = dict()
self.loaded_chunks = [[
None
for _ in World.get_loaded_range(chunk_pos[0], World.RADIUS_WIDTH)
] for _ in World.get_loaded_range(chunk_pos[1], World.RADIUS_HEIGHT)]
size = Chunk.SIZE, Chunk.SIZE
self.terrain_instructions = [[
Sprite(None, (0, 0), size)
for _ in World.get_loaded_range(chunk_pos[0], World.RADIUS_WIDTH)
] for _ in World.get_loaded_range(chunk_pos[1], World.RADIUS_HEIGHT)]
self.features_chunk_instructions = [[
InstructionGroup()
for _ in World.get_loaded_range(chunk_pos[0], World.RADIUS_WIDTH)
] for _ in World.get_loaded_range(chunk_pos[1], World.RADIUS_HEIGHT)]
self.top_features_chunk_instructions = [[
InstructionGroup()
for _ in World.get_loaded_range(chunk_pos[0], World.RADIUS_WIDTH)
] for _ in World.get_loaded_range(chunk_pos[1], World.RADIUS_HEIGHT)]
for row in self.features_chunk_instructions:
for instruction in row:
self.world_group.add(instruction)
self.load_area(self.loaded_center)
def __init__(self, cnf):
self.name = 'Paint'
self.cnf = cnf
self.x = self.y = self.z = 0
self.oldx = self.oldy = self.oldz = 0
self.video = self.cnf.rootwidget.oimage_wid
self.video.source = self.cnf.background_source
self.draw_widget = self.cnf.rootwidget.oimage_wid
self.draw_instructions = InstructionGroup()
self.draw_widget.canvas.add(self.draw_instructions)
self.firstrun = True
self.actuator_thread_run = True
self.sendrequest = Event()
if not self.cnf.single_thread:
self.requestthread = Thread(target=self.request_thread)
self.requestthread.start()
def __init__(self, **kwargs):
super(ScrollableLabel, self).__init__(**kwargs)
self.instr = InstructionGroup()
self.canvas.before.add(self.instr)
self.label = Label(size_hint=(1, None))
self.label.font_size = 18
self.add_widget(self.label)
# self.colorTuple = (1, 1, 1, 1)
# StackOverflow solution to ensure text wrapping
self.label.bind(
width=lambda *x: self.label.setter('text_size')(self.label, (self.label.width, None)),
texture_size=lambda *x: self.label.setter('height')(self.label, self.label.texture_size[1]))
def __init__(self, **kwargs): self.instr = InstructionGroup() self.bgColor_255 = (60,60,60,255) #BG color in the 0 to 255 scale #Using map to produce a tuple scale 0 to 1 from a tuple scaled 0 to 255 self.bgColor_1 = tuple(list(map(lambda x: round(x/255, 3), self.bgColor_255))) super(HeaderLabel, self).__init__(**kwargs) # Customizing the visuals self.canvas.before.add(self.instr) self.color = (1, 1, 1, 1) #Font color in the 0 to 1 scale self.bold = True self.font_size = 20
def selection(widget, select=False):
"""
Emphasizes the widget adding a clear transparent background.
"""
group = len(widget.canvas.get_group('sel')) > 0
if not group:
sel = InstructionGroup(group='sel')
sel.add(Color(1, 1, 1, 0.3))
sel.add(Rectangle(pos=widget.pos, size=widget.size))
with widget.canvas:
if select and not group:
widget.canvas.add(sel)
elif not select and group:
widget.canvas.remove_group('sel')
else:
pass # Nothing to do here!
