Real-Time API Beta

Module — 2 files

These files compile together (same module folder).

file_1.verse

# Credit: JPN: @GorosukeSan, EN: @GorosukeEN
# A follow on X (Twitter) or credit within the map would be greatly appreciated (optional)
# If you have any bug reports or feature requests, please contact the account mentioned above.

using { /Verse.org/Simulation }

ProjectTimeZone<public>:time_zone = time_zone_gmt{}

time_date<public> := struct<concrete>:
    @editable
    Year:int = 0

    @editable
    Month:int = 0
    
    @editable
    Day:int = 0

    @editable
    Hour:int = 0

    @editable
    Minute:int = 0

    @editable
    Second:int = 0

    @editable
    Millisecond:int = 0

time_span<public> := struct<concrete>:
    @editable
    Years:int = 0

    @editable
    Months:int = 0

    @editable
    Days:int = 0

    @editable
    Hours:int = 0

    @editable
    Minutes:int = 0

    @editable
    Seconds:int = 0

    @editable
    Milliseconds:int = 0

time_zone<public> := class<computes>:
    Time<public>:float

time_zone_gmt<public> := class<computes>(time_zone):
    Time<override>:float = 0.0

time_zone_tokyo<public> := class<computes>(time_zone):
    Time<override>:float = 32400.0

GetCurrentTimeDate<public>()<transacts>:time_date=
    MakeTimeDate(GetSecondsSinceEpoch())

MakeTimeDate<public>(InEpochTime:float)<transacts>:time_date=
    CurrentTime := Max(InEpochTime + ProjectTimeZone.Time, 0.0)

    EpochTimeSeconds := Floor[CurrentTime] or 0
    MilliSeconds := Mod[Floor[CurrentTime * 1000], 1000] or 0
    Seconds := Mod[EpochTimeSeconds, 60] or 0
    Minutes := Mod[Floor(EpochTimeSeconds / 60), 60] or 0
    Hours := Mod[Floor(EpochTimeSeconds / 3600), 24] or 0
    Days := Floor(EpochTimeSeconds / 86400) or 0

    var Years:int = 1970
    var TotalDays:int = Days
    loop:
        DaysInYear := 
            if(IsLeapYear[Years]):
                366
            else:
                365
        if(TotalDays >= DaysInYear):
            set TotalDays -= DaysInYear
            set Years += 1
        else:
            break

    var Month:int = 0
    loop:
        CurrentDay :=
            if(Month = 2 and IsLeapYear[Years]):
                29
            else:
                DaysInMonth[Month] or 0
                
        if(TotalDays >= CurrentDay):
            set TotalDays -= CurrentDay
            set Month += 1
        else:
            break

    time_date:
        Year := Years
        Month := Month + 1
        Day := TotalDays + 1
        Hour := Hours
        Minute := Minutes
        Second := Seconds
        Millisecond := MilliSeconds

(InTimeDate:time_date).ToFloat<public>()<transacts>:float=
    var TotalDays:int = 0
    for:
        CurrentYear := 1970..InTimeDate.Year - 1
    do:
        set TotalDays += 
            if(IsLeapYear[CurrentYear]):
                366
            else:
                365

    for:
        CurrentMonthIndex := 0..InTimeDate.Month - 1 - 1
        CurrentDays := DaysInMonth[CurrentMonthIndex]
    do:
        set TotalDays += 
            if(CurrentMonthIndex = 1 and IsLeapYear[InTimeDate.Year]):
                29
            else:
                CurrentDays

    var TotalSeconds:float = (TotalDays * 86400.0)
    set TotalSeconds += (InTimeDate.Day - 1) * 86400.0
    set TotalSeconds += InTimeDate.Hour * 3600.0
    set TotalSeconds += InTimeDate.Minute * 60.0
    set TotalSeconds += InTimeDate.Second * 1.0
    set TotalSeconds += InTimeDate.Millisecond * 0.001
    set TotalSeconds -= ProjectTimeZone.Time
    TotalSeconds

