async def get_quest_settings(p):
query = Quest.load(items=QuestAwardItem,
furniture=QuestAwardFurniture,
pet=QuestAwardPuffleItem,
tasks=QuestTask).gino
def encode_award(award):
award_id, award_type = AwardTypes[type(award)]
return {
'id': getattr(award, award_id),
'type': award_type,
'n': award.quantity if hasattr(award, 'quantity') else 1
}
def encode_task(task):
return {
'type': 'room' if task.room_id is not None else '',
'description': task.description,
'data': task.room_id if task.room_id is not None else task.data
}
async with db.transaction():
quest_settings = {
'ver': 1, 'spawnRoomId': p.room.id,
'quests': [
{
'id': quest.id,
'name': quest.name,
'awards': [encode_award(award) for award in quest.awards],
'tasks': [encode_task(task) for task in quest.tasks]
} async for quest in query.iterate()
]}
return ujson.dumps(quest_settings)
async def setup_waddles(room_collection):
async with db.transaction():
async for waddle in RoomWaddle.query.gino.iterate():
room_collection[waddle.room_id].waddles[waddle.id] = waddle
waddle.room = room_collection[waddle.room_id]
waddle.logic = WaddleLogicMapping[waddle.game]
waddle.penguins = [None] * waddle.seats
async def setup_membership(p):
if not p.server.config.expire_membership or p.moderator or p.character:
p.is_member = True
p.membership_days_total = FullBadgeAge if p.moderator or p.character else p.age
return
membership_history = PenguinMembership.query.where(PenguinMembership.penguin_id == p.id)
current_timestamp = datetime.now()
postcards = []
warning_postcards = MemberWarningPostcardsVanilla if p.is_vanilla_client else MemberWarningPostcardsLegacy
start_postcard = MemberStartPostcardVanilla if p.is_vanilla_client else MemberStartPostcardLegacy
async with db.transaction():
async for membership_record in membership_history.gino.iterate():
membership_recurring = membership_record.expires is None
membership_active = membership_recurring or membership_record.expires >= current_timestamp
if membership_record.start < current_timestamp:
if membership_active:
p.is_member = True
if not membership_recurring:
days_to_expiry = (membership_record.expires.date() - datetime.now().date()).days
p.membership_days_remain = days_to_expiry
if days_to_expiry <= MemberWarningDaysToExpiry and not membership_record.expires_aware:
postcards.append(dict(
penguin_id=p.id,
postcard_id=random.choice(warning_postcards),
send_date=membership_record.expires - timedelta(days=MemberWarningDaysToExpiry)
))
await membership_record.update(expires_aware=True).apply()
else:
if p.membership_days_remain < 0:
days_since_expiry = (membership_record.expires.date() - datetime.now().date()).days
p.membership_days_remain = min(p.membership_days_remain, days_since_expiry)
if not membership_record.expired_aware:
if p.is_vanilla_client:
postcards.append(dict(
penguin_id=p.id,
postcard_id=MemberExpiredPostcard,
send_date=membership_record.expires
))
await membership_record.update(expired_aware=True).apply()
if not membership_record.start_aware:
postcards.append(dict(
penguin_id=p.id,
postcard_id=start_postcard,
send_date=membership_record.start
))
await membership_record.update(start_aware=True).apply()
membership_end_date = current_timestamp if membership_active else membership_record.expires
p.membership_days_total += (membership_end_date - membership_record.start).days
if postcards:
await PenguinPostcard.insert().values(postcards).gino.status()
async def handle_refresh_my_track_likes(p):
likes = db.func.count(TrackLike.track_id)
track_likes_query = db.select([PenguinTrack.id, likes])\
.select_from(PenguinTrack.outerjoin(TrackLike))\
.where(PenguinTrack.owner_id == p.data.id)\
.group_by(PenguinTrack.id).gino.load(PenguinTrack.load(likes=ColumnLoader(likes)))
async with db.transaction():
async for track in track_likes_query.iterate():
await p.send_xt('getlikecountfortrack', p.data.id, track.id, track.likes)
async def get_tracks(self):
self.playlist = []
likes = db.func.count(TrackLike.track_id)
tracks_query = db.select([PenguinTrack, likes]) \
.select_from(PenguinTrack.outerjoin(TrackLike)) \
.where((PenguinTrack.owner_id.in_(tuple(self.room.penguins_by_id.keys())))
& (PenguinTrack.sharing == True)) \
.group_by(PenguinTrack.id).gino.load(PenguinTrack.load(likes=ColumnLoader(likes)))
async with db.transaction():
async for track in tracks_query.iterate():
self.playlist.append(track)
async def get_player_tracks(p):
player_tracks = []
likes = db.func.count(TrackLike.track_id)
tracks_query = db.select([PenguinTrack, likes])\
.select_from(PenguinTrack.outerjoin(TrackLike))\
.where(PenguinTrack.owner_id == p.data.id)\
.group_by(PenguinTrack.id).gino.load(PenguinTrack.load(likes=ColumnLoader(likes)))
async with db.transaction():
async for track in tracks_query.iterate():
player_tracks.append(f'{track.id}|{track.name}|{int(track.sharing)}|{track.likes}')
return player_tracks
async def init_all_quests(p):
query = Quest.load(tasks=QuestTask,
complete=PenguinQuestTask.on((PenguinQuestTask.penguin_id == p.data.id) &
(QuestTask.id == PenguinQuestTask.task_id))).gino
async with db.transaction():
async for quest in query.iterate():
for task in quest.tasks:
if task.id not in quest.in_progress.union(quest.complete):
await PenguinQuestTask.create(task_id=task.id, penguin_id=p.data.id)
await load_active_quests(p)
async def get_shared_tracks(p):
shared_tracks = []
likes = db.func.count(TrackLike.track_id)
tracks_query = db.select([PenguinTrack, likes])\
.select_from(PenguinTrack.outerjoin(TrackLike))\
.where((PenguinTrack.owner_id.in_(tuple(p.server.penguins_by_id.keys())) & (PenguinTrack.sharing == True)))\
.group_by(PenguinTrack.id).gino.load(PenguinTrack.load(likes=ColumnLoader(likes)))
async with db.transaction():
async for track in tracks_query.iterate():
penguin = p.server.penguins_by_id[track.owner_id]
shared_tracks.append(f'{penguin.data.id}|{penguin.data.nickname}|{track.id}|{track.likes}')
return shared_tracks
async def get_tracks(self):
self.playlist = []
self.penguins_by_track_id = {}
room = self.server.rooms[SoundStudio.StudioRoomId]
room_penguins = room.penguins_by_id.copy()
likes = db.func.count(TrackLike.track_id)
tracks_query = db.select([PenguinTrack, likes]) \
.select_from(PenguinTrack.outerjoin(TrackLike)) \
.where((PenguinTrack.owner_id.in_(tuple(room_penguins.keys())))
& (PenguinTrack.sharing == True)) \
.group_by(PenguinTrack.id).gino.load(PenguinTrack.load(likes=ColumnLoader(likes)))
async with db.transaction():
async for track in tracks_query.iterate():
self.playlist.append(track)
self.penguins_by_track_id[track.id] = room_penguins[
track.owner_id]
async def get_player_quest_status(p):
query = Quest.load(tasks=QuestTask,
items=QuestAwardItem,
furniture=QuestAwardFurniture,
pet=QuestAwardPuffleItem,
complete=PenguinQuestTask.on(
(PenguinQuestTask.penguin_id == p.id)
& (QuestTask.id == PenguinQuestTask.task_id))).gino
def has_award(quest):
for award in quest.items:
if award.item_id not in p.inventory:
return False
for award in quest.furniture:
if award.furniture_id not in p.furniture:
return False
for award in quest.pet:
if award.puffle_item_id not in p.puffle_items:
return False
return True
def encode_quest(quest):
tasks_complete = [task.id in quest.complete for task in quest.tasks]
quest_status = 'prize claimed' if has_award(quest) else 'complete' if all(tasks_complete) else 'available' \
if quest.in_progress else 'not available'
return {
'id': quest.id,
'status': quest_status,
'tasks': tasks_complete
}
async with db.transaction():
player_quest_status = {
'quests': [encode_quest(quest) async for quest in query.iterate()]
}
return ujson.dumps(player_quest_status)
async def setup_tables(room_collection):
async with db.transaction():
async for table in RoomTable.query.gino.iterate():
room_collection[table.room_id].tables[table.id] = table
table.room = room_collection[table.room_id]
table.logic = TableLogicMapping[table.game]()
async def setup_waddles(self):
async with db.transaction():
async for waddle in RoomWaddle.query.gino.iterate():
self[waddle.room_id].waddles[waddle.id] = waddle
async def setup_tables(self):
async with db.transaction():
async for table in RoomTable.query.gino.iterate():
self[table.room_id].tables[table.id] = table
