async def scramble(ctx):
guild = ctx.message.guild
logging.info(guild)
players = models.Player_list()
players.load_all()
for p in players.items:
old_team_id = p.team_id
# Pick a number & update player
team_id = randint(1, 3)
if old_team_id != team_id:
p.team_id = team_id
p.update()
old_team = models.Team()
old_team.load(old_team_id)
team = models.Team()
team.load(team_id)
# Clear/Assign role
old_team_role = get(guild.roles, name=old_team.name)
team_role = get(guild.roles, name=team.name)
member = guild.get_member(int(p.discord_id))
if member is None:
logging.info(
"Player w/ id {} not found. Maybe they left the server.".
format(p.discord_id))
continue
await member.remove_roles(old_team_role,
reason="Automated Team Scramble")
await member.add_roles(team_role, reason="Automated Team Scramble")
logging.info("{} (ID:{}) moved from {} to {}".format(
member.nick, p.discord_id, old_team.name, team.name))
await asyncio.sleep(1)
models.save()
logging.info("Scramble complete")
async def on_member_join(member):
pa_chan = get(member.guild.text_channels, name="player-assignments")
ins_chan = get(member.guild.text_channels, name="instructions")
# Assign the new member to one of the three teams randomly
# FIXME Get number of teams through the DB and not hardcode a 3
team_id = randint(1, 3)
t = models.Team()
t.load(team_id)
# Add flair to user
role = get(member.guild.roles, name=t.name)
await member.add_roles(role)
# Create new Player record.
p = models.Player()
# First check if they already exist
try:
p.custom_load("discord_id = ?", (member.id, ))
t.load(p.team_id)
await pa_chan.send("Welcome back, {}! the **{}** missed you!".format(
member.mention, t.name))
return
except Exception:
pass
p.discord_id = member.id
p.team_id = team_id
p.coins = config['starting_coins']
p.last_active_day = 0
p.shares = 100
p.insert()
models.save()
# Post message to player-assignments channel
await pa_chan.send("Welcome, {}! You have been assigned to the **{}**!\n\
Make sure to check out the {} and good luck!".format(
member.mention, t.name, ins_chan.mention))
async def pay(ctx, target_location, amount):
if not config['game_ongoing']: return
amount = int(amount) # dumb.
member = ctx.message.author
p = models.Player()
try:
p.custom_load("discord_id = ?", (member.id, ))
except Exception:
await ctx.send("I don't have you listed as a player, {}\n\
If you believe this is an error, please talk to a Lord or the King"
.format(member.mention))
return
# Make sure player has enough coins!!!
if amount < 1:
await ctx.send("You can't pay 0 or negative coins, {}".format(
member.mention))
return
elif amount > p.coins:
await ctx.send("{}, you don't have enough coins!".format(
member.mention))
return
# Get team, current location id, available locations
t = models.Team()
t.load(p.team_id)
current_loc = t.current_location_id
avail_locs = graphanalyzer.get_next_location_list(t.team_id)
# Make sure it's a valid target location.
if target_location.lower() not in (name.lower()
for name in avail_locs.keys()):
await ctx.send(
"I don't think {} is a valid location. Maybe you mistyped it?".
format(target_location))
return
# Get the ID for the target location...
target_loc = models.Location()
target_loc.custom_load("name = ? COLLATE NOCASE", (target_location, ))
edge = models.LocationEdge()
edge.custom_load("start_location_id = ? AND end_location_id = ?", (
current_loc,
target_loc.location_id,
))
# Store the payment in the db
payment = models.Payment()
payment.player_id = p.player_id
payment.team_id = p.team_id
payment.amount = amount
payment.location_edge = edge.edge_id
payment.time = helpers.get_game_day()
payment.insert()
# Remove coins from player's account.
p.coins -= amount
p.last_active_day = helpers.get_game_day()
p.update()
models.save()
# Send confirmation message.
await ctx.send("{} has paid **{}** coins toward **{}**".format(
member.mention, amount, target_loc.name))
async def team(ctx):
if not config['game_ongoing']: return
member = ctx.message.author
try:
p = models.Player()
p.custom_load("discord_id = ?", (member.id, ))
if p.last_active_day != helpers.get_game_day():
p.last_active_day = helpers.get_game_day()
p.update()
models.save()
except Exception:
await ctx.send("I don't think you're playing, {}\n\
(If you think this is a mistake, please talk to a Lord or the King)"
.format(member.mention))
return
t = models.Team()
t.load(p.team_id)
l = models.Location()
l.load(t.current_location_id)
funding_table = paymentreducer.get_funding_table(p.team_id,
helpers.get_game_day())
await ctx.send(
"Your team is in **{}**, with at least **{}km** to go!\nHere is how today's funding is going:\n{}"
.format(
l.name,
graphanalyzer.dijkstra(graphanalyzer.graph, t.current_location_id,
0), "```" + funding_table + "```"))
async def spectate(ctx):
member = ctx.message.author
player = models.Player()
team = models.Team()
try:
player.custom_load("discord_id = ?", (str(member.id), ))
team.load(player.team_id)
except Exception as e:
await ctx.send(
"I think you're already out of the game, {}. If you think this was a mistake, please talk to a Lord or the King"
.format(member.mention))
logging.error(e)
return
# Remove flair from user
role = get(member.guild.roles, name=team.name)
await member.remove_roles(role, reason='Player left game')
# Add spectator role
role = get(member.guild.roles, name='Spectator')
await member.add_roles(role, reason='Player left game')
player.delete()
models.save()
logging.info("{} has switched to spectating".format(member.id))
await ctx.send("{}, you're now a spectator. Enjoy the show!".format(
member.mention))
def player_update():
sys.stdout.flush()
my_scraper = scraper.NBADataScraper()
headers, data = my_scraper.set_players()
update_players(data)
players = models.Player.query.all()
for player in players:
if player.last_scraped and (not player.active or player.last_scraped >= datetime.datetime.utcnow()):
pass
else:
print(player.get_name(), player.nba_id)
random.seed()
time.sleep(random.randint(1, 3))
headers, data = my_scraper.get_play_season_totals(player.nba_id)
for season in data:
season = {i[0]: i[1] for i in zip(headers[0], season)}
if season['TEAM_ABBREVIATION'] == 'Tot':
pass
else:
nba_season = models.Season.query.filter_by(season_code=season['SEASON_ID']).first()
if not nba_season:
nba_season = models.Season()
nba_season.season_code = season['SEASON_ID']
nba_season.season_start = int(season['SEASON_ID'].split("-")[0])
nba_season.season_end = nba_season.season_start + 1
nba_season.add_object()
team = models.Team.query.filter_by(nba_team_id=season['TEAM_ID']).first()
if not team:
team = models.Team()
team.nba_team_id = season['TEAM_ID']
team.team_abbr = season['TEAM_ABBREVIATION']
team.add_object()
player_season = models.PlayerSeason.query.filter_by(player_id=player.player_id,
season_id=nba_season.season_id,
team_id=team.team_id).first()
updating_season = True
if not player_season:
player_season = models.PlayerSeason()
updating_season = False
player_season.player_id = player.player_id
player_season.season_id = nba_season.season_id
player_season.team_id = team.team_id
for item in season:
attr = player_season.get_attr_title(item)
if attr:
setattr(player_season, attr, season[item])
if updating_season:
player_season.update_object()
else:
player_season.add_object()
player.last_scraped = datetime.datetime.utcnow()
player.update_object()
return "Player Seasons Gotten"
def check_click(hex_id):
player_selected = None
# TODO replace with match class
current_teams = ["Rage", "Peace"]
players_on_field = []
for team_name in current_teams:
players_on_field = players_on_field + models.Team(
team_name).player_list
for player_x in players_on_field:
if models.Player(player_x).current_tile == hex_id:
player_selected = player_x
return player_selected
def getAllTeams(min, max):
totalTeams = []
for pos in range(min, max):
name = getSingleData(data4, "Add Your Team Name", pos)
users = getSingleData(
data4,
"List ALL members of your team. Please ONLY put your team members discord username. DO NOT include their tag. DO NOT include their current nickname. (separate users between one comma and one space) Example: Darrow8, Povellesto",
pos)
newTeam = md.Team(users=users, name=name, desc=None, sht_desc=None)
totalTeams.append(newTeam)
return totalTeams
def GetTeam(self, team_id):
"""
Returns team with id from database
"""
self.mydb.commit()
mycursor = self.mydb.cursor()
mycursor.execute("SELECT * FROM Teams WHERE id = %(id)s",
{'id': team_id})
team = mycursor.fetchone()
mycursor.close()
if team is not None:
return models.Team(team)
else:
return None
def GetTeams(self, jam_id):
"""
Returns a list of teams from jam with id from database
"""
self.mydb.commit()
mycursor = self.mydb.cursor()
expression = "SELECT * FROM Teams WHERE Jam_id = %s;"
mycursor.execute(expression, (jam_id, ))
teams = []
row = mycursor.fetchone()
while row is not None:
team = models.Team(row)
teams.append(team)
row = mycursor.fetchone()
mycursor.close()
return teams
def team_attempt_move(team_id):
process_log = ""
# Load team.
t = models.Team()
t.load(team_id)
flns = paymentreducer.get_funding_list(team_id,
helpers.get_game_day() - 1, False)
fl = paymentreducer.get_funding_list(team_id,
helpers.get_game_day() - 1, True)
# Check for best-funded succesful path
new_loc = t.current_location_id
biggest_funding = -1
was_sabotaged = False
for k, v in flns.items():
le = models.LocationEdge()
le.load(k)
if v >= le.weight and v > biggest_funding:
new_loc = le.end_location_id
biggest_funding = v
if fl[k] < le.weight:
was_sabotaged = True
else:
was_sabotaged = False
if biggest_funding == -1:
process_log = "The {} didn't raise enough to book passage anywhere...".format(
t.name)
else:
l = models.Location()
l.load(new_loc)
if was_sabotaged:
process_log = "The {} tried to travel to {}, but someone sabotaged them and they were stopped by the Black Cats!".format(
t.name, l.name)
else:
t.current_location_id = new_loc
t.update()
process_log = "The {} have successfully reached {}!".format(
t.name, l.name)
models.save()
return process_log + "\n"
async def join(ctx):
member = ctx.message.author
if config['game_ongoing']:
await ctx.send(
"Sorry, {}, you can't join the game while it's ongoing!".format(
member.mention))
return
p = models.Player()
# Make sure player doesn't already exist
try:
p.custom_load('discord_id = ?', (member.id, ))
await ctx.send(
"I think you're already playing, {}. If you think this is an error, please talk to a Lord or the King"
.format(member.mention))
return
except Exception:
pass
# Pick a team
team_id = randint(1, 3)
team = models.Team()
team.load(team_id)
# Add flair to user
role = get(member.guild.roles, name=team.name)
await member.add_roles(role, reason='Player joined game')
# Remove spectator role
role = get(member.guild.roles, name='Spectator')
if role in member.roles:
await member.remove_roles(role, reason='Player joined game')
# Create new player
p.discord_id = member.id
p.team_id = team_id
p.coins = config['starting_coins']
p.last_active_day = 0
p.shares = 100
p.insert()
models.save()
logging.info("{} has joined the {}".format(member.id, team.name))
await ctx.send("{}, you've been added to the **{}**! Good Luck!".format(
member.mention, team.name))
def get_next_location_list(team_id):
locations = {}
team = models.Team()
team.load(team_id)
edges = models.LocationEdge_list()
edges.custom_load("start_location_id = ?", (team.current_location_id, ))
# Load end locations
ls = models.Location_list()
# HACK HACK HACK
ls.custom_load(
"location_id IN ({})".format(','.join(["?"] * len(edges.items))),
[x.end_location_id for x in edges.items])
# MUCH BIGGER HACK that could have been solved with a join instead but why bother
for l in ls.items:
locations[l.name] = list(
filter(lambda x: x.end_location_id == l.location_id,
edges.items))[0].weight
return locations
def get_funding_table(team_id, day=-1):
#f = get_funding_list(team_id, day=helpers.get_game_day(), show_sabotage=False)
f = get_funding_list(team_id, day, show_sabotage=False)
if len(f.keys()) == 0:
return "No payments have been made yet today!"
t = models.Team()
t.load(team_id)
tab = []
row_format = "{:<18}{:<8}{:<8}\n"
tab.append(row_format.format('Location', 'Toll', 'Paid'))
tab.append("-" * (34) + "\n")
# FIXME toooo many queries
for k, v in f.items():
le = models.LocationEdge()
le.load(k)
l = models.Location()
l.load(le.end_location_id)
tab.append(row_format.format(l.name, le.weight, v))
return "".join(tab)
def action_possible_hexes(action_selected, current_gui, current_field):
possible_hexes = []
if action_selected == "Move":
# find options to move
current_hex_id = models.Player(
current_gui.player_id_selected).current_tile
adj_hexes = current_field.adjacent_hexes(current_hex_id)
for hex_id in adj_hexes:
player_occupied = check_click(hex_id)
if player_occupied is None:
possible_hexes.append(hex_id)
elif action_selected == "Throw":
# find options to throw
current_hex_id = models.Player(
current_gui.player_id_selected).current_tile
current_teams = ["Rage", "Peace"]
players_on_field = []
player_hexes = []
for team_name in current_teams:
players_on_field = players_on_field + models.Team(
team_name).player_list
# check validity of throw, only sideways and back passes
check_y = current_field.current_field[current_hex_id].hex_coord_y
for player_x in players_on_field:
hex_x = current_field.current_field[models.Player(
player_x).current_tile]
if hex_x.hex_coord_y <= check_y:
possible_hexes.append(hex_x.hex_id)
elif action_selected == "Tackle":
# find options to tackle
current_hex_id = models.Player(
current_gui.player_id_selected).current_tile
adj_hexes = current_field.adjacent_hexes(current_hex_id)
for hex_id in adj_hexes:
player_occupied = check_click(hex_id)
if player_occupied is not None:
possible_hexes.append(hex_id)
else:
print("Error, action not possible: ", action_selected)
return possible_hexes
async def validateteams(ctx):
bad = 0
guild = ctx.message.guild
logging.info(guild)
players = models.Player_list()
players.load_all()
for p in players.items:
member = guild.get_member(int(p.discord_id))
t = models.Team()
t.load(p.team_id)
if member is None:
logging.info(
"Player w/ id {} not found. Maybe they left the server.".
format(p.discord_id))
else:
if member.top_role.name != t.name:
logging.error(
"{} (ID:{})'s role is {}, but it should be {}".format(
member.nick, p.discord_id, member.top_role.name,
t.name))
bad += 1
logging.info("Validation done. {}/{} roles are correct.".format(
len(players.items) - bad, len(players.items)))
def init_db():
import models
# Creating tables
Base.metadata.create_all(bind=engine)
# Populating Release table
release = models.Release()
release.name = 'All'
db_session.add(release)
release = models.Release()
release.name = 'Kilo'
db_session.add(release)
release = models.Release()
release.name = 'Juno'
db_session.add(release)
release = models.Release()
release.name = 'Icehouse'
db_session.add(release)
release = models.Release()
release.name = 'Havana'
db_session.add(release)
release = models.Release()
release.name = 'Grizzly'
db_session.add(release)
release = models.Release()
release.name = 'Folsom'
db_session.add(release)
release = models.Release()
release.name = 'Essex'
db_session.add(release)
release = models.Release()
release.name = 'Diablo'
db_session.add(release)
release = models.Release()
release.name = 'Cactus'
db_session.add(release)
release = models.Release()
release.name = 'Bexar'
db_session.add(release)
release = models.Release()
release.name = 'Austin'
db_session.add(release)
db_session.commit()
# Populating User table
user1 = models.User()
user1.name = 'Arx Cruz'
user1.email = '*****@*****.**'
user1.user_id = 'arxcruz'
db_session.add(user1)
user2 = models.User()
user2.name = 'David Kranz'
user2.email = '*****@*****.**'
user2.user_id = 'david-kranz'
db_session.add(user2)
user3 = models.User()
user3.name = 'Arx Cruz Delete'
user3.email = '*****@*****.**'
user3.user_id = 'arxcruz'
db_session.add(user3)
db_session.commit()
# Populating team
team = models.Team()
team.name = 'Demo team 1'
team.users.append(user1)
team.users.append(user2)
db_session.add(team)
team = models.Team()
team.name = 'Demo team 2'
team.users.append(user1)
team.users.append(user2)
db_session.add(team)
db_session.commit()
report = models.CustomReport()
report.name = 'Test'
report.description = 'Test description'
report.url = 'http://www.redhat.com'
db_session.add(report)
report = models.CustomReport()
report.name = 'Test'
report.description = 'Test description'
report.url = ('http://www.thisisaverybigurl.com/?withalotofinformation'
'topassthroughblablablaaasfasfdasfdasfasfdasdfasdfasdfasdf')
db_session.add(report)
db_session.commit()
def seed():
"""Seed the database with sample data."""
import models
# the rooms
room_features = ['Projector', 'TV', 'Webcam', 'Phone Line']
rooms = {
'1560': ['Projector'],
'1561': ['TV', 'Webcam'],
'1562': ['Projector'],
'1563': ['TV'],
'1564': ['Projector'],
'1565': ['TV', 'Webcam'],
'1665': ['TV', 'Webcam'],
'1663': ['TV'],
'1662': ['Projector'],
'1661': ['Projector'],
'1660': ['Projector']
}
feature_dict = {}
for feature in room_features:
f = models.RoomFeature(name=feature)
get_db().add(f)
feature_dict[feature] = f
rooms_dict = {}
for room_number in rooms:
r = models.Room(number=room_number)
for feature in rooms[room_number]:
f = feature_dict[feature]
r.features.append(f)
rooms_dict[room_number] = r
get_db().add(r)
# the types of team
teamtype_dict = {}
teamtype_dict['single'] = models.TeamType(
name='single',
priority=4,
advance_time=7 * 2 # 2 weeks
)
get_db().add(teamtype_dict['single'])
get_db().add(
models.TeamType(
name='other_team',
priority=4,
advance_time=7 * 2 # 2 weeks
))
get_db().add(
models.TeamType(
name='class',
priority=3,
advance_time=7 * 2 # 2 weeks
))
get_db().add(
models.TeamType(
name='colab_class',
priority=2,
advance_time=7 * 2 # 2 weeks
))
get_db().add(
models.TeamType(
name='senior_project',
priority=1,
advance_time=7 * 2 # 2 weeks
))
# the permissions
perm_names = [
'team.create', 'team.create.elevated', 'team.delete',
'team.delete.elevated', 'team.read', 'team.read.elevated',
'team.update', 'team.update.elevated', 'reservation.create',
'reservation.delete', 'reservation.delete.elevated',
'reservation.read', 'reservation.update',
'reservation.update.elevated', 'room.update.elevated',
'room.create.elevated', 'room.read', 'room.delete.elevated',
'feature.create', 'feature.delete', 'feature.update', 'feature.read',
'role.create', 'role.delete', 'role.update'
]
perm_dict = {}
for perm in perm_names:
p = models.Permission(name=perm)
get_db().add(p)
perm_dict[perm] = p
roles = {
'student': [
'team.create', 'team.delete', 'team.read', 'team.update',
'reservation.create', 'reservation.delete', 'reservation.read',
'reservation.update', 'room.read', 'feature.read'
],
'labbie': [
'team.create', 'team.delete', 'team.read', 'team.update',
'reservation.create', 'reservation.delete', 'reservation.read',
'reservation.update', 'room.read', 'feature.read',
'team.read.elevated'
],
'professor': [
'team.create', 'team.delete', 'team.read', 'team.update',
'reservation.create', 'reservation.delete', 'reservation.read',
'reservation.update', 'room.read', 'feature.read',
'team.create.elevated', 'team.read.elevated'
],
'admin': [
'team.create', 'team.create.elevated', 'team.delete',
'team.delete.elevated', 'team.read', 'team.read.elevated',
'team.update', 'team.update.elevated', 'reservation.create',
'reservation.delete', 'reservation.delete.elevated',
'reservation.read', 'reservation.update',
'reservation.update.elevated', 'room.update.elevated',
'room.create.elevated', 'room.read', 'room.delete.elevated',
'feature.create', 'feature.delete', 'feature.update',
'feature.read', 'role.create', 'role.delete', 'role.update'
]
}
users_dict = {}
for role in roles:
r = models.Role(name=role)
for permission in roles[role]:
p = perm_dict[permission]
r.permissions.append(p)
get_db().add(r)
# seed a user TODO don't do this in production?
u = models.User(name=role, email=role + "@example.com")
u.roles.append(r)
team = models.Team(u.name)
team_type = teamtype_dict['single']
team.team_type = team_type
team.members.append(u)
u.teams.append(team)
users_dict[role] = u
get_db().add(team)
get_db().add(u)
reservation = models.Reservation(
start=datetime.datetime.now() + datetime.timedelta(days=7),
end=datetime.datetime.now() + datetime.timedelta(days=7, hours=1),
team=users_dict['admin'].teams[0],
room=rooms_dict['1660'],
created_by=users_dict['admin'])
get_db().add(reservation)
get_db().commit()
def db_start():
engine = create_engine('sqlite:///tmp/test.db', convert_unicode=True)
db.create_all()
db.session.commit()
user = models.User()
user.username = "******"
user.password = sha256_crypt.encrypt("pppp1234")
user.email = '*****@*****.**'
user.job = "szef projektu"
user.admin = True
user.poweruser = True
user.organizer = True
user.birthdate = "01.01.1999"
user.about = "Jestem dobrym adminem"
user.why = "Chcę organizować gamejam, poniewż uważam, że jest to jest to idealna forma rozwoju dla młodych ludzi."
db.session.add(user)
db.session.commit()
user = models.User()
user.username = "******"
user.password = sha256_crypt.encrypt("pppp1234")
user.email = '*****@*****.**'
user.job = "szef projektu"
user.admin = True
user.poweruser = True
user.organizer = True
user.birthdate = "01.01.1999"
user.about = "Jestem dobrym adminem"
user.why = "Chcę organizować gamejam, poniewż uważam, że jest to jest to idealna forma rozwoju dla młodych ludzi."
db.session.add(user)
db.session.commit()
user = models.User()
user.username = "******"
user.password = sha256_crypt.encrypt("wikwoj")
user.email = '*****@*****.**'
user.job = "pierwszy user"
user.admin = False
user.poweruser = True
user.organizer = True
user.birthdate = "01.01.1889"
user.about = "Jestem dobrym szefem"
user.why = "Chcę zwyciężyć każdy jam"
db.session.add(user)
db.session.commit()
user = models.User()
user.username = "******"
user.password = sha256_crypt.encrypt("marek")
user.email = '*****@*****.**'
user.job = "programista"
user.admin = False
user.poweruser = True
user.organizer = False
user.birthdate = "01.01.1889"
db.session.add(user)
db.session.commit()
user = models.User()
user.username = "******"
user.password = sha256_crypt.encrypt("stefan")
user.email = '*****@*****.**'
user.job = "dzwiękowiec"
user.admin = False
user.poweruser = True
user.birthdate = "01.01.1889"
db.session.add(user)
db.session.commit()
team = models.Team()
team.name = "BestTeam"
team.master = "patryk"
team.master_email = '*****@*****.**'
team.contributors = ['adam', 'innygosc', 'jakiskoles']
team.gameinjams = ['Jam testowy', 'Pierwszy jam', 'Ten jam nie istnieje']
db.session.add(team)
db.session.commit()
team = models.Team()
team.name = "DrużynaWygrywów"
team.master = "wikwoj"
team.master_email = '*****@*****.**'
team.contributors = ['wikwoj', 'bedegralwgre', 'jestemhardkorem']
team.gameinjams = [
'Jam testowy', 'Szybki jam', 'Ten jam nie istnieje', 'Global game jam'
]
db.session.add(team)
db.session.commit()
team = models.Team()
team.name = "MonsterCouch"
team.master = "marek"
team.master_email = '*****@*****.**'
team.contributors = ['Krzyś', 'artur', 'Helena']
team.gameinjams = [
'Pierwszy jam', 'Szybki jam', 'Ten jam nie istnieje', 'Global game jam'
]
db.session.add(team)
db.session.commit()
team = models.Team()
team.name = "LameTeam"
team.master = "stefan"
team.master_email = '*****@*****.**'
team.contributors = ['Chyzio', 'Zyzio', 'Dyzio']
team.gameinjams = ['Pierwszy jam', 'Szybki', 'Global game jam']
db.session.add(team)
db.session.commit()
message = models.Message()
message.title = 'testowa wiadomość'
message.adresser = 'patryk'
message.author = 'wikwoj'
message.content = 'No hej'
message.created = datetime.now()
db.session.add(message)
db.session.commit()
jam = models.Jam()
jam.title = "Jam testowy"
jam.master = "patryk"
jam.theme = "destruction"
jam.description = "Jam o rozwalaniu"
jam.master_email = '*****@*****.**'
jam.teams = ['BestTeam', "DrużynaWygrywów"]
jam.active = False
db.session.add(jam)
db.session.commit()
game = models.Game()
game.title = "Demolition n' Destruction"
game.team = "BestTeam"
game.description = 'gra o rozwalaniu i zniszczeniu'
game.jam = 'Jam testowy'
game.path = "Demolition n' Destruction.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Diablo Origins"
game.team = "DrużynaWygrywów"
game.description = 'gra o niszczniu potworów'
game.jam = 'Jam testowy'
game.path = "Diablo Origins.zip"
db.session.add(game)
db.session.commit()
jam = models.Jam()
jam.title = "Pierwszy jam"
jam.master = "patryk"
jam.theme = "destruction"
jam.description = "Jam o rozwalaniu"
jam.master_email = '*****@*****.**'
jam.teams = ['BestTeam', "MonsterCouch", 'LameTeam']
db.session.add(jam)
db.session.commit()
game = models.Game()
game.title = "Doom 0"
game.team = "BestTeam"
game.description = 'Prequel Doom'
game.jam = 'Pierwszy jam'
game.path = "Doom 0.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Jabba The Hutt - Fat worm story"
game.team = "MonsterCouch"
game.description = 'Przemierzaj pustynię Tatooine pod postacią grubego robaka i zjadaj szturmowców'
game.jam = 'Pierwszy jam'
game.path = "Jabba The Hutt - Fat worm story.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Devil ain't cry"
game.team = "LameTeam"
game.description = 'Doprowadź diabła do płaczu'
game.jam = 'Pierwszy jam'
game.path = "devil ain't cry.zip"
db.session.add(game)
db.session.commit()
jam = models.Jam()
jam.title = "Szybki jam"
jam.master = "wikwoj"
jam.theme = "Stranger things"
jam.description = "Jam o dziwnych i zwariowanych grach"
jam.master_email = '*****@*****.**'
jam.teams = ['DrużynaWygrywów', 'MonsterCouch', 'LameTeam']
db.session.add(jam)
db.session.commit()
game = models.Game()
game.title = "Lightsaber tactics"
game.team = "DrużynaWygrywów"
game.description = 'Platformowa gra 2D, w której poruszasz się zbuntowanym rycerzem Jedi i zabijasz młodych adeptów'
game.jam = 'Szybki jam'
game.path = "Lightsaber tactics.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Quit now"
game.team = "MonsterCouch"
game.description = 'Ciężka gra platformowa'
game.jam = 'Szybki jam'
game.path = "Quit now.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Worms arena"
game.team = "LameTeam"
game.description = 'Bijesz się na areni będąc robakiem'
game.jam = 'Szybki jam'
game.path = "worms arena.zip"
db.session.add(game)
db.session.commit()
jam = models.Jam()
jam.title = "Ten jam nie istnieje"
jam.master = "patryk"
jam.theme = "matrix"
jam.description = "Jam o niebyciu"
jam.master_email = '*****@*****.**'
jam.teams = ['DrużynaWygrywów', 'BestTeam', 'MonsterCouch']
jam.active = False
db.session.add(jam)
db.session.commit()
game = models.Game()
game.title = "Satelite destroyer"
game.team = "BestTeam"
game.description = 'Jako operator działa niszcz zbliżające się satelity wroga'
game.jam = 'Ten jam nie istnieje'
game.path = "Satelite destroyer.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Wolfenstein: the old order"
game.team = "DrużynaWygrywów"
game.description = 'Gra, w której musisz zabić Wiliama Josepha Blazkowicza'
game.jam = 'Ten jam nie istnieje'
game.path = "Wolfenstein the old order!.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Path of Neo"
game.team = "MonsterCouch"
game.description = 'Symulator Wiary'
game.jam = 'Ten jam nie istnieje'
game.path = "Path of neo.zip"
db.session.add(game)
db.session.commit()
jam = models.Jam()
jam.title = "Global game jam"
jam.master = "wikwoj"
jam.theme = "Wszystkie gry"
jam.description = "Jam, w ktorym tolerowane sa wszystkie gatunki gier"
jam.master_email = '*****@*****.**'
jam.teams = ['DrużynaWygrywów', "MonsterCouch", 'LameTeam']
jam.active = False
db.session.add(jam)
db.session.commit()
game = models.Game()
game.title = "Military trucks"
game.team = "MonsterCouch"
game.description = 'Prosta gra wyścigowa z pojazdami wojskowymi'
game.jam = 'Global game jam'
game.path = "Military trucks.tar.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Battle of tatooine"
game.team = "DrużynaWygrywów"
game.description = 'Jako operator działa niszcz zbliżające się statki wroga'
game.jam = 'Global game jam'
game.path = "Battle of tatooine.zip"
db.session.add(game)
db.session.commit()
game = models.Game()
game.title = "Shoot fast! Don't die!"
game.team = "LameTeam"
game.description = 'Multiplayer FPS typu arena'
game.jam = 'Global game jam'
game.path = "Shoot fast! Don't die!.zip"
db.session.add(game)
db.session.commit()
def drawBoard(field_current, gui_current):
# Draw background of board.
DISPLAYSURF.blit(BGIMAGE, BGIMAGE.get_rect())
board_width_hexes = 7
board_height_hexes = 5
unique_id = 0
hex_x = 0
# draw hexagon field
for x in range(board_width_hexes):
hex_x += 1
hex_y = 0
for y in range(board_height_hexes):
hex_y += 1
hex_details = models.Hex()
hex_side = SPACESIZE / math.sqrt(3)
hex_height_tip = abs(math.sin(math.degrees(30)) * hex_side)
hex_radius = abs(math.cos(math.degrees(30)) * hex_side)
# even row
if x % 2 == 0:
starty = (y * 2 * hex_radius) + YMARGIN
startx = (x * (hex_side + hex_height_tip)) + XMARGIN
# odd row
else:
starty = (y * 2 * hex_radius + hex_radius) + YMARGIN
startx = (x * (hex_side + hex_height_tip)) + XMARGIN
polygon_points = [
[hex_height_tip + startx, starty],
[hex_height_tip + hex_side + startx, starty],
[hex_height_tip * 2 + hex_side + startx, hex_radius + starty],
[hex_height_tip + hex_side + startx, hex_radius * 2 + starty],
[hex_height_tip + startx, hex_radius * 2 + starty],
[startx, hex_radius + starty]
]
unique_id += 1
center_x = int(startx + hex_height_tip + (hex_side / 2))
center_y = int(starty + hex_radius)
if field_current.field_layout[unique_id] == "field":
pygame.draw.polygon(DISPLAYSURF, DARKGRAY, polygon_points, 5)
# Label tiles, can hide
font_obj = pygame.font.Font('freesansbold.ttf', 15)
coord_to_write = "(" + str(hex_x) + ", " + str(hex_y) + ") " + str(
unique_id)
text_surface_object = font_obj.render(coord_to_write, True, BLACK)
text_rect_object = text_surface_object.get_rect()
text_rect_object.center = (center_x, center_y)
DISPLAYSURF.blit(text_surface_object, text_rect_object)
# assign tiles values and then make the field dict of hex class
hex_details.hex_id = unique_id
hex_details.hex_coord_x = hex_x
hex_details.hex_coord_y = hex_y
hex_details.pix_box_x = startx
hex_details.pix_box_y = starty
hex_details.center_pix_x = center_x
hex_details.center_pix_y = center_y
field_current.current_field.setdefault(unique_id, hex_details)
# Draw the players
# TODO replace with either Match class or store this in the field?
teams_in_match = ["Peace", "Rage"]
human_team_name = "Rage"
all_player_list = []
human_team_list = []
for team_name in teams_in_match:
team_x = models.Team(team_name)
all_player_list = team_x.player_list + all_player_list
if team_name is human_team_name:
human_team_list = team_x.player_list
for player_id in all_player_list:
player_x = models.Player(player_id)
hex_x = field_current.current_field[player_x.current_tile]
team_x = models.Team(player_x.team_name)
if team_x.team_color == "blue":
tile_color = BLUE
elif team_x.team_color == "red":
tile_color = RED
elif team_x.team_color == "white":
tile_color = WHITE
else:
tile_color = BLACK
pygame.draw.circle(DISPLAYSURF, tile_color,
(hex_x.center_pix_x, hex_x.center_pix_y),
PLAYERSIZE)
font_obj = pygame.font.SysFont('couriernew.ttf', 25)
if "Captain" in player_x.title:
player_title = "C"
elif "Tank" in player_x.title:
player_title = "T"
else:
player_title = "WTF"
text_surface_object = font_obj.render(player_title, True, BLACK,
tile_color)
text_rect_object = text_surface_object.get_rect()
text_rect_object.center = (hex_x.center_pix_x, hex_x.center_pix_y)
DISPLAYSURF.blit(text_surface_object, text_rect_object)
topbar_surface = pygame.Surface((BOARDWIDTH * SPACESIZE, YMARGIN - 10))
topbar_surface.fill(LIGHTERBLUE)
details_font = pygame.font.SysFont('couriernew.ttf', 40)
to_blit_list = [[topbar_surface, (5 + XMARGIN, 5)]]
text_color = BLACK
text_row = gui_current.top_message
text_surf = details_font.render(text_row, True, text_color, LIGHTERBLUE)
y_pos = int(YMARGIN / 2)
x_pos = XMARGIN + int(BOARDWIDTH * SPACESIZE / 2)
text_rect = text_surf.get_rect(center=(x_pos, y_pos))
to_blit_list.append([text_surf, text_rect])
DISPLAYSURF.blits(to_blit_list)
# Draw the player menu and selected player
if gui_current.player_id_selected is not None and gui_current.player_highlight is True:
current_field_dict = field_current.current_field
# circle around selected player
hex_to_highlight = models.Player(
gui_current.player_id_selected).current_tile
player_x = current_field_dict[hex_to_highlight].center_pix_x
player_y = current_field_dict[hex_to_highlight].center_pix_y
pygame.draw.circle(DISPLAYSURF, YELLOW, (player_x, player_y),
PLAYERSIZE, 2)
# player details on left side
sidebar_surface = pygame.Surface(
(XMARGIN - 10, int(BOARDWIDTH * SPACESIZE / 2)))
sidebar_surface.fill(DARKGRAY)
details_font = pygame.font.SysFont('couriernew.ttf', 25)
text_row_list = ["Player Details"]
row_i = 1
to_blit_list = [[sidebar_surface, (5, YMARGIN)]]
text_row_list.append(
"Name: " +
models.Player(gui_current.player_id_selected).player_name)
text_row_list.append(
"Team: " + models.Player(gui_current.player_id_selected).team_name)
text_row_list.append(
"Title: " + models.Player(gui_current.player_id_selected).title)
for row in text_row_list:
text_surf = details_font.render(row, True, GREEN, DARKGRAY)
y_pos = YMARGIN + int((SPACESIZE * row_i) / 2)
row_i += 1
text_rect = text_surf.get_rect(center=(int((XMARGIN - 5) / 2),
y_pos))
to_blit_list.append([text_surf, text_rect])
DISPLAYSURF.blits(to_blit_list)
# if player character, the show action menu
# can store menu as a dict with positions in gui_current, actions come from player class
action_list = ["Move", "Throw", "Tackle"]
action_button_dict = {}
if gui_current.player_id_selected in human_team_list:
sidebar_surface = pygame.Surface(
(XMARGIN - 10, BOARDWIDTH * SPACESIZE))
sidebar_surface.fill(LIGHTGRAY)
details_font = pygame.font.SysFont('couriernew.ttf', 25)
text_row_list = ["Action Menu"]
row_i = 1
to_blit_list = [[
sidebar_surface,
(5 + XMARGIN + BOARDWIDTH * SPACESIZE, YMARGIN)
]]
for action_x in action_list:
text_row_list.append(action_x)
for row in text_row_list:
# cheat for not showing options when not possible
text_color = WHITE
if field_current.ball_hex == models.Player(gui_current.player_id_selected).current_tile and \
row == "Tackle":
text_color = LIGHTGRAY
elif field_current.ball_hex != models.Player(gui_current.player_id_selected).current_tile and \
row == "Throw":
text_color = LIGHTGRAY
text_surf = details_font.render(row, True, text_color,
LIGHTGRAY)
y_pos = YMARGIN + int((SPACESIZE * row_i) / 2)
x_pos = XMARGIN + BOARDWIDTH * SPACESIZE + int(XMARGIN / 2)
text_rect = text_surf.get_rect(center=(x_pos, y_pos))
if row_i > 1: # not box around the menu title
button_rect_shape = pygame.Rect(text_rect.top,
text_rect.left,
XMARGIN - 30,
int(SPACESIZE / 2))
button_rect_shape.centerx = int(XMARGIN / 2)
button_rect_shape.centery = int(row_i * SPACESIZE / 2)
button_rect = pygame.draw.rect(sidebar_surface, DARKGRAY,
button_rect_shape, 2)
action_button_dict.setdefault(row, button_rect_shape)
row_i += 1
to_blit_list.append([text_surf, text_rect])
DISPLAYSURF.blits(to_blit_list)
gui_current.button_dict = action_button_dict
# reset ball if not in play
if field_current.ball_hex is None:
field_current.ball_hex = 16
ball_x = field_current.current_field[
field_current.ball_hex].center_pix_x - int(SPACESIZE / 5)
ball_y = field_current.current_field[
field_current.ball_hex].center_pix_y + int(SPACESIZE / 3)
pygame.draw.circle(DISPLAYSURF, BRIGHTBLUE, (ball_x, ball_y),
int(SPACESIZE / 5))
# draw highlighted hexes for actions
if len(gui_current.possible_hexes) > 0:
for hex_id in gui_current.possible_hexes:
highlight_x = field_current.current_field[hex_id].center_pix_x
highlight_y = field_current.current_field[hex_id].center_pix_y
pygame.draw.circle(DISPLAYSURF, YELLOW, (highlight_x, highlight_y),
PLAYERSIZE - 5, 2)
return field_current, gui_current
def implement_moves(current_field, move_list):
# TODO implement results display
for move_x in move_list:
if move_x.action_type == "Move":
# check if player is still there
if models.Player(
move_x.player_action).current_tile == move_x.hex_start:
# check if end space is free
# TODO replace with match class
teams_in_play = ["Rage", "Peace"]
all_player_hexes = []
for team_x in teams_in_play:
all_player_hexes = all_player_hexes + models.Team(
team_x).players_field_hexes()
if move_x.hex_end not in all_player_hexes:
# move player
player_0 = models.Player(move_x.player_action)
player_0.current_tile = move_x.hex_end
player_0.update_db()
elif move_x.action_type == "Throw":
print("Throw")
elif move_x.action_type == "Tackle":
# check if player is still there
if models.Player(
move_x.player_action).current_tile == move_x.hex_start:
# check if end space has an opponent
teams_in_play = ["Rage", "Peace"]
all_player_hexes = []
for team_x in teams_in_play:
all_player_hexes = all_player_hexes + models.Team(
team_x).players_field_hexes()
if move_x.hex_end in all_player_hexes and \
move_x.hex_end != models.Player(move_x.player_action).current_tile:
# move player
player_0 = models.Player(move_x.player_action)
player_0.current_tile = move_x.hex_end
player_0.update_db()
# move tackled player
player_1 = models.Player(check_click(move_x.hex_end))
tackle_complete = False
hex_3_x = None
hex_3_y = None
while tackle_complete is False:
hex_0 = current_field.current_field[move_x.hex_start]
hex_1 = current_field.current_field[
player_1.current_tile]
delta_x = 0
delta_y = 0
if hex_0.hex_coord_x == hex_1.hex_coord_x:
delta_x = 0
if hex_0.hex_coord_y > hex_1.hex_coord_y:
delta_y = -1
else:
delta_y = 1
elif hex_0.hex_coord_x > hex_1.hex_coord_x:
delta_x = -1
if hex_0.hex_coord_y == hex_1.hex_coord_y:
delta_y = -1
else:
delta_x = 1
if hex_0.hex_coord_y == hex_1.hex_coord_y:
delta_y = -1
hex_3_x = hex_1.hex_coord_x + delta_x
hex_3_y = hex_1.hex_coord_y + delta_y
# TODO check for player already in place and resolve
tackle_complete = True
for hex_id, hex_x in current_field.current_field.items():
if hex_x.hex_coord_x == hex_3_x and hex_x.hex_coord_y == hex_3_y:
player_1.current_tile = hex_id
player_1.update_db()
elif move_x.hex_end == models.Player(
move_x.player_action).current_tile:
print("Self-tackle")
else:
print("No one to tackle", move_x.hex_end, all_player_hexes)
# move both players
else:
print("action not found ", move_x.action_type)
return current_field
def runGame():
# get the right database for the starting players
db_creation.clean_db()
db_creation.new_db_empty()
db_creation.fill_db()
# set the stage
turn = 'player'
current_match = models.Match()
current_match.match_number = 1
current_match.match_teams = ["Rage", "Peace"]
current_match.human_team = "Rage"
starting_field = models.Field()
starting_gui = models.Gui()
current_field, current_gui = drawBoard(starting_field, starting_gui)
while True: # main game loop
# Keep looping for player and computer's turns.
player_move_commit_list = []
computer_move_commit_list = []
if turn == 'player':
# Player's turn:
moves_committed = False
moves_commit_list = []
while moves_committed is False:
# Keep looping until the player submits three moves
checkForQuit()
for event in pygame.event.get(): # event handling loop
if event.type == MOUSEBUTTONUP:
# Handle mouse click events
mousex, mousey = event.pos
hex_id, button_name = getSpaceClicked(
mousex, mousey, current_field, current_gui)
player_selected = check_click(hex_id)
if current_gui.action_selection is False and player_selected is not None:
# print(hex_id,models.Player(player_selected).player_name)
current_gui.player_highlight = True
current_gui.player_id_selected = player_selected
if player_selected in models.Team(
current_match.human_team).player_list:
current_gui.action_menu = True
current_gui.top_message = "Choose an action for " + models.Player(
player_selected).player_name
elif button_name is not None:
# draw possible hexes for an action
current_gui.possible_hexes = action_possible_hexes(
button_name, current_gui, current_field)
if len(current_gui.possible_hexes) > 0:
current_gui.action_selection = True
current_gui.action_to_do = button_name
current_gui.top_message = "Choose a hex for " + button_name
# TODO add back button or someway to cancel selection
elif hex_id in current_gui.possible_hexes and current_gui.action_selection is True:
# after hex selected
move_commit_x = action_commit(hex_id, current_gui)
moves_commit_list.append(move_commit_x)
current_gui.action_selection = False
current_gui.action_to_do = None
current_gui.possible_hexes = []
current_gui.player_id_selected = None
current_gui.player_highlight = False
m2 = len(
models.Team(
current_match.human_team).player_list)
m1 = len(moves_commit_list)
current_gui.top_message = str(
m1) + " out of " + str(m2) + " moves committed"
# update drawing of game board
current_field, current_gui = drawBoard(current_field,
current_gui)
# update display
MAINCLOCK.tick(FPS)
pygame.display.update()
# checks if all moves_committed
if len(moves_commit_list) >= len(
models.Team(current_match.human_team).player_list):
moves_committed = True
current_gui.top_message = "Player's turn complete. Computer's turn."
player_move_commit_list = moves_commit_list
# End the turn
else:
# Computer's turn:
current_field, current_gui = drawBoard(current_field, current_gui)
# Make it look like the computer is thinking by pausing a bit.
pauseUntil = time.time() + random.randint(5, 15) * 0.1
while time.time() < pauseUntil:
pygame.display.update()
current_gui.top_message = "Computer turn complete. Human's turn"
current_field = implement_moves(current_field, player_move_commit_list)
# update board
current_field, current_gui = drawBoard(current_field, current_gui)
# update display
MAINCLOCK.tick(FPS)
pygame.display.update()
# Only set for the player's turn if they can make a move.
turn = 'player'
async def sabotage(ctx, target_team, target_location, amount):
if not config['game_ongoing']: return
# just pay() but with negative coins and another team
amount = int(amount) # still dumb
member = ctx.message.author
p = models.Player()
try:
p.custom_load("discord_id = ?", (member.id, ))
except Exception:
await ctx.send(
"Gonna be hard to sabotage when I don't have you listed as a player, {}\n\
If you believe this is a mistake, please talk to a Lord or the King"
.format(member.mention))
return
# Mke sure player has enough coins
if amount < 1:
await ctx.send("You can't pay 0 or negative coins, {}".format(
member.mention))
return
elif amount > p.coins:
await ctx.send("{}, you don't have enough coins!".format(
member.mention))
return
t = models.Team()
try:
t.custom_load("name = ? COLLATE NOCASE",
(target_team, )) # TODO make this more user-friendly
except Exception:
await ctx.send(
"I don't think {} is a real team, {}. Make sure you type the full name!"
.format(target_team, member.mention))
return
if t.team_id == p.team_id:
await ctx.send(
"You can't sabotage your own team, {}!!! They won't like you for that!"
.format(member.mention))
return
current_loc = t.current_location_id
avail_locs = graphanalyzer.get_next_location_list(t.team_id)
# Validate target location...
if target_location.lower() not in (name.lower()
for name in avail_locs.keys()):
await ctx.send(
"I don't think {} is a valid location. Maybe a typo?".format(
target_location))
return
# Get id for the target location...
location = models.Location()
location.custom_load("name = ? COLLATE NOCASE", (target_location, ))
edge = models.LocationEdge()
edge.custom_load("start_location_id = ? AND end_location_id = ?",
(current_loc, location.location_id))
# Store the payment!
payment = models.Payment()
payment.player_id = p.player_id
payment.team_id = t.team_id
payment.amount = -amount # VERY IMPORTANT DIFFERENCE
payment.location_edge = edge.edge_id
payment.time = helpers.get_game_day()
payment.insert()
# Remove coins from the player's account
p.coins -= amount
p.last_active_day = helpers.get_game_day()
p.update()
models.save()
# Send confirmation message.
await ctx.send(
"{} has paid **{}** coins to sabotage the **{}'** trip to **{}**".
format(member.mention, amount, t.name, location.name))
def main():
conn = pymysql.connect(host=migrate_config.OLD_HOST,
port=migrate_config.OLD_PORT,
user=migrate_config.OLD_USER,
password=migrate_config.OLD_PASSWORD,
db=migrate_config.OLD_DATABASE)
joined_teams: Dict[int, List[int]] = {}
user_admin_teams: Dict[int, List[int]] = {}
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute("SELECT * FROM users")
print("loading user...")
for item in cursor.fetchall():
joined_teams[item["id"]] = json.loads(item["joined_teams"])
print(item["username"])
user = models.User(id=item["id"],
banned=item["banned"],
username=item["username"],
password=item["password"],
description=item["description"],
email=item["email"],
register_time=item["register_time"],
rating_history=json.loads(item["rating_history"]),
rating=item["rating"],
permission_group=item["permission_group"],
permissions=json.loads(item["permissions"]),
force_logout_before=item["force_logout_before"],
phone_number=None,
phone_verified=False)
db.session.add(user)
db.session.commit()
print("loading problems...")
cursor.execute("SELECT * FROM problems")
for item in cursor.fetchall():
print(item["id"], item["title"])
prob = models.Problem(id=item["id"],
uploader_id=item["uploader_id"],
title=item["title"],
background=item["background"],
content=item["content"],
input_format=item["input_format"],
output_format=item["output_format"],
hint=item["hint"],
example=json.loads(item["example"]),
files=json.loads(item["files"]),
downloads=json.loads(item["downloads"]),
provides=json.loads(item["provides"]),
subtasks=json.loads(item["subtasks"]),
public=item["public"],
spj_filename=item["spj_filename"],
using_file_io=item["using_file_io"],
input_file_name=item["input_file_name"],
output_file_name=item["output_file_name"],
problem_type=item["problem_type"],
can_see_results=item["can_see_results"],
create_time=item["create_time"],
extra_parameter=json.loads(
item["extra_parameter"]),
remote_judge_oj=item["remote_judge_oj"],
remote_problem_id=item["remote_problem_id"],
cached_submit_count=0,
cached_accepted_count=0,
team_id=None,
invite_code=str(uuid.uuid1()),
submission_visible=True)
db.session.add(prob)
db.session.commit()
print("loading submissions...")
cursor.execute("SELECT * FROM submissions")
for item in cursor.fetchall():
print(item["id"])
item.update(
dict(judge_result=json.loads(item["judge_result"]),
selected_compile_parameters=json.loads(
item["selected_compile_parameters"])))
submission = models.Submission(**item)
db.session.add(submission)
db.session.commit()
print("loading contests..")
cursor.execute("SELECT * FROM contest")
for item in cursor.fetchall():
print(item["id"])
item.update(dict(closed=False, problems=json.loads(item["problems"])))
contest = models.Contest(**item)
db.session.add(contest)
db.session.commit()
print("loading teams..")
cursor.execute("SELECT * FROM team")
for item in cursor.fetchall():
team = models.Team(id=item["id"],
name=item["name"],
description=item["description"],
owner_id=item["owner_id"],
tasks=json.loads(item["tasks"]),
create_time=item["create_time"],
invite_code=str(uuid.uuid1()),
private=False,
team_contests=[],
team_problems=[],
team_problemsets=[])
for uid in item["admins"]:
if uid not in user_admin_teams:
user_admin_teams[uid] = []
user_admin_teams[uid].append(item["id"])
db.session.add(team)
db.session.commit()
for user, teams in joined_teams.items():
admin_teams = user_admin_teams.get(user, set())
for x in teams:
db.session.add(
models.TeamMember(uid=user,
team_id=x,
is_admin=x in admin_teams))
db.session.commit()
print("loading permission groups..")
db.session.query(models.PermissionGroup).delete()
db.session.commit()
cursor.execute("SELECT * FROM permission_groups")
for item in cursor.fetchall():
item.update(dict(permissions=json.loads(item["permissions"])))
db.session.add(models.PermissionGroup(**item))
db.session.commit()
print("loading problemsets...")
cursor.execute("SELECT * FROM problem_set")
for item in cursor.fetchall():
item.update(dict(problems=json.loads(item["problems"])))
db.session.add(models.ProblemSet(**item))
db.session.commit()
print("loading remote accounts...")
cursor.execute("SELECT * FROM remote_accounts")
for item in cursor.fetchall():
item.update(dict(session=item["session"]))
db.session.add(models.RemoteAccount(**item))
db.session.commit()
print("loading discussions..")
cursor.execute("SELECT * FROM discussions")
for item in cursor.fetchall():
db.session.add(models.Discussion(**item, private=False))
db.session.commit()
print("loading comments..")
cursor.execute("SELECT * FROM comments")
for item in cursor.fetchall():
if not db.session.query(
models.Discussion).filter_by(id=item["discussion_id"]).count():
continue
db.session.add(models.Comment(**item))
db.session.commit()
print("Done!")
def ask_for_teams_at_event(event_code):
"""
Return an list of teams at the event code event_code
:param event_code the TBA code of the event
:return a list of Team objects
"""
teams_filename = '{}-teams.json'.format(event_code)
# Check if list of teams already exists
try:
with open(teams_filename, 'r') as f:
teams_from_file = json.loads(f.read())
local_teams = [
models.Team(tba_dictionary=team, from_file=True)
for team in teams_from_file
]
logger.info('Loaded teams from {}'.format(teams_filename))
return local_teams
except FileNotFoundError:
logger.info('no previously saved base team info. fetching.')
endpoint = 'https://www.thebluealliance.com/api/v3/event/{}/teams/simple'.format(
event_code)
headers = {'X-TBA-Auth-Key': tba_key}
logger.info('Asking for teams at event from {}'.format(endpoint))
if event_code in last_asked['teams_at_event']:
modified_since = last_asked['teams_at_event'][event_code]
logger.info('Using If-Modified-Since: {}'.format(modified_since))
headers['If-Modified-Since'] = modified_since
r = None
try:
r = requests.get(endpoint, headers=headers)
except requests.exceptions.ConnectionError as e:
logger.error('Connection error while requesting event code {}'.format(
event_code))
return []
logger.info('Status code: {}'.format(r.status_code))
if r.status_code == 304:
logger.info('No change in teams at event since last request')
elif r.status_code != 200:
return
response_json = r.json()
local_teams = []
for team in response_json:
team_object = models.Team(tba_dictionary=team)
local_teams.append(team_object)
logger.info('Added {} teams: {}'.format(
len(local_teams),
', '.join([str(team.number) for team in local_teams])))
last_asked['teams_at_event'][event_code] = r.headers['Last-Modified']
teams_as_dicts = [team.__dict__ for team in local_teams]
teams_filename = '{}-teams.json'.format(event_code)
with open(teams_filename, 'w') as f:
f.write(json.dumps(teams_as_dicts))
return local_teams
def read_tournament(self, json):
# Se recuperan los datos del JSON
league = models.League(self.league_name)
tournament = models.Tournament(discord_id=self.discord_id,
tournament_name=self.tournament)
# Ultima actualizacion de goblin spy
tournament.last_update = json["Info"]["rows"][0][3]
# Se guardan las instancias de equipos
all_teams = {}
ranking = models.Ranking()
# Lista de los equipos inscritos ordenados por puntuación
ranking_data = json["LeagueStandings"]["rows"]
for team_data in ranking_data:
# team[10] es la casilla del coachbame. Get_Coach revisa si el nombre está inscrito en la DB de usuarios
recover_coach = self.get_coach(team_data[10])
coach = models.Coach(team_data[10], team_data[10])
if recover_coach != team_data[10]:
coach.display_name = recover_coach[0]
coach.user_discord_id = recover_coach[1]
# Se guarda la raza como el emoticono de la raza (bb<race_name>)
team = models.Team(coach=coach,
team_name=team_data[17],
race=bloodBowl.Get_Race(int(team_data[16])),
wins=team_data[22],
draws=team_data[23],
loses=team_data[24],
rank=team_data[18],
td=team_data[25])
ranking.add_team(team)
all_teams[team.team_name] = team
# Primero se recuperan los datos del histórico. Después, si la competición no es de tipo escalera y tiene partidos programados, se recuperan estos, incluidos los ya jugados
# NOTA: Se crea una nueva instancia de un mismo partido porque en el json no hay ningun identificador comun entre Matches y Schedule
# Recuoperación del histórico
tournament.ranking = ranking
history = models.History()
matches_data = json["Matches"]["rows"]
for match_data in matches_data:
match = models.Match(local_team=all_teams[match_data[14]],
visitor_team=all_teams[match_data[17]],
local_score=match_data[15],
visitor_score=match_data[16],
status="played",
played_time=match_data[4])
history.add_match(match)
tournament.match_history = history
schedule_data = json["Schedule"]["rows"]
if schedule_data == None or len(schedule_data) == 0:
tournament_type = "ladder"
else:
tournament_type = schedule_data[0][7]
schedule = models.Schedule()
for match_data in schedule_data:
match = models.Match(local_team=all_teams[match_data[19]],
visitor_team=all_teams[match_data[25]],
local_score=match_data[29],
visitor_score=match_data[30],
status=match_data[10])
if match.status == "scheduled":
if schedule.current_round == 0:
schedule.current_round = match_data[8]
# Recupera si los usuarios de dicord han establecido una hora para jugar
match.programmed_time = self.get_programmed_time(match)
schedule.add_match(match_data[8], match)
tournament.schedule = schedule
league.add_tournament(tournament)
return league
("Peace", "200", "white")]
cursor.executemany('''INSERT INTO teams (team_name, team_id, team_color) VALUES (?,?,?)''', teams_tuple)
except Exception as e:
print("Fill failed", e)
try:
# technically a list of tuples, replace later with an excel or back db?
players_tuple = [(5000, "Bloodbeard", "Captain", 17, "Rage"),
(5001, "Meatwall", "Tank", 18, "Rage"),
(5002, "Love Dragon", "Captain", 20, "Peace"),
(5003, "Flower", "Tank", 14, "Peace")]
cursor.executemany(
'''INSERT INTO players (id, player_name, title, current_tile,team_name) VALUES (?,?,?,?,?)''',
players_tuple)
except Exception as e:
print("Fill failed", e)
db.commit()
db.close()
# TODO connect to mongoDB at startup
# # run functions
# clean_db()
# new_db_empty()
# fill_db()
# p1 = models.Player(5000)
# print(p1.player_name, p1.current_tile)
team1 = models.Team("Peace")
print(team1.player_list, team1.team_color)
team1 = models.Team("Rage")
print(team1.player_list, team1.team_color)
def create_user_team(db: Session, team: schemas.TeamCreate, worker_id: int):
db_team = models.Team(**team.dict(), owner_id=worker_id)
db.add(db_team)
db.commit()
db.refresh(db_team)
return db_team
