Guest User

Untitled

a guest
Nov 18th, 2024
67
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.31 KB | None | 0 0
  1. using { /Fortnite.com/Characters }
  2. using { /Fortnite.com/Devices }
  3. using { /Fortnite.com/Playspaces }
  4. using { /Fortnite.com/UI }
  5. using { /Fortnite.com/Vehicles }
  6. using { /UnrealEngine.com/Temporary/Curves }
  7. using { /UnrealEngine.com/Temporary/Diagnostics }
  8. using { /UnrealEngine.com/Temporary/SpatialMath }
  9. using { /UnrealEngine.com/Temporary/UI }
  10. using { /Verse.org/Concurrency }
  11. using { /Verse.org/Native }
  12. using { /Verse.org/Random }
  13. using { /Verse.org/Simulation }
  14. using { /Verse.org/Simulation/Tags }
  15. ###TIME TRIAL PIZZA PURSUIT---ALL IN ONE FILE ----
  16. # Game zones tags
  17. pickup_zone_tag<public> := class(tag):
  18. pickup_zone_level_1_tag<public> := class(pickup_zone_tag):
  19. pickup_zone_level_2_tag<public> := class(pickup_zone_tag):
  20. pickup_zone_level_3_tag<public> := class(pickup_zone_tag):
  21. delivery_zone_tag<public> := class(tag):
  22.  
  23. log_pizza_pursuit<internal> := class(log_channel){}
  24.  
  25. game_coordinator_device<public> := class(creative_device):
  26. @editable
  27. VehicleSpawner<public> : vehicle_spawner_atk_device = vehicle_spawner_atk_device{}
  28.  
  29. # How long the countdown timer will start counting down from.
  30. @editable
  31. InitialCountdownTime<public> : float = 30.0
  32.  
  33. @editable
  34. EndGame<public> : end_game_device = end_game_device{}
  35.  
  36. # How many seconds to add to the countdown timer when a pickup is delivered.
  37. @editable
  38. DeliveryBonusSeconds<public> : float = 20.0
  39.  
  40. @editable
  41. PickupMarker<public> : objective_marker = objective_marker{}
  42.  
  43. @editable
  44. ScoreManagerDevice<public> : score_manager_device = score_manager_device{}
  45.  
  46. @editable
  47. PizzaRemover<public> : item_remover_device = item_remover_device{}
  48.  
  49. @editable
  50. # Maps how many points a pickup is worth based on its pickup level.
  51. PointsForPickupLevel<public> : []int = array{1, 2, 3}
  52.  
  53. OnBegin<override>()<suspends> : void =
  54. FindPlayer()
  55. SetupZones()
  56.  
  57. # After entering the vehicle, the player could exit at any time; we
  58. # want to detect this every time it happens to put them back in the vehicle.
  59. VehicleSpawner.AgentExitsVehicleEvent.Subscribe(HandlePlayerExitsVehicle)
  60.  
  61. # We only want to be notified the first time the player enters the vehicle to start the game.
  62. # StartGameOnPlayerEntersVehicle will wait for that event and then start the gameplay loop.
  63. StartGameOnPlayerEntersVehicle()
  64.  
  65. Logger<private> : log = log{Channel := log_pizza_pursuit}
  66. var MaybePlayer<private> : ?player = false
  67. var CountdownTimer<private> : countdown_timer = countdown_timer{}
  68. var ScoreManager<private> : score_manager = score_manager{}
  69. DeliveryZoneSelector<private> : tagged_zone_selector = tagged_zone_selector{}
  70. var PickupZones<private> : []tagged_zone_selector = array{}
  71.  
  72. FindPlayer<private>() : void =
  73. # Since this is a single player experience, the first player (0)
  74. # should be the only one available.
  75. Playspace := Self.GetPlayspace()
  76. if (FirstPlayer := Playspace.GetPlayers()[0]):
  77. set MaybePlayer = option{FirstPlayer}
  78. Logger.Print("Player found")
  79. else:
  80. # Log an error if we can't find a player.
  81. # This shouldn't happen because at least one player is always present.
  82. Logger.Print("Can't find valid player", ?Level := log_level.Error)
  83.  
  84. SetupZones<private>() : void =
  85. # There's only one type of delivery zone, since they don't scale by difficulty level.
  86. DeliveryZoneSelector.InitZones(delivery_zone_tag{})
  87.  
  88. # We use gameplay tags to select zones (represented by devices) based on their difficulty level.
  89. # Using an array makes it easier to modify difficulty levels: we can add more
  90. # levels, increase/decrease their granularity or change their order without touching the code.
  91. # Create one tagged_zone_selector for each difficulty level tag so all devices with the same tag (i.e. same difficulty level)
  92. # end up in the same selection pool.
  93. LevelTags : []pickup_zone_tag = array{pickup_zone_level_1_tag{}, pickup_zone_level_2_tag{}, pickup_zone_level_3_tag{}}
  94. set PickupZones = for (ZoneTag : LevelTags):
  95. NewZone := tagged_zone_selector{}
  96. NewZone.InitZones(ZoneTag)
  97. NewZone
  98.  
  99. StartGameOnPlayerEntersVehicle<private>()<suspends> : void =
  100. VehiclePlayer := VehicleSpawner.AgentEntersVehicleEvent.Await()
  101. Logger.Print("Player entered the vehicle")
  102. set MaybePlayer = option{player[VehiclePlayer]}
  103. StartGame()
  104.  
  105. HandlePlayerExitsVehicle<private>(VehiclePlayer : agent) : void =
  106. Logger.Print("Player exited the vehicle. Reassigning player to vehicle")
  107. VehicleSpawner.AssignDriver(VehiclePlayer)
  108.  
  109. StartGame<private>()<suspends> : void =
  110. Logger.Print("Trying to start the game...")
  111. <# We construct a new countdown_timer that'll countdown from InitialCountdownTime once started.
  112. Also construct a new score_manager that'll keep track of the player's score and pickup level.
  113. The countdown_timer and score_manager require a player to show their UI to.
  114. We should have a valid player by now: the one that entered the vehicle, triggering the game start. #>
  115. if (ValidPlayer := MaybePlayer?):
  116. Logger.Print("Valid player, starting game...")
  117.  
  118. set ScoreManager = MakeScoreManager(ValidPlayer, ScoreManagerDevice)
  119. ScoreManager.AddScoreManagerToUI()
  120.  
  121. set CountdownTimer = MakeCountdownTimer(InitialCountdownTime, ValidPlayer)
  122. CountdownTimer.StartCountdown()
  123.  
  124. # We wait for the countdown to end.
  125. # At the same time, we also run the Pickup and Delivery game loop that constitutes the core gameplay.
  126. race:
  127. HandleCountdownEnd(ValidPlayer)
  128. PickupDeliveryLoop()
  129. else:
  130. Logger.Print("Can't find valid player. Aborting game start", ?Level := log_level.Error)
  131.  
  132. HandleCountdownEnd<private>(InPlayer : player)<suspends> : void =
  133. TotalTime := CountdownTimer.CountdownEndedEvent.Await()
  134. ScoreManager.AwardScore()
  135. EndGame.Activate(InPlayer)
  136.  
  137. PickupDeliveryLoop<private>()<suspends> : void =
  138. PickupZonesTags : []pickup_zone_tag = array{pickup_zone_level_1_tag{}, pickup_zone_level_2_tag{}, pickup_zone_level_3_tag{}}
  139. MaxPickupLevel := PickupZonesTags.Length - 1
  140. FirstPickupZoneCompletedEvent := event(){}
  141. <# Defer disabling the MapIndicator so that terminating the PickupDeliveryLoop always ends up disabling the marker.
  142. Defer also executes if the PickupDeliveryLoop is canceled. #>
  143. defer:
  144. if (ValidPlayer := MaybePlayer?):
  145. PickupMarker.MapIndicator.DeactivateObjectivePulse(ValidPlayer)
  146. PickupMarker.MapIndicator.Disable()
  147.  
  148. PickupMarker.MapIndicator.Enable()
  149.  
  150. loop:
  151. var PickupLevel : int = 0
  152. var IsFirstPickup : logic = true
  153.  
  154. <# Every time the loop restarts, we should reset the pickup level UI through the ScoreManager.
  155. The pickup level in the UI starts at 1 (not 0). Some players will be confused if it starts at 0.
  156. We index from 0, so PickupLevel=0 is Level 1 in the UI. #>
  157. ScoreManager.UpdatePickupLevel(PickupLevel + 1)
  158.  
  159. race:
  160. loop:
  161. if (PickupZone:base_zone = PickupZones[PickupLevel].SelectNext[]):
  162. PickupZone.ActivateZone()
  163. Sleep(0.0)
  164. PickupMarker.MoveMarker(PickupZone.GetTransform(), ?OverTime := 0.0)
  165. if (ValidPlayer := MaybePlayer?):
  166. PickupMarker.MapIndicator.ActivateObjectivePulse(ValidPlayer)
  167.  
  168. <# This is the only defer we need for any PickupZone we activate. It will either deactivate the first PickupZone at the end of each outer loop,
  169. or it'll deactivate any later PickupZone. That's because the expression is evaluated at the end, when the PickupZone variable has been bound to a newer zone. #>
  170. defer:
  171. PickupZone.DeactivateZone()
  172.  
  173. PickupZone.ZoneCompletedEvent.Await()
  174. Logger.Print("Picked up", ?Level:=log_level.Normal)
  175.  
  176. <# We remove pizzas pickups from the player inventory to avoid stacking them and having them drop to the ground once the stack is full. #>
  177. if (RemovingPlayer := MaybePlayer?):
  178. PizzaRemover.Remove(RemovingPlayer)
  179.  
  180. # After the first pickup we can enable the delivery zone.
  181. if (IsFirstPickup?):
  182. set IsFirstPickup = false
  183. FirstPickupZoneCompletedEvent.Signal()
  184.  
  185. if (PickupPoints := PointsForPickupLevel[PickupLevel]):
  186. ScoreManager.UpdatePendingScore(PickupPoints)
  187.  
  188. # Update the pickup level and ScoreManager.
  189. if (PickupLevel < MaxPickupLevel):
  190. set PickupLevel += 1
  191. ScoreManager.UpdatePickupLevel(PickupLevel + 1)
  192. else:
  193. Logger.Print("Can't find next PickupZone to select.", ?Level := log_level.Error)
  194. return # Error out of the PickupDeliveryLoop
  195. block:
  196. FirstPickupZoneCompletedEvent.Await()
  197.  
  198. if (DeliveryZone := DeliveryZoneSelector.SelectNext[]):
  199. DeliveryZone.ActivateZone()
  200.  
  201. # We defer zone deactivation so that canceling PickupDeliveryLoop also ends up deactivating any active delivery zone.
  202. defer:
  203. Logger.Print("Deactivating delivery zone.", ?Level:=log_level.Normal)
  204. DeliveryZone.DeactivateZone()
  205.  
  206. DeliveryZone.ZoneCompletedEvent.Await()
  207. Logger.Print("Delivered", ?Level:=log_level.Normal)
  208.  
  209. PointsCommitted := ScoreManager.AddPendingScoreToTotalScore()
  210. BonusTime : float = DeliveryBonusSeconds * PointsCommitted
  211. CountdownTimer.AddRemainingTime(BonusTime)
  212. else:
  213. Logger.Print("Can't find next DeliveryZone to select.", ?Level:=log_level.Error)
  214. return # Error out of the PickupDeliveryLoop
  215.  
  216. ################################################################################################################################################
  217. ### Base Zone
  218.  
  219. <# A zone is an area of the map (represented by a device) that can be Activated/Deactivated and that provides events
  220. to signal when the zone has been "Completed" (can't be completed anymore until next activation).
  221. Zone "Completed" depends on the device type (ActivatorDevice) for the zone.
  222. Suggested usage: ActivateZone() -> ZoneCompletedEvent.Await() -> DeactivateZone() #>
  223. base_zone<public> := class:
  224. ActivatorDevice<public> : creative_object_interface
  225. ZoneCompletedEvent<public> : event(base_zone) = event(base_zone){}
  226.  
  227. GetTransform<public>() : transform =
  228. ActivatorDevice.GetTransform()
  229.  
  230. <# Activates the Zone.
  231. You should enable devices and any visual indicators for the zone here. #>
  232. ActivateZone<public>() : void =
  233. # The base zone can handle zones defined as item spawners or capture areas.
  234. # Try and cast to each type to see which we're dealing with.
  235. if (CaptureArea := capture_area_device[ActivatorDevice]):
  236. CaptureArea.Enable()
  237. spawn { WaitForZoneCompleted(option{CaptureArea.AgentEntersEvent}) }
  238. else if (ItemSpawner := item_spawner_device[ActivatorDevice]):
  239. ItemSpawner.Enable()
  240. spawn { WaitForZoneCompleted(option{ItemSpawner.ItemPickedUpEvent}) }
  241.  
  242. <# Deactivates the Zone.
  243. You should disable devices and any visual indicators for the zone here. #>
  244. DeactivateZone<public>() : void =
  245. if (CaptureArea := capture_area_device[ActivatorDevice]):
  246. CaptureArea.Disable()
  247. else if (ItemSpawner := item_spawner_device[ActivatorDevice]):
  248. ItemSpawner.Disable()
  249. ZoneDeactivatedEvent.Signal()
  250.  
  251. <# This event is necessary to terminate the WaitForZoneCompleted coroutine if the zone is deactivated without being completed. #>
  252. ZoneDeactivatedEvent<protected> : event() = event(){}
  253.  
  254. WaitForZoneCompleted<private>(ZoneDeviceCompletionEventOpt : ?awaitable(agent))<suspends> : void =
  255. if (DeviceEvent := ZoneDeviceCompletionEventOpt?):
  256. race:
  257. block:
  258. DeviceEvent.Await()
  259. ZoneCompletedEvent.Signal(Self)
  260. ZoneDeactivatedEvent.Await()
  261.  
  262. MakeBaseZone<constructor><public>(InActivatorDevice : creative_object_interface) := base_zone:
  263. ActivatorDevice := InActivatorDevice
  264.  
  265. # The tagged_zone_selector creates zones based on triggers tagged with the tag passed to InitZones.
  266. tagged_zone_selector<public> := class:
  267. var Zones<protected> : []base_zone = array{}
  268.  
  269. #Refer to lines 93-96 for calling function
  270. InitZones<public>(ZoneTag : tag) : void =
  271. <# On creation of a zone selector, find all available zones
  272. and cache them so we don't consume time searching for tagged devices
  273. every time the next zone is selected. #>
  274.  
  275. ZoneDevices := GetCreativeObjectsWithTag(ZoneTag)
  276. set Zones = for (ZoneDevice : ZoneDevices):
  277. MakeBaseZone(ZoneDevice)
  278.  
  279. SelectNext<public>()<transacts><decides> : base_zone =
  280. Zones[GetRandomInt(0, Zones.Length-1)]
  281.  
  282. ############################################################################################################################################
  283. ## Objective Coordinator Device
  284.  
  285. objective_coordinator_device<public> := class<concrete>(creative_device):
  286.  
  287. var PlayerOpt<private> : ?player = false
  288.  
  289. @editable
  290. PickupMarker<public> : objective_marker = objective_marker{}
  291.  
  292. # Where the marker will be moved to
  293. @editable
  294. Destination<public> : transform = transform{}
  295.  
  296. # How much time the marker should take to reach its new location
  297. @editable
  298. MoveTime<public> : float = 0.0
  299.  
  300. OnBegin<override>()<suspends> : void =
  301.  
  302. FindPlayer()
  303.  
  304. PickupMarker.MoveMarker(Destination, ?OverTime := MoveTime)
  305.  
  306. # if Player is not set to false, active the objective pulse for the found player
  307. if (FoundPlayer := PlayerOpt?):
  308. PickupMarker.MapIndicator.ActivateObjectivePulse(FoundPlayer)
  309.  
  310. FindPlayer<private>() : void =
  311.  
  312. # Since this is a single player experience, the first player [0]
  313. # should be the only one available.
  314.  
  315. AllPlayers := Self.GetPlayspace().GetPlayers()
  316.  
  317. if (FirstPlayer := AllPlayers[0]):
  318. set PlayerOpt = option{FirstPlayer}
  319. Print("Player found")
  320. else:
  321. # Log an error if we can't find a player.
  322. Print("Can't find valid player")
  323.  
  324. #######################################################################################################################################################
  325. ### Objective Marker
  326.  
  327.  
  328. objective_marker<public> := struct<concrete>:
  329.  
  330. # The prop that will be moved
  331. @editable
  332. RootProp<public> : creative_prop = creative_prop{}
  333.  
  334. # The child of the prop that will move with it
  335. @editable
  336. MapIndicator<public> : map_indicator_device = map_indicator_device{}
  337.  
  338. # An extension method for objective_marker
  339. # The ? in front of OverTime specifies it as a named argument
  340. (Marker : objective_marker).MoveMarker<public>(Transform : transform, ?OverTime : float)<suspends> : void =
  341.  
  342. if (OverTime > 0.0):
  343. Marker.RootProp.MoveTo(Transform.Translation, Transform.Rotation, OverTime)
  344. else:
  345. if:
  346. Marker.RootProp.TeleportTo[Transform.Translation, Transform.Rotation]
  347.  
  348. ############################################################################################################################################################
  349. #### Countdown Timer
  350.  
  351.  
  352. MakeCountdownTimer<constructor><public>(MaxTime : float, InPlayer : agent) := countdown_timer:
  353. RemainingTime := MaxTime
  354. MaybePlayerUI := option{GetPlayerUI[player[InPlayer]]}
  355.  
  356. countdown_timer := class:
  357. <# This block runs for each instance of the countdown_timer class.
  358. We can setup the canvas once here. #>
  359. block:
  360. set Canvas = canvas:
  361. Slots := array:
  362. canvas_slot:
  363. Anchors := anchors:
  364. Minimum := vector2{X := 0.4, Y := 0.3}
  365. Maximum := vector2{X := 0.6, Y := 0.3}
  366. Alignment := vector2{X := 0.5, Y := 0.5 }
  367. Offsets := margin{Top := 0.0, Left := 0.0, Bottom := 0.0, Right := 0.0}
  368. SizeToContent := true
  369. Widget := RemainingTimeTextBlock
  370. canvas_slot:
  371. Anchors := anchors:
  372. Minimum := vector2{X := 0.4, Y := 0.3}
  373. Maximum := vector2{X := 0.6, Y := 0.3}
  374. Alignment := vector2{X := 0.0, Y := 1.0}
  375. Offsets := margin{Top := 0.0, Right := 0.0}
  376. SizeToContent := true
  377. Widget := AddedTimeTextBlock
  378.  
  379. CountdownEndedEvent<public> : event(float) = event(float){}
  380.  
  381. StartCountdown<public>() : void =
  382. if (PlayerUI := MaybePlayerUI?):
  383. PlayerUI.AddWidget(Canvas)
  384.  
  385. # Update the UI when we start the timer to see the initial RemainingTime on screen
  386. UpdateUI()
  387. spawn:
  388. RunCountdown()
  389.  
  390. AddRemainingTime<public>(Time : float) : void =
  391. set RemainingTime += Time
  392. # Immediately update UI for better player feedback when time is added.
  393. UpdateUI()
  394.  
  395. # Fire a simple callout to show the time being added.
  396. spawn:
  397. AddedTimeCallout(Time)
  398.  
  399. MaybePlayerUI<internal> : ?player_ui = false
  400. var RemainingTime<internal> : float = 0.0
  401. RemainingTimeTextBlock<private> : text_block = text_block{}
  402. AddedTimeTextBlock<private> : text_block = text_block{}
  403. RemainingTimeText<localizes><private>(CurrentRemainingTime : int) : message = "{CurrentRemainingTime}"
  404. AddedTimeText<localizes><private>(AddedTime : int) : message = " +{AddedTime}!"
  405. var Canvas<private> : canvas = canvas{}
  406. var TotalTime<private> : float = 0.0
  407. # The timer "precision": how often, in seconds, it ticks.
  408. TimerTickPeriod<private> : float = 1.0
  409.  
  410. RunCountdown<private>()<suspends> : void =
  411. # We loop with the TimerTickPeriod.
  412. # The UI is also updated each time.
  413. loop:
  414. Sleep(TimerTickPeriod)
  415. set TotalTime += TimerTickPeriod
  416. set RemainingTime -= TimerTickPeriod
  417. UpdateUI()
  418.  
  419. # Timer End
  420. if (RemainingTime <= 0.0):
  421.  
  422. Canvas.RemoveWidget(RemainingTimeTextBlock)
  423.  
  424. if (UI := MaybePlayerUI?):
  425. UI.RemoveWidget(Canvas)
  426.  
  427. CountdownEndedEvent.Signal(TotalTime)
  428. break
  429.  
  430. AddedTimeCallout<private>(Time : float)<suspends> : void =
  431. if:
  432. PlayerUI := MaybePlayerUI?
  433. IntTime := Int[Time]
  434. then:
  435. AddedTimeTextBlock.SetVisibility(widget_visibility.Visible)
  436. AddedTimeTextBlock.SetText(AddedTimeText(IntTime))
  437. Sleep(2.0)
  438. AddedTimeTextBlock.SetVisibility(widget_visibility.Hidden)
  439.  
  440. UpdateUI<private>() : void =
  441. if (IntTime := Int[RemainingTime]):
  442. RemainingTimeTextBlock.SetText(RemainingTimeText(IntTime))
  443.  
  444. ##################################################################################################################################
  445. ####Score Manager
  446.  
  447. MakeScoreManager<constructor><public>(InPlayer : player, InScoreManagerDevice : score_manager_device) := score_manager:
  448. MaybePlayer := option{InPlayer}
  449. MaybePlayerUI := option{GetPlayerUI[InPlayer]}
  450.  
  451. score_manager := class:
  452. <# Since we won't recreate the canvas during the score manager lifetime, do it once
  453. anytime an object of this type is created. #>
  454. block:
  455. set Canvas = canvas:
  456. Slots := array:
  457. canvas_slot:
  458. Widget := stack_box:
  459. Orientation := orientation.Vertical
  460. Slots := array:
  461. stack_box_slot:
  462. Widget := TotalGameScoreWidget
  463. stack_box_slot:
  464. Widget := PendingScoreWidget
  465. stack_box_slot:
  466. Widget := PickupLevelWidget
  467. Offsets := margin{ Top:=0.0, Left:=500.0 }
  468.  
  469. AddScoreManagerToUI<public>() : void =
  470. if (PlayerUI := MaybePlayerUI?):
  471. PlayerUI.AddWidget(Canvas)
  472. UpdateUI()
  473.  
  474. <# Adds PendingScore to TotalGameScore and resets PendingScore to 0.
  475. Returns the total number of Pickup Points added. #>
  476. AddPendingScoreToTotalScore<public>() : int =
  477. set TotalGameScore += PendingScore
  478.  
  479. defer:
  480. set PendingScore = 0
  481. UpdateUI()
  482.  
  483. PendingScore
  484.  
  485. <# Adds the given amount of points to the pending points. #>
  486. UpdatePendingScore<public>(Points : int) : void =
  487. set PendingScore += Points
  488. UpdateUI()
  489.  
  490. UpdatePickupLevel<public>(Level : int) : void =
  491. set PickupLevel = Level
  492. UpdateUI()
  493.  
  494. <# Awards the score to the player via the ScoreManagerDevice, activating it. #>
  495. AwardScore<public>() : void =
  496. ScoreManagerDevice.SetScoreAward(TotalGameScore)
  497. if (AwardedPlayer := MaybePlayer?):
  498. ScoreManagerDevice.Activate(AwardedPlayer)
  499.  
  500. MaybePlayer<internal> : ?player = false
  501. MaybePlayerUI<internal> : ?player_ui = false
  502. ScoreManagerDevice<internal> : score_manager_device = score_manager_device{}
  503. var Canvas<internal> : canvas = canvas{}
  504. TotalGameScoreWidget<internal> : text_block = text_block{}
  505. PendingScoreWidget<internal> : text_block = text_block{}
  506. PickupLevelWidget<internal> : text_block = text_block{}
  507.  
  508. PickupLevelText<private><localizes>(InLevel : int) : message = "Pickup Level: {InLevel}"
  509. PendingScoreText<private><localizes>(InPoints : int) : message = "Pending Points: {InPoints}"
  510. TotalGameScoreText<private><localizes>(InPoints : int) : message = "Total Points: {InPoints}"
  511. var TotalGameScore<private> : int = 0
  512. var PendingScore<private> : int = 0
  513. var PickupLevel<private> : int = 0
  514.  
  515. UpdateUI<private>() : void =
  516. if (PlayerUI := MaybePlayerUI?):
  517. PickupLevelWidget.SetText(PickupLevelText(PickupLevel))
  518. PendingScoreWidget.SetText(PendingScoreText(PendingScore))
  519. TotalGameScoreWidget.SetText(TotalGameScoreText(TotalGameScore))
Add Comment
Please, Sign In to add comment