NxServ Automated Lottery (FR) ― Expression 2

NxServ Automated Lottery (FR).txt

#[
    NxServ Automated Lottery (FR)
    Gérez votre loterie automatiquement sur NxServ!
    https://gist.github.com/vintproykt/b2e69018b55a68cbb137a25a7dd5c401

    Mainteneurs:
      + Rodion Borisov (vintproykt)
      + John William's (Epilepsys)

    Connectez `EGP` avec Wire EGP Emitter.
    Délai par défaut entre les loteries: 1 min 40 s. Réglez `LotteryDelay` sur le nombre de secondes jusqu'à la prochaine loterie. Délai minimum: 30 s.
    Devise: kr. Lots par défaut: 30, 100, 500, 1000, 5000, 10000, 20000, 30000, 50000, 80000, 100000. Peut être modifié avec `OrderedLots`.
    Vous pouvez transférer les droits d'utilisateur au maire actuel en définissant l'entité `Mayor`.
]#
@name NxServ Automated Lottery
@inputs EGP:wirelink Mayor:entity OrderedLots:array LotteryDelay
@outputs Active LotAmount LotIndex NextLottery_Time Until_NextLottery
@persist User:entity UseKey LotDelay Lots:array
@persist GUI_Color_FG:vector GUI_Color_Lot:vector GUI_FontName:string
@persist GUI_LotButton_Size:vector2 GUI_LotButtonPrev_Pos:vector2 GUI_LotButtonPrev_Hover GUI_LotButtonNext_Pos:vector2 GUI_LotButtonNext_Hover
@persist GUI_Toggle_Size:vector2 GUI_Toggle_Pos:vector2 GUI_Toggle_Hover

function egpNewText(N, Text:string, Pos:vector2, Size:vector2, AlignH, AlignV) {
    EGP:egpTextLayout(N, Text, Pos, Size)
    EGP:egpFont(N, GUI_FontName, 24)
    EGP:egpAlign(N, AlignH, AlignV)
    EGP:egpColor(N, GUI_Color_FG)
}

function egpFontSize(N, Size) { EGP:egpFont(N, GUI_FontName, Size) }

function egpSilkicon(N, Pos:vector2, Size, Name:string) {
    EGP:egpBox(N, Pos, vec2(Size))
    EGP:egpMaterial(N, "icon16/" + Name + ".png")
    EGP:egpColor(N, vec(240))
}

function toggleState() {
    if (Active) {
        EGP:egpPos(31, GUI_Toggle_Pos + vec2(10))
        EGP:egpColor(31, vec(0, 255, 0))
        EGP:egpPos(32, GUI_Toggle_Pos + vec2(10))
        EGP:egpSetText(32, "1")
        EGP:egpColor(32, vec())
    }
    else {
        EGP:egpPos(31, GUI_Toggle_Pos + vec2(GUI_Toggle_Size:x() - EGP:egpSize(31):x() - 20, 10))
        EGP:egpColor(31, vec(50, 0, 0))
        EGP:egpPos(32, GUI_Toggle_Pos + vec2(GUI_Toggle_Size:x() - EGP:egpSize(31):x() - 20, 10))
        EGP:egpSetText(32, "0")
        EGP:egpColor(32, vec(255))
    }
}

function setLot(N) {
    LotAmount = Lots[N, number]
    LotIndex = N
}

function renewNextLotteryTime() {
    NextLottery_Time = curtime() + Until_NextLottery
}

if (dupefinished()) { reset() }

if (first() | ~LotteryDelay) {
    if (LotteryDelay > 30) { LotDelay = LotteryDelay }
    else { LotDelay = 100 }
}

if (first() | ~OrderedLots) {
    if (->OrderedLots) { Lots = OrderedLots }
    else { Lots = array(30, 100, 500, 1000, 5000, 10000, 20000, 30000, 50000, 80000, 100000) }
    setLot(Lots:count())
}

