def move(self, player: Player, pos: Vector2):
if self.dungeon.is_valid_position(pos):
old_pos = player.pos
player.pos = pos
self.send_room_data(player)
# Fetch the rooms
old_room = self.dungeon.room_at_position(old_pos)
new_room = self.dungeon.room_at_position(pos)
# Update players in rooms
if old_pos != pos:
old_room.leave(player)
self.send_msg_to_room(old_room, "%s has left the room" % player.get_true_name(), [player])
new_room.join(player)
# Notify everyone in the room that a player has joined
self.send_msg_to_room(new_room, "%s has joined the room" % player.get_true_name(), [player])
# Notify player of the players in the room they have joined
if len(new_room.players) > 1:
player_names = ', '.join([ply.get_true_name() for ply in new_room.players if ply != player])
self.send(player, DataTags.WRITE, "There are %d people in this room: %s" %
(len(new_room.players) - 1, player_names))
# Save the player's position
self.player_persistence.save_data(player)
else:
self.send(player, DataTags.WRITE, "Not a valid direction!") # TODO - less confusing message if map changes
def load_data(self, player: Player):
data = self._player_data(player.player_id)
print(data)
if data is not None:
player.nickname = data['nickname']
player.pos = Vector2(data['pos_x'], data['pos_y'])
def test_multiple_leave(self):
for i in range(0, 20):
self.game_state.join(Player(i))
for i in range(0, 20):
self.game_state.leave(Player(i))
for i in range(0, 20):
assert not self.game_state.contains_player(Player(i))
def command_name(self, player: Player, name: str):
if len(name) > 20:
reason = "Nickname too long! (max 20)"
self.send(player, DataTags.WRITE, reason) # TODO change DUPLICATE_LOGIN
else:
old_name = player.get_name()
player.nickname = name
# Notify others of name change
self.send_msg_to_room(self.dungeon.room_at_position(player.pos), "%s (%s) has changed their name to %s" %
(old_name, player.username, player.nickname), [player])
# Notify the player of name change
self.send(player, DataTags.WRITE, "You have changed your name from %s to %s" %
(old_name, player.get_name()))
self.save(player)
def start(self, ip, port):
self.sock.connect((ip, port))
self.sendline("name {}".format(self.name))
for line in readline_from_socket(self.sock):
data = json.loads(line)
if "status" in data:
self.handle_status_message(data)
continue
if not self.display:
self.board = GameBoardClient(*data["map_size"])
self.players = [
Player(None, name="Player" + str(i))
for i in range(data["num_players"])
]
self.my_id = data["player_id"]
self.players[self.my_id].name = self.name
self.display = Display(600, 600, self.board.width,
self.board.height)
self.display.init()
self.board.update(data["map"])
self.display.clear()
self.display.draw_board(self.board, self.players)
self.display.update(fps=0)
self.resolve_round()
for event in pygame.event.get():
if event.type == pygame.QUIT:
print("Game terminated by host.")
sys.exit(0)
async def join(ctx, rank):
"""
The join function adds a user to the current party if they send the message
!join <current rank>
"""
server = get_server(ctx.guild)
current_players = server.current_players
player = ctx.author
for p in current_players:
if p.user == str(player):
await ctx.send(
str(player) + ' has already been added to the game!')
return
if rank not in RANKS:
await ctx.send("Please give a valid rank!")
return
elo = RANKS[rank]
if len(current_players) >= 10:
await ctx.send('There are already 10 people in the game')
return
addUser(str(player), 0, 0)
current_players.append(Player(str(player), elo))
embed = discord.Embed()
embed.add_field(name="Join success",
value=str(player) + " has successfully joined!",
inline=False)
await ctx.send(embed=embed)
def save_data(self, player: Player):
print("Saving player data")
try:
self.cursor.execute(
'INSERT OR IGNORE INTO %s (player_id, nickname, pos_x, pos_y) VALUES (?,?,?,?)'
% self.PLAYER_TABLE, (player.player_id, player.get_name(),
player.pos.x, player.pos.y))
self.cursor.execute(
'UPDATE %s SET nickname = ?, pos_x = ?, pos_y = ? WHERE player_id = ?'
% self.PLAYER_TABLE, (player.get_name(), player.pos.x,
player.pos.y, player.player_id))
except Exception as e:
print(e)
else:
self.db.commit()
def command_room_desc(self, player: Player, desc: str):
if len(desc) > 100:
self.send(player, DataTags.WRITE, "Description too long (max 100)")
else:
room = self.dungeon.room_at_position(player.pos)
room.desc = desc
self.send_msg_to_room(room, "Room description changed by %s to: %s" % (player.get_name(), desc))
self.dungeon.save()
def command_room_name(self, player: Player, name: str):
if len(name) > 30:
self.send(player, DataTags.WRITE, "Name too long (max 30)")
else:
room = self.dungeon.room_at_position(player.pos)
room.name = name
self.send_msg_to_room(room, "Room name changed by %s to: %s" % (player.get_name(), name))
self.dungeon.save()
def check_username(self, player: Player, username: str):
# TODO check if user is already logged in
if len(username) > 20:
reason = "Username too long! (max 20)"
self.send(player, DataTags.DUPLICATE_LOGIN,
reason) # TODO change DUPLICATE_LOGIN
self.send(player, LoginTags.ENTER_USERNAME)
return
# Set username first
if player.username is None:
player.username = username
# Load user's salt or create one
if self.username_exists(username):
player.salt = self.user_salt(username)
else:
player.salt = self.generate_salt()
# Tell user to enter password
self.send(player, LoginTags.ENTER_PASSWORD, player.salt)
def setUp(cls):
cls.player = Player()
cls.player.player_id = 1
cls.player.username = '******'
cls.play = Play(sqlite3.connect(':memory:'))
cls.play.join(cls.player)
cls.play.output_queue.get() # Remove clear
cls.play.output_queue.get() # Remove welcome msg
cls.play.output_queue.get() # Remove room info
cls.play.output_queue.get() # Remove player joined room
def join(self, player: Player):
# Check for duplicate connections
for ply in self.players:
if ply.username == player.username:
self.kick_queue.put((player, "You are already logged on from a different computer!"))
return
super().join(player)
self.player_persistence.load_data(player)
self.clear_players_screen(player)
self.welcome_message(player)
self.help_commands(player)
print("Moving player: %s to %s" % (player.get_name(), player.pos))
self.move(player, player.pos)
def test_update_to_login(self):
player = Player(1)
player_name = "TestMe"
self.login.join(player)
# First is username
self.login.update(
player, DataPacket.combine(LoginTags.CHECK_USERNAME, player_name))
# Second is password - no account TestMe so will create new
self.login.update(
player,
DataPacket.combine(LoginTags.CHECK_PASSWORD, self.salted_password))
# Verify the user was created
assert self.login.user_salt(player_name) is not None
assert self.login.username_exists(player_name)
# Verify the user is verified
assert player.login_verified
def welcome_message(self, player: Player):
msg = "Welcome to the Dungeon %s!" % player.get_name()
self.send(player, DataTags.WRITE, msg)
'''
Created on 16.08.2014
Migration helper...
put all your images in the static/face/ directory in format "forename_lastname.jpg"
@author: Christoph Gerneth
'''
import sys
import os
sys.path.append("../")
from server import Player, db
gifs = os.listdir("../static/face/")
db.drop_all()
db.create_all()
print gifs
for fn in gifs:
name = fn.split(".")[0]
name = name.split("_")
name_cap = map(str.capitalize, name)
obj = Player(name=" ".join(name_cap).decode('utf-8'),
imgurl=fn.decode("utf-8"))
db.session.add(obj)
db.session.commit()
def say(self, player: Player, msg: str):
room = self.dungeon.room_at_position(player.pos)
self.send_msg_to_room(room, player.get_name() + ": " + msg)
for x_change in range(-1, player1.range + 1):
for y_change in range(-1, player1.range + 1):
if player1.x + x_change == sprite.x and player1.y + y_change:
sprite.health -= player1.attack
last_attack_time = time()
def get_sprites_around_xy(x_range, y_range):
sprites_in_range = {}
for sprite_id, sprite in Sprite.sprites.items():
if sprite.x in x_range and sprite.y in y_range:
sprites_in_range[sprite_id] = sprite
return sprites_in_range
last_attack_time = time()
id_counter = 0
player1 = Player.Player(id_counter, "Player", 45, 9)
id_counter += 1
# Creates 15 randomly places enemies.
for i in range(15):
x, y = random.randint(0, 80), random.randint(0, 20)
while not is_tile_walkable(x, y):
x, y = random.randint(0, 80), random.randint(0, 20)
temp_enemy = Enemy.Enemy(id_counter, x, y, "giant_eye")
id_counter += 1
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.connect(("127.0.0.1", 5050))
display = None
board = None
players = None
for line in readline_from_socket(s):
try:
data = json.loads(line)
if not display:
board = GameBoardClient(*data["map_size"])
players = [
Player(None, name=player["name"]) for player in data["players"]
]
display = Display(600, 600, board.width, board.height)
display.init()
board.update(data["map"])
display.clear()
display.draw_board(board, players)
display.update(fps=0)
except Exception, e:
print("Error parsing:", e.message)
for event in pygame.event.get():
if event.type == pygame.QUIT:
print("Game terminated by host.")
def test_out_of_order_join(self):
self.game_state.join(Player(5))
self.game_state.join(Player(50))
self.game_state.join(Player(500))
def leave(self, player: Player):
super().leave(player)
room = self.dungeon.room_at_position(player.pos)
room.leave(player)
if player.get_name() is not None:
self.send_msg_to_room(room, "%s has left the server" % player.get_name(), [player])
def setUp(self):
self.game_state = GameState()
self.player_id = Player(random.randrange(255))
def setUp(cls):
cls.pp = PlayerPersistence(sqlite3.connect(':memory:'))
cls.player = Player()
cls.player.player_id = 1
cls.player.username = '******'