def paused(state, screen):
screen_w, screen_h = screen.get_size()
#Fadey screen
s = pygame.Surface((screen_w, screen_h))
s.set_alpha(5)
s.fill((254, 254, 254))
#Get sprites
unpause_butt, unpause_rect = get_image(main + '\\sprites\\unpause.png')
unpause_butt.convert()
unpause_butt.set_colorkey((255, 255, 255))
unpause_rect.centerx = int(screen_w / 2)
unpause_rect.centery = int(screen_h / 2 - (screen_h / 5))
return_title_butt, return_title_rect = get_image(
main + '\\sprites\\return_to_title.png')
return_title_butt.convert()
return_title_butt.set_colorkey((255, 255, 255))
return_title_rect.centerx = int(screen_w / 2)
return_title_rect.centery = int(screen_h / 2 + (screen_h / 5))
#Events
paused = True
while paused:
##Blits
screen.blit(unpause_butt, unpause_rect)
screen.blit(return_title_butt, return_title_rect)
screen.blit(s, (0, 0))
pygame.display.flip()
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
if unpause_rect.collidepoint(pos):
paused = False
state['title_screen'] = 0
state['game1'] = 1
return state
elif return_title_rect.collidepoint(pos):
paused = False
state['game1'] = 0
state['title'] = 1
return state
if event.type == pygame.QUIT:
state['running'] = 0
state['game1'] = 0
state['title'] = 0
pygame.quit()
return state
return state
def main():
args = parse_args()
img = get_image(args.image)
check_image_format(img)
check_image_mode(img)
message = discover(img, args.key)
print("Message:", message)
def renderPost(id):
post = post_dao.getPostById(id)
image_name = get_image(id)
return render_template('single.html',
title="Single",
post=post,
image=image_name or 'imagem_padrao.jpg')
def __init__(self, group, path, xsize, ysize, xpos, ypos):
self.group = group
if self.group == 'main_options':
pygame.sprite.Sprite.__init__(self, option_arrows)
elif self.group == 'difficulty_options':
pygame.sprite.Sprite.__init__(self, option_difficult_arrows)
elif self.group == 'words':
pygame.sprite.Sprite.__init__(self, option_word_arrows)
elif self.group == 'border':
pygame.sprite.Sprite.__init__(self, border_arrow)
elif self.group == 'player_arrow':
pygame.sprite.Sprite.__init__(self, player_arrow)
elif self.group == 'player_border_arrow':
pygame.sprite.Sprite.__init__(self, player_border_arrow)
self.path = path
self.xsize = xsize
self.ysize = ysize
self.xpos = xpos
self.ypos = ypos
self.path = main + self.path
self.image, self.rect = get_image(self.path, self.xsize, self.ysize)
self.image = self.image.convert()
self.image.set_colorkey((255, 255, 255))
self.rect.centerx = self.xpos
self.rect.centery = self.ypos
def blur_slider_callback(attr, _, new_kernel):
''' Adjust the Gaussian Blur kernel size '''
image = get_image(raw_image_obj)
image_blur = apply_gaussian_blur(image, new_kernel)
doc.add_next_tick_callback(partial(update_bokeh_dict,
processed_image_obj.data_source.data, image=[image_blur]))
def __init__(self, dict_entry):
pygame.sprite.Sprite.__init__(self, word_balloons)
self.dict_entry = dict_entry
self.type = dict_entry['Type'][0]
self.difficulty = dict_entry['Difficulty'][0]
self.english_str = dict_entry['English']
self.german_str = dict_entry['German'][0]
self.width = len(self.german_str)
self.height = random.randint(50, 100)
self.jrand = random.randint(0, 2)
if self.jrand == 0:
self.word_display, self.word_display_rect = get_image(
main + '\\sprites\\pixel_balloon1.png',
int(self.width * 24),
120,
reload=True)
elif self.jrand == 1:
self.word_display, self.word_display_rect = get_image(
main + '\\sprites\\pixel_balloon2.png',
int(self.width * 24),
120,
reload=True)
elif self.jrand == 2:
self.word_display, self.word_display_rect = get_image(
main + '\\sprites\\pixel_balloon3.png',
int(self.width * 24),
120,
reload=True)
self.word_display = self.word_display.convert()
self.word_display.set_colorkey((255, 255, 255))
self.word_display_rect.centery = int(
6 * screen_h / 10) + self.word_display_rect.height
self.word_display_rect.centerx = random.randint(
0 + self.width * 20, screen_w - self.width * 20)
self.word_block = Words.font.render(self.german_str, True, (1, 1, 1))
self.word_rect = self.word_block.get_rect()
self.word_rect.centery = self.word_display_rect.centery - 18
self.word_rect.centerx = self.word_display_rect.centerx
self.answer_block = Words.font.render(self.english_str[0], True,
(1, 1, 1))
self.answer_rect = self.answer_block.get_rect()
self.i = 0
def main():
args = parse_args()
img = get_image(args.image)
check_image_format(img)
check_image_mode(img)
_, height = img.size
for row in range(height):
discover(img, row)
def main():
args = parse_args()
img = get_image(args.image)
check_image_format(img)
check_image_mode(img)
message = discover(img)
print(message)
sys.exit(0)
def renderUpdate(id):
if 'logged_user' not in session or session['logged_user'] == None:
return redirect(url_for('renderLogin', next=url_for('renderAdmin')))
post = post_dao.getPostById(id)
image_name = get_image(id)
return render_template('update.html',
title="Edit",
post=post,
image=image_name or 'imagem_padrao.jpg')
def main():
args = parse_args()
img = get_image(args.image)
message = binary(args.message)
check_image_format(img)
check_image_mode(img)
copy_img = copy_image(img)
covered_img = cover(copy_img, message)
if args.output:
covered_img.save(args.output)
else:
covered_img.save(f"hidden.{img.format.lower()}")
def gameover(state, screen, victory=False):
if not victory:
gameover_img, gameover_rect = get_image(
main + '\\sprites\\gameover.png', screen_w, screen_h)
screen.blit(gameover_img, gameover_rect)
pygame.display.flip()
pygame.time.wait(3000)
if victory:
gamewon_img, gamewon_rect = get_image(
main + '\\sprites\\youwin.png', screen_w, screen_h)
screen.blit(gamewon_img, gamewon_rect)
pygame.display.flip()
pygame.time.wait(3000)
#Read in options
with open(main + '\\states\\user.txt', 'r') as f:
user = f.readlines()[0]
with open(main + '\\states\\difficulty.txt', 'r') as f:
difficulty = f.readlines()[0]
with open(main + '\\states\word_choice.txt', 'r') as f:
word_choice = f.readlines()[0]
#Save scores and potentially missed words
with open(
main + '\\' + user + '_scores\\' + difficulty + '_' +
word_choice + '.csv', 'a') as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow([datetime.date(datetime.now()), score])
with open(main + '\\' + user + '_scores\\missed_words.csv', 'a') as f:
writer = csv.writer(f, lineterminator='\n')
for i in missed_words:
for k, v in i.items():
writer.writerow([datetime.date(datetime.now()), (k, v)])
state['game1'] = 0
state['title'] = 1
return state
def __init__(self, path, xsize, ysize, xpos, ypos):
pygame.sprite.Sprite.__init__(self, arrows)
self.path = path
self.xsize = xsize
self.ysize = ysize
self.xpos = xpos
self.ypos = ypos
self.path = main + self.path
self.image, self.rect = get_image(self.path, self.xsize, self.ysize)
self.image = self.image.convert()
self.image.set_colorkey((255, 255, 255))
self.rect.centerx = self.xpos
self.rect.centery = self.ypos
def _get_os_distro(self, entry):
os_distro = 'unknown'
if 'image.id' in entry['resource_metadata']:
# Boot from image
image_id = entry['resource_metadata']['image.id']
os_distro = getattr(helpers.get_image(image_id), 'os_distro', 'unknown')
if entry['resource_metadata']['image_ref'] == 'None':
# Boot from volume
image_meta = getattr(helpers.get_volume(entry['resource_id']), 'volume_image_metadata', {})
os_distro = image_meta.get('os_distro', 'unknown')
return os_distro
def __init__(self, dict_entry):
pygame.sprite.Sprite.__init__(self, gender_balloons)
self.dict_entry = dict_entry
self.german_str = dict_entry['GermanNoun'][0]
self.gender_str = dict_entry['Gender'][0]
self.width = len(self.german_str)
self.height = random.randint(50, 100)
self.balloon_image, self.balloon_rect = get_image(
main + '\\sprites\\airballoon1.png',
self.width * 30,
self.height,
reload=True)
self.balloon_image = self.balloon_image.convert()
self.balloon_image.set_colorkey((255, 255, 255))
self.balloon_rect.centery = int(7 * screen_h / 10)
self.balloon_rect.centerx = random.randint(0 + self.width * 20,
screen_w - self.width * 20)
self.word_display, self.word_display_rect = get_image(
main + '\\sprites\\airballoon2.png',
int(self.width * 30),
40,
reload=True)
self.word_display = self.word_display.convert()
self.word_display.set_colorkey((255, 255, 255))
self.word_display_rect.centery = self.balloon_rect.centery + self.balloon_rect.height
self.word_display_rect.centerx = self.balloon_rect.centerx
self.word_block = Words.font.render(self.german_str, True, (1, 1, 1))
self.word_rect = self.word_block.get_rect()
self.word_rect.centery = self.word_display_rect.centery - 5
self.word_rect.centerx = self.balloon_rect.centerx - 10
self.answer_block = Words.font.render(self.gender_str, True, (1, 1, 1))
self.answer_rect = self.answer_block.get_rect()
self.i = 0
def __init__(self, path, xsize, ysize, xpos, ypos):
pygame.sprite.Sprite.__init__(self, letters)
self.i = int(random.randint(0, len(Letters.time)))
self.path = path
self.xsize = xsize
self.ysize = ysize
self.xpos = xpos
self.ypos = ypos
self.path = main + self.path
self.image, self.rect = get_image(self.path, self.xsize, self.ysize)
self.image = self.image.convert()
self.image.set_colorkey((255, 255, 255))
self.rect.centerx = self.xpos
self.rect.centery = self.ypos
def history():
""" Show a table of user's memes """
rows = db.execute("SELECT * FROM memes WHERE userID=:id",
id=session["user_id"])
memes = []
for row in rows:
row_dict = {}
row_dict["description"] = f"{row['text0']} | {row['text1']}"
row_dict["timestamp"] = row["timestamp"]
row_dict["link"] = get_image(row["memeID"], row["text0"], row["text1"])
memes.append(row_dict)
return render_template("history.html", memes=memes)
def build_app():
"""Test and build graph"""
init_postprocessing()
create_model()
set_threshold(0.5)
for path in ["images/laptop.jpeg", "images/winter.jpeg"]:
image, path = get_image(path)
LOGGER.info("Testing with image: %s", path)
detection = classify(image)
print("Test classification result: {}".format(detection))
CLOUD.configure_service("resnet", environment={"MAX_GRPC_WORKERS": 1})
CLOUD.expose_service("api")
CLOUD.set_basic_auth_credentials("pycloud", "demo")
def index():
"""Generate meme"""
if request.method == "POST":
meme_id, text0, text1 = request.form.get("format"), request.form.get(
"text0"), request.form.get("text1")
if not meme_id:
return apology("incomplete form", 403)
url = get_image(meme_id.split(',')[0], text0, text1)
db.execute(
"INSERT INTO memes ('memeID', 'text0', 'text1', 'userID', 'timestamp') VALUES (:memeID, :text0, :text1, :userID, datetime('now', 'localtime'))",
memeID=meme_id.split(',')[0],
text0=text0,
text1=text1,
userID=session["user_id"])
return render_template("meme.html", url=url)
else:
return render_template("index.html", memes=memes)
def test_patches():
img = helpers.get_image(1)
patch_size = 8
patch_maker = preprocess.Patches(img, patch_size)
patches = patch_maker.patches
reconstructed = patch_maker.reconstruct(patches)
assert patches.shape[0] == patch_size**2
assert np.allclose(img, reconstructed)
patch_size = 16
patch_maker = preprocess.Patches(img, patch_size)
assert patch_maker.size == patch_size
patches = patch_maker.patches
reconstructed = patch_maker.reconstruct(patches)
assert patches.shape[0] == patch_size**2
assert np.allclose(img, reconstructed)
img = np.random.rand(256, 256, 256)
patch_size = 16
with pytest.raises(MemoryError):
preprocess.Patches(img, patch_size).patches
def show_answer(screen, word_obj):
#Fadey screen
s = pygame.Surface((screen_w, screen_h))
s.set_alpha(5)
s.fill((254, 254, 254))
#Get sprites
answer_btn, answer_rect = get_image(
main + '\\sprites\\show_answer.png', int(screen_w / 1.4),
int(screen_h / 2))
answer_btn.convert()
answer_btn.set_colorkey((255, 255, 255))
answer_rect.centerx = int(screen_w / 2)
answer_rect.centery = int(screen_h / 2)
word_obj.answer_rect.centerx = answer_rect.centerx
word_obj.answer_rect.centery = answer_rect.centery
##Blits
screen.blit(s, (0, 0))
screen.blit(answer_btn, answer_rect)
screen.blit(word_obj.answer_block, word_obj.answer_rect)
pygame.display.flip()
pygame.time.wait(2000)
# Configure CS50 Library to use SQLite database
db = SQL("sqlite:///memegen.db")
# Make sure API key is set
if not os.environ.get("API_KEY"):
raise RuntimeError("API_KEY not set")
memes = [
meme for meme in requests.get("https://api.imgflip.com/get_memes").json()
["data"]["memes"] if meme["box_count"] == 2
]
# Load list of meme formats once
for meme in memes:
meme["url"] = get_image(meme["id"], "Text 1", "Text 2")
@app.route("/", methods=["GET", "POST"])
@login_required
def index():
"""Generate meme"""
if request.method == "POST":
meme_id, text0, text1 = request.form.get("format"), request.form.get(
"text0"), request.form.get("text1")
if not meme_id:
return apology("incomplete form", 403)
url = get_image(meme_id.split(',')[0], text0, text1)
def main():
args = parse_args()
img = get_image(args.image)
check_image_format(img)
check_image_mode(img)
discover(img, args.row)
def game1(state, screen):
screen_w, screen_h = screen.get_size()
##Get correct game states:
##Proper word selection:
active_word_list = []
with open(main + '\\states\\word_choice.txt', 'r') as f:
word_choice = f.readlines()[0]
with open(main + '\\states\\difficulty.txt', 'r') as f:
diff_choice = f.readlines()[0]
if word_choice == 'G':
active_word_list = gender_word_list
elif word_choice == 'P':
active_word_list = plural_word_list
else:
for entry in word_list:
if entry['Type'] == [word_choice
] and entry['Difficulty'] == [diff_choice]:
active_word_list.append(entry)
random.shuffle(active_word_list)
##Generator for nouns,adjs,verbs,mixed##
def gen_word_balloon():
for i in active_word_list:
yield Words(i)
def gen_gender_balloon():
for i in active_word_list:
yield Genders(i)
def gen_plural_balloon():
for i in active_word_list:
yield Plurals(i)
if word_choice == 'G':
generated_word = gen_gender_balloon()
elif word_choice == 'P':
generated_word = gen_plural_balloon()
else:
generated_word = gen_word_balloon()
#Get Sprites
sky, sky_rect = get_image(main + '\\sprites\\sky.png', screen_w, screen_h)
sky.convert()
sky.set_colorkey((255, 255, 255))
inputbox, inputbox_rect = get_image(main + '\\sprites\\inputbox.png',
int(screen_w / 2.25),
int(screen_h / 5))
inputbox.convert()
inputbox.set_colorkey((255, 255, 255))
inputbox_rect.left = int(screen_w / 12)
inputbox_rect.bottom = screen_h
pause_button, pause_rect = get_image(main + '\\sprites\\pause.png',
int(screen_w / 5), int(screen_h / 5))
pause_button.convert()
pause_button.set_colorkey((255, 255, 255))
pause_rect.right = int(screen_w)
pause_rect.bottom = screen_h
life1 = Lives('\\sprites\\life1.png', int(1 * screen_w / 12),
int(1 * screen_w / 12), int(7 * screen_w / 12),
int(10 * screen_h / 12))
life2 = Lives('\\sprites\\life2.png', int(1 * screen_w / 12),
int(1 * screen_w / 12), int(8 * screen_w / 12),
int(10 * screen_h / 12))
life3 = Lives('\\sprites\\life3.png', int(1 * screen_w / 12),
int(1 * screen_w / 12), int(9 * screen_w / 12),
int(10 * screen_h / 12))
#Variables
missed_words = []
score = 0
font = pygame.font.SysFont('comicsansms', 45)
lives = 3
text = ''
gen_state = 1
def paused(state, screen):
screen_w, screen_h = screen.get_size()
#Fadey screen
s = pygame.Surface((screen_w, screen_h))
s.set_alpha(5)
s.fill((254, 254, 254))
#Get sprites
unpause_butt, unpause_rect = get_image(main + '\\sprites\\unpause.png')
unpause_butt.convert()
unpause_butt.set_colorkey((255, 255, 255))
unpause_rect.centerx = int(screen_w / 2)
unpause_rect.centery = int(screen_h / 2 - (screen_h / 5))
return_title_butt, return_title_rect = get_image(
main + '\\sprites\\return_to_title.png')
return_title_butt.convert()
return_title_butt.set_colorkey((255, 255, 255))
return_title_rect.centerx = int(screen_w / 2)
return_title_rect.centery = int(screen_h / 2 + (screen_h / 5))
#Events
paused = True
while paused:
##Blits
screen.blit(unpause_butt, unpause_rect)
screen.blit(return_title_butt, return_title_rect)
screen.blit(s, (0, 0))
pygame.display.flip()
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
if unpause_rect.collidepoint(pos):
paused = False
state['title_screen'] = 0
state['game1'] = 1
return state
elif return_title_rect.collidepoint(pos):
paused = False
state['game1'] = 0
state['title'] = 1
return state
if event.type == pygame.QUIT:
state['running'] = 0
state['game1'] = 0
state['title'] = 0
pygame.quit()
return state
return state
def gameover(state, screen, victory=False):
if not victory:
gameover_img, gameover_rect = get_image(
main + '\\sprites\\gameover.png', screen_w, screen_h)
screen.blit(gameover_img, gameover_rect)
pygame.display.flip()
pygame.time.wait(3000)
if victory:
gamewon_img, gamewon_rect = get_image(
main + '\\sprites\\youwin.png', screen_w, screen_h)
screen.blit(gamewon_img, gamewon_rect)
pygame.display.flip()
pygame.time.wait(3000)
#Read in options
with open(main + '\\states\\user.txt', 'r') as f:
user = f.readlines()[0]
with open(main + '\\states\\difficulty.txt', 'r') as f:
difficulty = f.readlines()[0]
with open(main + '\\states\word_choice.txt', 'r') as f:
word_choice = f.readlines()[0]
#Save scores and potentially missed words
with open(
main + '\\' + user + '_scores\\' + difficulty + '_' +
word_choice + '.csv', 'a') as f:
writer = csv.writer(f, lineterminator='\n')
writer.writerow([datetime.date(datetime.now()), score])
with open(main + '\\' + user + '_scores\\missed_words.csv', 'a') as f:
writer = csv.writer(f, lineterminator='\n')
for i in missed_words:
for k, v in i.items():
writer.writerow([datetime.date(datetime.now()), (k, v)])
state['game1'] = 0
state['title'] = 1
return state
def show_answer(screen, word_obj):
#Fadey screen
s = pygame.Surface((screen_w, screen_h))
s.set_alpha(5)
s.fill((254, 254, 254))
#Get sprites
answer_btn, answer_rect = get_image(
main + '\\sprites\\show_answer.png', int(screen_w / 1.4),
int(screen_h / 2))
answer_btn.convert()
answer_btn.set_colorkey((255, 255, 255))
answer_rect.centerx = int(screen_w / 2)
answer_rect.centery = int(screen_h / 2)
word_obj.answer_rect.centerx = answer_rect.centerx
word_obj.answer_rect.centery = answer_rect.centery
##Blits
screen.blit(s, (0, 0))
screen.blit(answer_btn, answer_rect)
screen.blit(word_obj.answer_block, word_obj.answer_rect)
pygame.display.flip()
pygame.time.wait(2000)
##Main Game Loop
while state['game1'] == 1:
##Get generated word objects and calculate lives
if gen_state == 1:
word_obj = next(generated_word)
gen_state += 1
word_status = True
alive = True
word_obj.move()
word_status, alive = word_obj.border_check()
##Eventually print these on screen as well
if alive == False:
lives -= 1
if lives == 2:
life1.die()
pygame.display.update()
try:
print({word_obj.german_str: word_obj.english_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.english_str})
except AttributeError:
try:
print({word_obj.german_str: word_obj.gender_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.gender_str})
except AttributeError:
print({word_obj.german_str: word_obj.plural_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.plural_str})
show_answer(screen, word_obj)
elif lives == 1:
life2.kill()
try:
print({word_obj.german_str: word_obj.english_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.english_str})
except AttributeError:
try:
print({word_obj.german_str: word_obj.gender_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.gender_str})
except AttributeError:
print({word_obj.german_str: word_obj.plural_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.plural_str})
show_answer(screen, word_obj)
elif lives == 0:
life3.kill()
try:
print({word_obj.german_str: word_obj.english_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.english_str})
except AttributeError:
try:
print({word_obj.german_str: word_obj.gender_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.gender_str})
except AttributeError:
print({word_obj.german_str: word_obj.plural_str})
#Needs a try except to catch the gender/plural cases here
missed_words.append(
{word_obj.german_str: word_obj.plural_str})
show_answer(screen, word_obj)
lives = 3
state['game1'] = 0
gameover(state, screen)
if word_status == False:
gen_state += 1
try:
word_obj = next(generated_word)
except StopIteration:
gameover(state, screen, victory=True)
#Text input
block = font.render(text, True, (1, 1, 1))
block_rect = block.get_rect()
block_rect.centerx = inputbox_rect.centerx
block_rect.centery = inputbox_rect.centery
#Blits
screen.fill((255, 255, 255))
screen.blit(sky, sky_rect)
screen.blit(inputbox, inputbox_rect)
screen.blit(pause_button, pause_rect)
screen.blit(block, block_rect)
screen.blit(word_obj.word_display, word_obj.word_display_rect)
screen.blit(word_obj.word_block, word_obj.word_rect)
life_balloons.draw(screen)
pygame.display.flip()
##User Input
#Events
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
if pause_rect.collidepoint(pos):
state = paused(state, screen)
elif event.type == KEYDOWN:
##Check Answer Event##
if event.key == K_RETURN:
text = text.upper().strip()
##Normal word translations Events##
if word_choice == 'N' or word_choice == 'A' or word_choice == 'V' or word_choice == 'M':
check_list = [
eng.upper() for eng in word_obj.english_str
]
for counter, eng in enumerate(check_list):
if eng.startswith('TO '):
text = text.replace('TO ', '')
check_list[counter] = eng.replace('TO ', '')
elif eng.startswith('THE '):
text = text.replace('THE ', '')
check_list[counter] = eng.replace('THE ', '')
if text in check_list:
score += 1
try:
word_obj = next(generated_word)
except StopIteration:
gameover(state, screen, victory=True)
text = ''
else:
text = ''
##Gender word events##
if word_choice == 'G':
check_list = word_obj.gender_str.upper()
if text in [check_list]:
score += 1
try:
word_obj = next(generated_word)
except StopIteration:
gameover(state, screen, victory=True)
text = ''
else:
text = ''
##Plural word events##
if word_choice == 'P':
check_list = [word_obj.plural_str.upper()]
for counter, plural in enumerate(check_list):
if plural.startswith('DIE '):
text = text.replace('DIE ', '')
check_list[counter] = plural.replace(
'DIE ', '')
if text in check_list:
score += 1
try:
word_obj = next(generated_word)
except StopIteration:
gameover(state, screen, victory=True)
text = ''
else:
text = ''
elif event.key == K_BACKSPACE:
text = text[:-1]
elif event.key != K_BACKSPACE or event.key != K_RETURN:
text += event.unicode
if event.type == pygame.QUIT:
state['running'] = 0
state['game1'] = 0
pygame.quit()
return state
return state
def options(state, screen):
screen_w, screen_h = screen.get_size()
#Get Sprites
title_background, title_background_rect = get_image(
main + '\\sprites\\title_background.png', screen_w, screen_h)
title_background.convert()
title_background.set_colorkey((255, 255, 255))
cloud1 = Clouds('\\sprites\\cloud1.png', int(screen_w / 3),
int(screen_h / 6), int(64 * screen_w / 100),
int(25 * screen_h / 100))
cloud2 = Clouds('\\sprites\\cloud2.png', int(screen_w / 4),
int(screen_h / 5), int(44 * screen_w / 100),
int(50 * screen_h / 100))
# user_arrow = OptionArrows('main_options','\\sprites\\user_arrow.png', int(screen_w/3),int(screen_h/6), int(15*screen_w/100), int(25*screen_h/100))
difficulty_arrow = OptionArrows('main_options',
'\\sprites\\difficulty_arrow.png',
int(screen_w / 3.5), int(screen_h / 5),
int(20 * screen_w / 100),
int(30 * screen_h / 100))
choose_words_arrow = OptionArrows('main_options',
'\\sprites\\choose_words_arrow.png',
int(screen_w / 3.5), int(screen_h / 5),
int(20 * screen_w / 100),
int(45 * screen_h / 100))
user_arrow = OptionArrows('main_options', '\\sprites\\user_arrow.png',
int(screen_w / 3.5), int(screen_h / 5),
int(20 * screen_w / 100),
int(60 * screen_h / 100))
back_arrow = OptionArrows('main_options', '\\sprites\\back_arrow.png',
int(screen_w / 3.5), int(screen_h / 5),
int(20 * screen_w / 100),
int(75 * screen_h / 100))
easy_arrow = OptionArrows('difficulty_options',
'\\sprites\\easy_arrow.png', int(screen_w / 3),
int(screen_h / 6), int(55 * screen_w / 100),
int(20 * screen_h / 100))
medium_arrow = OptionArrows('difficulty_options',
'\\sprites\\medium_arrow.png',
int(screen_w / 3), int(screen_h / 6),
int(55 * screen_w / 100),
int(40 * screen_h / 100))
hard_arrow = OptionArrows('difficulty_options',
'\\sprites\\hard_arrow.png', int(screen_w / 3),
int(screen_h / 6), int(55 * screen_w / 100),
int(60 * screen_h / 100))
verbs_arrow = OptionArrows('words', '\\sprites\\verbs_arrow.png',
int(screen_w / 3), int(screen_h / 6),
int(55 * screen_w / 100),
int(10 * screen_h / 100))
adjectives_arrow = OptionArrows('words', '\\sprites\\adjectives_arrow.png',
int(screen_w / 3), int(screen_h / 6),
int(55 * screen_w / 100),
int(25 * screen_h / 100))
nouns_arrow = OptionArrows('words', '\\sprites\\nouns_arrow.png',
int(screen_w / 3), int(screen_h / 6),
int(55 * screen_w / 100),
int(40 * screen_h / 100))
plurals_arrow = OptionArrows('words', '\\sprites\\plurals_arrow.png',
int(screen_w / 3), int(screen_h / 6),
int(55 * screen_w / 100),
int(55 * screen_h / 100))
genders_arrow = OptionArrows('words', '\\sprites\\genders_arrow.png',
int(screen_w / 3), int(screen_h / 6),
int(55 * screen_w / 100),
int(70 * screen_h / 100))
mixed_arrow = OptionArrows('words', '\\sprites\\mixed_arrow.png',
int(screen_w / 3), int(screen_h / 6),
int(55 * screen_w / 100),
int(85 * screen_h / 100))
player1_arrow = OptionArrows('player_arrow', '\\sprites\\player1.png',
int(screen_w / 3), int(screen_h / 2),
int(45 * screen_w / 100),
int(50 * screen_h / 100))
player2_arrow = OptionArrows('player_arrow', '\\sprites\\player2.png',
int(screen_w / 3), int(screen_h / 2),
int(75 * screen_w / 100),
int(50 * screen_h / 100))
player1_border_arrow = OptionArrows('player_border_arrow',
'\\sprites\\player1_selected.png',
int(screen_w / 3), int(screen_h / 2),
int(45 * screen_w / 100),
int(50 * screen_h / 100))
player2_border_arrow = OptionArrows('player_border_arrow',
'\\sprites\\player2_selected.png',
int(screen_w / 3), int(screen_h / 2),
int(75 * screen_w / 100),
int(50 * screen_h / 100))
select_arrow = OptionArrows('border_arrow', '\\sprites\\arrow_border.png',
int(screen_w / 3), int(screen_h / 6),
int(65 * screen_w / 100),
int(60 * screen_h / 100))
dborder_state = {'E': 0, 'M': 0, 'H': 0}
wborder_state = {'V': 0, 'A': 0, 'N': 0, 'P': 0, 'G': 0, 'M': 0}
uborder_state = {'player1': 0, 'player2': 0}
btn_state = {'Words': 0, 'Difficulty': 0, 'User': 0, 'Back': 0}
dselect = False
wselect = False
uselect = False
while state['options'] == 1:
#Blits
screen.fill((1, 1, 1))
screen.blit(title_background, title_background_rect)
clouds.draw(screen)
option_arrows.draw(screen)
with open(main + '\\states\\difficulty.txt', 'r') as f:
d = f.readlines()
dborder_state = dict.fromkeys(dborder_state, 0)
dborder_state[d[0]] = 1
with open(main + '\\states\\word_choice.txt', 'r') as f:
w = f.readlines()
wborder_state = dict.fromkeys(wborder_state, 0)
wborder_state[w[0]] = 1
with open(main + '\\states\\user.txt', 'r') as f:
u = f.readlines()
uborder_state = dict.fromkeys(uborder_state, 0)
uborder_state[u[0]] = 1
##User Select
if btn_state['User'] == 1:
player_arrow.draw(screen)
if uborder_state['player1'] == 1:
player1_border_arrow.rect.centerx = player1_arrow.rect.centerx
player1_border_arrow.rect.centery = player1_arrow.rect.centery
screen.blit(player1_border_arrow.image,
player1_border_arrow.rect)
elif uborder_state['player2'] == 1:
player2_border_arrow.rect.centerx = player2_arrow.rect.centerx
player2_border_arrow.rect.centery = player2_arrow.rect.centery
screen.blit(player2_border_arrow.image,
player2_border_arrow.rect)
##SHOW CSV WORD CHOICES##
if btn_state['Words'] == 1:
option_word_arrows.draw(screen)
if wborder_state['V'] == 1:
select_arrow.rect.centerx = verbs_arrow.rect.centerx
select_arrow.rect.centery = verbs_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
elif wborder_state['A'] == 1:
select_arrow.rect.centerx = adjectives_arrow.rect.centerx
select_arrow.rect.centery = adjectives_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
elif wborder_state['N'] == 1:
select_arrow.rect.centerx = nouns_arrow.rect.centerx
select_arrow.rect.centery = nouns_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
elif wborder_state['P'] == 1:
select_arrow.rect.centerx = plurals_arrow.rect.centerx
select_arrow.rect.centery = plurals_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
elif wborder_state['G'] == 1:
select_arrow.rect.centerx = genders_arrow.rect.centerx
select_arrow.rect.centery = genders_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
elif wborder_state['M'] == 1:
select_arrow.rect.centerx = mixed_arrow.rect.centerx
select_arrow.rect.centery = mixed_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
##SHOW DIFFICULTY OPTIONS##
if btn_state['Difficulty'] == 1:
option_difficult_arrows.draw(screen)
if dborder_state['E'] == 1:
select_arrow.rect.centerx = easy_arrow.rect.centerx
select_arrow.rect.centery = easy_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
elif dborder_state['M'] == 1:
select_arrow.rect.centerx = medium_arrow.rect.centerx
select_arrow.rect.centery = medium_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
elif dborder_state['H'] == 1:
select_arrow.rect.centerx = hard_arrow.rect.centerx
select_arrow.rect.centery = hard_arrow.rect.centery
screen.blit(select_arrow.image, select_arrow.rect)
pygame.display.flip()
#Events
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
##Create option collisions##
if btn_state['User'] == 1:
if user_arrow.rect.collidepoint(pos):
uselect = False
btn_state['User'] = 0
break
for sprite in player_arrow:
if sprite.rect.collidepoint(pos):
uborder_state = uborder_state_definer(
uborder_state, sprite)
if btn_state['Difficulty'] == 1:
if difficulty_arrow.rect.collidepoint(pos):
dselect = False
btn_state['Difficulty'] = 0
break
for sprite in option_difficult_arrows:
if sprite.rect.collidepoint(pos):
dborder_state = dborder_state_definer(
dborder_state, sprite)
if btn_state['Words'] == 1:
if choose_words_arrow.rect.collidepoint(pos):
wselect = False
btn_state['Words'] = 0
break
for sprite in option_word_arrows:
if sprite.rect.collidepoint(pos):
wborder_state = wborder_state_definer(
wborder_state, sprite)
##BACK BUTTON##
##Option State Definitions##
if user_arrow.rect.collidepoint(pos):
uselect = True
btn_state = dict.fromkeys(btn_state, 0)
btn_state['User'] = 1
elif choose_words_arrow.rect.collidepoint(pos):
wselect = True
btn_state = dict.fromkeys(btn_state, 0)
btn_state['Words'] = 1
elif difficulty_arrow.rect.collidepoint(pos):
dselect = True
btn_state = dict.fromkeys(btn_state, 0)
btn_state['Difficulty'] = 1
elif back_arrow.rect.collidepoint(pos):
btn_state = dict.fromkeys(btn_state, 0)
btn_state['Back'] = 1
if btn_state['Back'] == 1:
state['title'] = 1
state['options'] = 0
return state
elif event.type == pygame.QUIT:
state['running'] = 0
pygame.quit()
return state
return state
def title_screen(state, screen):
pygame.init()
screen_w, screen_h = screen.get_size()
#Get Sprites
title_background, title_background_rect = get_image(
main + '\\sprites\\title_background.png', screen_w, screen_h)
title_background.convert()
title_background.set_colorkey((255, 255, 255))
play_arrow = Arrows('\\sprites\\play_arrow.png', int(screen_w / 3),
int(screen_h / 5), int(screen_w / 3),
int(65 * screen_h / 100))
options_arrow = Arrows('\\sprites\\options_arrow.png', int(screen_w / 3),
int(screen_h / 5), int(screen_w / 3),
int(80 * screen_h / 100))
b = Letters('\\sprites\\B_balloon1.png', int(screen_w / 6),
int(screen_h / 6), int(10 * screen_w / 100),
int(25 * screen_h / 100))
a1 = Letters('\\sprites\\A_balloon1.png', int(screen_w / 6),
int(screen_h / 6), int(24 * screen_w / 100),
int(25 * screen_h / 100))
l1 = Letters('\\sprites\\L_balloon1.png', int(screen_w / 6),
int(screen_h / 6), int(38 * screen_w / 100),
int(25 * screen_h / 100))
l2 = Letters('\\sprites\\L_balloon2.png', int(screen_w / 6),
int(screen_h / 6), int(50 * screen_w / 100),
int(25 * screen_h / 100))
o1 = Letters('\\sprites\\O_balloon1.png', int(screen_w / 6),
int(screen_h / 6), int(62 * screen_w / 100),
int(25 * screen_h / 100))
o2 = Letters('\\sprites\\O_balloon2.png', int(screen_w / 6),
int(screen_h / 6), int(75 * screen_w / 100),
int(25 * screen_h / 100))
n1 = Letters('\\sprites\\N1.png', int(screen_w / 6), int(screen_h / 6),
int(81 * screen_w / 100), int(25 * screen_h / 100))
p = Letters('\\sprites\\P.png', int(screen_w / 6), int(screen_h / 6),
int(12 * screen_w / 100), int(45 * screen_h / 100))
l3 = Letters('\\sprites\\L_balloon3.png', int(screen_w / 6),
int(screen_h / 6), int(24 * screen_w / 100),
int(45 * screen_h / 100))
a2 = Letters('\\sprites\\A_balloon2.png', int(screen_w / 6),
int(screen_h / 6), int(36 * screen_w / 100),
int(45 * screen_h / 100))
t = Letters('\\sprites\\T.png', int(screen_w / 6), int(screen_h / 6),
int(48 * screen_w / 100), int(45 * screen_h / 100))
o3 = Letters('\\sprites\\O_balloon3.png', int(screen_w / 6),
int(screen_h / 6), int(60 * screen_w / 100),
int(45 * screen_h / 100))
o4 = Letters('\\sprites\\O_balloon4.png', int(screen_w / 6),
int(screen_h / 6), int(72 * screen_w / 100),
int(45 * screen_h / 100))
n2 = Letters('\\sprites\\N2.png', int(screen_w / 6), int(screen_h / 6),
int(84 * screen_w / 100), int(45 * screen_h / 100))
cloud1 = Clouds('\\sprites\\cloud1.png', int(screen_w / 3),
int(screen_h / 6), int(64 * screen_w / 100),
int(25 * screen_h / 100))
cloud2 = Clouds('\\sprites\\cloud2.png', int(screen_w / 4),
int(screen_h / 5), int(44 * screen_w / 100),
int(50 * screen_h / 100))
while state['title'] == 1:
#Blits
screen.fill((1, 1, 1))
screen.blit(title_background, title_background_rect)
clouds.draw(screen)
letters.draw(screen)
arrows.draw(screen)
pygame.display.flip()
for sprite in letters:
sprite.move()
# for cloud in clouds:
# cloud.move()
#Events
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
if play_arrow.rect.collidepoint(pos):
state['title'] = 0
state['game1'] = 1
state['options'] = 0
elif options_arrow.rect.collidepoint(pos):
state['title'] = 0
state['game1'] = 0
state['options'] = 1
elif event.type == pygame.QUIT:
state['running'] = 0
pygame.quit()
return state
return state