タイピングゲームタイピングシステムを組み立てる Python/pygame 全文置いておきます。

これにて完成。

下の写真のような感じになります。

もじはどの打ち方でも対応してると思います。

例外があったらすみません。

コード全文張っておきます

ぶっちゃけスパゲティコードなので誰かまとめてほしい。

代わりにリファクタリングしてほしい。

import sys 
import pygame 
import winsound
import random
from pygame.locals import *

#ローマ字の綴り辞書
string_dict = {
"あ":["a"], "い":["i","yi"], "う":["u","wu","whu"], "え":["e"], "お":["o"],
"か":["ka","ca"], "き":["ki"], "く":["ku","cu","qu"], "け":["ke"], "こ":["ko","co"],
"さ":["sa"],"し":["si","ci","shi"],"す":["su"],"せ":["se","ce"],"そ":["so"],
"た":["ta"],"ち":["ti","chi"],"つ":["tu","tsu"],"て":["te"],"と":["to"],
"な":["na"],"に":["ni"],"ぬ":["nu"],"ね":["ne"],"の":["no"],
"は":["ha"],"ひ":["hi"],"ふ":["hu","fu"],"へ":["he"],"ほ":["ho"],
"ま":["ma"],"み":["mi"],"む":["mu"],"め":["me"],"も":["mo"],
"や":["ya"],"ゆ":["yu"],"よ":["yo"],
"ら":["ra"],"り":["ri"],"る":["ru"],"れ":["re"],"ろ":["ro"],
"わ":["wa"],"を":["wo"],"ん":["n","n'","xn"],
"が":["ga"],"ぎ":["gi"],"ぐ":["gu"],"げ":["ge"],"ご":["go"],
"ざ":["za"],"じ":["zi","ji"],"ず":["zu"],"ぜ":["ze"],"ぞ":["zo"],
"だ":["da"],"ぢ":["di"],"づ":["du"],"で":["de"],"ど":["do"],
"ば":["ba"],"び":["bi"],"ぶ":["bu"],"べ":["be"],"ぼ":["bo"],
"ぱ":["pa"],"ぴ":["pi"],"ぷ":["pu"],"ぺ":["pe"],"ぽ":["po"],
"きゃ":["kya","kilya","kixya"],"きぃ":["kyi","kili","kixi","kilyi","kixyi"],"きゅ":["kyu","kilyu","kixyu"],"きぇ":["kye","kile","kixe","kilye","kixye"],"きょ":["kyo","kilyo","kixyo"],
"ぎゃ":["gya","gilya","gixya"],"ぎぃ":["gyi","gili","gixi","gilyi","gixyi"],"ぎゅ":["gyu","gilyu","gixyu"],"ぎぇ":["gye","gile","gixe","gilye","gixye"],"ぎょ":["gyo","gilyo","gi"],
"しゃ":["sya","sha",],"しぃ":["syi","sili","sixi","silyi","sixyi"],"しゅ":["syu","shu","silyu","sixyu"],"しぇ":["she","sye","sile","sixe","silye","sixye"],"しょ":["syo","sho","silyo","sixyo"],
"じゃ":["ja","zya","jya","zilya","zixya","jilya","jixya"],"じぃ":["zyi","jyi","zili","zixi","jili","jixi","zilyi","zixyi","jilyi","jixyi"],"じゅ":["zyu","ju","jyu"],"じぇ":["zye","je","jye"],"じょ":["zyo","jo","jyo"],
"ちゃ":["tya","cha","cya"],"ちぃ":["tyi","cyi"],"ちゅ":["tyu","chu","cyu"],"ちぇ":["tye","che","cye"],"ちょ":["tyo","cho","cyo"],
"にゃ":["nya"],"にぃ":["nyi"],"にゅ":["nyu"],"にぇ":["nye"],"にょ":["nyo"],
"ひゃ":["hya"],"ひぃ":["hyi"],"ひゅ":["hyu"],"ひぇ":["hye"],"ひょ":["hyo"],
"ふぁ":["fa","fwa"],"ふぃ":["fi","fwi","fyi"],"ふぅ":["fwu"],"ふぇ":["fe","fwe","fye"],"ふぉ":["fo","fwo"],
"くぁ":["qwa","qa","kwa"],"くぃ":["qwi","qi","qyi"],"くぅ":["qwu"],"くぇ":["qwe","qe","qye"],"くぉ":["qwo","qo"],
"ぐぁ":["gya"],"ぐぃ":["gyi"],"ぐぅ":["gyu"],"ぐぇ":["gye"],"ぐぉ":["gyo"],
"すぁ":["swa"],"すぃ":["swi"],"すぅ":["swu"],"すぇ":["swe"],"すぉ":["swo"],
"てゃ":["tha"],"てぃ":["thi"],"てゅ":["thu"],"てぇ":["the"],"てょ":["tho"],
"とぁ":["twa"],"とぃ":["twi"],"とぅ":["twu"],"とぇ":["twe"],"とぉ":["two"],
"ぢゃ":["dya"],"ぢぃ":["dyi"],"ぢゅ":["dyu"],"ぢぇ":["dye"],"ぢょ":["dyo"],
"でゃ":["dha"],"でぃ":["dhi"],"でゅ":["dhu"],"でぇ":["dhe"],"でょ":["dho"],
"どぁ":["dwa"],"どぃ":["dwi"],"どぅ":["dwu"],"どぇ":["dwe"],"どぉ":["dwo"],
"びゃ":["bya"],"びぃ":["byi"],"びゅ":["byu"],"びぇ":["bye"],"びょ":["byo"],
"ぴゃ":["pya"],"ぴぃ":["pyi"],"ぴゅ":["pyu"],"ぴぇ":["pye"],"ぴょ":["pyo"],
"りょ":["ryo"],"ょ":["lyo","xyo"],
"ー":["-"]," ":[" "],
"っ":["xtu","ltu","xtsu","ltsu"],
"ぁ":["xa","la"],
"ぇ":["xe","le"],
"ゃ":["lya","xya"],"ゅ":["xyu","lyu"],
"a":"a","b":"b","c":"c","d":"d","e":"e","f":"f","g":"g","h":"h","i":"i","j":"j","k":"k","l":"l","m":"m","n":"n",
"o":"o","p":"p","q":"q","r":"r","s":"s","t":"t","u":"u","v":"v","w":"w","x":"x","y":"y","z":"z",
"":""
} 

