1
00:00:04,290 --> 00:00:05,650
‫やあ､ お帰りなさい｡

2
00:00:05,670 --> 00:00:09,900
‫このビデオでは､ 勝ち負けの条件に拘っています｡

3
00:00:10,320 --> 00:00:14,520
‫このゲーム企画で扱うのは最後の一つです｡

4
00:00:14,550 --> 00:00:16,860
‫では､ セクションプランを見てみましょう｡

5
00:00:16,860 --> 00:00:26,580
‫さて､ セクションプランの最初の5項目はすでにチェック済みで､ 最後の2項目は特殊効果と勝敗条件です｡

6
00:00:26,580 --> 00:00:32,250
‫この2つを入れ替えて､ 勝利条件と敗北条件を処理したいと思います｡ これは､ ゲームプレイのプログラミングロジックがこれで終わり､

7
00:00:32,250 --> 00:00:42,420
‫特殊効果は化粧品で､ 仕上げに近いものなので､ 最後の最後で処理できるようにします｡

8
00:00:42,420 --> 00:00:49,950
‫そこで､ このビデオでは､ ゲームの勝敗を知るためのゲームオーバー関数を作成します｡

9
00:00:49,950 --> 00:00:55,410
‫そして､ ゲームに勝つためには､ 世界のタワーの数を数える必要があります｡ すべてのタワーを破壊すれば､

10
00:00:55,410 --> 00:00:59,730
‫ゲームに勝ったことがわかるからです｡

11
00:00:59,730 --> 00:01:05,670
‫そして､ 戦車そのものが破壊されたら､ それを負け条件と考えればいいのです｡

12
00:01:05,670 --> 00:01:12,540
‫ゲームモードに戻り､ まず最初に行うのは､ 別のブループリント実装可能なイベントを作成することです｡

13
00:01:12,570 --> 00:01:20,520
‫このゲーム開始関数は､ C++から呼び出すことができますが､ そのロジックをゲームモードで実装しています｡

14
00:01:20,520 --> 00:01:27,720
‫ブループリント ブループリントの実装可能イベントのおかげで､ ゲームに負けた時のためにもう一つ作りたいと思います｡

15
00:01:27,720 --> 00:01:31,530
‫そこで､ Game Overというvoid関数を作ってみます｡

16
00:01:31,530 --> 00:01:37,530
‫そして今回は､ B one gameというブーリアン入力パラメータを取りたいと思います｡

17
00:01:37,530 --> 00:01:43,020
‫この関数で処理したいのは､ ゲームに負けたか勝ったかを表示することだけなので､

18
00:01:43,020 --> 00:01:50,130
‫もちろんこれはブループリントで実装可能なイベントとなります｡

19
00:01:50,130 --> 00:01:52,410
‫そこで､ ゲームオーバー機能を搭載しています｡

20
00:01:52,410 --> 00:01:55,350
‫さて､ この関数をいつ呼び出すべきかを知っておく必要があります｡

21
00:01:55,350 --> 00:02:02,550
‫まず､ ゲームに負けたときにこの関数を呼び出すことができるのは分かっています｡

22
00:02:02,550 --> 00:02:10,050
‫そして､ 死んだアクターが戦車の場合､ 戦車の破壊を処理し､ 有効な状態を

23
00:02:10,050 --> 00:02:16,680
‫false に設定していることがわかります｡

24
00:02:16,710 --> 00:02:25,020
‫もうひとつ､ ここでできることは､ 単純にゲームオーバーを呼び出してゲームを終了させることです｡ このブーリアンには､ 1つのゲームとして､

25
00:02:25,020 --> 00:02:27,240
‫falseを渡すことができます｡

26
00:02:27,240 --> 00:02:31,770
‫これで少なくともC++側からは､ ゲームに負ける心配はなくなったわけです｡

27
00:02:31,800 --> 00:02:34,770
‫あとは､ どのタイミングで勝負をかけるか｡

28
00:02:34,800 --> 00:02:36,540
‫さて､ ここで俳優が一人亡くなりました｡

29
00:02:36,540 --> 00:02:43,050
‫死んだアクターを塔に投じることができれば､ 塔を破壊したことがわかる｡

30
00:02:43,050 --> 00:02:53,220
‫さて､ ここでタワーの数を更新したり､ 世界に現在いくつのタワーがあるのかを記録する整数型の変数を更新するのに最適な場所と言えるでしょう｡

31
00:02:53,250 --> 00:02:53,580
‫今すぐ

32
00:02:53,580 --> 00:03:02,250
‫そのためには､ タワーの数を記録する変数が必要なので､ Hファイルのここにプライベート変数を追加します｡

