def __init__(self, target):
self.target = target
self.background_image = sf.Sprite(
sf.Texture.from_file(target.dialog_background))
self.dialog_icon = sf.Sprite(sf.Texture.from_file(target.dialog_icon))
self.label = target.label
self.next_label = self.label
### ATTENTION ^ BUG IF STRING IS EMPTY`
self.name = sf.Text(target.name, sf.Font.from_file("data/font.ttf"),
40)
self.name.position = 300, 475
#self.name.string = target.name
self.name.color = sf.Color(241, 213, 169)
#self.dialog_file = target.dialog_file
with open(target.dialog_file) as data_file:
self.data = json.load(data_file)
#print(self.data[self.label])
#self.font = sf.Font.from_file()
self.text = sf.Text(self.data[self.label]['text'],
sf.Font.from_file("data/font.ttf"), 40)
#self.text.string = self.data[self.label]['text']
self.text.position = 500, 610
self.text.color = sf.Color(45, 35, 18)
self.answers = []
self.cursor = sf.RectangleShape()
self.cursor.fill_color = sf.Color(30, 40, 50, 60)
self.cursor.size = 300, 30
self.cursor.position = 50, 565
self.loadAnswers()
self.texture = sf.Texture.create(window.size.x, window.size.y)
self.texture.update(window)
self.sprite = sf.Sprite(self.texture)
self.camera = sf.View()
self.camera.reset([0, 0, 1280, 800])
window.view = self.camera
def textInput(window, string, font, maxLength=None):
window.clear(sf.Color.BLACK)
text = sf.Text(string)
text.font = font
text.character_size = 40
text.color = sf.Color.WHITE
text.position = (centerWidth(window, text), (centerHeight(window, text)))
inputString = ""
inputText = sf.Text(inputString)
inputText.font = font
inputText.character_size = 24
inputText.color = sf.Color.GREEN
inputText.position = (centerWidth(window,
inputText), text.position[1] + 30)
while True:
window.clear(sf.Color.BLACK)
for event in window.events:
if type(event) is sf.CloseEvent:
exit()
if (type(event) is sf.TextEvent):
if (ord(event.unicode) == 13 and len(inputString) > 1): #Enter
return inputString
elif (ord(event.unicode) == 8
and len(inputString) >= 1): # Backspace
inputString = inputString[:-1]
inputText = sf.Text(inputString)
inputText.font = font
inputText.character_size = 24
inputText.color = sf.Color.GREEN
inputText.position = (centerWidth(window, inputText),
text.position[1] +
inputText.character_size +
text.character_size)
elif (ord(event.unicode) < 127 and ord(event.unicode) >= 65):
if (maxLength and len(inputString) == maxLength):
continue
inputString += event.unicode
inputText = sf.Text(inputString)
inputText.font = font
inputText.character_size = 24
inputText.color = sf.Color.GREEN
inputText.position = (centerWidth(window, inputText),
text.position[1] +
inputText.character_size +
text.character_size)
window.draw(text)
window.draw(inputText)
window.display()
def selectOptions(window, optionsStrings, selectValues, font):
# creates a screen with options in vertical layout given by optionsStrings, and
# returns the value from selectValues that is selected
window.clear(sf.Color.BLACK)
numOptions = len(optionsStrings)
textObjects = []
for string in optionsStrings:
textObjects.append(sf.Text(string))
for i in range(numOptions):
text = textObjects[i]
text.font = font
text.character_size = 40
text.color = sf.Color.WHITE
areaLow = i * window.height // numOptions
areaHight = areaLow + (window.height // numOptions)
text.position = (centerWidth(window, text),
(centerLocalHeight(areaLow, areaHight, text)))
optionChosen = False
indexOfSelected = 0
while (not optionChosen):
window.clear(sf.Color.BLACK)
mouseY = sf.Mouse.get_position(window)[1]
for i in range(numOptions):
color = None
if i == indexOfSelected:
color = sf.Color.GREEN
else:
color = sf.Color.WHITE
textObjects[i].color = color
for text in textObjects:
window.draw(text)
for event in window.events:
if type(event) is sf.CloseEvent:
exit()
if (type(event) is sf.MouseMoveEvent):
indexOfSelected = int(mouseY // (window.height / numOptions))
elif (type(event) is sf.MouseButtonEvent and event.pressed
or type(event) is sf.KeyEvent and event.pressed
and event.code == sf.Keyboard.RETURN):
return selectValues[indexOfSelected]
elif (type(event) is sf.KeyEvent and event.pressed):
if (event.code == sf.Keyboard.DOWN
or event.code == sf.Keyboard.RIGHT):
indexOfSelected = (indexOfSelected + 1) % numOptions
elif (event.code == sf.Keyboard.UP
or event.code == sf.Keyboard.LEFT):
indexOfSelected = (indexOfSelected - 1) % numOptions
window.display()
def __init__(self, target, low, high, step, init=None):
"""Initialize a new Spinner. target is window to
draw to, low is lower boundary, high is higher
boundary, step is the step size and init is
the initial value."""
super().__init__(target)
self.low = low
self.high = high
self.step = step
if init is None:
self.value = low
else:
self.value = init
self.more = Button(target, "Större")
self.more.set_listener(self.increment)
self.less = Button(target, "Mindre")
self.less.set_listener(self.decrement)
font = sf.Font.from_file(assets.get_asset("/fonts/GeosansLight.ttf"))
self.display = sf.Text()
self.display.font = font
self.display.string = str(self.value)
self.set_character_size(14)
self.set_position((0, 0))
def load(self, config_file):
sprite = sf.Sprite(sf.Texture.from_file("data/images/loading.png"))
window.clear()
window.draw(sprite)
window.display()
self.time_of_text_live = 250
with open(config_file) as data_file:
self.data = json.load(data_file)
self.name = self.data['level_name']
self.game_objects.clear()
self.usable.clear()
self.npcs.clear()
self.loot.clear()
for g_object in self.data['game_objects']:
self.game_objects.append(
GameObject(g_object['object'], position=g_object['position']))
for f_npc in self.data['npc']:
try:
npc = f_npc['npc']
pos = f_npc['position']
self.npcs.append(NPC(npc, pos))
except Exception as e:
print(e)
self.npcs.append(NPC(f_npc))
self.floating_name = sf.Text(
self.name, sf.Font.from_file("data/files/fonts/Bricks.otf"), 100)
self.time_of_text_live = 250
def __init__(self, target, single_player, color=None):
"""Instantiate SizeMenu. target is window to draw to,
single_player is whether a single player game is to
be played and color is the color the player wants to
play as in case of single player."""
super().__init__(target)
if single_player and color is None:
raise ValueError("Color must not be None if single_player is True.")
self.next_scene = None
self.single_player = single_player
self.color = color
font = sf.Font.from_file(assets.get_asset("/fonts/GeosansLight.ttf"))
self.title = sf.Text()
self.title.string = "Välj storlek på brädet"
self.title.font = font
self.size = Spinner(target, 4, 20, 2, 8)
self.next = Button(target, "Fortsätt")
self.next.set_listener(self._switch_to_game)
self.add_component(self.size)
self.add_component(self.next)
self._setup_components()
def __init__(self):
self.loading_text = sf.Text('Initializing...')
self.loading_text.character_size = 64
self.loading_text.font = sf.Font.from_file('loading.ttf')
self.texture = sf.Texture.from_file("data/world16384.png")
self.world = sf.Sprite(self.texture)
self.video_mode = sf.VideoMode.get_fullscreen_modes()[0]
vm_size = self.video_mode.width, self.video_mode.height
self.world.origin = (c / 2 for c in self.texture.size)
self.world.position = (c / 2 for c in vm_size)
self.world.ratio = (min(
v / t for t, v in zip(self.texture.size, vm_size)), ) * 2
self.original_ratio = self.world.ratio.x
self.fc_logo = sf.Sprite(sf.Texture.from_file("fcbayern.png"))
self.fc_logo.origin = 200, 400
self.fc_logo.position = vm_size[0] / 2, vm_size[1] / 2 - 30
self.dhl = sf.Sprite(sf.Texture.from_file("globalfamily.png"))
self.dhl.origin = self.dhl.texture.size
self.dhl.position = (x - 60 for x in vm_size)
self.loading_text.position = vm_size[0] / 2, vm_size[1] / 2 + 30
self.loading_text.color = sf.Color(255, 255, 255, 255)
self.fade = sf.RectangleShape(vm_size)
self.fade.fill_color = sf.Color(0, 0, 0, 200)
self.fade.position = (0, 0)
self.window = sf.RenderWindow(self.video_mode, "FanMap")
self.window.framerate_limit = 60
self.q = Queue()
self.objects = []
self.zoomt = -1
self.zoomdirec = 0
self.target_origin = self.world.origin
super().__init__()
def __init__(self, target):
super().__init__(target)
self.next_scene = None
size = self.target.size
view = sf.View(sf.Rectangle((0, 0), (size.x, size.y)))
self.target.view = view
font = sf.Font.from_file(assets.get_asset("/fonts/Amethyst.ttf"))
# Title
self.title = sf.Text()
self.title.string = "Reversi"
self.title.font = font
self.title.color = sf.Color.WHITE
title_bounds = self.title.global_bounds
# Menu items
self.menuitems = []
for item in [["Spela en spelare", self._switch_colormenu], ["Spela två spelare", self._switch_sizemenu], ["Avsluta", target.close]]:
button = Button(target, item[0])
button.set_listener(item[1])
self.menuitems.append(button)
self.add_component(button)
self._setup_buttons()
def __init__(self, dialog, text, action):
super(DialogButton, self).__init__()
#self.sprite = #sf.Sprite(sf.Texture.from_file("data/texture.png"))
self.text = sf.Text(text, sf.Font.from_file("data/font.ttf"))
self.focused = False
self.action = action
self.text.color = sf.Color(133, 109, 48)
self.dialog = dialog
def pynk_text_width_callback(handle,height,text,len):
type=pynk.ffi.from_handle(handle.ptr)
temp=sf.Text()
temp.font=type
temp.string=pynk.ffi.string(text, len).decode('ascii')
temp.character_size=height
text_width=temp.find_character_pos(len).x-temp.find_character_pos(0).x
return text_width
def __init__(self, id, x, y, text, font, color=[25, 25, 25], size=20):
self.font = sf.Font.from_file(font)
self.text = sf.Text()
self.text.font = self.font
self.text.string = text
self.text.character_size = 20
self.text.color = sf.Color(color[0], color[1], color[2])
self.text.position = (x, y)
def draw(self, target, states):
if self.is_loaded:
self.on_draw(target, states)
else:
error = sf.Text("Shader not\nsupported")
error.font = sf.Font.from_file("data/sansation.ttf")
error.position = (320, 200)
error.character_size = 36
target.draw(error, states)
def nuklearSfmlDrawText(self,cmd,window):
p=pynk.ffi.cast("struct nk_command_text*",cmd)
font = pynk.ffi.from_handle(p.font.userdata.ptr)
text=sf.Text()
text.font=font
text.string=pynk.ffi.string(p.string, p.length).decode('ascii')
text.character_size=p.height
text.color=sf.Color(p.foreground.r,p.foreground.g,p.foreground.b,p.foreground.a)
text.position=sf.Vector2(p.x,p.y)
window.draw(text)
def message(window, color, message, pos, size=25):
g = sf.Text()
g.string = str(message)
g.font = font
g.character_size = size
g.position = pos
g.color = sf.Color(color[0], color[1], color[2])
window.draw(g)
def __init__(self):
self.camera = sf.View()
self.camera.reset([0, 0, 1280, 800])
window.view = self.camera
self.texture = sf.Texture.create(window.size.x, window.size.y)
self.texture.update(window)
self.sprite = sf.Sprite(self.texture)
self.rect = sf.RectangleShape()
self.rect.position = 0, 0
self.rect.size = window.size.x, window.size.y / 2
self.rect.fill_color = sf.Color(30, 30, 30, 200)
self.text = sf.Text("",
sf.Font.from_file("data/files/fonts/Bricks.otf"),
20)
self.ps1 = sf.Text("->: ", sf.Font.from_file("data/font.ttf"), 20)
self.ps1.position = 0, window.size.y / 2 - 30
self.text.position = 25, window.size.y / 2 - 30
self.shader = sf.Shader.from_file(fragment="data/blur.frag")
self.shader.set_parameter("source")
self.shader.set_parameter("offsetFactor", 0.00075, 0.00075)
self.states = sf.RenderStates()
self.states.shader = self.shader
def new_button(self, name, position, color, size="standard"):
btn_shape = sf.RectangleShape()
if size == "standard":
btn_shape.size = (200, 75)
elif size == "small":
btn_shape.size = (100, 75)
btn_shape.position = position
btn_shape.fill_color = color
btn_text = sf.Text(name)
btn_text.font = self.FONT
btn_text.color = sf.Color.BLACK
btn_text.position = btn_shape.position + sf.Vector2(25, 75 / 2)
return {'shape': btn_shape, 'text': btn_text}
def __init__(self, text, x=0, y=0):
"""
Create a Text object.
Parameters:
text (str) : text in button
x (int) : position of left corner
y (int) : position of upper corner
"""
super().__init__(x, y)
self._text = sf.Text(text)
self._text.font = font
self._text.character_size = 20
self.__string = text
def makeText(window,
string="",
size=30,
font=None,
position=(0, 0),
color=sf.Color.WHITE):
text = sf.Text(string)
text.character_size = size
text.font = font
if position == "center":
text.position = (centerWidth(window, text), centerHeight(window, text))
else:
text.position = position
text.color = color
return text
def __init__(self, font, text, color, position, size):
self.font = font
self.label = sf.Text()
self.label.font = self.font
self.text = text
self.label.string = unicode(self.text)
self.color = color
self.label.color = self.color
self.position = position
self.size = size
self.label.character_size = self.size
self.hover_color = sf.Color.CYAN
self.centerText()
self.setPosition(self.position)
def __init__(self, target, text, pos=(0, 0)):
"""Initialize new button with text text at
position pos."""
super().__init__(target)
font = sf.Font.from_file(assets.get_asset("/fonts/GeosansLight.ttf"))
self.text = sf.Text()
self.text.string = text
self.text.font = font
self.text.color = sf.Color.WHITE
self.set_character_size(18)
self.set_position(pos)
self.listener = None
def on_load(self):
with open("data/text.txt") as file:
self.text = sf.Text(file.read())
self.text.font = sf.Font.from_file("data/sansation.ttf")
self.text.character_size = 22
self.text.position = (30, 20)
try:
# load the shader
self.shader = sf.Shader.from_file("data/wave.vert",
"data/blur.frag")
except IOError as error:
print("An error occured: {0}".format(error))
exit(1)
return True
def on_load(self):
with open("data/text.txt") as file:
self.text = sf.Text(file.read())
self.text.font = sf.Font.from_file("data/sansation.ttf")
self.text.character_size = 22
self.text.position = (30, 20)
self.texture = sf.Texture.from_file("data/background.jpg")
self.sprite = sf.Sprite(self.texture)
try:
# load the shader
self.shader = sf.Shader.from_file(
"data/wave.vert") #, "data/blur.frag")
except:
pass
return True
def __init__(self, target):
self.camera = sf.View()
self.camera.reset([0, 0, 1280, 800])
window.view = self.camera
self.texture = sf.Texture.create(window.size.x, window.size.y)
self.texture.update(window)
self.sprite = sf.Sprite(self.texture)
self.background = sf.Sprite(
sf.Texture.from_file("data/images/inventory_background2.png"))
codes = state_machine.states[len(state_machine.states) -
1].player.inventory
self.inventory = []
for code in codes:
self.inventory.append(InventoryObject(code))
begin = {'x': 505, 'y': 165}
#355,162
self.offset = 57
group_by = 10
counter = -1
row = 0
for c, obj in enumerate(self.inventory, 0):
counter += 1
if counter >= group_by:
counter = 0
row += 1
obj.sprite.position = [
begin['x'] + counter * self.offset,
begin['y'] + self.offset * row
]
self.info_table = sf.Text("", sf.Font.from_file("data/font.ttf"), 20)
self.cursor = sf.Sprite(
sf.Texture.from_file("data/images/inventory_cursor.png"))
self.cursor.position = [begin['x'] - 6, begin['y'] - 7]
self.info_table.position = [
begin['x'] + self.offset, begin['y'] + self.offset
]
self.cursor_target = 0
#self.cursor.position = [self.inventory[self.cursor_target].position.x-6,self.inventory[self.cursor_target].position.y-8]
try:
self.info_table.string = self.inventory[0].description
except Exception as e:
print(e)
def __init__(self, target):
super().__init__(target)
self.next_scene = None
font = sf.Font.from_file(assets.get_asset("/fonts/GeosansLight.ttf"))
self.title = sf.Text()
self.title.string = "Vilken färg vill du spela som?"
self.title.font = font
self.button_white = Button(self.target, "Vit")
self.button_white.set_listener(self._switch_size_white)
self.button_black = Button(self.target, "Svart")
self.button_black.set_listener(self._switch_size_black)
self.add_component(self.button_white)
self.add_component(self.button_black)
self._setup_components()
def drawText(window,
string="",
size=30,
font=None,
position=(0, 0),
xposition=None,
yposition=None,
color=sf.Color.WHITE):
text = sf.Text(string)
text.character_size = size
text.font = font
text.color = color
if position == "center":
text.position = (centerWidth(window, text), centerHeight(window, text))
else:
text.position = position
if xposition is not None:
text.position = (xposition, text.position[1])
if yposition is not None:
text.position = (text.position[0], yposition)
window.draw(text)
return text
def __init__(self, config_file="data/files/levels/test_level.json"):
super(Level, self).__init__()
with open(config_file) as data_file:
self.data = json.load(data_file)
self.name = self.data['level_name']
self.game_objects = []
self.npcs = []
self.loot = []
self.usable = []
for g_object in self.data['game_objects']:
self.game_objects.append(
GameObject(g_object['object'], position=g_object['position']))
for f_npc in self.data['npc']:
try:
npc = f_npc['npc']
pos = f_npc['position']
self.npcs.append(NPC(npc, pos))
except Exception as e:
self.npcs.append(NPC(f_npc))
self.floating_name = sf.Text(
self.name, sf.Font.from_file("data/files/fonts/Bricks.otf"), 100)
self.time_of_text_live = 250
def _create(self):
self.anim_player.play(self._style.anim)
if isinstance(self._style.background, sf.Color):
self._bg = sf.RectangleShape(
(self._style.width, self._style.height))
self._bg.fill_color = self._style.background
else:
self._bg = sf.Sprite(self._style.background)
if self._style.anim is not None:
self._bg.texture_rectangle = self._style.anim.frames[
0].rectangle
self._bg.position = self._position
if isinstance(self._style.font, sf.Font):
self._front = sf.Text(self._text)
self._front.font = self._style.font
self._front.character_size = self._style.font_size
else:
self._front = BitmapText(self._text, self._style.font)
self._front.font = self._style.font
self._front.position = self._position + sf.Vector2(self.style.width, self.style.height) / 2\
- sf.Vector2(self._front.global_bounds.width / 2, self._front.global_bounds.height / 2) \
- sf.Vector2(self._front.global_bounds.left, self._front.global_bounds.top)
glVertex3f(-size, -size, -size)
glTexCoord2f(1, 0)
glVertex3f(size, -size, -size)
glTexCoord2f(1, 1)
glVertex3f(size, -size, size)
glTexCoord2f(0, 1)
glVertex3f(-size, size, size)
glTexCoord2f(0, 0)
glVertex3f(-size, size, -size)
glTexCoord2f(1, 0)
glVertex3f(size, size, -size)
glTexCoord2f(1, 1)
glVertex3f(size, size, size)
glEnd()
# draw some text on top of our OpenGL object
window.push_GL_states()
text = sf.Text("pySFML / OpenGL demo", font)
text.color = sf.Color(255, 255, 255, 170)
text.position = (230, 450)
window.draw(text)
window.pop_GL_states()
# finally, display the rendered frame on screen
window.display()
# don't forget to destroy our texture
glDeleteTextures(1, texture)
exit(1)
text_background = sf.Sprite(text_background_texture)
text_background.position = (0, 520)
text_background.color = sf.Color(255, 255, 255, 200)
# load the messages font
try:
font = sf.Font.from_file("data/sansation.ttf")
except IOError as error:
print("An error occured: {0}".format(error))
exit(1)
# create the description text
description = sf.Text("Current effect: {0}".format(effects[current].name),
font, 20)
description.position = (10, 530)
description.color = sf.Color(80, 80, 80)
# create the instructions text
instructions = sf.Text(
"Press left and right arrows to change the current shader", font, 20)
instructions.position = (280, 555)
instructions.color = sf.Color(80, 80, 80)
clock = sf.Clock()
# start the game loop
while window.is_open:
# update the current example
def __init__(self, grid_step):
self.grid_step = grid_step
self.directions = 4
# creating a grid
self.create_grid(self.grid_step)
self.create_grid_elements()
self.walls_list = []
self.deleted_walls = False
# path line
self.path = sf.VertexArray(sf.PrimitiveType.LINES_STRIP, 0)
# path outline, just to make the line look thicker
self.path_outline1 = sf.VertexArray(sf.PrimitiveType.LINES_STRIP, 0)
self.path_outline2 = sf.VertexArray(sf.PrimitiveType.LINES_STRIP, 0)
# GUI
self.search_button = self.new_button(
'Search',
(self.GRID_POS.x + self.grid_box.size.x + 75, self.GRID_POS.y + 25),
sf.Color(50, 200, 50)
)
self.reset_button = self.new_button(
'Reset',
(self.GRID_POS.x + self.grid_box.size.x + 75, self.GRID_POS.y + 125),
sf.Color(200, 50, 50)
)
self.dezoom_button = self.new_button(
' -',
(self.GRID_POS.x + self.grid_box.size.x + 72, self.GRID_POS.y + 225),
sf.Color(160, 160, 160), size="small"
)
self.zoom_button = self.new_button(
' +',
(self.GRID_POS.x + self.grid_box.size.x + 72 + 105, self.GRID_POS.y + 225),
sf.Color(160, 160, 160), size="small"
)
self.directions_text = sf.Text('Directions :')
self.directions_text.font = self.FONT
self.directions_text.color = sf.Color.BLACK
self.directions_text.character_size = 25
self.directions_text.origin = (0, -self.directions_text.character_size/2)
self.directions_text.position = (self.GRID_POS.x + self.grid_box.size.x + 72, self.GRID_POS.y + 375)
self.direction4_button = self.new_button(
' 4',
(self.GRID_POS.x + self.grid_box.size.x + 72, self.GRID_POS.y + 425),
sf.Color(160, 160, 160), size="small"
)
self.direction8_button = self.new_button(
' 8',
(self.GRID_POS.x + self.grid_box.size.x + 72 + 105, self.GRID_POS.y + 425),
sf.Color(160, 160, 160), size="small"
)
self.fps_text = sf.Text('fps:')
self.fps_text.font = self.FONT
self.fps_text.color = sf.Color.BLACK
self.fps_text.character_size = 20
self.fps_text.origin = (0, -self.fps_text.character_size / 2)
self.fps_text.position = (0, 0)
self.fps_history = [] # used to compute average FPS
self.message = sf.Text('')
self.message.font = self.FONT
self.message.color = sf.Color.BLACK
self.message.character_size = 25
self.message.origin = (0, -self.message.character_size / 2)
self.message.position = (350, 10)
self.author = sf.Text('Modar NASSER (c) 2020')
self.author.font = self.FONT
self.author.color = sf.Color.BLACK
self.author.character_size = 20
self.author.origin = (self.author.global_bounds.width, self.author.character_size/2)
self.fps_clock = sf.Clock() # used to get real fps
self.astar_clock = sf.Clock() # used to get how much time the agorithm takes
self.current_state = self.START_POS_STATE
self.window = sf.RenderWindow(sf.VideoMode(1422, 800), "A* algorithm simulator")
self.window.framerate_limit = 100
self.icon = sf.Image.from_file(pyInstallerPath('assets/icon64.png'))
self.window.set_icon(64, 64, sf.Image.from_file(pyInstallerPath('assets/icon64.png')).pixels.tobytes())
self.author.position = (self.window.size.x-5, self.window.size.y-5)
