def setUp(self):
self.port = randint(10000, 65000)
self.server_manager = None
self.server_started = False
def server_thread(test_case):
test_case.server_manager = ServerManager(config_object={'network':{'port': self.port}})
def on_run():
test_case.server_started = True
test_case.server_manager.on_run = on_run
dbs = test_case.server_manager.db_session_type()
dbs.add(User(name='john', password='******'))
dbs.add(User(name='lazy', password=''))
dbs.add(GamePawn(name='test_pawn', width=2, height=3, shapestring="100110"))
dbs.add(GameBoard(name='test_board', width=6, height=8, shapestring="0"*48))
dbs.flush()
test_case.server_manager.run()
self.server_thread = Thread(target=server_thread, args=(self,))
self.server_thread.start()
while not self.server_started:
sleep(milliseconds(10))
sleep(milliseconds(100))
def Move(self,step):
if self._clock.elapsed_time < sf.milliseconds(10):
return
self._clock.restart()
if self._position.x < 0:
self._position.x = 0
if self._position.y < 0:
self._position.y = 0
if (self._position.x + self.GetWidth()) > self._location.GetWidth():
self._position.x = self._location.GetWidth() - self.GetWidth()
if (self._position.y + self.GetHeight()) > self._location.GetHeight():
self._position.y = self._location.GetHeight() - self.GetHeight()
if step.x==0 and step.y==0:
self._stopCounter += 1
if self._stopCounter > 10:
self.StopAnimate()
music = musicCollection.GetMusic("ACTOR", "STEP")
music.stop()
else:
obj.Object.Move(self, step)
self._stopCounter = 0
self.SetAnimation("WALK")
self.StartAnimate()
music = musicCollection.GetMusic("ACTOR", "STEP")
if music.status == sf.audio.SoundSource.STOPPED and self._stepBetweenTime.elapsed_time.seconds > TIME_BETWEEN_STEPS:
self._stepBetweenTime.restart()
music.volume = 50
music.play()
def thread(self, sound, volume, loops=0):
sound.play()
sound.volume = rint(volume)
# loop while the sound is playing
time = 0
killtime = 0
deltat = 10
while sound.status in (sfml.Sound.PLAYING, sfml.Sound.PAUSED):
# leave some CPU time for other processes
sfml.sleep(sfml.milliseconds(deltat))
time += deltat
if sound.fadein and time < sound.fadein:
sound.volume = rint(volume * float(time) / sound.fadein)
if sound.fadeout and time > sound.duration - sound.fadeout:
sound.volume = rint(volume * float(time) / (rint(volume * float(time) / sound.fadein)))
if not sound.kill_in is None:
killtime += deltat
if killtime > sound.kill_in:
sound.stop()
sound.kill_in = None
break
else:
sound.volume *= 1 - float(killtime / sound.kill_in)
if loops > 0:
self.thread(sound, volume, loops - 1)
if self.permanent == sound:
self.thread(sound, volume)
elif self.permanent and sound.typ == "music":
self.thread(self.permanent, volume)
def gerer_fps(temps_actuel):
print(temps_actuel.elapsed_time.milliseconds)
if temps_actuel.elapsed_time.milliseconds < 30:
sf.sleep(sf.milliseconds(30-temps_actuel.elapsed_time.milliseconds))
temps_actuel.restart()
def gerer_fps(temps_actuel):
print(temps_actuel.elapsed_time.milliseconds)
if temps_actuel.elapsed_time.milliseconds < 30:
sf.sleep(sf.milliseconds(30 - temps_actuel.elapsed_time.milliseconds))
temps_actuel.restart()
def _sfml(s_file, times=None, fadeout=None):
global FRAMERATE
sound = sf.Music.from_file(s_file)
for t in range(times):
sound.play()
while sound.status == sf.Music.PLAYING:
sf.sleep(sf.milliseconds(FRAMERATE))
def __init__(self, window):
self._window = window
self._clear_color = sf.Color(255, 255, 255)
self._background_sprite = None
self._background_texture = None
self._window_opened = True
self._clock = sf.Clock()
self._fps = 30
self._frame_time = sf.milliseconds(1000 / self._fps)
def __init__(self, window): self._window = window self._clear_color = sf.Color(255, 255, 255) self._background_sprite = None self._background_texture = None self._window_opened = True self._clock = sf.Clock() self._fps = 30 self._frame_time = sf.milliseconds(1000 / self._fps)
def __playMusicFromFile(self, music_file):
if not self.pausing:
self.music = sf.Music.from_file(music_file)
## Play it
self.music.play()
#loop while the sound is playing
while self.music.status == sf.Music.PLAYING:
#leave some cpu time for other processes
sf.sleep(sf.milliseconds(100))
def __init__(self, number_of_frames, duration):
sf.Drawable.__init__(self)
# if current_frame == number_of_frames then it means there's no
# frame left or in other words, the animation is over.
self._current_frame = 0
self._number_of_frames = number_of_frames
# integer arithmetic operation not supported yet for sf.Time
self._frame_time = sf.milliseconds(duration.milliseconds / number_of_frames)
def __init__(self) : self.PlayerLife = 2 self.PlayerBomb = 3 self.Focus = False self.PlayerCoor = sfml.Vector2(100,400) self.Clock = sfml.Clock() self.TimeToMove = sfml.milliseconds(45) self.EnemyList = [] self.Boss = None self.Bounds = sfml.Rectangle((30,30),(500,550)) self.BulletList = []
def do_server(port):
# build an audio stream to play sound data as it is received through the network
audio_stream = NetworkAudioStream()
audio_stream.start(port)
# loop until the sound playback is finished
while audio_stream.status != sf.SoundStream.STOPPED:
# leave some CPU time for other threads
sf.sleep(sf.milliseconds(100))
# wait until the user presses 'enter' key
input("Press enter to replay the sound...")
# replay the sound (just to make sure replaying the received data is OK)
audio_stream.play();
# loop until the sound playback is finished
while audio_stream.status != sf.SoundStream.STOPPED:
sf.sleep(sf.milliseconds(100))
def main():
# check that the device can capture audio
if not sf.SoundRecorder.is_available():
print("Sorry, audio capture is not supported by your system")
return
# choose the sample rate
sample_rate = int(input("Please choose the sample rate for sound capture (44100 is CD quality): "))
# wait for user input...
input("Press enter to start recording audio")
# here we'll use an integrated custom recorder, which saves the captured data into a sf.SoundBuffer
recorder = sf.SoundBufferRecorder()
# audio capture is done in a separate thread, so we can block the main thread while it is capturing
recorder.start(sample_rate)
input("Recording... press enter to stop")
recorder.stop()
# get the buffer containing the captured data
buffer = recorder.buffer
# display captured sound informations
print("Sound information:")
print("{0} seconds".format(buffer.duration))
print("{0} samples / seconds".format(buffer.sample_rate))
print("{0} channels".format(buffer.channel_count))
# choose what to do with the recorded sound data
choice = input("What do you want to do with captured sound (p = play, s = save) ? ")
if choice == 's':
# choose the filename
filename = input("Choose the file to create: ")
# save the buffer
buffer.to_file(filename);
else:
# create a sound instance and play it
sound = sf.Sound(buffer)
sound.play();
# wait until finished
while sound.status == sf.Sound.PLAYING:
# leave some CPU time for other threads
sf.sleep(sf.milliseconds(100))
# finished !
print("Done !")
# wait until the user presses 'enter' key
input("Press enter to exit...")
def setUp(self):
self.port = randint(10000, 65000)
self.server_manager = None
self.server_started = False
def server_thread(test_case):
test_case.server_manager = ServerManager(config_object={'network':{'port': self.port}})
def on_run():
test_case.server_started = True
test_case.server_manager.on_run = on_run
dbs = test_case.server_manager.db_session_type()
dbs.add(User(name='john', password='******'))
dbs.add(User(name='lazy', password=''))
dbs.flush()
test_case.server_manager.run()
self.server_thread = Thread(target=server_thread, args=(self,))
self.server_thread.start()
while not self.server_started:
sleep(milliseconds(10))
sleep(milliseconds(100))
def play_music():
# load an ogg music file
music = sf.Music.from_file("data/orchestral.ogg")
# display music informations
print("orchestral.ogg:")
print("{0} seconds".format(music.duration))
print("{0} samples / sec".format(music.sample_rate))
print("{0} channels".format(music.channel_count))
# play it
music.play()
# loop while the music is playing
while music.status == sf.Music.PLAYING:
# leave some CPU time for other processes
sf.sleep(sf.milliseconds(100))
def play_sound():
# load a sound buffer from a wav file
buffer = sf.SoundBuffer.from_file("data/canary.wav")
# display sound informations
print("canary.wav:")
print("{0} seconds".format(buffer.duration))
print("{0} samples / sec".format(buffer.sample_rate))
print("{0} channels".format(buffer.channel_count))
# create a sound instance and play it
sound = sf.Sound(buffer)
sound.play()
# loop while the sound is playing
while sound.status == sf.Sound.PLAYING:
# leave some CPU time for other processes
sf.sleep(sf.milliseconds(100))
def on_get_data(self, chunk): # we have reached the end of the buffer and all audio data have been played : we can stop playback if self.offset >= len(self.samples) and self.has_finished: return False # no new data has arrived since last update : wait until we get some while self.offset >= len(self.samples) and not self.has_finished: sf.sleep(sf.milliseconds(10)) # don't forget to lock as we run in two separate threads lock = threading.Lock() lock.acquire() # fill audio data to pass to the stream chunk.data = self.samples.data[self.offset*2:] # update the playing offset self.offset += len(chunk) lock.release() return True
def playsong(cls, songname, play_offset=0, loop=True):
""" Reproduce determinada canción.
'play_offset' indica la nueva posición donde comenzara a
sonar la musica. Esto se aplica DESPUÉS de iniciar la reproducción.
el tiempo se expresa en milisegundos.
'loop' al ser falso, reproduce la musica una sola vez. de lo contrario
reproducirá la canción por siempre en bucle.
"""
if hasattr(cls.actualsong, "play"):
# tiene el volumen en 0 la canción actual?
if cls.actualsong == 0:
# detenemos la canción y le restablecemos el volumen
cls.actualsong.stop()
cls.actualsong.volume = 100.0
try:
cls.actualsong = cls.songs[songname]
cls.actualsong.loop = loop
cls.actualsong.play()
cls.actualsong.playing_offset = sfml.milliseconds(play_offset)
except KeyError:
logging.exception("Canción {0} no a "
"sido cargada o no existe".format(songname))
def set_fps(self, fps):
self._fps = fps
self._frame_time = sf.milliseconds(1000 / self._fps)
def set_fps(self, fps): self._fps = fps self._frame_time = sf.milliseconds(1000 / self._fps)
def _work(self):
while self.working:
if self.selector.wait(sf.milliseconds(100)):
clients_to_remove = set()
unaccepted_to_remove = set()
for client_id, data in self.clients.items():
if self.selector.is_ready(data.socket):
try:
if data.current_packet_size == -1:
if data.receive_to_buffer(_packet_length_size):
msg = data.buffer
data.buffer = b''
data.current_packet_size = struct.unpack('I', msg)[0]
else:
if data.receive_to_buffer(data.current_packet_size):
msg = data.get_buffer()
module, packet = pickle.loads(msg)
handler = self.query_handlers.get(module)
if handler and \
(not self.permission_checker or self.permission_checker(client_id, module)):
result = handler(client_id, packet)
else:
result = None
# send result
# channel 0 => response to query
msg = pickle.dumps((0, result))
data.socket.send(struct.pack('I', len(msg)))
data.socket.send(msg)
data.current_packet_size = -1
except net.SocketDisconnected:
if self.disconnect_handler:
self.disconnect_handler(client_id)
self.selector.remove(data.socket)
clients_to_remove.add(client_id)
for client_id, data in self.unaccepted.items():
if self.selector.is_ready(data.socket):
try:
if data.receive_to_buffer(_hello_message_size):
msg = data.get_buffer()
if msg[:len(_hello_message)] == _hello_message:
try:
api_version = int(pickle.loads(msg[len(_hello_message):]))
if self.api_version_checker(api_version):
data.socket.send(_accept_message.ljust(_hello_message_size, b'\x00'))
self.clients[client_id] = data
data.current_packet_size = -1
unaccepted_to_remove.add(client_id)
if self.accept_handler:
self.accept_handler(client_id)
else:
data.socket.disconnect()
self.selector.remove(data.socket)
unaccepted_to_remove.add(client_id)
except TypeError:
data.socket.disconnect()
self.selector.remove(data.socket)
unaccepted_to_remove.add(client_id)
else:
data.socket.disconnect()
self.selector.remove(data.socket)
unaccepted_to_remove.add(client_id)
except net.SocketDisconnected:
self.selector.remove(data.socket)
unaccepted_to_remove.add(client_id)
for client_id in clients_to_remove:
del self.clients[client_id]
for client_id in unaccepted_to_remove:
del self.unaccepted[client_id]
if self.selector.is_ready(self.listener):
socket = self.listener.accept()
client_id = next(self.id_generator)
self.unaccepted[client_id] = _ClientData(client_id, socket)
self.selector.add(socket)
lives = 5
enemies = []
bullets = []
blasts = []
player.position = (50, window.size.y / 2)
game_state = 1
window.clear(sfml.Color(0, 128, 255))
window.draw(title_text)
alpha = int(
math.fabs((blink_clock.elapsed_time.milliseconds %
blink_interval) - blink_interval / 2) / blink_interval *
2 * 255)
press_space_text.color = sfml.Color(255, 255, 255, alpha)
window.draw(press_space_text)
window.display()
sfml.system.sleep(sfml.milliseconds(20))
# Game
elif game_state is 1:
# Handle player input
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.UP):
player.move((0, -player_speed))
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.DOWN):
player.move((0, player_speed))
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.LEFT):
player.move((-player_speed, 0))
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.RIGHT):
player.move((player_speed, 0))
# Fire!
if sfml.Keyboard.is_key_pressed(
sfml.Keyboard.SPACE
if game_state is 0:
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.SPACE):
score = 0
lives = 5
enemies = []
bullets = []
blasts = []
player.position = (50, window.size.y/2)
game_state = 1
window.clear(sfml.Color(0,128,255))
window.draw(title_text)
alpha = int(math.fabs((blink_clock.elapsed_time.milliseconds % blink_interval) - blink_interval/2)/blink_interval*2*255)
press_space_text.color = sfml.Color(255, 255, 255, alpha)
window.draw(press_space_text)
window.display()
sfml.system.sleep(sfml.milliseconds(20))
# Game
elif game_state is 1:
# Handle player input
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.UP):
player.move((0, -player_speed))
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.DOWN):
player.move((0, player_speed))
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.LEFT):
player.move((-player_speed, 0))
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.RIGHT):
player.move((player_speed, 0))
# Fire!
if sfml.Keyboard.is_key_pressed(sfml.Keyboard.SPACE) and fire_clock.elapsed_time.milliseconds > fire_cooldown:
blast = sfml.Sprite(blast_tx)