33
00:03:02,250 --> 00:03:03,960
‫そして､ この地でそれを実現したい｡

34
00:03:03,960 --> 00:03:08,880
‫そこで､ INT 32を作成し､ これをターゲット・タワーと呼ぶことにします｡

35
00:03:09,120 --> 00:03:17,760
‫ここで､ この値をすぐにゼロに初期化することができますが､ タワーの数が減少するにつれて､ これを更新する必要があります｡

36
00:03:17,760 --> 00:03:22,350
‫そして､ これを世界に存在するタワーの数に設定する必要もあります｡

37
00:03:22,470 --> 00:03:28,170
‫さて､ これを4つにハードコードすることもできますが､ レベルにタワーを追加し始めたらどうなるでしょうか？

38
00:03:28,170 --> 00:03:30,690
‫まあ､ そうなると､ ちょっとややこしいんですけどね｡

39
00:03:30,690 --> 00:03:35,580
‫そこで､ 代わりにやってみたいのが､ 世界にいくつの塔があるかということです｡

40
00:03:35,610 --> 00:03:43,050
‫さて､ このために32を返す関数を作ると､ この関数は世界にいくつの塔があるか調べて､

41
00:03:43,050 --> 00:03:45,810
‫その数を返すことができます｡

42
00:03:45,810 --> 00:03:51,450
‫そこで､ この関数を呼び出して､ ターゲットタワーの数を取得することにします｡

43
00:03:51,600 --> 00:03:55,650
‫では､ この関数にCPファイル内でボディを与えてみましょう｡

44
00:03:55,680 --> 00:04:05,040
‫一番下まで降りていって､ 関数本体を作成します｡ 関数名の前にクラス名を入れるのを忘れないようにします｡

45
00:04:05,040 --> 00:04:13,170
‫さて､ これでエンド32を返しますが､ タワーの数をどうやって調べるか決めなければなりません｡

46
00:04:13,200 --> 00:04:19,800
‫さて､ ゲームプレイのスタティックには､ Get All Actors of classという関数が存在します｡

47
00:04:19,800 --> 00:04:21,300
‫以下はそのドキュメントです｡

48
00:04:21,300 --> 00:04:25,770
‫指定したクラスのワールドにいるすべてのアクターを探すと書いてあります｡

49
00:04:25,770 --> 00:04:28,890
‫そこで､ 特定のクラスを指定する必要があります｡

50
00:04:28,920 --> 00:04:31,530
‫さて､ この関数は3つの入力を持つ｡

51
00:04:31,530 --> 00:04:33,720
‫1つ目は､ ワールドコンテキストオブジェクトです｡

52
00:04:33,720 --> 00:04:34,770
‫それは簡単なことです｡

53
00:04:34,770 --> 00:04:36,180
‫私たちはその扱い方を知っています｡

54
00:04:36,180 --> 00:04:41,610
‫しかし､ 次にアクターのPTサブクラスがあり､ これはアクタークラスと呼ばれています｡

55
00:04:41,610 --> 00:04:49,740
‫さて､ PTのサブクラスを必要とする関数は､ 入力としてuクラスを受け入れることができ､ 3番目のパラメータはT配列であることを見てきました｡

56
00:04:49,770 --> 00:05:03,680
‫アクターポインターの配列が必要ですが､ これは参照として渡され､ const参照ではないので､ この関数がactという入力パラメータを変更する可能性があることを示唆しているように思えます｡

57
00:05:03,730 --> 00:05:08,530
‫ここにもヒントがあります｡ それは､ 俳優を呼んでいることです｡

58
00:05:08,530 --> 00:05:18,220
‫これはアウトパラメータで､ 関数を呼び出した後に､ 関数によって入れられた値を持つという意味です｡

59
00:05:18,220 --> 00:05:21,340
‫つまり､ 関数の出力のようなものと考えることができます｡

60
00:05:21,340 --> 00:05:30,640
‫ここで､ パラメータとして､ アクタークラス（検索するアクターのクラス）を指定しなければ､ 結果配列は空になると書かれています｡

61
00:05:30,640 --> 00:05:37,240
‫すべてのタワーを見つけたいので､ out actors は指定されたクラスのアクターの出力配列です｡

62
00:05:37,240 --> 00:05:48,160
‫つまり､ この関数を呼び出して配列を渡すと､ 関数が終了したときに､ その配列には指定したクラスの世界のすべてのアクターへのポインタが含まれることになるのです｡

63
00:05:48,160 --> 00:05:51,880
‫つまり､ この関数はワールドコンテキストオブジェクトを必要とすることがわかります｡

