pinkskyee
(pinkskyee)
1
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
LevelClass := class {
AgentOB : agent
HUD : hud_message_device
CSD : cinematic_sequence_device
var Level : int = 0
MaxLevel : int = 150
var CompletedLevels : int = 0
var BaseDifficulty : float = 1.0
var DifficultyScaling : float = 1.0
var UpdateQueue : []int = array{}
var IsProcessingQueue : logic = false
var DifficultyMultiplerInClass : float = 1.0
GetCurrentDifficulty()<transacts> : float =
return BaseDifficulty + (DifficultyScaling * (CompletedLevels * DifficultyMultiplerInClass))
MessageFromString<localizes>(InValue : string)<transacts> : message = "{InValue}"
UpdateHUDText() : void = {
Calc := (Level * 1.0) / (MaxLevel * 1.0)
if (ProgressValue := Int[(Calc * 100)]) {
HUD.SetText(MessageFromString("Progress: {ProgressValue}%"))
}
}
}
level_class_data_persistable := class <persistable><final> {
Level : int = 0
MaxLevel : int = 0
}
level_class_data_update<constructor>(OldStat : level_class_data_persistable)<transacts> := level_class_data_persistable {
Level := OldStat.Level
MaxLevel := OldStat.MaxLevel
}
var Data:weak_map(player, level_class_data_persistable) = map{}
level_device := class(creative_device):
@editable CSD_A : []cinematic_sequence_device = array{}
@editable HUD_A : []hud_message_device = array{}
@editable TriggerDeviceTest : trigger_device = trigger_device{}
@editable WantDifficulty : logic = false
@editable WantPersistance : logic = false
@editable DifficultyMultipler : float = 1.0
var PlayerHUDMap : [agent]LevelClass = map{}
OnBegin<override>()<suspends>:void=
AllPlayers := GetPlayspace().GetPlayers()
for (Index -> Player : AllPlayers) {
spawn{OnPlayerJoined(Player)}
}
Sleep(0.3)
GetPlayspace().PlayerAddedEvent().Subscribe(PlayerJoinedNonSuspends)
GetPlayspace().PlayerRemovedEvent().Subscribe(OnPlayerRemoved)
TriggerDeviceTest.TriggeredEvent.Subscribe(TriggerFunction)
PlayerJoinedNonSuspends(Player : player) : void = {
spawn{OnPlayerJoined(Player)}
}
OnPlayerJoined(Player : player) <suspends>: void = {
for (Index -> PlayerP : GetPlayspace().GetPlayers()) {
if (PlayerP = Player) {
if (HUD_I := HUD_A[Index], CSD_I := CSD_A[Index]) {
NewPlayerClass := LevelClass {
AgentOB := Player
HUD := HUD_I
CSD := CSD_I
}
if (set PlayerHUDMap[Player] = NewPlayerClass) {}
if (not Data[Player]) {
if (set Data[Player] = level_class_data_persistable{}) {}
}
if (WantPersistance = true) {
if (PlayerPersistanceData := Data[Player]) {
Print("Persistance Data: {PlayerPersistanceData.Level}")
set NewPlayerClass.Level = PlayerPersistanceData.Level
}
}
set NewPlayerClass.DifficultyMultiplerInClass = DifficultyMultipler
NewPlayerClass.UpdateHUDText()
CSD_I.Play(Player)
CSD_I.Pause(Player)
Sleep(0.5)
HUD_I.Show(Player)
AnimateBar(Player, NewPlayerClass)
}
}
}
}
OnPlayerRemoved(PlayerLeft : agent): void = {
if (Agent := agent[PlayerLeft]) {
if (ActualPlayer := PlayerHUDMap[Agent]) {
var TempPlayerMap : [agent]LevelClass = map{}
for (Key -> Value : PlayerHUDMap, Key <> Agent) {
set TempPlayerMap = ConcatenateMaps(TempPlayerMap, map{Key => Value})
}
set PlayerHUDMap = TempPlayerMap
}
}
}
TriggerFunction(PossibleAgent : ?agent) : void = {
if (Agent := PossibleAgent?) {
if (Player := player[Agent], PlayerClass := PlayerHUDMap[Player]) {
Print("Should Do The Thing")
UpdateProgress(Player, 10)
}
}
}
UpdateProgress<public>(Player : player, BaseProgress : int) : void = {
if (PlayerClass := PlayerHUDMap[Player]) {
var CurrentDifficulty : float = 0.0
if (WantDifficulty = true) {
set CurrentDifficulty = PlayerClass.GetCurrentDifficulty()
} else {
set CurrentDifficulty = 1.0
}
if (AdjustedProgressIF := Int[(BaseProgress * 1.0) / CurrentDifficulty]) {
var AdjustedProgress : int = AdjustedProgressIF
if (AdjustedProgress < 1) { set AdjustedProgress = 1 }
spawn{UpdateProgressBarQueue(Player, PlayerClass, AdjustedProgress)}
}
}
}
UpdateProgressBarQueue<public>(Player : player, PlayerClass : LevelClass, ChangeLevel : int) <suspends>: void = {
set PlayerClass.UpdateQueue += array{ChangeLevel}
if (PlayerClass.IsProcessingQueue = false) {
set PlayerClass.IsProcessingQueue = true
loop:
if (PlayerClass.UpdateQueue.Length > 0) {
if (Update := PlayerClass.UpdateQueue[0], RemovedArray := PlayerClass.UpdateQueue.Slice[1]) {
set PlayerClass.UpdateQueue = RemovedArray
if (PlayerClass.Level + Update >= PlayerClass.MaxLevel) {
set PlayerClass.CompletedLevels += 1
set PlayerClass.Level = 0
PlayerClass.CSD.SetPlaybackFrame(0)
Print("Level Complete! New Difficulty: {PlayerClass.GetCurrentDifficulty()}")
} else {
set PlayerClass.Level += Update
}
Print("Level: {PlayerClass.Level}, Difficulty: {PlayerClass.GetCurrentDifficulty()}")
AnimateBar(Player, PlayerClass)
}
} else {
set PlayerClass.IsProcessingQueue = false
if (PlayerData := Data[Player]) {
if:
OldData := Data[Player]
set Data[Player] = level_class_data_persistable {
level_class_data_update<constructor>(OldData)
Level := PlayerClass.Level
}
then:
}
PlayerClass.UpdateHUDText()
break
}
}
}
AnimateBar<public>(Player : player, PlayerClass : LevelClass) <suspends>: void = {
Print("{PlayerClass.Level}")
CSD := PlayerClass.CSD
HUD := PlayerClass.HUD
Level := PlayerClass.Level
MaxLevel := PlayerClass.MaxLevel
Calc := (Level * 1.0) / (MaxLevel * 1.0)
Calc2 := Calc * MaxLevel
Print("{Calc2}")
if (FullCalc := Int[Calc2]) {
var Number : int = CSD.GetPlaybackFrame()
if (FullCalc > Number) {
loop:
Sleep(0.0)
CSD.SetPlaybackFrame(Number)
if (Number = FullCalc) {
if (Number = 150) {
set PlayerClass.CompletedLevels += 1
Print("Level Complete! New Difficulty: {PlayerClass.GetCurrentDifficulty()}")
set PlayerClass.Level = 0
CSD.SetPlaybackFrame(0)
}
break
} else {
set Number += 1
}
} else {
loop:
Sleep(0.0)
CSD.SetPlaybackFrame(Number)
if (Number = FullCalc) {
break
} else {
set Number -= 1
}
}
}
}