#単語辞
word_dict = {
"先物取引":"さきものとりひき",
"オプション取引":"おぷしょんとりひき",
"外国為替証拠金取引":"がいこくかわせしょうこきんとりひき",
"ネイサンの逆売り":"ねいさんのぎゃくうり",
"日銀砲":"にちぎんほう",
"普通銀行":"ふつうぎんこう",
"中央銀行":"ちゅうおうぎんこう",
"為替相場":"かわせそうば",
"金融派生商品":"きんゆうはせいしょうひん",
"デリバティブ取引":"でりばてぃぶとりひき",
"ベンチャーキャピタル":"べんちゃーきゃぴたる",
"投資ファンド":"とうしふぁんど",
"ヘッジファンド":"へっじふぁんど",
"変動金利":"へんどうきんり",
"固定金利":"こていきんり",
"インカムゲイン":"いんかむげいん",
"キャピタルゲイン":"きゃぴたるげいん",
"地政学リスク":"ちせいがくりすく",
"信託銀行":"しんたくぎんこう",
"レバレッジ":"ればれっじ",
"プライベートバンキング":"ぷらいべーとばんきんぐ",
"仮想通貨":"かそうつうか",
"アジア通貨危機":"あじあつうかきき",
"モーゲージ債":"もーげーじさい",
"既得権益":"きとくけんえき",
"不動産投資信託":"ふどうさんとうししんたく",
"上場投資信託":"じょうじょうとうししんたく",
"通貨スワップ":"つうかすわっぷ",
"高頻度取引":"こうひんどとりひき",
"ストックオプション":"すとっくおぷしょん",
"新規上場":"しんきじょうじょう",
"システムトレード":"しすてむとれーど",
}

aditional_dict = {}


def shuffledict(d):                            #↓↓↓  辞書型をシャッフルする関数(shuffledict)  ↓↓↓
     keys = list(d.keys())                     #辞書型(d)のキーをリスト(keys)に変換
     random.shuffle(keys)                      #キーリスト(keys)をシャッフル
     new_dict = [(key,d[key]) for key in keys] #キーリスト(keys)に対応するバリューを取り出し,新しい辞書(new_dict)を作成
     return dict(new_dict)                     #新しい辞書(new_dict)を返す


