On 12/13/2011 01:01 AM, Cranky Frankie wrote:
I tried putting the ty_message block in a WHILE TRUE loop, and that
didn't work. Then I tried the same with the
games.screen.add(ty_message) line and that didn't work either. I think
what might work is if I can find a way to delete the ty_message and
readd it, over and over in a loop with a delay, bu:
This is a common problem when people start GUI/graphics programming;
once you enter the GUI mainloop, you're no longer in control of the
program flow. Instead the mainloop will process events and callbacks;
therefore if you want a blinking text, you had to arrange such that your
blinker function will be called every second.
In pygame, you can do the following:
#!/usr/bin/env python
import pygame
# initialize pygame, this must be called before
# doing anything with pygame
pygame.init()
# create a screen
screen = pygame.display.set_mode((400, 400))
# setup the text
font = pygame.font.Font(None, 36)
text = font.render("Hello World", True, (100, 100, 100))
display = True
# the main loop
while pygame.time.get_ticks() < 10000: # run the program for 10 seconds
# empty the screen
screen.fill((255, 255, 255))
display = not display
# draw the text to the screen only if display is True
if display:
screen.blit(text, (100, 100))
# update the actual screen
pygame.display.flip()
# wait for half second
pygame.time.wait(500)
You can do this in pygame since pygame do not provide a mainloop.
I took a quick glance at livewires, their main loop implementation is
very simple; however it discards all events except for mouse, keyboard,
and the quit event. In typical game engine, you usually will register an
event to the event handler to be executed every second that will
draw/undraw the text. However, in livewires event handling system you
can't do that. Therefore, if you want to do it, you'd have to override
the event handling method in the Screen class.
However, for a quick hack, I think you can abuse the after_death=
parameter; you can register a function that will games.screen.add() a
Message, then after_death, it registers an invisible message which
registers a Message after its death which registers the visible message
after death which ... . In short, the following (I haven't tested it,
although I think it should work):
stop = False
def add_visible_ty():
if stop: return
message = games.Message(
value = "Thank You!",
size = 100,
color = color.red,
x = games.screen.width/2,
y = games.screen.height/2,
lifetime = 500,
after_death = add_invisible_ty
)
games.screen.add(message)
def add_invisible_ty():
if stop: return
message = games.Message(
value = "",
size = 100,
color = color.red,
x = games.screen.width/2,
y = games.screen.height/2,
lifetime = 500,
after_death = add_visible_ty
)
games.screen.add(message)
games.screen.delete(ty_message)
doesn't work - delete is not a valid method.
There are two rendering style for graphics programming; one is called
the "retained mode", in which the libraries retain a complete model of
the objects to be rendered and graphic calls do not directly cause
actual rendering but instead update an internal model, the other is the
"immediate mode" in which graphic calls directly cause rendering of
graphics objects to the display.
pygame falls into the latter; pygame do not keep track of objects that
it has drawn on screen, therefore if you need to "delete" an object from
the screen, you'd need to redraw the whole screen except the object you
had deleted. At the very least, you'd need to redraw the part of the
screen that had changed due to the deletion.
livewires falls into the former; in livewires there is an internal
object that represent each screen object and it keep tracks of which
objects and which part of the screen that are "dirty".
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
http://mail.python.org/mailman/listinfo/tutor