64
00:05:51,880 --> 00:05:56,500
‫さて､ ゲームモード内からこれを呼び出すのであれば､ 次にこれを渡せばよい｡

65
00:05:56,500 --> 00:06:03,490
‫Aアクタを指定するPTサブクラスが必要で､ これが新しいクラスポインタになりうることが分かっている｡

66
00:06:03,490 --> 00:06:06,070
‫ここで､ 検索するクラスを指定する必要があります｡

67
00:06:06,070 --> 00:06:12,010
‫アクターを指定すると､ 世界の各アクターへのポインターで満たされた大きな配列が得られます｡

68
00:06:12,010 --> 00:06:13,810
‫でも､ 役者は全員必要ない｡

69
00:06:13,810 --> 00:06:23,290
‫タワーが必要なだけなので､ タワーの静的クラスを使用して､ A Tower C++ クラスを表す新しいクラスを返します｡

70
00:06:23,290 --> 00:06:26,770
‫さて､ 3番目のパラメータは､ アクターポインタのT配列です｡

71
00:06:26,770 --> 00:06:35,980
‫そこで､ 角括弧の中にアクターポインターを指定したT配列型のローカル変数を作成すれば､ ゲームプレイのスタティックが呼び出せます｡

72
00:06:36,010 --> 00:06:41,620
‫これら 3 つの入力を渡すクラスのすべてのアクターを取得します｡ このアクションの結果､ towers

73
00:06:41,620 --> 00:06:45,970
‫配列にワールド内のすべてのタワーへのポインタが含まれることになります｡

74
00:06:45,970 --> 00:06:53,830
‫トレイは､ 同じ型を共有する要素であれば､ いくつでも格納できる素敵なコンテナ・クラスです｡

75
00:06:53,830 --> 00:07:01,690
‫そして､ このクラスには､ トレイにアイテムを収納する際に使える機能がかなり充実しています｡

76
00:07:01,720 --> 00:07:08,710
‫さて､ これからずっと下にスクロールして､ Numという関数をお見せします｡ 短い4つの数字で､

77
00:07:08,830 --> 00:07:12,310
‫配列の要素数を返すと書いてあります｡

78
00:07:12,310 --> 00:07:20,380
‫そこで､ この関数を使って､ 世界中の塔が揃った時点で配列の要素数を求めることができます｡

79
00:07:20,380 --> 00:07:26,080
‫そこで､ Towerのnumを呼び出せば､ これを関数の戻り値として使うことができる｡

80
00:07:26,080 --> 00:07:31,930
‫そして､ この関数の戻り値を get target tower count と呼び､ n 32 とすることで､

81
00:07:31,930 --> 00:07:35,980
‫タワーの配列の要素数を返すことができることを確認しました｡

82
00:07:35,980 --> 00:07:41,230
‫そこで､ このターゲットタワーの数を取得する機能の実装に挑戦してみたいと思います｡

83
00:07:41,230 --> 00:07:44,710
‫そこで､ A actor 型のローカル t 配列を作成します｡

84
00:07:44,710 --> 00:07:47,110
‫タワーと呼んでもいいし､ 何でもいいんです｡

85
00:07:47,110 --> 00:07:54,220
‫今､ あなたはゲーム､ 再生静的関数を使用し､ クラスのすべてのアクタを取得し､ 正しい入力パラメータを渡すことを確認してください｡

86
00:07:54,220 --> 00:08:00,310
‫この関数を呼び出すと､ トレイにはワールド内のすべてのタワーへのポインタが格納されるので､

87
00:08:00,310 --> 00:08:07,930
‫トレイクラスに属する num 関数を使ってタワーの数を返すだけでよいのです｡

88
00:08:07,930 --> 00:08:10,660
‫だから､ ビデオを一時停止して､ 実行してください｡

89
00:08:10,660 --> 00:08:12,640
‫今すぐターゲットタワーのカウントを取得

90
00:08:15,670 --> 00:08:16,000
‫なるほど｡

91
00:08:16,000 --> 00:08:17,980
‫そこで､ 目標塔数を設定します｡

92
00:08:18,010 --> 00:08:24,250
‫さて､ まず最初に､ この配列に格納する要素のタイプとしてアクターポインターを指定して､

93
00:08:24,250 --> 00:08:26,590
‫ローカルなt配列を作成します｡

94
00:08:26,590 --> 00:08:33,100
‫そして､ これからこの塔を呼び出すのですが､ ゲームプレイの静止画を呼び出す必要があるので､ そのヘッダが含まれていることを確認する必要があります｡

95
00:08:33,130 --> 00:08:39,340
‫今は､ 他の機能でも使っているからそうなんだろうけど､ 確認はしておいた方がいいと思う｡