MakeTimeSpan<public>(InTime:float)<transacts>:time_span=
    CurrentTime := Max(InTime, 0.0)

    TimeSeconds := Floor[CurrentTime] or 0
    MilliSeconds := Mod[Floor(TimeSeconds * 1000), 1000] or 0
    Seconds := Mod[TimeSeconds, 60] or 0
    Minutes := Mod[Floor(TimeSeconds / 60), 60] or 0
    Hours := Mod[Floor(TimeSeconds / 3600), 24] or 0
    Days := Floor(TimeSeconds / 86400) or 0
    
    var Years:int = 0
    var TotalDays:int = Days
    loop:
        DaysInYear := 
            if(IsLeapYear[Years]):
                366
            else:
                365
        if(TotalDays >= DaysInYear):
            set TotalDays -= DaysInYear
            set Years += 1
        else:
            break

    var Month:int = 0
    loop:
        CurrentDay :=
            if(Month = 2 and IsLeapYear[Years]):
                29
            else:
                DaysInMonth[Month] or 0
                
        if(TotalDays >= CurrentDay):
            set TotalDays -= CurrentDay
            set Month += 1
        else:
            break

    time_span:
        Years := Years
        Months := Month
        Days := TotalDays
        Hours := Hours
        Minutes := Minutes
        Seconds := Seconds
        Milliseconds := MilliSeconds

(InTimeSpan:time_span).ToFloat<public>()<transacts>:float=
    var TotalDays:int = 0
    for:
        CurrentYear := 0..InTimeSpan.Years - 1
    do:
        set TotalDays += 
            if(IsLeapYear[CurrentYear]):
                366
            else:
                365

    for:
        CurrentMonthIndex := 0..InTimeSpan.Months - 1
        CurrentDays := DaysInMonth[CurrentMonthIndex]
    do:
        set TotalDays += 
            if(CurrentMonthIndex = 1 and IsLeapYear[InTimeSpan.Years]):
                29
            else:
                CurrentDays

    var TotalSeconds:float = (TotalDays * 86400.0)
    set TotalSeconds += InTimeSpan.Days * 86400.0
    set TotalSeconds += InTimeSpan.Hours * 3600.0
    set TotalSeconds += InTimeSpan.Minutes * 60.0
    set TotalSeconds += InTimeSpan.Seconds * 1.0
    set TotalSeconds += InTimeSpan.Milliseconds * 0.001
    TotalSeconds

Equal<public>(X:time_date, Y:time_date)<transacts><decides>:void=
    X.ToFloat() = Y.ToFloat()

GreaterThan<public>(X:time_date, Y:time_date)<transacts><decides>:void=
    X.ToFloat() > Y.ToFloat()

EqualOrGreaterThan<public>(X:time_date, Y:time_date)<transacts><decides>:void=
    X.ToFloat() >= Y.ToFloat()

LessThan<public>(X:time_date, Y:time_date)<transacts><decides>:void=
    X.ToFloat() < Y.ToFloat()

EqualOrLessThan<public>(X:time_date, Y:time_date)<transacts><decides>:void=
    X.ToFloat() <= Y.ToFloat()

Distance<public>(X:time_date, Y:time_date)<transacts>:time_span=
    TimeDifference := Abs(X.ToFloat() - Y.ToFloat())
    MakeTimeSpan(TimeDifference)

operator'+'<public>(X:time_date, Y:time_span)<transacts>:time_date=
    Result := X.ToFloat() + Y.ToFloat()
    MakeTimeDate(Result)

operator'-'<public>(X:time_date, Y:time_span)<transacts>:time_date=
    Result := Max(X.ToFloat() - Y.ToFloat(), 0.0)
    MakeTimeDate(Result)

operator'*'<public>(X:time_date, Y:float)<transacts>:time_span=
    Result := X.ToFloat() * Y
    MakeTimeSpan(Result)

operator'/'<public>(X:time_date, Y:float)<transacts>:time_span=
    Result := X.ToFloat() / Y
    MakeTimeSpan(Result)

operator'*'<public>(X:time_date, Y:time_span)<transacts>:time_span=
    Result := X.ToFloat() * Y.ToFloat()
    MakeTimeSpan(Result)

operator'/'<public>(X:time_date, Y:time_span)<transacts>:time_span=
    Result := X.ToFloat() / Y.ToFloat()
    MakeTimeSpan(Result)

operator'+'<public>(X:time_span, Y:time_span)<transacts>:time_span=
    Result := X.ToFloat() + Y.ToFloat()
    MakeTimeSpan(Result)

operator'-'<public>(X:time_span, Y:time_span)<transacts>:time_span=
    Result := Max(X.ToFloat() - Y.ToFloat(), 0.0)
    MakeTimeSpan(Result)

operator'*'<public>(X:time_span, Y:float)<transacts>:time_span=
    Result := X.ToFloat() * Y
    MakeTimeSpan(Result)

