def _credits_option(self):
fullname = file_path(
constants.FILES['texts']['menu']['credits']['text'][0],
constants.TEXTS_DIR)
if os.access(fullname, os.F_OK) and os.access(fullname, os.R_OK):
if self.game_opts.verbose:
print('Go to the credits screen.')
c = Credits(self.screen,
self.game_opts,
self.window_frame,
self.menu_settings_bg,
self.select_option_snd,
fullname)
if not c.run():
# quit if the close button is
# pressed (inside the credits)
self._quit_option()
else:
path = os.path.basename(__file__)
print("{0}: couldn't read text file: {1}".format(path, fullname))
raise SystemExit
def view_onboarded_users(user_id, session_token, offset=0, limit=20):
if session_token:
offset = int(offset)
limit = int(limit)
user_id = int(user_id)
if offset < 0 or limit < 0:
raise ValueError
db = database.Database()
db.logger = current_app.logger
session_user_id = db.validate_session(session_token)
if session_user_id == user_id:
displayed_users = db.list_onboarded_users(session_user_id,
offset,
limit)
user_count = len(displayed_users)
augmented_user_data = []
for each_user in displayed_users:
new_obj = dict(each_user)
new_obj["email"] = new_obj["email_address"]
ledger = TransactionLedger(each_user['user_id'], db, current_app.logger)
user_credits = Credits(each_user['user_id'], db, current_app.logger)
new_obj['transactions'] = ledger.get_transaction_count()
new_obj['credits_balance'] = user_credits.get_credit_balance()
new_obj['owned_tokens'] = ledger.get_owned_token_count()
augmented_user_data.append(new_obj)
return render_template("admin/admin_users.jinja2",
session_token=session_token,
users=augmented_user_data,
view_wallet=True,
user_count=user_count,
limit=limit,
offset=offset)
else:
abort(403)
def main(self, screen):
pygame.mixer.init()
clock = pygame.time.Clock()
background = load_image('menu_background.png')
music = load_sound('music_credits.ogg')
menu = kezmenu.KezMenu(
['Engage', lambda: Quantum().mainLoop(40)],
['Enlighten', lambda: Tutorial().mainLoop(40)],
['Archive', lambda: Highscore().mainLoop(40)],
['Collaborating Minds', lambda: Credits().mainLoop(40)],
['Abort', lambda: setattr(self, 'running', False)],
)
menu.x = 10
menu.y = 10
menu.enableEffect('raise-col-padding-on-focus', enlarge_time=0.1)
menu.color = (0, 0, 255)
menu.focus_color = (174, 23, 92)
menu.font = load_font('adelle.ttf', 20)
music.play(-1)
while self.running:
menu.update(pygame.event.get(), clock.tick(30) / 1000.)
screen.blit(background, (0, 0))
menu.draw(screen)
pygame.display.flip()
def create_main_menu():
global main_menu, scores_menu, saves_menu
# Main menu
main_menu = pygame_menu.Menu(300, 300, 'Deadline', theme=fd_theme)
# Table of SCORES
scores_menu = Scores(int(window_width / 1.3), int(window_height / 1.3),
fd_theme)
scores_menu.menu.set_onclose(create_main_menu)
# Table of SAVES
saves_menu = Saves(int(window_width / 1.3), int(window_height / 1.3),
start_game, fd_theme)
main_menu.add_button('Play', start_game)
main_menu.add_button('Scores', scores_menu.menu)
main_menu.add_button('Saves', saves_menu.menu)
credit_list = [
"Deadline - Fire Maze", " ", " Menues", "Timofey Katkov", " ",
"Game play", "Daniil Nesterenko", "Timofey Katkov", " ", "Maze",
"Daniil Nesterenko"
" ", " ", "Music", "Timofey Katkov, EROZZION Music", " ",
"P.S. : inspired by all deadlines and fire dungeons",
"Thanks for playing"
]
c = Credits(credit_list, surface, 'Sigma Five.otf')
main_menu.add_button('About', c.main)
main_menu.add_button('Quit', pygame_menu.events.EXIT)
def initialize(standard_screen):
globals.STDSCR = standard_screen
globals.MAIN = MainMenu()
globals.INTERFACES.append(globals.MAIN)
globals.MAP = GameMap()
globals.INTERFACES.append(globals.MAP)
globals.INVENTORY = Inventory()
globals.INTERFACES.append(globals.INVENTORY)
globals.PAUSE = PauseMenu()
globals.INTERFACES.append(globals.PAUSE)
globals.STORY = StoryScreen()
globals.INTERFACES.append(globals.STORY)
globals.CONTROLS_MAP = Controls(Controls.Type.game_map)
globals.INTERFACES.append(globals.CONTROLS_MAP)
globals.CONTROLS_INVENTORY = Controls(Controls.Type.inventory)
globals.INTERFACES.append(globals.CONTROLS_INVENTORY)
globals.CREDITS = Credits()
globals.INTERFACES.append(globals.CREDITS)
globals.NEW_GAME = NewGameDialog()
globals.INTERFACES.append(globals.NEW_GAME)
globals.QUIT_GAME = EndGameDialog()
globals.INTERFACES.append(globals.QUIT_GAME)
globals.SAVE_GAME = SaveGameDialog()
globals.INTERFACES.append(globals.SAVE_GAME)
globals.MONSTER = MonsterDialog()
globals.INTERFACES.append(globals.MONSTER)
globals.ITEM = ItemDialog()
globals.INTERFACES.append(globals.ITEM)
globals.GAME_OVER = GameOverDialog()
globals.INTERFACES.append(globals.GAME_OVER)
globals.LADDER = LadderDialog()
globals.INTERFACES.append(globals.LADDER)
def postInit(self):
#
# initialize game content
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
def homepage_create_user():
if request.method == "POST":
if EMAIL_REGEX.match(request.form['email_address']) is None:
error = "Invalid e-mail address."
return render_template("create_user.jinja2", error_msg=error)
if len(request.form['passwd']) < 8:
error = "Passwords must consist of at least 8 characters."
return render_template("create_user.jinja2", error_msg=error)
if request.form["passwd"] == request.form["passwd_repeat"]:
ip_addr = request.access_route[-1]
user_passwd = request.form["passwd"]
full_name = request.form["full_name"]
db = Database()
result = db.create_user(full_name,
request.form['email_address'],
user_passwd,
ip_addr)
if result:
if result[0] == -1:
error = "User with this e-mail address already exists."
return render_template("create_user.jinja2", error_msg=error)
session_id = result[1]
# log event
create_user_event = events.Event("Users Create User",
db,
logger=current_app.logger)
metadata = {"ip_addr": ip_addr, "created_by": "self"}
create_user_event.log_event(result[0], json.dumps(metadata))
user_ctx = users.UserContext(result[0], db=db, logger=current_app.logger)
# default permissions
user_ctx.add_permission("onboard-users")
user_ctx.add_permission("launch-ico")
user_ctx.add_permission("ethereum-network")
db.update_user_permissions(result[0], user_ctx.acl())
config_stream = open("config.json", "r")
config_data = json.load(config_stream)
config_stream.close()
if config_data["new_user_tokens"] > 0:
cr = Credits(result[0], db, current_app.logger)
cr.issue_credits(config_data["new_user_tokens"],
{"ip_addr": ip_addr, "reason": "New User Bonus"})
return redirect(url_for("admin.admin_main", session_token=session_id))
else:
error = "Passwords did not match."
return render_template("create_user.jinja2", error_msg=error)
return render_template("create_user.jinja2")
def admin_tokens(session_token):
if session_token:
db = database.Database(logger=current_app.logger)
user_id = db.validate_session(session_token)
ctx = UserContext(user_id, db=db, logger=db.logger)
can_launch_ico = ctx.check_acl("launch-ico")
erc20_mined = Event("ERC20 Token Mined", db, logger=current_app.logger)
mined_count = erc20_mined.get_event_count(user_id)
mined_ids = []
if mined_count:
mined_erc20_events = erc20_mined.get_latest_events(mined_count, user_id)
for each in mined_erc20_events:
json_data = json.loads(each[0])
token_id = json_data["token_id"]
if token_id not in mined_ids:
mined_ids.append(token_id)
if can_launch_ico or len(ctx.acl()["management"]) > 0:
owned_tokens = []
for key in ctx.acl()["management"].keys():
token_id = ctx.acl()["management"][key]["token_id"]
token_info = db.get_smart_contract_info(token_id)
owned_tokens.append(token_info)
owned_tokens.extend(get_owned_tokens(user_id, db, current_app.logger))
if len(owned_tokens) == 0:
owned_tokens = None
email_address = ctx.user_info["email_address"]
last_logged_in = ctx.user_info["last_logged_in"].isoformat()
last_logged_in_ip = ctx.user_info["last_logged_in_ip"]
credit_ctx = Credits(user_id, db, current_app.logger)
credit_balance = credit_ctx.get_credit_balance()
if owned_tokens:
for each in owned_tokens:
if each["token_id"] in mined_ids:
if each["eth_address"] is None:
each["pending"] = True
else:
each["pending"] = False
return render_template("admin/admin_tokens.jinja2",
session_token=session_token,
owned_tokens=owned_tokens,
can_launch_ico=can_launch_ico,
email_address=email_address,
last_logged_in=last_logged_in,
last_logged_in_ip=last_logged_in_ip,
credit_balance=credit_balance)
abort(403)
def admin_main(session_token, transactions=False):
db = database.Database(logger=current_app.logger)
user_id = db.validate_session(session_token)
if user_id:
user_ctx = UserContext(user_id, db, current_app.logger)
launch_ico = user_ctx.check_acl("launch-ico")
onboard_users = user_ctx.check_acl("onboard-users")
reset_passwords = user_ctx.check_acl("reset-passwords")
ethereum_network = user_ctx.check_acl("ethereum-network")
view_event_log = user_ctx.check_acl("view-event-log")
issue_credits = user_ctx.check_acl("issue-credits")
manager = len(user_ctx.acl()["administrator"]) > 0 or len(user_ctx.get_manager_tokens()) > 0
if user_ctx.user_info["email_address"] == "admin":
manager = True
charting = Charting(db, logger=current_app.logger)
eth_nodes = db.list_ethereum_nodes()
epoch = datetime.datetime.now() - datetime.timedelta(hours=24)
node_gas_prices = {}
moving_average_gas_price_data = charting.get_gas_price_moving_average(start=epoch)
for node in eth_nodes:
node_gas_prices[node["node_identifier"]] = charting.get_gas_price_for_node_id(node["id"], start=epoch)
graphing_metrics = {
"moving_average": {"gas_price": json.dumps(moving_average_gas_price_data)},
}
for each in node_gas_prices.keys():
graphing_metrics[each] = json.dumps(node_gas_prices[each])
cr = Credits(user_id, db, current_app.logger)
return render_template("admin/admin_main.jinja2",
full_name=user_ctx.user_info['full_name'],
email_address=user_ctx.user_info['email_address'],
last_logged_in=user_ctx.user_info['last_logged_in'],
credits=cr.get_credit_balance(),
session_token=session_token,
launch_ico=launch_ico,
onboard_users=onboard_users,
reset_passwords=reset_passwords,
ethereum_network=ethereum_network,
view_event_log=view_event_log,
issue_credits=issue_credits,
manager=manager,
metrics=graphing_metrics,
user_id=user_id)
else:
return render_template("admin/admin_login.jinja2", error="Invalid session.")
def __init__(self):
super(FrontScreen, self).__init__(
clutter.BinLayout(clutter.BIN_ALIGNMENT_CENTER,
clutter.BIN_ALIGNMENT_CENTER)
)
layout = self.get_layout_manager()
self.credits = Credits()
layout.add(self.credits,
clutter.BIN_ALIGNMENT_START,
clutter.BIN_ALIGNMENT_END)
self.right_arrow = RightArrow()
layout.add(self.right_arrow,
clutter.BIN_ALIGNMENT_END,
clutter.BIN_ALIGNMENT_CENTER)
self.boxed_contents = clutter.Box(clutter.BoxLayout())
box_layout = self.boxed_contents.get_layout_manager()
box_layout.set_use_animations(True)
box_layout.set_vertical(True)
box_layout.set_spacing(100)
self.header = LogoLarge()
box_layout.pack(self.header, True, False, False,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
self.labels = (
clutter.Text(settings.FRONT_SCREEN_FONT, 'songs'),
clutter.Text(settings.FRONT_SCREEN_FONT, 'artists'),
)
self.selected = self.labels[0]
for label in self.labels:
label.set_color(FONT_COLOR)
label.set_opacity(FONT_OPACITY)
label.set_property('scale-gravity', clutter.GRAVITY_CENTER)
box_layout.pack(label, True, False, False,
clutter.BOX_ALIGNMENT_CENTER,
clutter.BOX_ALIGNMENT_CENTER)
layout.add(self.boxed_contents,
clutter.BIN_ALIGNMENT_CENTER,
clutter.BIN_ALIGNMENT_START)
self.highlight(self.selected)
def erc20_publish():
session_token = request.form["session_token"]
token_id_form_field = request.form["token_id"]
confirmation = request.form["confirmation"]
db = database.Database()
user_id = db.validate_session(session_token)
if user_id:
token_id = int(token_id_form_field)
if token_id < 1:
raise ValueError
sc = SmartContract(smart_token_id=token_id)
if sc.smart_contract_id < 1:
abort(404)
if confirmation == "true":
credits = Credits(user_id, db, current_app.logger)
current_balance = credits.get_credit_balance()
if current_balance < credits.erc20_publish_price:
message = "Your credit balance of <span class=\"credit_balance\">"
message += str(current_balance) + "</span> is less than the <span class=\"credit_price\">"
message += str(credits.erc20_publish_price) + "</span> required to publish an ERC20 token."
message += "<p>[ <a class=\"login_anchor\" href=\"/admin/credits/purchase/"
message += session_token + "\">purchase credits</a> ]</p>"
return render_template("admin/admin_confirmation.jinja2",
title="Unable to publice ERC20 contract",
session_token=session_token,
confirmation_value=token_id,
confirmation_title="Insufficient Credits",
confirmation_type="insufficient_credits",
confirmation_message=message,
default_choice="Cancel")
message = "Are you sure you want to publish <em>" + sc.token_name + "</em> permanently to the Ethereum "
message += "blockchain, costing <span class=\"credit_price\">"
message += str(credits.erc20_publish_price) + "</span> credits?"
return render_template("admin/admin_confirmation.jinja2",
title="Confirm",
session_token=session_token,
confirmation_value=token_id,
confirmation_title="Publish ERC20 contract?",
confirmation_message=message,
confirmation_type="erc20_publish",
choices=["Cancel"],
default_choice="Publish")
def __init__(self, title):
super(Header, self).__init__(
clutter.BinLayout(
clutter.BIN_ALIGNMENT_CENTER,
clutter.BIN_ALIGNMENT_START,
))
layout = self.get_layout_manager()
#layout.set_vertical(False)
# Setup default header elements.
self.logo = LogoSmall()
self.title = clutter.Text(settings.HEADER_TITLE_FONT, title)
self.title.set_color(FONT_COLOR)
self.credits = Credits()
layout.add(self.logo, clutter.BIN_ALIGNMENT_START,
clutter.BIN_ALIGNMENT_START)
layout.add(self.title, clutter.BIN_ALIGNMENT_CENTER,
clutter.BIN_ALIGNMENT_START)
layout.add(self.credits, clutter.BIN_ALIGNMENT_END,
clutter.BIN_ALIGNMENT_START)
def view_users(session_token, offset=0, limit=20):
if session_token:
offset = int(offset)
limit = int(limit)
if offset < 0 or limit < 0:
raise ValueError
db = database.Database()
db.logger = current_app.logger
user_id = db.validate_session(session_token)
if user_id:
user_ctx = UserContext(user_id, db, current_app.logger)
user_data = db.list_users(offset, limit)
user_count = db.get_user_count()
can_reset_password = user_ctx.check_acl("reset-passwords")
can_change_permissions = user_ctx.check_acl("change-permissions")
can_issue_credits = user_ctx.check_acl("issue-credits")
can_view_wallet = user_ctx.check_acl("assign-tokens") or user_ctx.check_acl("remove-tokens")
augmented_user_data = []
for each_user in user_data:
new_obj = dict(each_user)
ledger = TransactionLedger(each_user['user_id'], db, current_app.logger)
user_credits = Credits(each_user['user_id'], db, current_app.logger)
new_obj['transactions'] = ledger.get_transaction_count()
new_obj['credits_balance'] = user_credits.get_credit_balance()
new_obj['owned_tokens'] = ledger.get_owned_token_count()
augmented_user_data.append(new_obj)
return render_template("admin/admin_users.jinja2",
session_token=session_token,
users=augmented_user_data,
reset_password=can_reset_password,
change_permissions=can_change_permissions,
issue_credits=can_issue_credits,
view_wallet=can_view_wallet,
user_count=user_count,
limit=limit,
offset=offset)
def _credits_option(self):
# get the path of the filename
fullname = file_path(
constants.FILES['texts']['menu']['credits']['text'][0],
constants.TEXTS_DIR)
# if credits text file exists and is readable
if os.access(fullname, os.F_OK) and os.access(fullname, os.R_OK):
if self.game_opts.verbose:
print('Go to the credits screen.')
# create the credits screen
c = Credits(self.screen, self.game_opts, self.window_frame,
self.menu_settings_bg, self.select_option_snd,
fullname)
# run the credits screen
if not c.run():
# quit if the close button is
# pressed (inside the credits)
self._quit_option()
else:
print((' '.join(("Couldn't read text file:", fullname))))
def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
base.notify.info("Version {}".format(versionstring))
FSM.__init__(self, "FSM-Game")
#
# BASIC APPLICATION CONFIGURATIONS
#
# disable pandas default camera driver
self.disableMouse()
# set antialias for the complete sceen to automatic
self.render.setAntialias(AntialiasAttrib.MAuto)
# shader generator
render.setShaderAuto()
# Enhance font readability
DGG.getDefaultFont().setPixelsPerUnit(100)
# get the displays width and height for later usage
self.dispWidth = self.pipe.getDisplayWidth()
self.dispHeight = self.pipe.getDisplayHeight()
#
# CONFIGURATION LOADING
#
# load given variables or set defaults
# check if particles should be enabled
# NOTE: If you use the internal physics engine, this always has
# to be enabled!
particles = ConfigVariableBool("particles-enabled", True).getValue()
if particles:
self.enableParticles()
def setFullscreen():
"""Helper function to set the window fullscreen
with width and height set to the screens size"""
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(self.dispWidth, self.dispHeight)
# request the new properties
base.win.requestProperties(props)
# Set the config variables so we correctly store the
# new size and fullscreen setting later
winSize = ConfigVariableString("win-size")
winSize.setValue("{} {}".format(self.dispWidth, self.dispHeight))
fullscreen = ConfigVariableBool("fullscreen")
fullscreen.setValue(True)
# Render a frame to make sure the fullscreen is applied
# before we do anything else
self.taskMgr.step()
# make sure to propagate the new aspect ratio properly so
# the GUI and other things will be scaled appropriately
aspectRatio = self.dispWidth / self.dispHeight
self.adjustWindowAspectRatio(aspectRatio)
# check if the config file hasn't been created
if not os.path.exists(prcFile):
setFullscreen()
# automatically safe configuration at application exit
#base.exitFunc = self.__writeConfig
#
# INITIALIZE GAME CONTENT
#
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
self.menu = Menu()
self.credits = Credits()
self.charSelection = CharacterSelection()
self.levelSelection = LevelSelection()
self.koScreen = KoScreen()
self.hud = Hud()
self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
self.menuMusic.setLoop(True)
self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
self.fightMusic.setLoop(True)
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
#
# EVENT HANDLING
#
# By default we accept the escape key
self.accept("escape", self.__escape)
#
# ENTER GAMES INITIAL FSM STATE
#
self.request("Menu")
def showCredits(self):
credits = Credits(self)
credits.show()
def admin_confirm():
session_token = request.form["session_token"]
confirmation_type = request.form["confirmation_type"]
confirmation_val = request.form["confirmation_value"]
choice = request.form["choice"]
if confirmation_type == "recover_email":
if choice == "Send E-mail":
email_address = request.form['email_address']
mailer = Mailer(email_address, request.access_route[-1], current_app.logger)
mailer.recover_password()
return render_template("admin/admin_login.jinja2", error="""
If the e-mail address is in the database, instructions have been sent on how to recover
your password. Please check your spam/junk mail folder.
""")
return redirect(url_for('homepage'))
elif confirmation_type == "no_erc20_tokens":
return redirect(url_for('admin.admin_tokens', session_token=session_token))
elif confirmation_type == "erc20_publish" and choice == "Cancel":
return redirect(url_for('admin.admin_tokens', session_token=session_token))
elif confirmation_type == "create_erc20_failed" and choice == "OK":
return redirect(url_for('admin.admin_tokens', session_token=session_token))
elif confirmation_type == "onboarded_new_user":
if choice == "Administration":
return redirect(url_for('admin.admin_main', session_token=session_token))
else:
return redirect(url_for('admin.create_user', session_token=session_token))
elif confirmation_type == "reset-password":
if choice == "Cancel":
return redirect(url_for("admin.view_users", session_token=session_token, limit=PAGE_LIMIT, offset=0))
elif confirmation_type == "acl_updated":
if choice == "OK":
return redirect(url_for("admin.view_users", session_token=session_token, limit=PAGE_LIMIT, offset=0))
db = database.Database(logger=current_app.logger)
user_id = db.validate_session(session_token)
if user_id:
user_ctx = UserContext(user_id, db, current_app.logger)
if confirmation_type == "erc20_publish":
token_id = int(confirmation_val)
sc = SmartContract(smart_token_id=token_id)
credits = Credits(user_id, db, logger=current_app.logger)
if sc.smart_contract_id > 0:
event_data = {"token_name": sc.token_name,
"token_symbol": sc.token_symbol,
"token_count": sc.tokens,
"token_id": sc.smart_contract_id,
"ip_address": request.access_route[-1]}
if user_ctx.check_acl("launch-ico"):
credits_balance = credits.get_credit_balance()
if credits_balance >= credits.erc20_publish_price:
new_event = Event("ERC20 Token Mined", db, logger=current_app.logger)
event_id = new_event.log_event(user_id, event_data)
event_data["event_id"] = event_id
credits.debit(credits.erc20_publish_price, event_data)
command_id = db.post_command(json.dumps({"erc20_function":"publish",
"token_name":sc.token_name,
"token_symbol":sc.token_symbol,
"token_count":sc.tokens,
"token_id":sc.smart_contract_id}), 100)
if command_id:
return redirect(url_for("admin.admin_tokens", session_token=session_token))
else:
abort(500)
else:
credits.logger.error("Insufficient credits for ERC20 Publish: "
+ user_ctx.user_info["email_address"])
abort(403)
elif confirmation_type == "reset-password":
user_id = int(confirmation_val)
if request.form["password"] != request.form["repeat_password"]:
return render_template("admin/admin_confirmation.jinja2",
confirmation_type="reset-password",
confirmation_value=user_id,
title="Reset Password",
confirmation_title="Reset Password",
confirmation_message="Passwords must match both times.",
new_password=True,
choices=["Cancel"],
default_choice="Reset Password",
session_token=session_token)
if db.reset_password(int(confirmation_val), request.form["password"]):
return redirect(url_for("admin.view_users", session_token=session_token, limit=PAGE_LIMIT, offset=0))
elif confirmation_type == "issue-credits":
if choice == "Issue Credits" and user_ctx.check_acl("issue-credits"):
user_credits = Credits(confirmation_val, db, current_app.logger)
amount = int(request.form["credits"])
# max issued credits 10,000
if 0 < amount < 100000:
user_credits.issue_credits(amount, {"ip_addr": request.access_route[-1], "admin": user_id})
return redirect(
url_for("admin.view_users", session_token=session_token, limit=PAGE_LIMIT, offset=0))
else:
raise ValueError
abort(403)
def __init__(self):
# variables -----------------------------------------------
# load background
self.backg = Background(BKG_FOLDER + "stars.png")
# set initial score
self.score = 0
# load sound and music volume from file
# if there's a problem with the file, simply create a new one with default values
try:
volume = pickle.load(open("volume.p", "rb"))
except:
volume = {"sound": 100, "music": 30}
pickle.dump(volume, open("volume.p", "wb"))
# sounds
self.laserSnd = pygame.mixer.Sound(SND_FOLDER + "laser.wav")
self.explodeSnd = pygame.mixer.Sound(SND_FOLDER + "explosion.wav")
self.powerUpSnd = pygame.mixer.Sound(SND_FOLDER + "powerUp.wav")
# put everything into a list so it's easier to change the volume
# the list elements are the same objects as the initial ones
# as python copies by reference and not by value (I would have
# preferred to use pointers, to avoid ambiguity, but oh well...)
self.sounds = [self.laserSnd, self.explodeSnd, self.powerUpSnd]
# set volume for all sound objects
for snd in self.sounds:
snd.set_volume(volume["sound"] / 100.) # set new volume
# music
self.music = pygame.mixer.music.load(MUS_FOLDER +
"reachingForTheSun.mp3")
pygame.mixer.music.play(-1) # loop
pygame.mixer.music.set_volume(volume["music"] / 100.)
# creating user ship
self.userShip1 = ShipY001()
self.userShip2 = ShipY002()
self.userShip3 = ShipY003()
self.userShip1.speed = 10
self.userShip2.speed = 10
self.userShip3.speed = 10
# group of all sprites
self.userSprites1 = pygame.sprite.Group()
self.userSprites2 = pygame.sprite.Group()
self.userSprites3 = pygame.sprite.Group()
self.laserSprites = pygame.sprite.Group()
self.aiSprites = pygame.sprite.Group()
self.powerUpSprites = pygame.sprite.Group()
# add to groups
self.userSprites1.add(self.userShip1)
self.userSprites2.add(self.userShip2)
self.userSprites3.add(self.userShip3)
# Creating main menu
self.menu = Menu(["Quit", "Credits", "Volume", "Play"], self.backg)
# Creating game_mode
self.mode = Menu(["HELL", "HARD", "NORMAL"], self.backg)
self.modeBack = 0
# Creating pause menu (could be generated later, but shouldn't impact performance)
self.pause = Menu(["Quit", "Volume", "Restart", "Continue"],
self.backg)
# Creating volume menu (could be generated later, but shouldn't impact performance)
self.volume = Volume(self.backg, volume)
self.volumeBack = 0 # some stupid flag to tell us whether we came from the main menu
# of from the pause menu
# Creating credits
self.credits = Credits([
"Sound: Obtained from Freesound",
"Music: 'Reaching for the Sun' by Deshiel and Bacon92",
"Graphics: Filipa Silva", "Code: Alexandre Lopes"
], self.backg)
# gameState
# Available states: menu, credits ,game, gameOver
self.gameState = "menu"
def menu(self, screen):
pygame.mixer.music.play()
Beaten.level1 = False
Beaten.level2 = False
Beaten.level3 = False
Beaten.level4 = False
Options.boyleft = True
Options.boyright = False
Options.girlleft = False
Options.girlright = True
Options.soundon = True
Options.name1 = ""
Options.name1true = False
Options.name2 = ""
Options.name2true = False
state = 0
fonts = pygame.font.get_fonts()
firstfont = pygame.font.SysFont("Default",65)
secondfont = pygame.font.SysFont("Default",65)
thirdfont = pygame.font.SysFont("Default",45)
fourthfont = pygame.font.SysFont("Default",45)
fifthfont = pygame.font.SysFont("Default",48)
setting_font = "OPTIONS"
how_font = "HOW TO"
play_font = "PLAY"
quit_font = "QUIT"
credit_font = "CREDITS"
quit_write = firstfont.render(quit_font, 1, [255,255,255])
play_write = secondfont.render(play_font,1,[255,255,255])
how_write1 = thirdfont.render(how_font,1,[255,255,255])
how_write2 = thirdfont.render(play_font,1,[255,255,255])
setting_write = fourthfont.render(setting_font,1,[255,255,255])
credit_write = fifthfont.render(credit_font,1,[255,255,255])
while state == 0:
if Options.soundon == False:
pygame.mixer.music.stop()
mpos = pygame.mouse.get_pos()
screen.blit(hi, (0,0))
screen.blit(instruct,(185,5))
screen.blit(box,(100,200))
screen.blit(box1,(450,200))
screen.blit(box2,(800,200))
screen.blit(box3,(280,420))
screen.blit(box4,(630,420))
screen.blit(quit_write,(675,468))
screen.blit(play_write,(145,248))
screen.blit(how_write1,(490,235))
screen.blit(how_write2,(515,275))
screen.blit(setting_write,(832,253))
screen.blit(credit_write,(307,472))
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
keys = pygame.key.get_pressed()
if keys[pygame.K_b]:
Beaten.level1 = True
Beaten.level2 = True
Beaten.level3 = True
Beaten.level4 = True
if((mpos[0]<452 and mpos[0]>295) and (mpos[1]<532 and mpos[1]>439)):
fifthfont.set_italic(True)
credit_write = fifthfont.render(credit_font,1,[255,0,0])
if event.type == MOUSEBUTTONDOWN:
Credits().run(screen)
else:
fifthfont.set_italic(False)
credit_write = fifthfont.render(credit_font,1,[255,255,255])
if (mpos[0]<837 and mpos[0]>630) and (mpos[1]<567 and mpos[1]>420):
firstfont.set_italic(True)
quit_write = firstfont.render(quit_font,1,[255,0,0])
if event.type == MOUSEBUTTONDOWN:
pygame.quit()
else:
firstfont.set_italic(False)
quit_write = firstfont.render(quit_font,1,[255,255,255])
if(mpos[0]<307 and mpos[0]>100) and (mpos[1]<347 and mpos[1]>200):
secondfont.set_italic(True)
play_write = secondfont.render(play_font,1,[255,0,0])
if event.type == MOUSEBUTTONDOWN:
#pygame.mixer.music.load("click_one.ogg")
#pygame.mixer.music.play()
LevelSelection().run(screen)
else:
secondfont.set_italic(False)
play_write = secondfont.render(play_font,1,[255,255,255])
if(mpos[0]<657 and mpos[0]>450) and (mpos[1]<347 and mpos[1]>200):
thirdfont.set_italic(True)
how_write1 = thirdfont.render(how_font,1,[255,0,0])
how_write2 = thirdfont.render(play_font,1,[255,0,0])
if event.type == MOUSEBUTTONDOWN:
#pygame.mixer.music.load("click_one.ogg")
#pygame.mixer.music.play()
HowtoPlay().run(screen)
else:
thirdfont.set_italic(False)
how_write1 = thirdfont.render(how_font,1,[255,255,255])
how_write2 = thirdfont.render(play_font,1,[255,255,255])
if(mpos[0]<1007 and mpos[0]>800) and (mpos[1]<347 and mpos[1]>200):
fourthfont.set_italic(True)
setting_write = fourthfont.render(setting_font,1,[255,0,0])
if event.type == MOUSEBUTTONDOWN:
#pygame.mixer.music.load("click_one.ogg")
#pygame.mixer.music.play()
Settings().run(screen)
else:
fourthfont.set_italic(False)
setting_write = fourthfont.render(setting_font,1,[255,255,255])
pygame.display.flip()
def handle_events(self):
keep_going = True
for event in pygame.event.get():
if event.type == pygame.QUIT:
keep_going = False
elif self.in_prompt:
if event.type == pygame.MOUSEBUTTONDOWN:
button_pressed = event.dict['button']
mouse_pos = event.dict['pos']
clicked_obj = self.prompt.check_collisions(mouse_pos)
if button_pressed == 1:
if isinstance(clicked_obj, Button):
if clicked_obj.action is "okay":
self.in_prompt = False
elif clicked_obj.action is "exit":
keep_going = False
elif clicked_obj.action is "restart":
keep_going = False
__main__.main()
elif clicked_obj.action is "artifact":
self.in_prompt = False
self.user.members[0].abilities += [LastHope()]
elif clicked_obj.action is "credits":
keep_going = False
credits = Credits()
credits.run()
elif event.type == pygame.KEYDOWN:
key_pressed = event.dict['key'] % 256
self.prompt.handle_keydown(key_pressed)
elif event.type == pygame.KEYDOWN:
key_pressed = event.dict['key'] % 256
if key_pressed == pygame.K_a:
self.dx += -Campaign.USER_SPEED
elif key_pressed == pygame.K_d:
self.dx += Campaign.USER_SPEED
elif key_pressed == pygame.K_w:
self.dy += -Campaign.USER_SPEED
elif key_pressed == pygame.K_s:
self.dy += Campaign.USER_SPEED
elif key_pressed == pygame.K_ESCAPE:
if self.fullscreen:
self.fullscreen = False
self.init_screen()
self.init_camera()
else:
self.fullscreen = True
self.init_screen()
self.init_camera()
elif event.type == pygame.KEYUP:
key_released = event.dict['key'] % 256
if key_released == pygame.K_a:
self.dx -= -Campaign.USER_SPEED
elif key_released == pygame.K_d:
self.dx -= Campaign.USER_SPEED
elif key_released == pygame.K_w:
self.dy -= -Campaign.USER_SPEED
elif key_released == pygame.K_s:
self.dy -= Campaign.USER_SPEED
elif event.type == pygame.MOUSEBUTTONDOWN:
button_pressed = event.dict['button']
if button_pressed == 5:
self.camera.zoom_out()
elif button_pressed == 4:
self.camera.zoom_in()
return keep_going
def credits(screen):
return Credits(screen,menu)
def __init__(self, app, files=[]):
Gtk.Window.__init__(self, title="Saludame", application=app)
self.__new_game = ''
self.__data = {}
self.set_icon_from_file(os.path.join(BASEPATH, "assets/saludame.svg"))
self.set_resizable(False)
self.set_position(Gtk.WindowPosition.CENTER)
self.maximize()
self.size = (800, 600)
self.headerBar = Gtk.HeaderBar()
self.headerBar.get_style_context().add_class("header")
self.headerBar.set_show_close_button(True)
self.headerBar.set_title(_("Saludame"))
self.set_titlebar(self.headerBar)
self.startup_window = StartupWindow(self._start_cb, self._load_last_cb)
self.pygame_canvas = PygameCanvas()
self.health_library = ContentWindow()
self.guides = GuidesWindow()
self.credits = Credits()
self.notebook = Gtk.Notebook()
self.notebook.get_style_context().add_class("mynotebook")
self.notebook.append_page(self.startup_window,
Gtk.Label(_("Activity")))
self.notebook.append_page(self.pygame_canvas, Gtk.Label(_("Game")))
self.notebook.append_page(self.health_library,
Gtk.Label(_("Health Library")))
self.notebook.append_page(self.guides, Gtk.Label(_("Guides")))
self.notebook.append_page(self.credits, Gtk.Label(_("Credits")))
self.add(self.notebook)
logging.debug("Create main")
self.game = Main()
self.game.set_game_over_callback(self.game_over_callback)
game.set_library_function = self.set_library
self.healt_toolbar = self.health_library.get_toolbar()
self.game_toolbar = self.get_game_toolbar()
self.headerBar.pack_start(self.healt_toolbar)
self.headerBar.pack_start(self.game_toolbar)
self.notebook.connect('switch_page', self.__switch_page)
self.connect("delete-event", self.__salir)
self.connect("realize", self.__realize)
self.show_all()
self.notebook.get_children()[1].hide()
self.healt_toolbar.hide()
self.game_toolbar.hide()
self.notebook.set_current_page(0)