96
00:08:39,370 --> 00:08:47,380
‫次に､ ゲームプレイの静止画を使って､ クラスのすべてのアクターを取得することを呼び出します｡

97
00:08:47,410 --> 00:08:55,990
‫さて､ 最初の入力はワールドコンテキストオブジェクトで､ これを渡します｡ 次はアクタークラスを表すサブクラスです｡

98
00:08:55,990 --> 00:09:04,270
‫そして､ 塔の静的クラスを使えば､ 塔のクラスを表すUクラスが返ってくるという話をしました｡

99
00:09:04,300 --> 00:09:09,190
‫今一度､ タワーが含まれているかどうかを確認するのは良い考えだと思います｡

100
00:09:09,220 --> 00:09:14,740
‫さて､ 最後の3つ目のパラメータはトレイになるので､ タワーを渡すことができます｡

101
00:09:14,740 --> 00:09:21,880
‫そのため､ この関数を呼び出すと､ towerには世界中のすべてのタワーへのポインタが含まれるようになる｡

102
00:09:21,880 --> 00:09:28,000
‫実際､ towerから派生したクラスのオブジェクトが存在すれば､ それらも取得することになる｡

103
00:09:28,000 --> 00:09:33,780
‫つまり､ tower配列があるので､ 単純にその配列の要素数を返せばいいわけです｡

104
00:09:33,790 --> 00:09:40,660
‫そこで､ returnステートメントを使って､ towers dot numを使い､ ターゲットのタワー数を取得することにします｡

105
00:09:40,660 --> 00:09:41,740
‫だから､ これはすごいことなんです｡

106
00:09:41,740 --> 00:09:49,090
‫これを利用して､ ターゲットタワーと呼ぶ塔の数を初期化し､ ゲームを開始するときに行うことができます｡

107
00:09:49,090 --> 00:09:51,780
‫だから､ それをここに置いて､ ゲームスタートの処理をするんです｡

108
00:09:51,790 --> 00:09:54,400
‫むしろ､ それを一番最初にやってほしい｡

109
00:09:54,400 --> 00:10:02,530
‫そこで､ target towersを取り出し､ get target tower countの戻り値と等しくなるように設定します｡

110
00:10:02,560 --> 00:10:07,240
‫ここで､ target towersは､ 我々の世界のタワーの数で初期化される必要があります｡

111
00:10:07,240 --> 00:10:13,120
‫これは素晴らしいことですが､ 塔が死ぬたびにこのカウントを更新する必要があります｡ つまり､

112
00:10:13,120 --> 00:10:16,000
‫アクターが死んだ関数に行く必要があります｡

113
00:10:16,000 --> 00:10:22,660
‫ここで､ 死んだアクターを破壊されたタワーにキャストした場合､ 破壊を処理した後､ target towers変数を更新して､

114
00:10:22,660 --> 00:10:30,430
‫target towersと言い､ decrimment演算子を使用できるようにします｡

115
00:10:30,430 --> 00:10:35,560
‫ポストデクリメント演算子とプレディクティブ演算子のどちらかを使うことができる｡

116
00:10:35,560 --> 00:10:41,800
‫どちらも､ ターゲットのタワーを取って､ そこから1つ引くという同じ行動になります｡

117
00:10:41,800 --> 00:10:49,660
‫さて､ ターゲットタワーから1を引くと同時に､ 今度はターゲットタワーが0になったかどうかを確認する必要があります｡

118
00:10:49,660 --> 00:10:55,150
‫そこで､ ここにターゲット・タワーがゼロになったかどうかのifチェックを入れてみます｡

119
00:10:55,780 --> 00:11:02,380
‫さて､ そうなったらすぐにゲームが終わるはずなので､ すべてのタワーを破壊したので､

120
00:11:02,710 --> 00:11:10,660
‫真の4b1ゲームのゲームオーバー関数の受け渡しを呼び出し､ これを勝利と見なすことができます｡

121
00:11:10,660 --> 00:11:13,180
‫では､ 早速コードをコンパイルしてみましょう｡

122
00:11:13,180 --> 00:11:19,420
‫さて､ このビデオを終える前に､ エディタでゲームモードブルーペイントを作成したいと思います｡

123
00:11:19,420 --> 00:11:21,040
‫そこで､ ビープチューンです｡

124
00:11:21,040 --> 00:11:24,400
‫ゲームモードと､ このイベントスタートゲームに感謝しています｡

125
00:11:24,400 --> 00:11:31,780
‫そして､ ゲーム開始ウィジェットを作成し､ ビューポートに追加して､ ゲーム開始のカウントダウン・タイマーを見ることができるようにしているところです｡

