Added Fast graphics for low specification PC

Author: blueSparrow2000

game.py

@@ -118,7 +118,7 @@ def calc_song_progress_percent(song_length,song_start_time,current_time):  # ret
     return progress
 
 
-def run_FGHJ(screen,clock,song_name,stage_speed,offset,judgement_shown,guide_line_shown):
+def run_FGHJ(screen,clock,song_name,stage_speed,offset,judgement_shown,guide_line_shown,high_quality_verifying_graphics):
     global bar_color, wait_delay, change_background_color
     game_run = True
     score = [0]
@@ -142,7 +142,7 @@ def run_FGHJ(screen,clock,song_name,stage_speed,offset,judgement_shown,guide_lin
         game_run = False
         view_score_menu(screen, clock, song_name, score, song_difficulty, total_points)
         return
-    verifier = Verifier(screen,score,stage_speed,judgement_shown,song_bpm)
+    verifier = Verifier(screen,score,stage_speed,judgement_shown,song_bpm,high_quality_verifying_graphics)
 
 
 
@@ -261,6 +261,7 @@ def run_FGHJ(screen,clock,song_name,stage_speed,offset,judgement_shown,guide_lin
                         change_background_color = 1
                         screen.fill(background_color[change_background_color])
                         tile.fix_loc()
+                        verifier.draw_judgement()
                         for T in tiles_off_screen + nodes_on_screen + holds_on_screen:
                             T.draw(screen,screen_freeze)
                         draw_frame(screen)

main.py

@@ -134,13 +134,18 @@ def update_song_info():
                             stage_speed = boundary_checker(min_speed,max_speed,stage_speed)
 
                 if abs(xp - width//2) < big_text*3:  # toggle judgement
-                    if abs(yp - (mode_y_level + mode_location_offset['huge'] + big_text))< big_text//2:
+                    if abs(yp - (mode_y_level + mode_location_offset['huge'] + big_text + big_text//2))< big_text//2:
                         judgement_shown = not judgement_shown #not judgement_shown
 
-                if abs(xp - width//2) < big_text*3:  # toggle judgement
-                    if abs(yp - (mode_y_level + mode_location_offset['huge'] + big_text*3))< big_text//2:
+                if abs(xp - width//2) < big_text*3:  # toggle guide line
+                    if abs(yp - (mode_y_level + mode_location_offset['huge'] + big_text*2 + big_text//2))< big_text//2:
                         guide_line_shown = not guide_line_shown
 
+                if abs(xp - width // 2) < big_text * 3:  # toggle graphics
+                    if abs(yp - (mode_y_level + mode_location_offset['huge'] + big_text * 3 + big_text//2)) < big_text // 2:
+                        high_quality_verifying_graphics = not high_quality_verifying_graphics
+
+
             if event.type == pygame.MOUSEBUTTONDOWN:
                 if event.button == 4:
                     music_pointer -= 1
@@ -163,7 +168,7 @@ def update_song_info():
                     run, meta_run = exit()
                     break
                 elif event.key == pygame.K_RETURN:
-                    run_FGHJ(screen,clock,song_name,stage_speed,offset,judgement_shown,guide_line_shown)
+                    run_FGHJ(screen,clock,song_name,stage_speed,offset,judgement_shown,guide_line_shown,high_quality_verifying_graphics)
                     run = False
                     break
 
@@ -208,19 +213,29 @@ def update_song_info():
                    highlight_text_color)
 
         if judgement_shown:
-            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text, 'Hide judgement detail', small_text, background_color[0],
+            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text, 'Judgement detail: On', small_text, background_color[0],
                        highlight_text_color)
         else:
-            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text, 'Show judgement detail', small_text, background_color[0],
+            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text, 'Judgement detail: Off', small_text, background_color[0],
                        highlight_text_color)
 
         if guide_line_shown:
-            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text*3, 'Hide guide lines', small_text, background_color[0],
+            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text*2, 'Guide line: On', small_text, background_color[0],
+                       highlight_text_color)
+        else:
+            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text*2, 'Guide line: Off', small_text, background_color[0],
+                       highlight_text_color)
+
+
+        if high_quality_verifying_graphics:
+            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text*3, 'Graphics: Fancy', small_text, background_color[0],
                        highlight_text_color)
         else:
-            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text*3, 'Show guide lines', small_text, background_color[0],
+            write_text(screen, width // 2,  mode_y_level + mode_location_offset['Giant'] + big_text*3, 'Graphics: Fast', small_text, background_color[0],
                        highlight_text_color)
 
+
+
         for index in range(min_index,max_index+1):
             music = music_list[index]
             location = index - music_pointer

tiles.py

@@ -48,7 +48,7 @@ def fix_loc(self, loc = None):
             self.y = self.judgement_line
 
     def check_border(self):
-        if self.special == 'BadApple' and self.y > self.judgement_line:  # 'Late' for special node
+        if self.special == 'BadApple' and self.y > self.judgement_line + 5:  # 'Late' for special node
             #print('border cross for Bad apple!')
             return True # border crossed for special node
 

variables.py

@@ -18,7 +18,7 @@
 song_name = None # as a default
 song_info_list = []
 
-high_quality_verifying_graphics = True
+high_quality_verifying_graphics = False
 
 
 # time settings

verifier_class.py

@@ -12,8 +12,8 @@
 from utility_functions import *
 
 class Verifier():
-    def __init__(self,screen, score,speed,judgement_shown,bpm):
-        global fps, high_quality_verifying_graphics
+    def __init__(self,screen, score,speed,judgement_shown,bpm,high_quality_verifying_graphics):
+        global fps
         self.screen = screen
         self.speed = speed
         self.score = score
@@ -22,6 +22,7 @@ def __init__(self,screen, score,speed,judgement_shown,bpm):
         self.judgement_highest_pos = int((self.judgement_frames) *0.7)
         self.judgement_shown = judgement_shown
         self.high_quality_verifying_graphics = high_quality_verifying_graphics
+        self.verification_show_time = 300 # ms
 
         self.frame_error = int(((10/fps)*self.speed) + 1)
         self.song_bpm = bpm
@@ -78,10 +79,21 @@ def node_check(self,nodes_on_screen,tiles_off_screen,events):
             if node.check_border() or self.check_pressed(node,events):
                 if node.special == 'BadApple':
                     tiles_off_screen.append(node)
+                    nodes_on_screen.remove(node)
+                    if self.check_pressed(node,events):
+                        self.verify_judgement_node(node)
+                    else: # lost
+                        self.verify_judgement_node(node,enforce_Lost=True)
+                    continue
                 nodes_on_screen.remove(node)
                 self.verify_judgement_node(node)
 
 
+
+
+
+
+
     def draw_guide_lines_node(self,nodes_on_screen,screen):
         for node in nodes_on_screen:
             for i in range(len(self.node_judgement_line_half_sizes)):
@@ -95,11 +107,18 @@ def append_verification_tile(self,tile_verification):
         if self.high_quality_verifying_graphics:
             self.tiles_to_verify.append(tile_verification)
         else:
-            time_added_verification = tile_verification + [pygame.time.get_ticks()]
-            self.tiles_to_verify.append(time_added_verification)
+            tile_verification.append(pygame.time.get_ticks())
+            #print(tile_verification)
+            self.tiles_to_verify.append(tile_verification)
 
 
-    def verify_judgement_node(self,node):
+    def verify_judgement_node(self,node,enforce_Lost = False):
+        if enforce_Lost:
+            self.append_verification_tile([node, ("Lost", ''), self.judgement_frames])
+            if self.judgement_shown:
+                print("Enforced Lost")
+            return
+
         result = ''
         detail = ''
         human_error = node.y - judgement_line
@@ -124,7 +143,7 @@ def verify_judgement_node(self,node):
 
         # print result of Lost/Hit/Perfect on the screen
         #print(result)
-        self.tiles_to_verify.append([node,(result,detail),self.judgement_frames])
+        self.append_verification_tile([node,(result,detail),self.judgement_frames])
 
 
         self.score[0] += point
@@ -175,7 +194,7 @@ def verify_judgement_hold(self,hold, events):
                 return
         #print(result)
         #print("sending %s to"%hold.this_judgement_pos)
-        self.tiles_to_verify.append([hold,(result,detail),self.judgement_frames])
+        self.append_verification_tile([hold,(result,detail),self.judgement_frames])
         self.score[0] += point
         self.update_hold_judgement_pos(hold)
         if result=="Lost":
@@ -227,14 +246,32 @@ def draw_judgement(self):
                 if verification[2] <= 1:
                     self.tiles_to_verify.remove(verification)
                 else:
-
                     write_text(self.screen, line_axes[verification[0].line-1], judgement_line -judgement_text*3 + self.calc_pos(verification[2]), "%s"%(verification[1][0]), judgement_text, background_color[0], highlight_text_color)
                     write_text(self.screen, line_axes[verification[0].line - 1],
                                judgement_line - judgement_text * 3 + self.calc_pos(verification[2])+judgement_text,
                                "%s" % (verification[1][1]), detail_text, background_color[0], highlight_text_color)
                     verification[2] -= 1
         else:
-            pass
+            cur_time = pygame.time.get_ticks()
+            for i in range(len(self.tiles_to_verify) - 1, -1, -1):
+                verification = self.tiles_to_verify[i]
+                if cur_time - verification[3] > self.verification_show_time:
+                    self.tiles_to_verify.remove(verification)
+                else:
+                    write_text(self.screen, line_axes[verification[0].line - 1],
+                               judgement_line - judgement_text * 3,
+                               "%s" % (verification[1][0]), judgement_text, background_color[0], highlight_text_color)
+
+
 
     def calc_pos(self,note_stage):
-        return (max(self.judgement_highest_pos, note_stage) - self.judgement_highest_pos)
+        return (max(self.judgement_highest_pos, note_stage) - self.judgement_highest_pos)
+
+
+
+
+
+
+
+
+