if (first() | ~EGP) {
    if (!->EGP) { exit() }

    T_Automated_Lottery = "Loterie automatisée"
    T_lot_amount = "montant du lot"
    T_left_until_next_lottery = "avant la prochaine loterie"

    EGP:egpClear()
    EGP:egpDrawTopLeft(1)

    GUI_Color_FG = vec(240)
    GUI_Color_Lot = GUI_Color_FG:setZ(0)
    GUI_FontName = "Roboto-Condensed"
    MaxWidth = EGP:egpSize():x() - 20

    EGP:egpBox(1, vec2(), EGP:egpSize())
    EGP:egpColor(1, vec(20))

    egpNewText(2, T_Automated_Lottery, vec2(10, 10), vec2(MaxWidth, 50), 1, 1)
    egpFontSize(2, 48)
    EGP:egpBox(3, vec2(10, 10 + EGP:egpSize(2):y()), vec2(MaxWidth, 5))
    EGP:egpColor(3, GUI_Color_FG)

    egpSilkicon(10, vec2(10, 120), 100, "money")
    egpNewText(11, "", vec2(120, 120), vec2(MaxWidth - 100, 75), 0, 1)
    egpFontSize(11, 72)
    EGP:egpColor(11, GUI_Color_Lot)
    egpNewText(12, T_lot_amount, vec2(120, 195), vec2(MaxWidth - 160, 25), 0, 1)
    EGP:egpColor(12, GUI_Color_Lot)

    GUI_LotButton_Size = vec2(25)
    GUI_LotButtonPrev_Pos = vec2(MaxWidth - 45, 195)
    EGP:egpRoundedBox(13, GUI_LotButtonPrev_Pos, GUI_LotButton_Size)
    EGP:egpRadius(13, 5)
    EGP:egpRoundedBoxOutline(14, GUI_LotButtonPrev_Pos, GUI_LotButton_Size)
    EGP:egpRadius(14, 5)
    egpSilkicon(15, GUI_LotButtonPrev_Pos + vec2(5), 16, "coins_delete")
    GUI_LotButtonNext_Pos = vec2(MaxWidth - 15, 195)
    EGP:egpRoundedBox(16, GUI_LotButtonNext_Pos, GUI_LotButton_Size)
    EGP:egpRadius(16, 5)
    EGP:egpRoundedBoxOutline(17, GUI_LotButtonNext_Pos, GUI_LotButton_Size)
    EGP:egpRadius(17, 5)
    egpSilkicon(18, GUI_LotButtonNext_Pos + vec2(5), 16, "coins_add")

    egpSilkicon(20, vec2(10, 230), 100, "time_go")
    egpNewText(21, "", vec2(120, 230), vec2(MaxWidth - 100, 75), 0, 1)
    egpFontSize(21, 72)
    egpNewText(22, T_left_until_next_lottery, vec2(120, 305), vec2(MaxWidth - 100, 25), 0, 1)

    GUI_Toggle_Size = vec2(140, 80)
    GUI_Toggle_Pos = vec2(MaxWidth / 2 - 60, 376)
    EGP:egpRoundedBox(30, GUI_Toggle_Pos, GUI_Toggle_Size)
    EGP:egpRadius(30, 5)
    EGP:egpRoundedBox(31, GUI_Toggle_Pos + vec2(10), vec2(60))
    EGP:egpRadius(31, 5)
    egpNewText(32, "", GUI_Toggle_Pos + vec2(10), vec2(60), 1, 1)
    EGP:egpFont(32, "Courier", 30)
    toggleState()

    runOnTick(1)
}

if (first() | ~Mayor) {
    runOnKeys(User, 0)
    if (Mayor:isPlayer()) { User = Mayor }
    else { User = owner() }
    runOnKeys(User, 1)
}

if (tickClk()) {
    Cur = EGP:egpCursor(User)

    # Update lot
    Money = LotAmount:toString() + ","
    DelAt = Money:find(" ")
    while (DelAt > 4) {
        Money = Money:sub(1, DelAt - 4) + "," + Money:sub(DelAt - 3)
    }
    EGP:egpSetText(11, Money:sub(1, Money:length() - 1) + " kr")

    # Update lot buttons
    if (inrange(Cur, GUI_LotButtonPrev_Pos, GUI_LotButtonPrev_Pos + GUI_LotButton_Size)) {
        GUI_LotButtonPrev_Hover = 1
        EGP:egpSize(14, 2)
        if (UseKey) {
            EGP:egpColor(13, vec4(GUI_Color_Lot, 100))
            EGP:egpColor(14, GUI_Color_FG)
        }
    }
    else {
        GUI_LotButtonPrev_Hover = 0
        EGP:egpSize(14, 1)
    }
    if (inrange(Cur, GUI_LotButtonNext_Pos, GUI_LotButtonNext_Pos + GUI_LotButton_Size)) {
        GUI_LotButtonNext_Hover = 1
        EGP:egpSize(17, 2)
        if (UseKey) {
            EGP:egpColor(16, vec4(GUI_Color_Lot, 100))
            EGP:egpColor(17, GUI_Color_FG)
        }
    }
    else {
        GUI_LotButtonNext_Hover = 0
        EGP:egpSize(17, 1)
    }
    if (!UseKey) {
        EGP:egpColor(13, vec4())
        EGP:egpColor(14, GUI_Color_Lot)
        EGP:egpColor(16, vec4())
        EGP:egpColor(17, GUI_Color_Lot)
    }

    # Update timer
    Seconds = floor(Until_NextLottery) % 60
    Minutes = floor(Until_NextLottery / 60)
    UntilString = ""
    if (Minutes) { UntilString += Minutes + " min " }
    if (Seconds) { UntilString += Seconds + " s" }
    EGP:egpSetText(21, UntilString:trim())
    EGP:egpAlpha(20, 5 + 250 * Active)
    EGP:egpAlpha(21, 5 + 250 * Active)
    EGP:egpAlpha(22, 5 + 250 * Active)

    # Update toggle
    if (inrange(Cur, GUI_Toggle_Pos, GUI_Toggle_Pos + GUI_Toggle_Size)) {
        GUI_Toggle_Hover = 1
        EGP:egpColor(30, vec(100))
    }
    else {
        GUI_Toggle_Hover = 0
        EGP:egpColor(30, vec(50))
    }

    if (Active) {
        Until_NextLottery = max(0, NextLottery_Time - curtime())
        if (changed(Active) | !Until_NextLottery) {
            if (!Until_NextLottery) {
                Until_NextLottery = LotDelay
                nxLottery(LotAmount)
            }
            renewNextLotteryTime()
        }
    }
    else {
        Until_NextLottery = 10
        renewNextLotteryTime()
    }
}

UseKey = User:keyUse()
if (changed(UseKey) & UseKey) {
    if (GUI_LotButtonPrev_Hover & LotIndex > 1) { setLot(LotIndex - 1) }
    if (GUI_LotButtonNext_Hover & LotIndex < Lots:count()) { setLot(LotIndex + 1) }
    if (GUI_Toggle_Hover) {
        Active = !Active
        toggleState()
    }
}