def draw(self, surf, gameStateObj):
currentTime = Engine.get_time()
# if should be displaying exp bar OR should be displaying level Up screen
if self.state.getState() in [
'exp_wait', 'exp_leave', 'exp0', 'exp100', 'init',
'prepare_promote'
]:
if self.exp_bar:
self.exp_bar.draw(surf)
elif self.state.getState() == 'levelUp':
self.levelUpAnimation.draw(surf, gameStateObj)
"""
marker1 = self.animationMarker[0]
marker2 = self.animationMarker[1]
LvlSurf = Engine.subsurface(self.levelUpAnimation, (marker2*78, marker1*16, 78, 16))
x, y = self.unit.position
topleft = (x-gameStateObj.cameraOffset.x-2)*GC.TILEWIDTH, (y-gameStateObj.cameraOffset.y-1)*GC.TILEHEIGHT
surf.blit(LvlSurf, topleft)
"""
elif self.state.getState() == 'levelScreen':
# Highlight underline -- yellow, blue
new_color = Image_Modification.color_transition2((88, 16, -40),
(-80, -32, 40))
# Scroll out
if currentTime - self.state_time > self.LEVELUPWAIT + (
self.get_num_sparks() + 1) * self.SPARKTIME + 300:
self.unit_scroll_offset += 10
self.screen_scroll_offset += 20
self.animations = []
else: # scroll in
if self.unit_scroll_offset:
self.lastSparkUpdate = currentTime - 300 # add 300 extra milliseconds of waiting at beginning
self.unit_scroll_offset -= 10
self.unit_scroll_offset = max(0, self.unit_scroll_offset)
self.screen_scroll_offset -= 20
self.screen_scroll_offset = max(0, self.screen_scroll_offset)
DisplayWidth = self.levelUpScreen.get_width()
DisplayHeight = self.levelUpScreen.get_height()
# Level up screen
LevelUpSurface = Engine.create_surface(
(DisplayWidth, DisplayHeight), transparent=True, convert=True)
# Create background
LevelSurf = self.levelUpScreen
LevelUpSurface.blit(LevelSurf, (0, 0))
# Render top banner text
long_name = gameStateObj.metaDataObj['class_dict'][
self.unit.klass]['long_name']
GC.FONT['text_white'].blit(long_name, LevelUpSurface, (12, 3))
GC.FONT['text_yellow'].blit(
cf.WORDS['Lv'], LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 12, 3))
if self.first_spark_flag or self.force_level:
level = str(self.unit.level)
elif self.unit.level == 1:
level = str(self.prev_level)
else:
level = str(self.unit.level - 1)
GC.FONT['text_blue'].blit(level, LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 50 -
GC.FONT['text_blue'].size(level)[0], 3))
# Blit first spark
if self.force_level and not self.first_spark_flag:
self.first_spark_flag = True
self.lastSparkUpdate = currentTime
elif self.screen_scroll_offset == 0 and not self.first_spark_flag and currentTime - self.lastSparkUpdate > self.SPARKTIME + 500:
position = (87, 27)
spark_animation = CustomObjects.Animation(self.statupanimation,
position, (11, 1),
animation_speed=32,
ignore_map=True)
self.animations.append(spark_animation)
self.first_spark_flag = True
self.lastSparkUpdate = currentTime
# Sound
GC.SOUNDDICT['Level_Up_Level'].play()
# Add sparks to animation list one at a time
if self.first_spark_flag and currentTime - self.lastSparkUpdate > self.SPARKTIME:
self.sparkCounter += 1
self.sparkUp = True # Whether the sparkCounter was actually incremented or not
if self.sparkCounter > 7:
self.sparkCounter = 7
self.sparkUp = False
else:
while self.levelup_list[self.sparkCounter] == 0:
self.sparkCounter += 1
self.sparkUp = True
if self.sparkCounter > 7:
self.sparkCounter = 7
self.sparkUp = False
break
if self.sparkUp:
self.underline_offset = 36 # for underline growing
# Add animations and Sound
# Animations
if self.sparkCounter >= 4:
position = (88,
(self.sparkCounter - 4) * GC.TILEHEIGHT +
61)
else:
position = (24, self.sparkCounter * GC.TILEHEIGHT + 61)
arrow_animation = CustomObjects.Animation(
self.uparrow, (position[0] + 31, position[1] - 37),
(10, 1),
animation_speed=32,
ignore_map=True,
hold=True)
self.arrow_animations.append(arrow_animation)
spark_animation = CustomObjects.Animation(
self.statupanimation,
position, (11, 1),
animation_speed=32,
ignore_map=True)
self.animations.append(spark_animation)
# Only 1-7 are supported increases for a levelup right now
# assert 8 > self.levelup_list[self.sparkCounter] > 0, "%s %s"%(self.levelup_list, self.levelup_list[self.sparkCounter])
if 1 <= self.levelup_list[self.sparkCounter] <= 4:
row = Engine.subsurface(
self.numbers,
(0,
(self.levelup_list[self.sparkCounter] - 1) * 24,
10 * 28, 24))
number_animation = CustomObjects.Animation(
row, (position[0] + 29, position[1] + 23), (10, 1),
animation_speed=32,
ignore_map=True,
hold=True)
else:
row = Engine.subsurface(
self.numbers, (0, (Utility.clamp(
self.levelup_list[self.sparkCounter], 1, 7) -
1) * 24, 2 * 28, 24))
number_animation = CustomObjects.Animation(
row, (position[0] + 29, position[1] + 23), (2, 1),
animation_speed=32,
ignore_map=True,
hold=True)
number_animation.frameCount = -5 # delay this animation for 5 frames
self.animations.append(number_animation)
# Sound
GC.SOUNDDICT['Stat Up'].play()
self.lastSparkUpdate = currentTime # Reset the last update time.
# HP, Str, Mag, Skl, Spd, Luck, Def, Res
new_underline_surf = Image_Modification.change_image_color(
self.statunderline, new_color)
for num in range(len(self.levelup_list[0:self.sparkCounter + 1])):
if self.levelup_list[
num] > 0: # IE it should be updated, since it leveled up
if num == self.sparkCounter:
rect = (self.underline_offset, 0,
new_underline_surf.get_width() -
self.underline_offset, 3)
new_underline_surf = Engine.subsurface(
new_underline_surf, rect)
self.underline_offset -= 6
self.underline_offset = max(0, self.underline_offset)
if num >= 4:
topleft = (76 + self.underline_offset // 2,
45 + GC.TILEHEIGHT * (num - 4))
else:
topleft = (12 + self.underline_offset // 2,
45 + GC.TILEHEIGHT * (num))
else:
if num >= 4:
topleft = (76, 45 + GC.TILEHEIGHT * (num - 4))
else:
topleft = (12, 45 + GC.TILEHEIGHT * (num))
LevelUpSurface.blit(new_underline_surf, topleft)
# Update and draw arrow animations
self.arrow_animations = [
animation for animation in self.arrow_animations
if not animation.update(gameStateObj)
]
for animation in self.arrow_animations:
animation.draw(LevelUpSurface, gameStateObj, blend=new_color)
# Update and draw number animations
self.number_animations = [
animation for animation in self.number_animations
if not animation.update(gameStateObj)
]
for animation in self.number_animations:
animation.draw(LevelUpSurface, gameStateObj, blend=new_color)
GC.FONT['text_yellow'].blit('HP', LevelUpSurface, (10, 35))
GC.FONT['text_yellow'].blit(cf.WORDS['STR'], LevelUpSurface,
(10, GC.TILEHEIGHT + 35))
GC.FONT['text_yellow'].blit(cf.WORDS['MAG'], LevelUpSurface,
(10, GC.TILEHEIGHT * 2 + 35))
GC.FONT['text_yellow'].blit(cf.WORDS['SKL'], LevelUpSurface,
(10, GC.TILEHEIGHT * 3 + 35))
GC.FONT['text_yellow'].blit(
cf.WORDS['SPD'], LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 8, 35))
GC.FONT['text_yellow'].blit(
cf.WORDS['LCK'], LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 8, GC.TILEHEIGHT + 35))
GC.FONT['text_yellow'].blit(
cf.WORDS['DEF'], LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 8, GC.TILEHEIGHT * 2 + 35))
GC.FONT['text_yellow'].blit(
cf.WORDS['RES'], LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 8, GC.TILEHEIGHT * 3 + 35))
hp_text = self.unit.stats['HP'].base_stat - (
self.levelup_list[0] if self.sparkCounter < 0 else 0)
str_text = self.unit.stats['STR'].base_stat - (
self.levelup_list[1] if self.sparkCounter < 1 else 0)
mag_text = self.unit.stats['MAG'].base_stat - (
self.levelup_list[2] if self.sparkCounter < 2 else 0)
skl_text = self.unit.stats['SKL'].base_stat - (
self.levelup_list[3] if self.sparkCounter < 3 else 0)
spd_text = self.unit.stats['SPD'].base_stat - (
self.levelup_list[4] if self.sparkCounter < 4 else 0)
lck_text = self.unit.stats['LCK'].base_stat - (
self.levelup_list[5] if self.sparkCounter < 5 else 0)
def_text = self.unit.stats['DEF'].base_stat - (
self.levelup_list[6] if self.sparkCounter < 6 else 0)
res_text = self.unit.stats['RES'].base_stat - (
self.levelup_list[7] if self.sparkCounter < 7 else 0)
GC.FONT['text_blue'].blit(
str(hp_text), LevelUpSurface,
(50 - GC.FONT['text_blue'].size(str(hp_text))[0], 35))
GC.FONT['text_blue'].blit(
str(str_text), LevelUpSurface,
(50 - GC.FONT['text_blue'].size(str(str_text))[0],
GC.TILEHEIGHT + 35))
GC.FONT['text_blue'].blit(
str(mag_text), LevelUpSurface,
(50 - GC.FONT['text_blue'].size(str(mag_text))[0],
GC.TILEHEIGHT * 2 + 35))
GC.FONT['text_blue'].blit(
str(skl_text), LevelUpSurface,
(50 - GC.FONT['text_blue'].size(str(skl_text))[0],
GC.TILEHEIGHT * 3 + 35))
GC.FONT['text_blue'].blit(
str(spd_text), LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 48 -
GC.FONT['text_blue'].size(str(spd_text))[0], 35))
GC.FONT['text_blue'].blit(
str(lck_text), LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 48 -
GC.FONT['text_blue'].size(str(lck_text))[0],
GC.TILEHEIGHT + 35))
GC.FONT['text_blue'].blit(
str(def_text), LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 48 -
GC.FONT['text_blue'].size(str(def_text))[0],
GC.TILEHEIGHT * 2 + 35))
GC.FONT['text_blue'].blit(
str(res_text), LevelUpSurface,
(LevelUpSurface.get_width() / 2 + 48 -
GC.FONT['text_blue'].size(str(res_text))[0],
GC.TILEHEIGHT * 3 + 35))
"""
# HP, Str, Mag, Skl, Spd, Luck, Def, Res
for num in range(len(self.levelup_list[0:self.sparkCounter])):
if self.levelup_list[num] != 0: # IE it should be updated, since it leveled up
# Blit number
if num >= 4:
topleft = (LevelUpSurface.get_width()/2+50, GC.TILEHEIGHT * (num - 4) + 33)
else:
topleft = (52, GC.TILEHEIGHT * num + 33)
change = str(self.levelup_list[num])
if self.levelup_list[num] > 0:
change = '+' + change
GC.FONT['stat_white'].blit(change, LevelUpSurface, topleft)
"""
pos = (6 - self.screen_scroll_offset,
GC.WINHEIGHT - 8 - LevelUpSurface.get_height())
surf.blit(LevelUpSurface, pos)
# Blit unit's pic
BigPortraitSurf = self.unit.bigportrait
pos = (GC.WINWIDTH - BigPortraitSurf.get_width() - 4,
GC.WINHEIGHT + self.unit_scroll_offset -
BigPortraitSurf.get_height())
surf.blit(BigPortraitSurf, pos)
# Update and draw animations
self.animations = [
animation for animation in self.animations
if not animation.update(gameStateObj)
]
for animation in self.animations:
animation.draw(surf, gameStateObj)
