def __init__(self,screen):
screenrect=screen.get_rect()
bgcolor=COLORS['tabledark']
fgcolor=COLORS['yellow']
helpdata=['','Bridget 0.1',
'--------------------------------',
'F1/ctrl+H - Show Help',
'F5/ctrl+N - New Rubber',
'F9 - Toggle Show All Hands',
'B - Show/Hide Bidding',
'Mouse - select card','ESC - Quit',
'--------------------------------']
self.help= TextBox(helpdata, None, (400,300),18,COLORS['black'],COLORS['yellow'])
self.contract= TextBox(['Contract:'],(10,125),None, 14,bgcolor,fgcolor)
self.trickcount=TextBox(['Tricks:'], (10,145),None, 14,bgcolor,fgcolor)
self.dealer= TextBox(['Dealer:'], (10,105),None, 14,bgcolor,fgcolor)
self.score=ScoreBox(screen)
self.trickpics=TrickPics(screen)
self.handinfo=[]
# size=(125,80)
# pos=(50,160)
# for iseat in range(GLOBALS.deck.nseats):
# self.handinfo.append(TextBox(None,pos,size,14,GLOBALS.colors['black'],GLOBALS.colors['yellow']))
self.help.centered=1
self.help.alpha=200
self.help.update()
self.draw(screen)
def __init__(self, engine, index):
self.engine = engine
self.index = index
self.engine.heroes[index].name = ''
cursor_image = pyglet.image.load('./resources/cursor.png')
self.title = pyglet.text.Label('SELECT NAME', x=72, y=24, font_size=8)
self.name_box = TextBox(48, 32, 104, 192, RED)
self.char_box = TextBox(184, 160, 32, 16)
self.cursor = pyglet.sprite.Sprite(cursor_image, x=32, y=143)
self.chars = {
(48, 152): 'A', (64, 152): 'B', (80, 152): 'C', (96, 152): 'D', (112, 152): 'E',
(128, 152): 'F', (144, 152): 'G', (160, 152): 'H', (176, 152): 'I', (192, 152): 'J',
(48, 136): 'K', (64, 136): 'L', (80, 136): 'M', (96, 136): 'N', (112, 136): 'O',
(128, 136): 'P', (144, 136): 'Q', (160, 136): 'R', (176, 136): 'S', (192, 136): 'T',
(48, 120): 'U', (64, 120): 'V', (80, 120): 'W', (96, 120): 'X', (112, 120): 'Y',
(128, 120): 'Z', (144, 120): "'", (160, 120): ',', (176, 120): '.', (192, 120): ' ',
(48, 104): 'a', (64, 104): 'b', (80, 104): 'c', (96, 104): 'd', (112, 104): 'e',
(128, 104): 'f', (144, 104): 'g', (160, 104): 'h', (176, 104): 'i', (192, 104): 'j',
(48, 88): 'k', (64, 88): 'l', (80, 88): 'm', (96, 88): 'n', (112, 88): 'o',
(128, 88): 'p', (144, 88): 'q', (160, 88): 'r', (176, 88): 's', (192, 88): 't',
(48, 72): 'u', (64, 72): 'v', (80, 72): 'w', (96, 72): 'x', (112, 72): 'y',
(128, 72): 'z', (144, 72): '-', (160, 72): chr(0x2026), (176, 72): '!', (192, 72): '?'
# ellipsis
}
self.labels = [pyglet.text.Label(self.chars[key], x=key[0], y=key[1], font_size=8)
for key in self.chars.keys()]
self.engine.push_handlers(on_draw=self.on_draw,
on_key_press=self.on_key_press)
class ScoreWidget:
"""Widget to show a score and associated image"""
def __init__(self, image, window, stringfunc=None, bgtileimage=None):
self.image = image
self.bgtileimage = bgtileimage
self.window = window
self.stringfunc = (stringfunc if stringfunc != None else
lambda a, b: str(a) + ("/"+str(b) if b != None else ""))
self.textbox = TextBox(22, (205, 205, 75), True)
def draw(self, region, quantity, total=None):
"""Draw the score widget"""
region = pygame.Rect(region)
old_clip = self.window.get_clip()
self.window.set_clip(region)
if self.bgtileimage:
for ix in range(region.left, region.right, self.bgtileimage.get_width()):
for iy in range(region.top, region.bottom, self.bgtileimage.get_height()):
self.window.blit(self.bgtileimage, (ix, iy))
else:
pygame.draw.rect(self.window, BLACK, region)
imageregion = region.inflate(-10,-10)
imageregion.height -= 20
if imageregion.height > 0 and imageregion.height > 0:
fittedimage = self.image.get_rect().fit(imageregion)
self.window.blit(pygame.transform.scale(self.image, fittedimage.size), fittedimage)
string = self.stringfunc(quantity, total)
self.textbox.draw(string, region, (True, False), self.window)
self.window.set_clip(old_clip)
def splash(message, fontsize=40, icon=None):
"""Display a splash message across the viewing area"""
pygame.draw.rect(self.window, BLACK, region)
textbox = TextBox(fontsize, WHITE, False)
if icon is not None:
self.window.blit(icon, [(region.size[axis]-icon.get_size()[axis])/2 for axis in [0,1]])
region.move_ip(0, icon.get_height()/2 + fontsize)
textbox.draw(message, region, surface=self.window)
def update(self):
self.add_input_button.update()
self.delete_input_button.update()
self.calculate_button.update()
text("Magnitude", 250, 90)
text("Direction", 450, 90)
text("X", 620, 90)
text("Y", 720, 90)
text("Z", 820, 90)
#Code for adding and deleting input boxes
if self.add_input_button.getData() == True:
self.magnitude_text_boxes.append(
TextBox(250, self.text_box_y, 100, 30, 20))
self.direction_text_boxes.append(
TextBox(450, self.text_box_y, 100, 30, 20))
self.text_box_y += 30
elif self.delete_input_button.getData() == True:
self.magnitude_text_boxes.pop(len(self.magnitude_text_boxes) - 1)
self.direction_text_boxes.pop(len(self.direction_text_boxes) - 1)
self.text_box_y -= 30
#Update input boxes
for text_box in self.magnitude_text_boxes:
text_box.update()
for text_box in self.direction_text_boxes:
text_box.update()
#If the Calculate button is pressed, calculate values
if self.calculate_button.getData() == True:
self.x_answers = []
self.y_answers = []
self.z_answers = []
for i in range(len(self.magnitude_text_boxes)):
self.x_answers.append(
float(self.magnitude_text_boxes[i].getData()) *
math.cos(int(self.direction_text_boxes[i].getData())))
self.y_answers.append(
float(self.magnitude_text_boxes[i].getData()) *
math.sin(int(self.direction_text_boxes[i].getData())))
inside = pow(float(self.magnitude_text_boxes[i].getData()),
2) - pow(self.x_answers[i], 2) - pow(
self.y_answers[i], 2)
self.z_answers.append(pow(inside, .333))
#If there are an answers, display them
if len(self.x_answers) > 0:
last_index = 0
for i in range(len(self.x_answers)):
text(self.x_answers[i], 600, 140 + i * 30)
text(self.y_answers[i], 700, 140 + i * 30)
text(self.z_answers[i], 800, 140 + i * 30)
last_index = i
text("Totals:", 450, 170 + last_index * 30)
text(sum(self.x_answers), 600, 170 + last_index * 30)
text(sum(self.y_answers), 700, 170 + last_index * 30)
text(sum(self.z_answers), 800, 170 + last_index * 30)
def __init__(self, defaultCrypto='BTC', defaultExchange='USD'):
super().__init__()
self.setAutoFillBackground(True)
fontSize = 10
cryptoX = 320
cryptoY = 30
cryptoWidth = 70
cryptoHeight = 25
horizontalTextBoxSpace = 30
exchangeX = cryptoX + cryptoWidth + horizontalTextBoxSpace
exchangeY = cryptoY + cryptoHeight + 25
exchangeWidth = cryptoWidth
exchangeHeight = cryptoHeight
self.canvas = Canvas(self)
self.canvas.move(0, 0)
self.canvas.resize(315, 300)
labelWidth = 30
labelCrypto = QLabel(self)
labelCrypto.setText('Crypto')
labelCrypto.move(cryptoX + (cryptoWidth - labelWidth) / 2.5,
cryptoY - 20)
labelExchange = QLabel(self)
labelExchange.setText('Exchange')
labelExchange.move(cryptoX + (cryptoWidth - labelWidth) / 2.5 - 2,
exchangeY - 20)
self.cryptoTextBox = TextBox(self,
defaultText=defaultCrypto,
placeholder='Crypto',
fontSize=fontSize,
x=cryptoX,
y=cryptoY,
width=cryptoWidth,
height=cryptoHeight)
self.exchangeTextBox = TextBox(self,
defaultText=defaultExchange,
placeholder='Exchange',
fontSize=fontSize,
x=cryptoX,
y=exchangeY,
width=cryptoWidth,
height=exchangeHeight)
buttonGo = QPushButton('Go', self)
buttonGo.move(cryptoX - 2, exchangeY + exchangeHeight + 20)
buttonGo.clicked.connect(self.updateGraph)
def __init__(self, left):
# uses screen dimensions for player placement
self.screen_dim = g_const.screen_dim
# player dimensions
self.p_w = g_const.p_w
self.p_h = g_const.p_h
# surface to be displayed, rect to be transformed
self.p_surface = g_const.face_surface
self.p_surface = pyg.transform.scale(self.p_surface,
(self.p_w, self.p_h))
self.p_rect = self.p_surface.get_rect() # pos: 0, 0
if g_const.p_move_frame_speed:
self.p_speed = g_const.p_speed_frame
else:
self.p_speed = g_const.p_speed_sec
self.p_left = left
if not left:
self.p_rect.x = self.screen_dim.w - self.p_rect.w
self.score = 0
self.show_winner_text = False
self.pause_for_win = False
self.score_text = TextBox(40, g_const.game_text_font,
g_const.game_text_color, self.p_left)
self.win_text = TextBox(20, g_const.game_text_font,
g_const.game_text_color, self.p_left)
if self.p_left:
self.score_text.set_pos(self.screen_dim.w // 2,
self.screen_dim.h - 50)
self.score_text.set_right_align(self.screen_dim.w // 2 - 15)
self.win_text.set_pos(self.screen_dim.w // 2,
self.screen_dim.h // 2 + 40)
self.win_text.set_right_align(self.screen_dim.w // 2 - 15)
else:
self.score_text.set_pos(self.screen_dim.w // 2 + 15,
self.screen_dim.h - 50)
self.win_text.set_pos(self.screen_dim.w // 2 + 15,
self.screen_dim.h // 2 + 40)
self.win_text.update_text("WINNER")
self.up_state = self.down_state = False
self.reset_player()
def setup_menu_screen(self):
title = TextBox(sf.Texture.from_file("res/title.png"))
title.origin = title.local_bounds.center
title.set_position((self.window.size.x / 2, (self.window.size.y / 3)))
self.button_dict['title'] = title
assaultgunbutton = Button(sf.Texture.from_file("res/AssaultGunButton.png"))
assaultgunbutton.origin = assaultgunbutton.local_bounds.center
assaultgunbutton.set_position(self.window.size / 2)
self.button_dict['assaultgun'] = assaultgunbutton
tankbutton = Button(sf.Texture.from_file("res/TankButton.png"))
tankbutton.origin = tankbutton.local_bounds.center
tankbutton.set_position((self.window.size.x / 2, (self.window.size.y / 3) * 2))
self.button_dict['tank'] = tankbutton
class VectorDotProduct:
x1 = TextBox(250, 40, 100, 30, 20)
x2 = TextBox(250, 110, 100, 30, 20)
y1 = TextBox(380, 40, 100, 30, 20)
y2 = TextBox(380, 110, 100, 30, 20)
button = Button(250, 180, 250, 30, "Calculate", 20)
magnitude1 = 0
magnitude2 = 0
direction = 0
dot_product = 0
def update(self):
#update input boxes, button, and show text
self.x1.update()
self.x2.update()
self.y1.update()
self.y2.update()
self.button.update()
text("X1", 250, 30)
text("Y1", 380, 30)
text("X2", 250, 100)
text("Y2", 380, 100)
text("Magnitude 1:", 250, 250)
text("Magnitude 2:", 250, 280)
text("Direction:", 250, 310)
text("Dot Product:", 250, 340)
#If the Calculate button is pressed, calculate values
if self.button.getData() == True:
self.magnitude1 = sqrt(
pow(int(self.x1.getData()), 2) +
pow(int(self.y1.getData()), 2))
self.magnitude2 = sqrt(
pow(int(self.x2.getData()), 2) +
pow(int(self.y2.getData()), 2))
self.direction = math.asin(
int(self.y2.getData()) / self.magnitude2) - math.asin(
int(self.y1.getData()) / self.magnitude1)
self.dot_product = abs(
int(self.x1.getData()) * int(self.x2.getData()) *
int(self.y1.getData()) * int(self.y2.getData())) * math.cos(
self.direction)
#display answers
text(self.magnitude1, 400, 250)
text(self.magnitude2, 400, 280)
text(self.direction, 400, 310)
text(self.dot_product, 400, 340)
def __init__(self, image, window, stringfunc=None, bgtileimage=None):
self.image = image
self.bgtileimage = bgtileimage
self.window = window
self.stringfunc = (stringfunc if stringfunc != None else
lambda a, b: str(a) + ("/"+str(b) if b != None else ""))
self.textbox = TextBox(22, (205, 205, 75), True)
def __init__(self, size = 5):
self.size = size
TextBox.set_size(TextBox, self.size)
self.box_arr = []
for x in range(0, size):
for y in range(0, size):
txt = TextBox([25 + (TextBox.get_width(TextBox) + 10) * x, 75 + (TextBox.get_height(TextBox) + 10) * y])
self.box_arr.append(txt)
random_c = self.randomize_array()
self.assign_colors(random_c, self.box_arr)
random_t = self.randomize_array()
self.assign_text(random_t, self.box_arr)
self.spymaster = pg.draw.rect(self.screen, [200, 200, 200], (1175, 25, 210, 40))
text_obj = self.font1.render('Spymaster', True, (0,0,0))
self.screen.blit(text_obj, (1220, 30))
self.is_master = False
def setup_menu_screen(self):
title = TextBox(sf.Texture.from_file("res/title.png"))
title.origin = title.local_bounds.center
title.set_position((self.window.size.x / 2, (self.window.size.y / 3)))
self.button_dict['title'] = title
assaultgunbutton = Button(
sf.Texture.from_file("res/AssaultGunButton.png"))
assaultgunbutton.origin = assaultgunbutton.local_bounds.center
assaultgunbutton.set_position(self.window.size / 2)
self.button_dict['assaultgun'] = assaultgunbutton
tankbutton = Button(sf.Texture.from_file("res/TankButton.png"))
tankbutton.origin = tankbutton.local_bounds.center
tankbutton.set_position(
(self.window.size.x / 2, (self.window.size.y / 3) * 2))
self.button_dict['tank'] = tankbutton
def __init__(self, **kwargs):
self.choicesPopup = PopupPanel(True, False)
self.choices = ListBox()
self.items = SimpleAutoCompletionItems()
self.popupAdded = False
self.visible = False
self.choices.addClickListener(self)
self.choices.addChangeListener(self)
self.choicesPopup.add(self.choices)
self.choicesPopup.addStyleName("AutoCompleteChoices")
self.choices.setStyleName("list")
if not kwargs.has_key('StyleName'): kwargs['StyleName']="gwt-AutoCompleteTextBox"
TextBox.__init__(self, **kwargs)
self.addKeyboardListener(self)
def __init__(self, format='%d-%m-%Y'):
self.format = format
self.tbox = TextBox()
self.tbox.setVisibleLength(10)
# assume valid sep is - / . or nothing
if format.find('-') >= 0:
self.sep = '-'
elif format.find('/') >= 0:
self.sep = '/'
elif format.find('.') >= 0:
self.sep = '.'
else:
self.sep = ''
# self.sep = format[2] # is this too presumptious?
self.calendar = Calendar()
self.img = Image(self.icon_img)
self.img.addStyleName(self.icon_style)
self.calendarLink = HyperlinkImage(self.img)
self.todayLink = Hyperlink(today_text)
self.todayLink.addStyleName(today_style)
#
# lay it out
#
hp = HorizontalPanel()
hp.setSpacing(2)
vp = VerticalPanel()
hp.add(self.tbox)
vp.add(self.calendarLink)
vp.add(self.todayLink)
#vp.add(self.calendar)
hp.add(vp)
Composite.__init__(self)
self.initWidget(hp)
#
# done with layout, so now set up some listeners
#
self.tbox.addFocusListener(self) # hook to onLostFocus
self.calendar.addSelectedDateListener(getattr(self, "onDateSelected"))
self.todayLink.addClickListener(getattr(self, "onTodayClicked"))
self.calendarLink.addClickListener(getattr(self, "onShowCalendar"))
def getUserInput(self, question, hideInput=False):
seaGreen = (30, 144, 100)
backgroundColour = seaGreen
black = (0, 0, 0)
fontColour = black
width = 800
height = 60
fontSize = 48
textBox = TextBox(self.__screen, question, fontColour,
backgroundColour, width, height, fontSize, hideInput)
return textBox.input
def __init__(self,Parent,BoxName, Y, X, W, editable=0,**properties):
TextBox.__init__(self, Parent, BoxName, Y, X, W-4)
self.PARENT = Parent
self.Y = Y
self.X = X
self.W = W - 4
self.H = 1
self.EDITABLE = editable
menuName = (W-5) * ' '
self._menu = Menu(Parent,'cbm',Y,X+1,menuName)
self._button = Button(Parent,'cbbutt',Y,X+W-4,3,chr(tiDAW))
self._button.SetMethod("CLICK", self._Show)
self._menu.CANGETFOCUS = 0
self._menu.SetMethod("CHOSEN",self._chosen)
self._menu.maxLengthFixed = 1
self._menu.maxLength = W - 4
self._chosen = None
self.VALUES = []
Parent.AddControl(self._button)
class MessageBox:
"""Horizontal bar with messages"""
def __init__(self, player, window):
self.player = player
self.window = window
self.textbox = TextBox(20, BLACK, False)
self.string = None
def draw(self, region):
"""Draw the message box"""
if self.string != None:
region = pygame.Rect(region)
textsurface = self.textbox.draw(self.string, region, (True, True))
MARGINX = 8
MARGINY = 3
boxregion = textsurface.get_rect(center=region.center).inflate(2 * MARGINX, 2 * MARGINY).clip(region)
minwidth = hudimages.MessageBackgroundLeft.get_width() + hudimages.MessageBackgroundRight.get_width()
boxregion.inflate_ip(max(0, minwidth - boxregion.width), 0)
oldclip = self.window.get_clip()
self.window.set_clip(boxregion)
imagewidth = hudimages.MessageBackground.get_width()
horiztileoffset = 0
while horiztileoffset < boxregion.width:
self.window.blit(hudimages.MessageBackground, boxregion.move(horiztileoffset, 0))
horiztileoffset += imagewidth
self.window.blit(hudimages.MessageBackgroundLeft, boxregion)
self.window.blit(
hudimages.MessageBackgroundRight,
boxregion.move(-hudimages.MessageBackgroundRight.get_width(), 0).topright,
)
self.window.blit(textsurface, textsurface.get_rect(center=region.center))
self.window.set_clip(oldclip)
def update(self):
highestpriority = 0
highestprioritymgo = None
self.string = None
with self.player.statelock:
if self.player.geplayer is None:
return False
mgolist = self.player.geplayer.world.gemgos
if len(mgolist) > 0:
for mgo in mgolist:
if mgo.message[1] > highestpriority:
highestpriority = mgo.message[1]
highestprioritymgo = mgo
if highestprioritymgo != None and highestprioritymgo.message[0] != None:
self.string = highestprioritymgo.message[0]
highestprioritymgo.mdnotify()
def input_depth_limit(self, point):
prompt = "Please type the maximum depth."
prompt_surf = self.font.render(prompt, True, (0,0,0))
prompt_rect = prompt_surf.get_rect()
prompt_rect.center = self.surface.get_width() // 2, self.surface.get_height() // 2 - 20
box = pygame.Rect(0, 0, prompt_rect.width + 30, prompt_rect.height + 50)
box.center = (self.surface.get_width() // 2, self.surface.get_height() // 2)
tb = TextBox(box.centerx, box.centery + 12, hight=16, border= False, active=(255,255,255), allowZero= True)
pygame.draw.rect(self.surface, (255,255,255), box)
pygame.draw.rect(self.surface, (0,0,0), box, width = 3)
self.surface.blit(prompt_surf, prompt_rect)
tb.render(self.surface, self.font)
pygame.draw.line(self.surface, (0,0,0), (box.left + 50, box.bottom - 15), (box.right - 50, box.bottom - 15), 3)
return (tb.takeInput(self.surface, self.screen, self.font))
def __init__(self,screen,seat,cards):
Hand.__init__(self,cards)
self.name=seat[0].lower()
self.human=False
self.dummy=False
self.humanspartner=False
self.contractowner=False
self.bgcolor=COLORS['tablelight']
self.orient='h'
self.winsize=[373,370]
# self.winsize=[cs[0]+12*self.dx,cs[1]+12*self.dy]
self.x,self.y,self.dx,self.dy=10,10,25,25
sr=screen.get_rect()
cs=DECKDEFS.cardsize
seatx=[sr.centerx, sr.right-cs[0]/2, sr.centerx, cs[0]/2]
seaty=[cs[1]/2, sr.bottom-self.winsize[1]/2, sr.bottom-cs[1]/2, sr.bottom-self.winsize[1]/2]
for iseat in range(len(DECKDEFS.seats)):
if self.name==DECKDEFS.seats[iseat].lower()[0]:
self.orient=('h','v')[iseat%2]
self.x=seatx[iseat]
self.y=seaty[iseat]
break
if self.orient=='v':
self.surf=pygame.Surface((cs[0],self.winsize[1]),1).convert()
else:
self.surf=pygame.Surface((self.winsize[0],cs[1]),1).convert()
self.rect=self.surf.get_rect()
self.rect.centerx=self.x
self.rect.centery=self.y
self.clear(screen)
w,h=75,75
if self.name=='n':
x=sr.centerx-w/2
y=cs[1]
self.offset=(0,-10)
elif self.name=='e':
x=sr.right-w-cs[0]
y=sr.centery-h/2
self.offset=(-10,0)
elif self.name=='s':
x=sr.centerx-w/2
y=sr.bottom-cs[1]-h
self.offset=(0,10)
elif self.name=='w':
x=cs[0]
y=sr.centery-h/2
self.offset=(10,0)
# self.info=TextBox(None,(x,y),(w,h),14,COLORS['tablelight'],COLORS['yellow'])
self.info=TextBox(None,(x,y),(w,h),14,COLORS['grey'],COLORS['yellow'])
self.info.centeredy=False
self.updateInfo()
def __init__(self,
min_value,
max_value,
start_value=None,
step=None,
**kwargs):
if not kwargs.has_key("StyleName"):
kwargs['StyleName'] = "gwt-InputControl"
self.input = TextBox()
self.input.addKeyboardListener(self)
#element = DOM.createDiv()
if kwargs.has_key('Element'):
# XXX FIXME: unlikely to work!
element = kwargs.pop('Element')
else:
element = self.input.getElement() # YUK!!!
Control.__init__(self, element, min_value, max_value, start_value,
step, **kwargs)
self.addClickListener(self)
self.addFocusListener(self)
self.addKeyboardListener(self)
def __init__(self, min_value, max_value, start_value=None, step=None,
**kwargs):
if not kwargs.has_key("StyleName"): kwargs['StyleName'] = "gwt-InputControl"
self.input = TextBox()
self.input.addKeyboardListener(self)
#element = DOM.createDiv()
if kwargs.has_key('Element'):
# XXX FIXME: unlikely to work!
element = kwargs.pop('Element')
else:
element = self.input.getElement() # YUK!!!
Control.__init__(self, element, min_value, max_value, start_value, step,
**kwargs)
self.addClickListener(self)
self.addFocusListener(self)
self.addKeyboardListener(self)
def __init__(self, center, radius = 30, width = 0):
self.center = Vector2(center)
self.radius = radius
self.width = width
self.color = Node.default_color
self.adjacent = []
self.parent = None
self.parents = []
self.state = ""
self.heuristic = 1
self.total_cost = 0
self.f_cost = 0
self.type = ""
self.selected = False
self.tb = TextBox(self.center.x, self.center.y - self.radius * 1.7, 42, 23, color = (219, 189, 247),allowZero=True)
def run(self):
play_btn = Button(self.load_screen.win,
RETRO_BLUE,
0.106125 * WIDTH,
0.702 * HEIGHT,
size=100,
on_click=self.check_play_screen,
btn_text="Play")
self.load_screen.add_game_object("play_btn", (10, play_btn))
exit_btn = Button(self.load_screen.win,
RETRO_BLUE,
0.76375 * WIDTH,
0.702 * HEIGHT,
size=100,
on_click=self.exit_trigger,
btn_text="Exit")
self.load_screen.add_game_object("exit_btn", (11, exit_btn))
settings_btn = Button(self.load_screen.win,
RETRO_BLUE,
0.39625 * WIDTH,
0.702 * HEIGHT,
size=100,
on_click=None,
btn_text="Settings")
self.load_screen.add_game_object("settings_btn", (12, settings_btn))
snake = Snake(self.play_screen.win)
self.play_screen.add_game_object("snake", (10, snake))
score_box = TextBox(self.play_screen.win, NEON_YELLOW, 650, 100,
"fonts/true-crimes.ttf", "Score: ", 50)
self.play_screen.add_game_object("score_box", (8, score_box))
apple = Apple(self.play_screen.win, RETRO_PINK, 28)
self.play_screen.add_game_object("apple", (9, apple))
while True:
self.active_screen.screen_update()
def __init__(self,format='%d-%m-%Y'):
self.format = format
self.tbox = TextBox()
self.tbox.setVisibleLength(10)
# assume valid sep is - / . or nothing
if format.find('-') >= 0:
self.sep = '-'
elif format.find('/') >= 0:
self.sep = '/'
elif format.find('.') >= 0:
self.sep = '.'
else:
self.sep = ''
# self.sep = format[2] # is this too presumptious?
self.calendar = Calendar()
img = Image("icon_calendar.gif")
img.addStyleName("calendar-img")
self.calendarLink = HyperlinkImage(img)
self.todayLink = Hyperlink('Today')
self.todayLink.addStyleName("calendar-today-link")
#
# lay it out
#
hp = HorizontalPanel()
hp.setSpacing(2)
vp = VerticalPanel()
hp.add(self.tbox)
vp.add(self.calendarLink)
vp.add(self.todayLink)
#vp.add(self.calendar)
hp.add(vp)
Composite.__init__(self)
self.initWidget(hp)
#
# done with layout, so now set up some listeners
#
self.tbox.addFocusListener(self) # hook to onLostFocus
self.calendar.addSelectedDateListener(getattr(self,"onDateSelected"))
self.todayLink.addClickListener(getattr(self,"onTodayClicked"))
self.calendarLink.addClickListener(getattr(self,"onShowCalendar"))
def __init__(self, format="%d-%m-%Y"):
self.format = format
self.tbox = TextBox()
self.tbox.setVisibleLength(10)
# assume valid sep is - / . or nothing
if format.find("-") >= 0:
self.sep = "-"
elif format.find("/") >= 0:
self.sep = "/"
elif format.find(".") >= 0:
self.sep = "."
else:
self.sep = ""
# self.sep = format[2] # is this too presumptious?
self.calendar = Calendar()
self.img = Image(self.icon_img)
self.img.addStyleName(self.icon_style)
self.calendarLink = HyperlinkImage(self.img, targetHistoryToken=History.getToken())
self.todayLink = Hyperlink(self.today_text, targetHistoryToken=History.getToken())
self.todayLink.addStyleName(self.today_style)
#
# lay it out
#
hp = HorizontalPanel()
hp.setSpacing(2)
vp = VerticalPanel()
hp.add(self.tbox)
vp.add(self.calendarLink)
vp.add(self.todayLink)
# vp.add(self.calendar)
hp.add(vp)
Composite.__init__(self)
self.initWidget(hp)
#
# done with layout, so now set up some listeners
#
self.tbox.addFocusListener(self) # hook to onLostFocus
self.calendar.addSelectedDateListener(getattr(self, "onDateSelected"))
self.todayLink.addClickListener(getattr(self, "onTodayClicked"))
self.calendarLink.addClickListener(getattr(self, "onShowCalendar"))
class InputControl(Control):
def __init__(self,
min_value,
max_value,
start_value=None,
step=None,
**kwargs):
if not kwargs.has_key("StyleName"):
kwargs['StyleName'] = "gwt-InputControl"
self.input = TextBox()
self.input.addKeyboardListener(self)
#element = DOM.createDiv()
if kwargs.has_key('Element'):
# XXX FIXME: unlikely to work!
element = kwargs.pop('Element')
else:
element = self.input.getElement() # YUK!!!
Control.__init__(self, element, min_value, max_value, start_value,
step, **kwargs)
self.addClickListener(self)
self.addFocusListener(self)
self.addKeyboardListener(self)
def onFocus(self, sender):
self.addStyleName("gwt-InputControl-focussed")
def onLostFocus(self, sender):
self.removeStyleName("gwt-InputControl-focussed")
def setControlPos(self, value):
self.input.setText(value)
def onKeyPress(self, sender, keycode, modifiers):
if keycode == KeyboardListener.KEY_ENTER:
DOM.eventPreventDefault(DOM.eventGetCurrentEvent())
txt = self.input.getText()
if not txt:
return
new_value = float(txt)
new_value = self.processValue(new_value)
self.setControlPos(new_value)
self.setValue(new_value)
else:
Control.onKeyPress(self, sender, keycode, modifiers)
def __init__(self,
startNode,
endNode,
weight=1,
color=(0, 0, 0),
width=15):
self.startNode = startNode
self.endNode = endNode
self.weight = weight
self.color = color
self.width = width
self.direction = 0 #> 0: no direction, 1: from start to end
self.startingPoint = startNode.center
self.endingPoint = endNode.center
self.tb = TextBox(self.startingPoint.x - self.endingPoint.x,
self.startingPoint.y - self.endingPoint.y)
self.start = self.startingPoint
self.end = self.endingPoint
self.rad = math.pi / 180
self.rotation = self.arrow()
def __init__(self,
startNode,
endNode,
directed=False,
weight=1,
color=(0, 0, 0),
width=15):
self.startNode = startNode
self.endNode = endNode
self.weight = 1
self.color = (0, 0, 0)
self.width = width
self.directed = directed
self.startingPoint = startNode.center
self.endingPoint = endNode.center
self.tb = TextBox((self.startingPoint.x + self.endingPoint.x) // 2,
(self.startingPoint.y + self.endingPoint.y) // 2)
self.start = self.startingPoint
self.end = self.endingPoint
self.rad = math.pi / 180
self.rotation = self.arrow()
class InputControl(Control):
def __init__(self, min_value, max_value, start_value=None, step=None,
**kwargs):
if not kwargs.has_key("StyleName"):
kwargs['StyleName'] = "gwt-InputControl"
self.input = TextBox()
self.input.addKeyboardListener(self)
#element = DOM.createDiv()
if kwargs.has_key('Element'):
# XXX FIXME: unlikely to work!
element = kwargs.pop('Element')
else:
element = self.input.getElement() # YUK!!!
Control.__init__(self, element, min_value, max_value, start_value, step,
**kwargs)
self.addClickListener(self)
self.addFocusListener(self)
self.addKeyboardListener(self)
def onFocus(self, sender):
self.addStyleName("gwt-InputControl-focussed")
def onLostFocus(self, sender):
self.removeStyleName("gwt-InputControl-focussed")
def setControlPos(self, value):
self.input.setText(value)
def onKeyPress(self, sender, keycode, modifiers):
if keycode == KeyboardListener.KEY_ENTER:
DOM.eventPreventDefault(DOM.eventGetCurrentEvent())
txt = self.input.getText()
if not txt:
return
new_value = float(txt)
new_value = self.processValue(new_value)
self.setControlPos(new_value)
self.setValue(new_value)
else:
Control.onKeyPress(self, sender, keycode, modifiers)
def text_writer(size, all_text, delta, start_coords, font_size, buttons_group=None, event=None, draw_rect=None,
number_event=None, lvls_data=None):
x, y = start_coords
dx, dy = delta
if buttons_group is not None:
button = True
number_event = 0 if number_event is None else number_event
else:
button = False
image = pygame.Surface(size)
image.fill(FILL_COLOR_UTILITIES)
lines_group = pygame.sprite.Group()
if lvls_data is not None:
green = (82, 222, 133)
red = (222, 65, 78)
colors = [green if i == True else red for i in lvls_data]
colors = iter(colors)
else:
colors = [COLOR_TEXT for i in range(len(all_text))]
colors = iter(colors)
for line in all_text:
if button:
ClickableTextBox(buttons_group, event, number_event, (x, y), line, font_size, draw_rect=draw_rect,
color=next(colors))
number_event += 1
else:
TextBox(lines_group, (x, y), line, font_size, draw_rect=False, color=COLOR_TEXT)
x += dx
y += dy
lines_group.draw(image)
image.set_colorkey(FILL_COLOR_UTILITIES)
return image
def main(self):
BLACK = (0, 0, 0)
self.displaySurface.fill((BLACK))
line1 = TextBox('Enter exit to quit')
pos = line1.draw()
line2 = TextBox('Chat:')
pos = line2.draw(pos)
pygame.display.set_caption('Chatting with ' + self.comm.target)
pygame.display.update()
quit = False
lastMsg = ''
while not quit:
(typeInput, message, addr) = self.utilities.getKeyOrMqtt()
print('typeInput: [' + str(typeInput) + ']')
#if typeInput == pygame.MOUSEBUTTONUP:
# break
if message.lower() == 'exit':
quit = True
# self.utilities.udpBroadcast (client, 'Player left chat', 3333) # key input
elif typeInput == 'mqtt':
line = TextBox(addr + ':' + message)
pos = line.draw(pos)
print('Received mqtt input: [' + message + ']')
pygame.display.flip()
elif self.utilities.msg != lastMsg:
if not line is None:
line.clearLast()
lastMsg = self.utilities.msg
line = TextBox(lastMsg)
line.draw(pos)
pygame.display.flip()
print('Go back to the main page...')
from Communications import Communications
pygame.init()
DISPLAYSURF = pygame.display.set_mode((1200, 800))
FONT = pygame.font.Font('freesansbold.ttf', 16)
BIGFONT = pygame.font.Font('freesansbold.ttf', 32)
pygame.display.set_caption('Flippy')
utilities = Utilities(DISPLAYSURF, BIGFONT)
name = 'laptop' if (platform.system() == 'Windows') else 'pi7'
target = 'pi7' if (platform.system() == 'Windows') else 'laptop'
comm = Communications('messages', 'localhost', name)
comm.connectBroker()
comm.setTarget(target)
utilities.comm = comm
line = TextBox('Enter exit to quit')
pos = line.draw()
line = TextBox('Chat:')
pos = line.draw(pos)
pygame.display.flip()
run = True
lastMsg = ''
line = None
while run:
(event, data, addr) = utilities.getKeyOrMqtt()
print('[event,data,addr]: [' + str(event) + ',' + str(data) + ',' +
str(addr) + ']')
if event == pygame.MOUSEBUTTONUP:
break
elif event == 'mqtt':
def build_text_box(self, left=4, top=500, height=200, color=(20, 30, 200)):
self.text_box = TextBox(pygame.Rect(left, top, self.screen_size[0] - left * 2, height), "TEXT", color)
def __init__(self, player, window):
self.player = player
self.window = window
self.textbox = TextBox(20, BLACK, False)
self.string = None
class Player():
# input: display Surface object, boolean to determine which side of field
def __init__(self, left):
# uses screen dimensions for player placement
self.screen_dim = g_const.screen_dim
# player dimensions
self.p_w = g_const.p_w
self.p_h = g_const.p_h
# surface to be displayed, rect to be transformed
self.p_surface = g_const.face_surface
self.p_surface = pyg.transform.scale(self.p_surface,
(self.p_w, self.p_h))
self.p_rect = self.p_surface.get_rect() # pos: 0, 0
if g_const.p_move_frame_speed:
self.p_speed = g_const.p_speed_frame
else:
self.p_speed = g_const.p_speed_sec
self.p_left = left
if not left:
self.p_rect.x = self.screen_dim.w - self.p_rect.w
self.score = 0
self.show_winner_text = False
self.pause_for_win = False
self.score_text = TextBox(40, g_const.game_text_font,
g_const.game_text_color, self.p_left)
self.win_text = TextBox(20, g_const.game_text_font,
g_const.game_text_color, self.p_left)
if self.p_left:
self.score_text.set_pos(self.screen_dim.w // 2,
self.screen_dim.h - 50)
self.score_text.set_right_align(self.screen_dim.w // 2 - 15)
self.win_text.set_pos(self.screen_dim.w // 2,
self.screen_dim.h // 2 + 40)
self.win_text.set_right_align(self.screen_dim.w // 2 - 15)
else:
self.score_text.set_pos(self.screen_dim.w // 2 + 15,
self.screen_dim.h - 50)
self.win_text.set_pos(self.screen_dim.w // 2 + 15,
self.screen_dim.h // 2 + 40)
self.win_text.update_text("WINNER")
self.up_state = self.down_state = False
self.reset_player()
def update(self, events, dt):
self.player_event_listener(events)
# print(self.p_speed * dt)
if self.up_state:
if g_const.p_move_frame_speed:
self.p_rect.move_ip(
(0, -self.p_speed if self.p_rect.top >= 0 else 0))
else:
self.p_rect.move_ip(
(0, -self.p_speed * dt if self.p_rect.top >= 0 else 0))
if self.down_state:
if g_const.p_move_frame_speed:
self.p_rect.move_ip(
(0, self.p_speed
if self.p_rect.bottom < self.screen_dim.h else 0))
else:
self.p_rect.move_ip(
(0, self.p_speed *
dt if self.p_rect.bottom <= self.screen_dim.h else 0))
if self.score == g_const.winning_score and not self.pause_for_win:
pyg.event.post(
self.create_game_won_ev(g_const.p_p1_won_id if self.
p_left else g_const.p_p2_won_id))
self.show_winner_text = True
def player_event_listener(self, events):
for event in events:
if event.type == pyg.KEYDOWN:
if self.p_left:
if event.key == pyg.K_w:
self.up_state = True
elif event.key == pyg.K_s:
self.down_state = True
else:
if event.key == pyg.K_UP:
self.up_state = True
elif event.key == pyg.K_DOWN:
self.down_state = True
if self.pause_for_win and event.key == pyg.K_SPACE:
self.pause_for_win = False
self.show_winner_text = False
self.reset_score()
self.score_text.update_text(str(self.score))
elif event.type == pyg.KEYUP:
if self.p_left:
if event.key == pyg.K_w:
self.up_state = False
elif event.key == pyg.K_s:
self.down_state = False
else:
if event.key == pyg.K_UP:
self.up_state = False
elif event.key == pyg.K_DOWN:
self.down_state = False
elif event.type == g_const.GAMEREADY_ID:
if event.move_to_player_id != 0:
if event.move_to_player_id == 1:
if self.p_left: self.score += 1
else:
if not self.p_left: self.score += 1
self.score_text.update_text(str(self.score))
elif event.type == g_const.GAMEWIN_ID:
self.pause_for_win = True
def get_pos(self):
pos = (self.p_rect.x, self.p_rect.y)
return pos
# center player position
def reset_player(self):
self.p_rect.centery = self.screen_dim.h // 2
def reset_score(self):
self.score = 0
def create_game_won_ev(self, player_won_id):
event = g_const.GAMEWIN_EV
event.winning_player_id = player_won_id
return event
from TextBox import TextBox
from Graph import Graph
###> Setting up pygame
init()
pygame.mixer.pre_init(
44100, -16, 2, 512
) #! handles a lot of things. Used here to remove delay before sound plays
clock = pygame.time.Clock()
hor, ver = 1200, 900
pygame.display.set_caption("CAPTION")
# pygame.display.set_icon(pygame.image.load(""))
screen = pygame.display.set_mode((hor, ver))
tb = TextBox(100, 100)
g = Graph(screen, 30)
def draw_grid(width, length, size):
for hor in range(length // size):
pygame.draw.line(screen, (160, 160, 160), (0, size * hor),
(width, size * hor))
for ver in range(width // size):
pygame.draw.line(screen, (160, 160, 160), (size * ver, 0),
(size * ver, length))
#> Main Loop
#>
WIDTH // 2 - 100, 625, True, window)
slower_button = Button("Slower", pygame.Color("Yellow"), font,
WIDTH // 2 - 150, 680, True, window)
stop_button = Button("Stop", pygame.Color("Red"), font, WIDTH // 2, 680,
True, window)
faster_button = Button("Faster", pygame.Color("Green"), font,
WIDTH // 2 + 150, 680, True, window)
reset_button = Button("Reset", pygame.Color("Grey"), font, 10, HEIGHT - 40,
False, window)
#Show sort type being done
if sort_type:
sort_type_text = TextBox(sort_type.capitalize() + "Sort",
pygame.Color("Grey"), font, WIDTH // 2, 25,
True, window)
#Draw list
list.display_list(window, bottom_left_pos, MAX_ELEMENT_HEIGHT,
MAX_LIST_WIDTH)
event_list = pygame.event.get()
for event in event_list:
if event.type == pygame.QUIT:
run = False
elif event.type == pygame.MOUSEBUTTONDOWN: #Respond to button presses
if bubble_sort_button.is_clicked(event.pos):
sort_type = "bubble"
elif selection_sort_button.is_clicked(event.pos):
sort_type = "selection"
def setGUI(self, whichGUI):
self.TextFieldLabels.clear()
if whichGUI is 0:
triangleText = TextLabel('TRIANGLE', 0, 0, 'comic', 80,
(255, 255, 255))
triangleText.setPosition(
self.width / 2 - triangleText.getWidth() / 2, 100)
self.TextFieldLabels.append(triangleText)
invadersText = TextLabel('INVADERS', 0, 0, 'comic', 80,
(255, 255, 255))
invadersText.setPosition(
self.width / 2 - invadersText.getWidth() / 2,
triangleText.getPosition()[1] + triangleText.getHeight())
self.TextFieldLabels.append(invadersText)
gameText = TextLabel('GAME', 0, 0, 'comic', 80, (255, 255, 255))
gameText.setPosition(
self.width / 2 - gameText.getWidth() / 2,
invadersText.getPosition()[1] + invadersText.getHeight())
self.TextFieldLabels.append(gameText)
enter = TextLabel('Please enter your name', 0, 0, 'comic', 30,
(255, 255, 255))
enter.setPosition(
self.width / 2 - enter.getWidth() / 2,
gameText.getPosition()[1] + gameText.getHeight() * 2)
self.TextFieldLabels.append(enter)
self.textBoxEnter = TextBox(
triangleText.getWidth(), None,
self.width / 2 - triangleText.getWidth() / 2,
enter.getPosition()[1] + enter.getHeight() * 2)
# checkbox info here
elif whichGUI is 1 or whichGUI is 2:
gameOver = TextLabel('GAME OVER!', 0, 0, 'comic', 80,
(255, 255, 255))
gameOver.setPosition(self.width / 2 - gameOver.getWidth() / 2, 100)
self.TextFieldLabels.append(gameOver)
score = TextLabel('Your score: {}'.format(self.level), 0, 0,
'comic', 80, (255, 255, 255))
score.setPosition(self.width / 2 - score.getWidth() / 2,
gameOver.getPosition()[1] + gameOver.getHeight())
self.TextFieldLabels.append(score)
if whichGUI is 2:
pressSpace = TextLabel('Press SPACE to restart game', 0, 0,
'comic', 50, (255, 255, 255))
pressSpace.setPosition(
self.width / 2 - pressSpace.getWidth() / 2,
self.height / 2)
self.TextFieldLabels.append(pressSpace)
pressTab = TextLabel('Hold TAB to see best scores', 0, 0,
'comic', 50, (255, 255, 255))
pressTab.setPosition(
self.width / 2 - pressTab.getWidth() / 2,
pressSpace.getPosition()[1] + pressSpace.getHeight() * 2)
self.TextFieldLabels.append(pressTab)
elif whichGUI is 3:
bestScores = TextLabel('BEST SCORES:', 0, 0, 'comic', 60,
(255, 255, 255))
bestScores.setPosition(self.width / 2 - bestScores.getWidth() / 2,
50)
self.TextFieldLabels.append(bestScores)
# connecting to database and reading TOP 10 scores!
self.db.connect()
rows = self.db.getTop10('scoresTable')
self.db.close()
fakeName = TextLabel(str(rows[0][1]), 0, 0, 'comic', 30,
(255, 255, 255))
fakeName.setPosition(
bestScores.getPosition()[0],
bestScores.getPosition()[1] + bestScores.getHeight() * 2)
self.TextFieldLabels.append(fakeName)
fakeScore = TextLabel(str(rows[0][2]), 0, 0, 'comic', 30,
(255, 255, 255))
fakeScore.setPosition(
bestScores.getPosition()[0] + bestScores.getWidth() -
fakeScore.getWidth(),
bestScores.getPosition()[1] + bestScores.getHeight() * 2)
self.TextFieldLabels.append(fakeScore)
for x in range(1, len(rows)):
previousName = fakeName
previousScore = fakeScore
fakeName = TextLabel(str(rows[x][1]), 0, 0, 'comic', 30,
(255, 255, 255))
fakeName.setPosition(
bestScores.getPosition()[0],
previousName.getPosition()[1] +
previousName.getHeight() * 2)
self.TextFieldLabels.append(fakeName)
fakeScore = TextLabel(str(rows[x][2]), 0, 0, 'comic', 30,
(255, 255, 255))
fakeScore.setPosition(
bestScores.getPosition()[0] + bestScores.getWidth() -
fakeScore.getWidth(),
previousScore.getPosition()[1] +
previousScore.getHeight() * 2)
self.TextFieldLabels.append(fakeScore)
class InfoBoxes:
def __init__(self,screen):
screenrect=screen.get_rect()
bgcolor=COLORS['tabledark']
fgcolor=COLORS['yellow']
helpdata=['','Bridget 0.1',
'--------------------------------',
'F1/ctrl+H - Show Help',
'F5/ctrl+N - New Rubber',
'F9 - Toggle Show All Hands',
'B - Show/Hide Bidding',
'Mouse - select card','ESC - Quit',
'--------------------------------']
self.help= TextBox(helpdata, None, (400,300),18,COLORS['black'],COLORS['yellow'])
self.contract= TextBox(['Contract:'],(10,125),None, 14,bgcolor,fgcolor)
self.trickcount=TextBox(['Tricks:'], (10,145),None, 14,bgcolor,fgcolor)
self.dealer= TextBox(['Dealer:'], (10,105),None, 14,bgcolor,fgcolor)
self.score=ScoreBox(screen)
self.trickpics=TrickPics(screen)
self.handinfo=[]
# size=(125,80)
# pos=(50,160)
# for iseat in range(GLOBALS.deck.nseats):
# self.handinfo.append(TextBox(None,pos,size,14,GLOBALS.colors['black'],GLOBALS.colors['yellow']))
self.help.centered=1
self.help.alpha=200
self.help.update()
self.draw(screen)
def showHandsInfo(self,screen,table):
surf=screen.copy()
for ihand in range(DECKDEFS.nseats):
if not table.getVisible(table.rubber.deal.getHand(ihand)):
continue
handinfo=self.handinfo[ihand]
screen.blit(handinfo.surf,handinfo.rect.topleft)
pygame.display.flip()
UTILITIES.pause()
screen.blit(surf,(0,0))
def drawHandsInfo(self,deal):
for ihand in range(DECKDEFS.nseats):
hand=deal.getHand(ihand)
self.handinfo[ihand].erase()
data=[hand.HCP,hand.DP,hand.QT,hand.NL]
self.handinfo[ihand].update(data)
def draw(self,screen):
self.trickcount.draw(screen)
self.contract.draw(screen)
self.dealer.draw(screen)
def updateTrickCount(self,screen,trickcount):
data=['Tricks: ']
if not trickcount==None:
data[0]+='%i - %i'%(trickcount[0],trickcount[1])
self.trickcount.draw(screen,data)
def updateContract(self,screen,contract=None):
self.contract.surf.fill(self.contract.colorbg)
data='Contract: '
if contract:
data+=DECKDEFS.seats[contract.owner]
img1=self.contract.font.render(data,1,self.contract.colorfg)
rect=img1.get_rect()
rect.centery=self.contract.surf.get_rect().centery
rect.left=2
self.contract.surf.blit(img1,rect.topleft)#(2,0))
if contract:
pos=(img1.get_rect().width+25,8)
UTILITIES.blitBid(self.contract.font,self.contract.surf,contract,self.contract.colorfg,pos,True)
self.contract.show(screen)
def updateDealer(self,screen,dealer):
if not dealer==None:
data=['Dealer: '+DECKDEFS.seats[dealer]]
self.dealer.draw(screen,data)
class SceneNameSelect:
def __init__(self, engine, index):
self.engine = engine
self.index = index
self.engine.heroes[index].name = ''
cursor_image = pyglet.image.load('./resources/cursor.png')
self.title = pyglet.text.Label('SELECT NAME', x=72, y=24, font_size=8)
self.name_box = TextBox(48, 32, 104, 192, RED)
self.char_box = TextBox(184, 160, 32, 16)
self.cursor = pyglet.sprite.Sprite(cursor_image, x=32, y=143)
self.chars = {
(48, 152): 'A', (64, 152): 'B', (80, 152): 'C', (96, 152): 'D', (112, 152): 'E',
(128, 152): 'F', (144, 152): 'G', (160, 152): 'H', (176, 152): 'I', (192, 152): 'J',
(48, 136): 'K', (64, 136): 'L', (80, 136): 'M', (96, 136): 'N', (112, 136): 'O',
(128, 136): 'P', (144, 136): 'Q', (160, 136): 'R', (176, 136): 'S', (192, 136): 'T',
(48, 120): 'U', (64, 120): 'V', (80, 120): 'W', (96, 120): 'X', (112, 120): 'Y',
(128, 120): 'Z', (144, 120): "'", (160, 120): ',', (176, 120): '.', (192, 120): ' ',
(48, 104): 'a', (64, 104): 'b', (80, 104): 'c', (96, 104): 'd', (112, 104): 'e',
(128, 104): 'f', (144, 104): 'g', (160, 104): 'h', (176, 104): 'i', (192, 104): 'j',
(48, 88): 'k', (64, 88): 'l', (80, 88): 'm', (96, 88): 'n', (112, 88): 'o',
(128, 88): 'p', (144, 88): 'q', (160, 88): 'r', (176, 88): 's', (192, 88): 't',
(48, 72): 'u', (64, 72): 'v', (80, 72): 'w', (96, 72): 'x', (112, 72): 'y',
(128, 72): 'z', (144, 72): '-', (160, 72): chr(0x2026), (176, 72): '!', (192, 72): '?'
# ellipsis
}
self.labels = [pyglet.text.Label(self.chars[key], x=key[0], y=key[1], font_size=8)
for key in self.chars.keys()]
self.engine.push_handlers(on_draw=self.on_draw,
on_key_press=self.on_key_press)
def on_draw(self):
self.engine.window.clear()
self.name_box.draw()
pyglet.text.Label(self.engine.heroes[self.index].name, x=112, y=200, font_size=8).draw()
self.char_box.draw()
self.title.draw()
for label in self.labels:
label.draw()
self.cursor.draw()
return pyglet.event.EVENT_HANDLED # so the default (blank) drawing doesn't take over
def on_key_press(self, symbol, modifiers):
if symbol in LEFT:
self.cursor.x = 176 if self.cursor.x == 32 else self.cursor.x - 16
elif symbol in RIGHT:
self.cursor.x = 32 if self.cursor.x == 176 else self.cursor.x + 16
if symbol in DOWN:
self.cursor.y = 143 if self.cursor.y == 63 else self.cursor.y - 16
elif symbol in UP:
self.cursor.y = 63 if self.cursor.y == 143 else self.cursor.y + 16
if symbol in BUTTON_A:
if len(self.engine.heroes[self.index].name) >= 4:
self.engine.pop_handlers()
self.engine.scenes.remove(self)
else:
self.engine.heroes[self.index].name += self.chars[(self.cursor.x + 16, self.cursor.y + 9)]
elif symbol in BUTTON_B:
if len(self.engine.heroes[self.index].name) <= 0:
self.engine.pop_handlers()
self.engine.scenes.remove(self)
else:
self.engine.heroes[self.index].name = self.engine.heroes[self.index].name[:-1]
if symbol != pyglet.window.key.ESCAPE: # the only keyboard event we want propagating up the stack
return pyglet.event.EVENT_HANDLED
class DateField(Composite):
def __init__(self,format='%d-%m-%Y'):
self.format = format
self.tbox = TextBox()
self.tbox.setVisibleLength(10)
# assume valid sep is - / . or nothing
if format.find('-') >= 0:
self.sep = '-'
elif format.find('/') >= 0:
self.sep = '/'
elif format.find('.') >= 0:
self.sep = '.'
else:
self.sep = ''
# self.sep = format[2] # is this too presumptious?
self.calendar = Calendar()
img = Image("icon_calendar.gif")
img.addStyleName("calendar-img")
self.calendarLink = HyperlinkImage(img)
self.todayLink = Hyperlink('Today')
self.todayLink.addStyleName("calendar-today-link")
#
# lay it out
#
hp = HorizontalPanel()
hp.setSpacing(2)
vp = VerticalPanel()
hp.add(self.tbox)
vp.add(self.calendarLink)
vp.add(self.todayLink)
#vp.add(self.calendar)
hp.add(vp)
Composite.__init__(self)
self.initWidget(hp)
#
# done with layout, so now set up some listeners
#
self.tbox.addFocusListener(self) # hook to onLostFocus
self.calendar.addSelectedDateListener(getattr(self,"onDateSelected"))
self.todayLink.addClickListener(getattr(self,"onTodayClicked"))
self.calendarLink.addClickListener(getattr(self,"onShowCalendar"))
def getTextBox(self):
return self.tbox
def getCalendar(self):
return self.calendar
def setID(self,id):
self.tbox.setID(id)
def onDateSelected(self, yyyy, mm, dd):
secs = time.mktime((int(yyyy),int(mm),int(dd),0,0,0,0,0,-1))
d = time.strftime(self.format,time.localtime(secs))
self.tbox.setText(d)
def onLostFocus(self, sender):
#
text = self.tbox.getText().strip()
# if blank - leave it alone
if text and len(text) == 8:
# ok what format do we have? assume ddmmyyyy --> dd-mm-yyyy
self.tbox.setText( text[0:2] + self.sep + text[2:4] + self.sep + text[4:8] )
def onFocus(self, sender):
pass
def onTodayClicked(self, event):
today = time.strftime(self.format)
self.tbox.setText( today )
def onShowCalendar(self, sender):
p = CalendarPopup(self.calendar)
x = self.tbox.getAbsoluteLeft() + 10
y = self.tbox.getAbsoluteTop() + 10
p.setPopupPosition(x,y)
p.show()
class Seat(Hand):
def __init__(self,screen,seat,cards):
Hand.__init__(self,cards)
self.name=seat[0].lower()
self.human=False
self.dummy=False
self.humanspartner=False
self.contractowner=False
self.bgcolor=COLORS['tablelight']
self.orient='h'
self.winsize=[373,370]
# self.winsize=[cs[0]+12*self.dx,cs[1]+12*self.dy]
self.x,self.y,self.dx,self.dy=10,10,25,25
sr=screen.get_rect()
cs=DECKDEFS.cardsize
seatx=[sr.centerx, sr.right-cs[0]/2, sr.centerx, cs[0]/2]
seaty=[cs[1]/2, sr.bottom-self.winsize[1]/2, sr.bottom-cs[1]/2, sr.bottom-self.winsize[1]/2]
for iseat in range(len(DECKDEFS.seats)):
if self.name==DECKDEFS.seats[iseat].lower()[0]:
self.orient=('h','v')[iseat%2]
self.x=seatx[iseat]
self.y=seaty[iseat]
break
if self.orient=='v':
self.surf=pygame.Surface((cs[0],self.winsize[1]),1).convert()
else:
self.surf=pygame.Surface((self.winsize[0],cs[1]),1).convert()
self.rect=self.surf.get_rect()
self.rect.centerx=self.x
self.rect.centery=self.y
self.clear(screen)
w,h=75,75
if self.name=='n':
x=sr.centerx-w/2
y=cs[1]
self.offset=(0,-10)
elif self.name=='e':
x=sr.right-w-cs[0]
y=sr.centery-h/2
self.offset=(-10,0)
elif self.name=='s':
x=sr.centerx-w/2
y=sr.bottom-cs[1]-h
self.offset=(0,10)
elif self.name=='w':
x=cs[0]
y=sr.centery-h/2
self.offset=(10,0)
# self.info=TextBox(None,(x,y),(w,h),14,COLORS['tablelight'],COLORS['yellow'])
self.info=TextBox(None,(x,y),(w,h),14,COLORS['grey'],COLORS['yellow'])
self.info.centeredy=False
self.updateInfo()
def updateInfo(self):
self.info.erase()
data=[" HC = "+str(self.HCP),
" DP = "+str(self.DP),
" QT = "+str(self.QT),
" NL = "+str(self.NL)]
self.info.update(data)
def setCards(self,cards):
Hand.setCards(self,cards)
Seat.updateInfo(self)
def clear(self,screen):
self.surf.fill(self.bgcolor)
screen.blit(self.surf,self.rect.topleft)
def getCardIndex(self,screenpos):
seatpos=(screenpos[0]-self.rect.left,screenpos[1]-self.rect.top)
for icard in range(len(self.cards)):
ireverse=len(self.cards)-icard-1
rect=pygame.Rect(self.getCardPos(ireverse),DECKDEFS.cardsize)
if rect.collidepoint(seatpos):
return ireverse
return None
def getCard(self,screenpos):
index=self.getCardIndex(screenpos)
if index==None:
return None
else:
return self.cards[index]
def playCard(self,screen,card,auto=False):
icard=self.findCard(card)
self.removeCard(card)
self.clear(screen)
self.draw(screen)
screencenter=screen.get_rect().center
pos0=self.getCardPosPicked(icard)
pos1=(screencenter[0]-DECKDEFS.cardsize[0]/2,screencenter[1]-DECKDEFS.cardsize[1]/2)
if not auto:
EFFECTS.drawTrace(screen,card.img,pos0,pos1,30,0,24)
def getCardPos(self,icard):
if self.orient=='v':
return (0,self.dy*icard)
else:
return (self.dx*icard,0)
def getCardAbsPos(self,icard):
relpos=self.getCardPos(icard)
seatpos=(self.rect.left,self.rect.top)
return (seatpos[0]+relpos[0],seatpos[1]+relpos[1])
def getCardPosPicked(self,icard):
(x0,y0)=self.getCardAbsPos(icard)
return (x0+self.offset[0],y0+self.offset[1])
def drawOneCard(self,screen,icard):
pos=self.getCardPos(icard)
self.cards[icard].draw(self.surf,pos)
screen.blit(self.surf,self.rect)
pygame.display.flip()
def draw(self,screen,motion=True):
for icard in range(len(self.cards)):
pos=self.getCardPos(icard)
self.cards[icard].draw(self.surf,pos)
screen.blit(self.surf,self.rect)
class DateField(Composite):
icon_img = "icon_calendar.gif"
icon_style = "calendar-img"
today_text = "Today"
today_style = "calendar-today-link"
def __init__(self, format='%d-%m-%Y'):
self.format = format
self.tbox = TextBox()
self.tbox.setVisibleLength(10)
# assume valid sep is - / . or nothing
if format.find('-') >= 0:
self.sep = '-'
elif format.find('/') >= 0:
self.sep = '/'
elif format.find('.') >= 0:
self.sep = '.'
else:
self.sep = ''
# self.sep = format[2] # is this too presumptious?
self.calendar = Calendar()
self.img = Image(self.icon_img)
self.img.addStyleName(self.icon_style)
self.calendarLink = HyperlinkImage(self.img)
self.todayLink = Hyperlink(today_text)
self.todayLink.addStyleName(today_style)
#
# lay it out
#
hp = HorizontalPanel()
hp.setSpacing(2)
vp = VerticalPanel()
hp.add(self.tbox)
vp.add(self.calendarLink)
vp.add(self.todayLink)
#vp.add(self.calendar)
hp.add(vp)
Composite.__init__(self)
self.initWidget(hp)
#
# done with layout, so now set up some listeners
#
self.tbox.addFocusListener(self) # hook to onLostFocus
self.calendar.addSelectedDateListener(getattr(self, "onDateSelected"))
self.todayLink.addClickListener(getattr(self, "onTodayClicked"))
self.calendarLink.addClickListener(getattr(self, "onShowCalendar"))
def getTextBox(self):
return self.tbox
def getCalendar(self):
return self.calendar
def setID(self, id):
self.tbox.setID(id)
def onDateSelected(self, yyyy, mm, dd):
secs = time.mktime((int(yyyy), int(mm), int(dd), 0, 0, 0, 0, 0, -1))
d = time.strftime(self.format, time.localtime(secs))
self.tbox.setText(d)
def onLostFocus(self, sender):
#
text = self.tbox.getText().strip()
# if blank - leave it alone
if text and len(text) == 8:
# ok what format do we have? assume ddmmyyyy --> dd-mm-yyyy
self.tbox.setText(text[0:2] + self.sep + text[2:4] + self.sep +
text[4:8])
def onFocus(self, sender):
pass
def onTodayClicked(self, event):
today = time.strftime(self.format)
self.tbox.setText(today)
def onShowCalendar(self, sender):
p = CalendarPopup(self.calendar)
x = self.tbox.getAbsoluteLeft() + 10
y = self.tbox.getAbsoluteTop() + 10
p.setPopupPosition(x, y)
p.show()
class Camera(object):
def __init__(self, screen_size, player):
print "this is a camera"
self.screen_size = screen_size
self.view = None
self.player = player
self.controller = Controller(self.player)
self.delay_timer = 0
self.center_box = pygame.Rect(
self.screen_size[0] / 4, self.screen_size[1] / 4, self.screen_size[0] / 2, self.screen_size[1] / 2
)
self.cam_center = (self.screen_size[0] / 2, self.screen_size[1] / 2)
self.cam_offset_x = 0
self.cam_offset_y = 0
self.camera_speed = self.player.speed
self.map = None
self.action_map = None
self.destination_door = None
self.fade_alpha = 0
self.fade_speed = 5
self.fade_out = False
self.fade_in = False
self.text_box = None
self.build_text_box()
self.blackness = pygame.Surface(self.screen_size)
self.blackness.fill((0, 0, 0))
self.blackness.set_alpha(self.fade_alpha)
def build_text_box(self, left=4, top=500, height=200, color=(20, 30, 200)):
self.text_box = TextBox(pygame.Rect(left, top, self.screen_size[0] - left * 2, height), "TEXT", color)
def convert_door_destination(self, cords):
x = int(cords[0]) * self.map.tileset_data["t_width"]
y = int(cords[1]) * self.map.tileset_data["t_height"]
return x, y
def load_action_map(self, action_map_url):
self.action_map = ActionMap(action_map_url, self.text_box)
def load_map(self, map_url):
real_url = os.path.join("..", "assets", "world", map_url)
self.map = Map(real_url, self.text_box)
if self.map.starting_location:
self.player.teleport(self.map.starting_location)
self.view = pygame.Surface(self.map.map_size)
self.cam_offset_x = self.player.sprite_rect.left
self.cam_offset_y = self.player.sprite_rect.top
def update(self, screen):
if not self.fade_in and not self.fade_out:
# check for door intersection here?
for d in self.map.door_list:
if d.door.colliderect(self.player.pass_rect):
self.destination_door = d
self.fade_alpha = 0
self.fade_out = True
delay = self.controller.poll(self.map, self.text_box, self.delay_timer, self.action_map)
if delay:
self.delay_timer += delay
# check if camera should shift
if self.player.sprite_rect.left < self.cam_offset_x - self.center_box.left:
self.cam_offset_x -= self.camera_speed
elif self.player.sprite_rect.left > self.cam_offset_x + self.center_box.left:
self.cam_offset_x += self.camera_speed
if self.player.sprite_rect.top < self.cam_offset_y - self.center_box.top:
self.cam_offset_y -= self.camera_speed
elif self.player.sprite_rect.top > self.cam_offset_y + self.center_box.top:
self.cam_offset_y += self.camera_speed
# draw things
self.map.draw(self.view, passmap=False)
self.player.draw(self.view)
self.map.draw_upper(self.view)
screen.blit(self.view, (self.cam_center[0] - self.cam_offset_x, self.cam_center[1] - self.cam_offset_y))
# screen.blit(self.blackness, (0, 0))
if self.text_box:
self.text_box.draw(screen)
if self.fade_in:
if self.fade_alpha > 0:
self.fade_alpha -= self.fade_speed
self.blackness.set_alpha(self.fade_alpha)
screen.blit(self.blackness, (0, 0))
else:
self.fade_in = False
elif self.fade_out:
if self.fade_alpha < 255:
self.fade_alpha += self.fade_speed
self.blackness.set_alpha(self.fade_alpha)
screen.blit(self.blackness, (0, 0))
else:
self.fade_out = False
self.load_map(self.destination_door.destination_map)
self.player.teleport(self.convert_door_destination(self.destination_door.destination_cords))
if self.delay_timer > 0:
self.delay_timer -= 1