126
00:11:31,780 --> 00:11:39,820
‫つまり､ start game が呼び出されることは分かっていますが､ game over blueprint の実装可能なイベントも実装する必要があります｡

127
00:11:39,820 --> 00:11:47,260
‫右クリックして､ game overと入力すると､ これが私たちのイベント､ game overです｡

128
00:11:47,290 --> 00:11:50,860
‫このゲームは1つで､ ブール値であることに注意してください｡

129
00:11:50,860 --> 00:11:57,220
‫つまり､ C++からこの関数を呼び出すと､ B1ゲームのブール値が渡されるわけです｡

130
00:11:57,220 --> 00:12:05,440
‫ブループリントのイベントノードでは､ 小文字のBが取り除かれ､ 1 と game の間にスペースが置かれます（これは､ ある種の礼儀です）｡

131
00:12:05,440 --> 00:12:11,650
‫これからウィジェットをいくつか作成して､ ゲームの勝ち負けを確認できるようにしますが､ それは今後のビデオで紹介します｡

132
00:12:11,650 --> 00:12:17,770
‫とりあえず､ これが呼び出されて正しく呼び出されたことを確認したいので､ print stringノードでそれを行い､

133
00:12:17,770 --> 00:12:22,180
‫このbooleanに基づいた値を表示することができます｡

134
00:12:22,180 --> 00:12:30,280
‫このbooleanをそのまま文字列入力にクリック＆ドラッグすると､ booleanを文字列に変換する項目があることがわかる｡

135
00:12:30,280 --> 00:12:44,350
‫これもブール値を文字列に変換してくれる便利な変換ノードで､ その機能は､ ブール値の真偽値に基づいてtrueやfalseという言葉に変換するものである｡

136
00:12:44,710 --> 00:12:46,120
‫では､ これをテストしてみてはどうだろう｡

137
00:12:46,120 --> 00:12:48,040
‫コンパイルして､ 再生を押してみる｡

138
00:12:49,400 --> 00:12:52,570
‫よし､ これで試合に勝てるようになったぞ｡

139
00:12:52,580 --> 00:12:55,340
‫その前に負けることがないようにと願っています｡

140
00:12:55,430 --> 00:13:01,430
‫そして､ 私はゲームに負け､ 画面左上にfalseがプリントアップされているのが見えます｡

141
00:13:01,430 --> 00:13:12,050
‫つまり､ ゲームに負けるとfalseが渡された状態でイベントgame overが呼ばれることがわかったので､ ゲームに勝ったらtrueが渡されるようにする必要があるのです｡

142
00:13:12,050 --> 00:13:14,900
‫では､ すべてのタレットを倒してみましょう｡

143
00:13:15,380 --> 00:13:18,020
‫だから､ 本当に当たらないようにしないといけないんです｡

144
00:13:18,020 --> 00:13:19,250
‫あ､ もうやられちゃいました｡

145
00:13:19,910 --> 00:13:21,560
‫これはかなりチャレンジングなことです｡

146
00:13:22,840 --> 00:13:24,820
‫そして､ そこに行く｡

147
00:13:24,820 --> 00:13:28,720
‫そして､ 画面左上にはtrueがプリントされています｡

148
00:13:28,750 --> 00:13:31,600
‫数秒しか表示されないので､ 見逃してしまうかもしれません｡

149
00:13:31,630 --> 00:13:32,350
‫なるほど､ 素晴らしい｡

150
00:13:32,350 --> 00:13:35,050
‫だから､ 今は勝ち組と負け組の条件があるんです｡

151
00:13:35,080 --> 00:13:42,850
‫次のステップは､ print stringノードに依存しないように､ これを実際にウィジェットの形で画面に表示することです｡

152
00:13:42,880 --> 00:13:53,890
‫あとは､ 勝敗を知らせるウィジェットの作成などです｡

153
00:13:53,890 --> 00:13:58,900
‫また､ トレイとゲームプレイのスタティック機能を使って､ タワーの数を数えました｡

154
00:13:58,930 --> 00:14:00,600
‫クラスの全アクターを取得する｡

155
00:14:00,610 --> 00:14:01,270
‫素晴らしい仕事です｡

156
00:14:01,270 --> 00:14:03,370
‫このゲームは本当によくできている｡

157
00:14:03,370 --> 00:14:10,840
‫次のビデオでは､ これらのウィジェットを作成し､ 特殊効果を追加してゲームに磨きをかける準備が整ったところです｡

158
00:14:10,870 --> 00:14:12,520
‫次の動画でお会いしましょう｡