def dismessage(sf,msg,h):
     sysfont = pygame.font.SysFont("hg正楷書体pro", 50)###フォントの設定
     message  =sysfont.render(msg,True,(250,0,0)) ###文字の色
     message_rect = message.get_rect()###転送する領域
     message_rect.center = (350,h)###表示する位置
     sf.blit(message,message_rect)###上記の設定を反映させる
     pygame.display.update()###画面の更新

def startswith_list(w,l):               #↓↓↓  リストの前方一致を抽出(リスト型)する関数(startswith_list)  ↓↓↓
     match = []                         #前方一致リスト(match)
     for i in range(len(l)):            #リスト(l)の要素分繰り返す
         if l[i].startswith(w) == True: #文字(w)と前方一致する場合
             match.append(l[i])         #前方一致リスト(match)に加える
     return match                       #前方一致リスト(match)を返す


def kana_divide(kana):                     #↓↓↓  ひらがな(kana)を分割しリスト化する関数(kana_divide)  ↓↓↓
     kana_separate = []                    #分割されたひらがなリスト(kana-separate["あ","し","た"] ← kana"あした")
     ltu = ["a","i","u","e","o","n"]
     count = 1                             #小文字(string_small)の処理に使用
     judge = -1                            #「っ」の処理に使用

     for i in range(len(kana)):            #kanaの文字数分繰り返す
         if judge == i:                    #前回「っ」の処理をしていたら今回処理なし
             continue

         else:
             if i != 0 and kana[i-1] + kana[i] in string_dict:   #小文字の処理↓
                 b = kana_separate.pop(i-count)#ひとつ前の文字を削除
                 a = b + kana[i]   #ひとつ前の文字と合わせてリスト(kana_separate)に加える
                 kana_separate.append(a)
                 count += 1                #リストとiのずれを修正

             elif i != len(kana) - 1 and kana[i] == "っ" and string_dict[kana[i+1]][0][0] not in ltu:         #「っ」の処理↓
                 a = kana[i] + kana[i+1]   #次の文字と合わせてリスト(kana_separate)に加える
                 kana_separate.append(a)
                 judge = i+1               #次の処理を飛ばす判定に使用
                 count += 1                #リストとiずれを修正

             else :                        #通常の処理↓
                 a = kana[i]               #そのままリスト(kana_separate)に加える
                 kana_separate.append(a)

     return kana_separate                  #分割されたひらがなリスト(kana_separate)を返す


def kana_into_romaji(kana_separate):                                 #↓↓↓  分割されたひらがなリスト(kana_separate)をローマ字に変換する関数(kana_into_romaji)  ↓↓↓
     romaji_separate = []                                            #分割されたローマ字リスト(romaji_separate["a","si","ta"] ← kana_separate["あ","し","た"])
     judge = -1                                                      #「ん」の判定に使用
     nn = ["a","i","u","e","o","y","n"]                              #「ん」をnnで打たなければならない処理の判別
     aditional_list = []
     
     for i in range(len(kana_separate)):                             #分割されたひらがなリスト(kana_separate)の要素分繰り返す

         if kana_separate[i] in string_dict:
             romaji_separate.append(string_dict[kana_separate[i]][0])#綴り辞書(string_dict)から一つ目の打ち方をリスト(romaji_separate)に加える

         elif kana_separate[i] in aditional_dict:
             romaji_separate.append(aditional_dict[kana_separate[i]][0])

         else :
             string_list = string_dict[kana_separate[i][1:]]
             for j in range(len(string_list)):
                 a = string_list[j][0] + string_list[j]
                 aditional_list.append(a)
             aditional_dict[kana_separate[i]] = aditional_list
             aditional_list = []
             if len(kana_separate[i]) == 3:
                 string_list = string_dict[kana_separate[i][1]]
                 for k in range(len(string_list)):
                     a = string_list[k][0] + string_list[k]
                     aditional_list.append(a)
                 aditional_dict[kana_separate[i][:2]] = aditional_list
                 aditional_list = []
             romaji_separate.append(aditional_dict[kana_separate[i]][0])

         if judge == i and romaji_separate[i][0] in nn:
             romaji_separate[i-1] = "nn"

         if kana_separate[i] == "ん":
             judge = i + 1

             if i == len(kana_separate) - 1:
                 romaji_separate[i] = "nn"

     return romaji_separate, aditional_dict