operator'/'<public>(X:time_span, Y:float)<transacts>:time_span=
    Result := X.ToFloat() / Y
    MakeTimeSpan(Result)

operator'*'<public>(X:time_span, Y:time_span)<transacts>:time_span=
    Result := X.ToFloat() * Y.ToFloat()
    MakeTimeSpan(Result)

operator'/'<public>(X:time_span, Y:time_span)<transacts>:time_span=
    Result := X.ToFloat() / Y.ToFloat()
    MakeTimeSpan(Result)

day_of_week<public> := enum:
    Sunday
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday

GetDayOfWeek<public>(InTimeDate:time_date)<transacts>:day_of_week=
    TimeSeconds := InTimeDate.ToFloat()
    TotalDays := Floor[TimeSeconds / 86400.0] or 0
    DayIndex := Mod[TotalDays + 4, 7] or 0
    DayOfWeeks[DayIndex] or day_of_week.Sunday

DaysInMonth<public>:[]int = array{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
IsLeapYear<public>(InYear:int)<computes><decides>:void=
    (Mod[InYear, 4] = 0, Mod[InYear, 100] <> 0) or (Mod[InYear, 400] = 0)

DayOfWeeks<public>:[]day_of_week = array:
    day_of_week.Sunday
    day_of_week.Monday
    day_of_week.Tuesday
    day_of_week.Wednesday
    day_of_week.Thursday
    day_of_week.Friday
    day_of_week.Saturday

GetEventState<public>(Args:event_args)<transacts>:void=
    CurrentDate := GetCurrentTimeDate()
    GetEventState(CurrentDate, Args)

GetEventState<public>(Args:event_repeat_args)<transacts>:void=
    CurrentDate := GetCurrentTimeDate()
    GetEventState(CurrentDate, Args)

event_args<public> := struct:
    StartDate:time_date
    Duration:time_span

event_repeat_args<public> := struct:
    StartDate:time_date
    Duration:time_span
    Interval:time_span

event_state<public> := enum:
    NotStarted
    Ongoing
    WaitingForNext
    Ended

GetEventState<public>(InCurrentDate:time_date, Args:event_args)<transacts>:event_state=
    if:
        LessThan[InCurrentDate, Args.StartDate]
    then:
        event_state.NotStarted
    else if:
        EqualOrGreaterThan[InCurrentDate, Args.StartDate] and LessThan[InCurrentDate, Args.StartDate + Args.Duration]
    then:
        event_state.Ongoing
    else:
        event_state.Ended

GetEventState<public>(InCurrentDate:time_date, Args:event_repeat_args)<transacts>:event_state=
    if:
        LessThan[InCurrentDate, Args.StartDate]
    then:
        event_state.NotStarted
    else:
        EventStartDate := GetEventStartDate(InCurrentDate, Args)
        if:
            EqualOrGreaterThan[InCurrentDate, EventStartDate] and LessThan[InCurrentDate, EventStartDate + Args.Duration]
        then:
            event_state.Ongoing
        else:
            event_state.WaitingForNext

GetEventStartDate<public>(InCurrentDate:time_date, Args:event_repeat_args)<transacts>:time_date=
    if:
        LessThan[InCurrentDate, Args.StartDate]
    then:
        Args.StartDate
    else:
        ElapsedTime := Distance(Args.StartDate, InCurrentDate)
        Interval := Args.Duration + Args.Interval
        ElpasedSize := ElapsedTime / Interval
        TempStartTime := Args.StartDate + (Interval * ElpasedSize.ToFloat())
        if:
            EqualOrGreaterThan[InCurrentDate, TempStartTime + Args.Duration]
        then:
            TempStartTime + Interval
        else:
            TempStartTime

date_type<public> := enum:
    Year
    Month
    Day
    Hour
    Minute
    Second

(InDateType:date_type).GetTier<public>()<computes>:int=
    case(InDateType):
        date_type.Year => 0
        date_type.Month => 1
        date_type.Day => 2
        date_type.Hour => 3
        date_type.Minute => 4
        date_type.Second => 5

(InTimeDate:time_date).Override<public>(InDateType:date_type, InValue:int)<transacts>:time_date=
    ArgTier := InDateType.GetTier()
    YearTier := date_type.Year.GetTier()
    MonthTier := date_type.Month.GetTier()
    DayTier := date_type.Day.GetTier()
    HourTier := date_type.Hour.GetTier()
    MinuteTier := date_type.Minute.GetTier()
    SecondTier := date_type.Second.GetTier()

    time_date:
        Year :=
            if(ArgTier = YearTier):
                InValue
            else if(ArgTier < YearTier):
                0
            else:
                InTimeDate.Year
        Month :=
            if(ArgTier = MonthTier):
                InValue
            else if(ArgTier < MonthTier):
                1
            else:
                InTimeDate.Month
        Day :=
            if(ArgTier = DayTier):
                InValue
            else if(ArgTier < DayTier):
                1
            else:
                InTimeDate.Day
        Hour :=
            if(ArgTier = HourTier):
                InValue
            else if(ArgTier < HourTier):
                0
            else:
                InTimeDate.Hour
        Minute :=
            if(ArgTier = MinuteTier):
                InValue
            else if(ArgTier < MinuteTier):
                0
            else:
                InTimeDate.Minute
        Second :=
            if(ArgTier = SecondTier):
                InValue
            else if(ArgTier < SecondTier):
                0
            else:
                InTimeDate.Second

(InTimeDate:time_date).Today<public>()<transacts>:time_date=
    time_date:
        Year := InTimeDate.Year
        Month := InTimeDate.Month
        Day := InTimeDate.Day
        Hour := 0
        Minute := 0
        Second := 0
        Millisecond := 0

(InTimeDate:time_date).Yesterday<public>()<transacts>:time_date=
    InTimeDate.Today() - time_span{Days := 1}

(InTimeDate:time_date).Tomorrow<public>()<transacts>:time_date=
    InTimeDate.Today() + time_span{Days := 1}

(InTimeDate:time_date).Today<public>(Hour:int)<transacts>:time_date=
    if(InTimeDate.Hour < Hour):
        InTimeDate.Yesterday() + time_span{Hours := Hour}
    else:
        InTimeDate.Today() + time_span{Hours := Hour}

(InTimeDate:time_date).Tomorrow<public>(Hour:int)<transacts>:time_date=
    InTimeDate.Today(Hour) + time_span{Days := 1}

(InTimeDate:time_date).Yesterday<public>(Hour:int)<transacts>:time_date=
    InTimeDate.Today(Hour) - time_span{Days := 1}

ToString<public>(InTimeDate:time_date)<computes>:string=
    "{InTimeDate.Year}-{InTimeDate.Month}-{InTimeDate.Day} {InTimeDate.Hour}:{InTimeDate.Minute}:{InTimeDate.Second}.{InTimeDate.Millisecond}"

ToString<public>(InTimeSpan:time_span)<computes>:string=
    "{InTimeSpan.Years} years, {InTimeSpan.Months} months, {InTimeSpan.Days} days, {InTimeSpan.Hours} hours, {InTimeSpan.Minutes} minutes, {InTimeSpan.Seconds} seconds"

ToString<public>(InDateTime:day_of_week)<computes>:string=
    case(InDateTime):
        day_of_week.Sunday=> "Sunday"
        day_of_week.Monday=> "Monday"
        day_of_week.Tuesday=> "Tuesday"
        day_of_week.Wednesday=> "Wednesday"
        day_of_week.Thursday=> "Thursday"
        day_of_week.Friday=> "Friday"
        day_of_week.Saturday=> "Saturday"

ToString<public>(InDateType:date_type)<computes>:string=
    case(InDateType):
        date_type.Year=> "Year"
        date_type.Month=> "Month"
        date_type.Day=> "Day"
        date_type.Hour=> "Hour"
        date_type.Minute=> "Minute"
        date_type.Second=> "Second"

ToString<public>(InEventState:event_state)<computes>:string=
    case(InEventState):
        event_state.NotStarted=> "NotStarted"
        event_state.Ongoing=> "Ongoing"
        event_state.WaitingForNext=> "WaitingForNext"
        event_state.Ended=> "Ended"

file_2.verse

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

live_event_once_device<public> := class(creative_device):
    @editable
    StartDate<public>:time_date = time_date{}
    @editable
    Duration<public>:time_span = time_span{}
    @editable
    AnnounceHUDMessage<public>:hud_message_device = hud_message_device{}
    
    OnBegin<override>()<suspends>:void=
        var IsAnnounced:logic = false
        EventArgs := event_args:
            StartDate := StartDate
            Duration := Duration
        loop:
            Sleep(1.0)
            if:
                GetEventState(EventArgs) = event_state.Ongoing
            then:
                if:
                    not IsAnnounced?
                then:
                    AnnounceHUDMessage.Show()
                    set IsAnnounced = true

live_event_repeat_device<public> := class(creative_device):
    @editable
    StartDate<public>:time_date = time_date{}
    @editable
    Duration<public>:time_span = time_span{}
    @editable
    Interval<public>:time_span = time_span{}
    @editable
    AnnounceHUDMessage<public>:hud_message_device = hud_message_device{}
    
    OnBegin<override>()<suspends>:void=
        var IsAnnounced:logic = false
        EventArgs := event_repeat_args:
            StartDate := StartDate
            Duration := Duration
            Interval := Interval
        loop:
            Sleep(1.0)
            if:
                GetEventState(EventArgs) = event_state.Ongoing
            then:
                if:
                    not IsAnnounced?
                then:
                    AnnounceHUDMessage.Show()
                    set IsAnnounced = true
            else:
                set IsAnnounced = false

var SaveData<public>:weak_map(player, save_data) = map{}

MakeSaveData<public><constructor>(InData:save_data)<transacts> := save_data:
    LastLoginTime := InData.LastLoginTime
    ActiveQuestIDs := InData.ActiveQuestIDs

save_data<public> := class<final><persistable>:
    LastLoginTime<public>:float = 0.0
    ActiveQuestIDs<public>:[]int = array{}

daily_quest_device<public> := class(creative_device):

    @editable
    QuestTrackers:[]tracker_device = array{}

    @editable
    QuestCount:int = 3
    
    @editable
    UpdateHour:int = 21

    InitializeSaveData<public>(InPlayer:player):void=
        if:
            not SaveData[InPlayer]
        then:
            NewQuestIDs := PickQuests()
            CurrentToday := GetCurrentTimeDate().Today(UpdateHour)
            if:
                set SaveData[InPlayer] = save_data:
                    LastLoginTime := CurrentToday.ToFloat()
                    ActiveQuestIDs := NewQuestIDs

            for:
                TrackerElement : QuestTrackers
            do:
                TrackerElement.Remove(InPlayer)
            for:
                QuestID : NewQuestIDs
                TargetTracker := QuestTrackers[QuestID]
            do:
                TargetTracker.Assign(InPlayer)

    CheckQuestUpdte<public>(InPlayer:player):void=
        if:
            CurrentSaveData := SaveData[InPlayer]
        then:
            if:
                LastLoginTime := MakeTimeDate(CurrentSaveData.LastLoginTime)
                CurrentTime := GetCurrentTimeDate().Today(UpdateHour)
                Distance(LastLoginTime, CurrentTime).Days >= 1
            then:
                NewQuestIDs := PickQuests()
                if:
                    set SaveData[InPlayer] = save_data:
                        LastLoginTime := CurrentTime.ToFloat()
                        ActiveQuestIDs := NewQuestIDs
                        MakeSaveData<constructor>(CurrentSaveData)

                for:
                    TrackerElement : QuestTrackers
                do:
                    TrackerElement.Remove(InPlayer)
                for:
                    QuestID : NewQuestIDs
                    TargetTracker := QuestTrackers[QuestID]
                do:
                    TargetTracker.Assign(InPlayer)
            else:
                for:
                    QuestID : CurrentSaveData.ActiveQuestIDs
                    TargetTracker := QuestTrackers[QuestID]
                do:
                    TargetTracker.Assign(InPlayer)

    PickQuests<public>():[]int=
        IDs := 
            for:
                Index := 0..QuestTrackers.Length - 1
            do:
                Index
        IDs.Slice[0, QuestCount] or array{}

    OnBegin<override>()<suspends>:void=
        for:
            PlayerElement : GetPlayspace().GetPlayers()
        do:
            OnPlay(PlayerElement)
        GetPlayspace().PlayerAddedEvent().Subscribe(OnPlay)
        GetPlayspace().PlayerRemovedEvent().Subscribe(OnLeave)

        loop:
            Sleep(1.0)
            for:
                PlayerElement : GetPlayspace().GetPlayers()
            do:
                CheckQuestUpdte(PlayerElement)

    OnPlay(InPlayer:player):void=
        InitializeSaveData(InPlayer)
        CheckQuestUpdte(InPlayer)

    OnLeave(InPlayer:player):void=
        CurrentTime := GetCurrentTimeDate().Today(UpdateHour)
        if:
            CurrentSaveData := SaveData[InPlayer]
            set SaveData[InPlayer] = save_data:
                LastLoginTime := CurrentTime.ToFloat()
                MakeSaveData<constructor>(CurrentSaveData)
        then:

Copy-paste each file above is always free.

Real-Time API Beta

Comments