def run_game(): #↓↓↓  ゲームのプログラム実行  ↓↓↓
     
     #↓↓↓  ゲームの準備(変数の定義など)  ↓↓↓
     pygame.font.init()
     
     clock = pygame.time.Clock() 
     counter = 63
     pygame.time.set_timer(pygame.USEREVENT, 1000) 
     
     font_1 = pygame.font.SysFont(None, 38)           #ローマ字に使うフォント設定(font_1)
     font_2 = pygame.font.SysFont("hg正楷書体pro", 50) #単語に使うフォント設定(font_2)
     font_3 = pygame.font.SysFont("hg正楷書体pro", 40) #タイトルや次の単語に使うフォント設定(font_3)


     word_dict_r = shuffledict(word_dict) #ランダムな単語辞書を作成(word_dict_r)

     word_list = [] #単語リストを作成
     for i in word_dict_r.keys():
         word_list.append(i)

     nextword_list = [] #次の単語リストを作成
     for i in word_dict_r.keys():
         nextword_list.append(i)
     x = ""
     nextword_list.append(x)
     del nextword_list[0]

     kana_list = [] #ひらがなリストを作成
     for i in word_dict_r.values():
         kana_list.append(i)


     word = word_list.pop(0)         #最初の単語(word)を単語リスト(word_list)から取得&削除
     nextword = nextword_list.pop(0) #最初の'次の単語'(nextword)を次の単語リスト(nextword_list)から取得&削除
     kana = kana_list.pop(0)         #最初のひらがな(kana)をひらがなリスト(kana_list)から取得&削除


     kana_separate = kana_divide(kana)                 #分割されたひらがなリスト(kana_separate)を作成(kana-separate["あ","し","た"] ← kana"あした")
     romaji_separate, aditional_dict = kana_into_romaji(kana_separate) #分割されたローマ字リスト(romaji_separate)を作成(romaji_separate["a","si","ta"] ← kana_separate["あ","し","た"])

     
     kana_first = kana_separate.pop(0)
     romaji_first = romaji_separate.pop(0)          #分割されたローマ字リスト(romaji_separate)の1番目を取得&削除(romaji_first"a" ← romaji_separate["ki","ta"])
     romaji_after_second = "".join(romaji_separate) #残りのローマ字リスト(romaji_separate)を文字列に変換(romaji_after_second"kita" ← romaji_separate["ki","ta"])
     
     
     finish_type = "" #打ち終わったタイプ(finish_type)
     judge_type = ""  #別の綴りの判別に使用
     judge_n = "0"    #nnの判定に使用(前の文字の綴りが"n"のときもう一度"n"を打っても正解)


     count_c = 0         #正しいタイプ数のカウント(count_c)
     count_m = 0         #ミスタイプ数のカウント(count_m)
        
     #↓↓↓  ゲームの画面設定&表示  ↓↓↓
     pygame.init() #初期化
     screen = pygame.display.set_mode((720, 480)) #画面のサイズ
     screen.fill((250,250,250))
     romaji = romaji_first + romaji_after_second                                    #1単語分のローマ字(ローマ字を中心に表示させるために使用)
     sf_romaji = font_1.render(romaji, True, (0, 0, 0))                             #1単語分のローマ字のフォント設定(ローマ字を中心に表示させるために使用)
     center_x_romaji = screen.get_rect().width / 2 - sf_romaji.get_rect().width / 2 #ローマ字を中心に表示させるx座標

     surface = pygame.display.get_surface()

     for i in range(3,0,-1):
          dismessage(surface,str(i),200)###カウントダウンを3秒間
          screen.fill((250,250,250))###画面の更新
          pygame.time.delay(1000)###一秒まつ

    

     running = True
    
  
     while running: 

         screen.fill((250,250,250))
         sf_word = font_2.render(word, True, (0, 0, 0))
         center_x_word = screen.get_rect().width / 2 - sf_word.get_rect().width / 2 #中心に表示させるx座標
         length  =  sf_word.get_rect().width + 100
         pygame.draw.rect(screen,(175,150,0), (center_x_word-50 ,154,length,95))
         sf_romaji_1 = font_1.render(finish_type, True, (150, 150, 150))   #打ち終わったタイプ(finish_type)のフォント設定(sf_romaji)
         sf_romaji_2 = font_1.render(romaji_first, True, (250,0,0))        #1文字目のローマ字(romaji_first)のフォント設定(sf_romaji_2)
         sf_romaji_3 = font_1.render(romaji_after_second, True, (250,0,0)) #2文字目以降のローマ字(romaji_after_second)のフォント設定(sf_romaji_3)
         screen.blit(sf_romaji_1, (center_x_romaji, 160))                                                               #打ち終わったタイプ(finish_type)を表示
         screen.blit(sf_romaji_2, (center_x_romaji + sf_romaji_1.get_rect().width, 160))                                #1文字目のローマ字(romaji_first)を表示
         screen.blit(sf_romaji_3, (center_x_romaji + sf_romaji_1.get_rect().width + sf_romaji_2.get_rect().width, 160)) #2文字目以降のローマ字(romaji_after_second)を表示
         screen.blit(sf_word,(center_x_word,185))                                   #単語(word)を表示
         sf_nextword = font_3.render("next"+nextword, True, (250, 250, 250)) #次の単語(nextword)のフォント設定(sf_nextword)
         length  =  sf_nextword.get_rect().width+10
         pygame.draw.rect(screen,(30,30,30), ( 150,260,length,50)) 
         screen.blit(sf_nextword, (150, 260))                           #次の単語(nextword)を表示    
        
         #↓↓↓  ゲームのプログラム本体  ↓↓↓
         for event in pygame.event.get():
             if event.type == pygame.QUIT: #closeボタンが押された時の処理
                 sys.exit(0)                #ウィンドウを閉じ

             if event.type == pygame.KEYDOWN:  #キーボードが押された場合の処理
                 if event.key == K_ESCAPE:
                     running = False
                 finish_type += chr(event.key) #打ち終わったタイプ(finish_type)に加える("a" + "k") 上限1単語
                 judge_type += chr(event.key)  #別の綴り判断に使用("s" + "h") 上限

                 
                 if chr(event.key) == romaji_first[0]: #表示と同じタイプをした場合の処理
                     romaji_first = romaji_first[1:]   #1文字目のローマ字の打ち終わったタイプを消す('i' ← 'ki')
                     count_c += 1                      #正しいタイプ数+1

                 elif judge_n == "1" and chr(event.key) == "n": #前の文字の綴りが"n" and "n"をタイプした場合の処理↓
                     count_c += 1                               #正しいタイプ数+1
                     judge_type = ""

                     
                 else :                                                                #表示と異なるタイプをした場合の処理
                     if kana_first in string_dict:
                         string_list = string_dict[kana_first]                       #タイプしている平仮名(kana_first)のすべての綴りを綴り辞書(string_dict)から取得(string_list["syu","shu","sixyu","silyu"])
                     else :
                         string_list = aditional_dict[kana_first]
                     different_type_list = startswith_list(judge_type, string_list) #綴りリスト(string_list)から今のタイプ(judge_type)と一致するものを取り出す(different_type_list["sixyu","silyu"] ← judge_type"si")


                     if different_type_list != []:                               #一致する綴り(different_type_list)がある場合の処理↓
                         romaji_first = different_type_list[0][len(judge_type):] #ローマ字の変更('hu' → 'xyu')

                     elif len(kana_first) >= 2:
                         string_list = string_dict[kana_first[0]]
                         different_type_list = startswith_list(judge_type, string_list)
                        

                         if different_type_list != []:
                            
                             kana_second = kana_first[1:]
                             kana_first = kana_first[0]
                             kana_separate.insert(0, kana_second)
                             romaji_first = different_type_list[0][len(judge_type):]
                             romaji_second = string_dict[kana_second][0]
                             romaji_separate.insert(0, romaji_second)
                             romaji_after_second = "".join(romaji_separate)

                         elif len(kana_first) ==3:
                             string_list = aditional_dict[kana_first[:2]]
                             different_type_list = startswith_list(judge_type, string_list)
                             if different_type_list != []:

                                 kana_second = kana_first[3]
                                 kana_first = kana_first[:2]
                                 kana_separate.insert(0, kana_second)
                                 romaji_first = different_type_list[0][len(judge_type):]
                                 romaji_second = string_dict[kana_second][0]
                                 romaji_separate.insert(0, romaji_second)
                                 romaji_after_second = "".join(romaji_separate)

                             else :
                                 finish_type = finish_type[:-1]        #今回のタイプを消す
                                 judge_type = judge_type[:-1]          #今回のタイプを消す
                                 count_m += 1                          #ミスタイプの数+1
                                 count_c -=1
                              
                         else :
                             finish_type = finish_type[:-1]        #今回のタイプを消す
                             judge_type = judge_type[:-1]          #今回のタイプを消す
                             count_m += 1                          #ミスタイプの数+
                             count_c -=1


                     
                     else :                                    #ミスタイプの場合の処理
                         finish_type = finish_type[:-1]        #今回のタイプを消す
                         judge_type = judge_type[:-1]          #今回のタイプを消す
                         count_m += 1                          #ミスタイプの数+1
          


                     
                 judge_n = "0"

                 if romaji_first == "":

                     if romaji_separate == []:

                         if kana_list == []:         #すべての単語を打ち終わった場合の処理↓
                             pygame.init()           #初期化
                             
                         else :                                                #一つの単語を打ち終わった場合の処理↓
                             word = word_list.pop(0)                           #単語(word)を変更
                             nextword = nextword_list.pop(0)                   #次の単語(nextword)を変更
                             kana = kana_list.pop(0)                           #ひらがな(kana)を変更
                             kana_separate = kana_divide(kana)                 #分割されたひらがなリスト(kana_separate)を作成
                             romaji_separate, aditional_dict = kana_into_romaji(kana_separate) #分割されたローマ字リスト(romaji_separate)を作成
                             kana_first = kana_separate.pop(0)                         
                             romaji_first = romaji_separate.pop(0)             #最初の平仮名のローマ字を用意(romaji_first)
                             romaji_after_second = "".join(romaji_separate)    #残りのローマ字リスト(romaji_separate)を文字列に変換(romaji_after_second)
                             finish_type = ""                                  #打ち終わったタイプ(1単語分)を初期化
                             judge_type = ""                                   #打ち終わったタイプ(1文字分)を初期化
                             romaji = romaji_first + romaji_after_second                                    #1単語分のローマ字(ローマ字を中心に表示させるために使用)
                             sf_romaji = font_1.render(romaji, True, (0, 0, 0))                             #1単語分のローマ字のフォント設定(ローマ字を中心に表示させるために使用)
                             center_x_romaji = screen.get_rect().width / 2 - sf_romaji.get_rect().width / 2 #ローマ字を中心に表示させるx座標

                     else :                                             #平仮名1文字分のローマ字を打ち終わった場合の処理↓
                         kana_first = kana_separate.pop(0)
                         romaji_first = romaji_separate.pop(0)          #次の平仮名のローマ字を用意(romaji_first)
                         romaji_after_second = "".join(romaji_separate) #残りのローマ字リスト(romaji_separate)を文字列に変換(romaji_after_second)
                         if judge_type == "n":                          #綴りが"n"だった場合の処理↓
                             judge_n = "1"                              #judge_n ON
                         else :                                         #綴りが"n"以外だった場合の処理↓
                             judge_n = "0"                              #judge_n OFF
                         judge_type = ""                                #打ち終わったタイプ(1文字分)を初期


             if event.type == pygame.USEREVENT: 
                counter -= 1    
                if counter == 0 :
                     a = True
                     while a :

                        pygame.init()  ###画面の初期
                        screen.fill((0,0,0))
                    
                        
                        if count_c == 0:
                            if count_m ==0:
                                corect_rate = 0
                        else :
                            corect_rate = round((count_c / (count_c + count_m))*100,1)###正答率の表示
                            
                        spead = round((count_c / time),2)

                        screen.blit(font_3.render("{}回".format(count_c), True, (100,0,0)), (430,140))
                        screen.blit(font_3.render("{}回".format(count_m), True,(100,0,0)),(430,185)) 
                        screen.blit(font_3.render("{}%".format(corect_rate), True,(100,0,0)),(430,230))
                        screen.blit(font_3.render("{}回".format(spead), True,(100,0,0)),(430,275)) 

                        
                        for event in pygame.event.get():
                            if event.type == pygame.KEYDOWN:
                                if event.key == K_ESCAPE:
                                    a = False
                                    running = False
                                  

                        pygame.display.update()


         else :
               pygame.draw.rect(screen,(180,40,0), ( 388,28,counter*5,40))
               screen.blit(font_1.render(str(counter),True,(250,0,0)),(200,40))
               pygame.display.flip()
               clock.tick(60) 
               

if __name__ =="__main__":
     run_game()
     

感想

疲れました。

ここからの公開に私は心が折れたので、pythonistの活躍に期待します。

コメントを残す

メールアドレスが公開されることはありません。 * が付いている欄は必須項目です