tx · EL2Xou7JPE4n1YSL6rvU8uSqZxH2w6NNRzURRatL4upC

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.07400000 Waves

2023.07.19 20:15 [2673028] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EL2Xou7JPE4n1YSL6rvU8uSqZxH2w6NNRzURRatL4upC",
    "fee": 7400000,
    "feeAssetId": null,
    "timestamp": 1689786957044,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "3727u5eaysvjpH7PCUGtL8uQW8QtSYsJEnh5wMVNHBve2jS9qo6M4vXTURKwWjvjpvfTidYzicGvRRDPcV5nUqFQ"
    ],
    "script": "base64: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",
    "height": 2673028,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GJdS8zUHF8CeiHdC2efy44VeWkNejZaHty4K7ZxowFkg
Next: E9w2WP9s2HdvRQ2j5JGWRysKWfVfj82kg2rgmt4qt6Te

Diff: 
Old
New
Differences
113
113
 
let productionMatrix = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_30_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_50_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_70_0,0,0,0,0,0,0_201"]
114
114
 
115
115
 
let rIdxCoeff = 6
116
+
117
+
let rIdxSlots = 10
116
118
 
117
119
 
let PRODUCTPKGSIZE = 10
118
120
 
594
596
 
        }
595
597
 
596
598
 
597
-
func addProd (idxCnt,pList,isPositive) = {
599
+
func addProd (idxCnt,pList,isPositive,segment,mainAux,slot) = {
598
600
 
    let parts = split(idxCnt, ":")
599
601
 
    if ((size(parts) != 2))
600
602
 
        then throw("Incorrect format, should be index:amount")
608
610
 
                else if ((0 > count))
609
611
 
                    then throw("Count can't be negative")
610
612
 
                    else if ((count == 0))
611
-
                        then pList
613
+
                        then $Tuple2(pList, false)
612
614
 
                        else {
613
615
 
                            func addP (acc,item) =                             {
614
616
 
                                let j = acc._1
619
621
 
                                    then (count > curr)
620
622
 
                                    else false)
621
623
 
                                    then throw(((((("You have " + toString(curr)) + " of ") + prodTypes[j]) + ", but tried to use ") + toString(count)))
622
-
                                    else $Tuple2((j + 1), (acc._2 :+ toString(if ((productIdx != j))
623
-
                                        then curr
624
-
                                        else (curr + (if (isPositive)
625
-
                                            then count
626
-
                                            else -(count))))))
624
+
                                    else {
625
+
                                        let isBig = if (!(isPositive))
626
+
                                            then {
627
+
                                                let compat = split(item, "_")[rIdxSlots]
628
+
                                                if ((compat == ""))
629
+
                                                    then throw("Item cannot be equipped")
630
+
                                                    else {
631
+
                                                        let c = parseIntValue(compat)
632
+
                                                        let cSeg = (c / 100)
633
+
                                                        if ((segment != cSeg))
634
+
                                                            then throw("Segment incompatible")
635
+
                                                            else {
636
+
                                                                let cMainAux = ((c % 100) / 10)
637
+
                                                                if ((mainAux != cMainAux))
638
+
                                                                    then throw("Slot incompatible")
639
+
                                                                    else {
640
+
                                                                        let cNumSlots = (c % 10)
641
+
                                                                        if (if ((slot != 0))
642
+
                                                                            then (cNumSlots > 1)
643
+
                                                                            else false)
644
+
                                                                            then throw("Big items should occupy slot 0")
645
+
                                                                            else (cNumSlots > 1)
646
+
                                                                        }
647
+
                                                                }
648
+
                                                        }
649
+
                                                }
650
+
                                            else false
651
+
                                        $Tuple3((j + 1), (acc._2 :+ toString(if ((productIdx != j))
652
+
                                            then curr
653
+
                                            else (curr + (if (isPositive)
654
+
                                                then count
655
+
                                                else -(count))))), if (acc._3)
656
+
                                            then true
657
+
                                            else isBig)
658
+
                                        }
627
659
 
                                }
628
660
 
629
-
(                            let $l = productionMatrix
630
-
                            let $s = size($l)
631
-
                            let $acc0 = $Tuple2(0, nil)
632
-
                            func $f0_1 ($a,$i) =                             if (($i >= $s))
633
-
                                then $a
634
-
                                else addP($a, $l[$i])
635
-
636
-
                            func $f0_2 ($a,$i) =                             if (($i >= $s))
637
-
                                then $a
638
-
                                else throw("List size exceeds 42")
639
-
640
-
                            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42))._2
661
+
                            let result = {
662
+
                                let $l = productionMatrix
663
+
                                let $s = size($l)
664
+
                                let $acc0 = $Tuple3(0, nil, false)
665
+
                                func $f0_1 ($a,$i) =                                 if (($i >= $s))
666
+
                                    then $a
667
+
                                    else addP($a, $l[$i])
668
+
669
+
                                func $f0_2 ($a,$i) =                                 if (($i >= $s))
670
+
                                    then $a
671
+
                                    else throw("List size exceeds 27")
672
+
673
+
                                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27)
674
+
                                }
675
+
                            $Tuple2(result._2, result._3)
641
676
 
                            }
642
677
 
            }
643
678
 
    }
644
679
 
645
680
 
646
-
func slotsGroup (g,bpIn,isPositive) = if ((g != ""))
681
+
func slotsGroup (g,bpIn,isPositive,segment,mainAux) = if ((g != ""))
647
682
 
    then {
648
683
 
        let slots = split(g, ",")
649
684
 
        if ((size(slots) > MAXSLOTS))
659
694
 
                    then bpIn
660
695
 
                    else {
661
696
 
                        let tmpS0 = if ((s0 != ""))
662
-
                            then addProd(s0, bpIn, isPositive)
663
-
                            else bpIn
697
+
                            then addProd(s0, bpIn, isPositive, segment, mainAux, 0)
698
+
                            else $Tuple2(bpIn, false)
664
699
 
                        if ((s1 != ""))
665
-
                            then addProd(s1, tmpS0, isPositive)
666
-
                            else tmpS0
700
+
                            then if (tmpS0._2)
701
+
                                then throw("Big item already occupies slot")
702
+
                                else addProd(s1, tmpS0._1, isPositive, segment, mainAux, 1)._1
703
+
                            else tmpS0._1
667
704
 
                        }
668
705
 
                }
669
706
 
        }
672
709
 
673
710
 
func dress (segList,pList,isPositive) = {
674
711
 
    func segment (acc,seg) =     {
712
+
        let j = acc._1
675
713
 
        let mainAux = split(seg, ";")
676
714
 
        if ((size(mainAux) != NUMMAINAUX))
677
715
 
            then throw("Wrong segment format")
681
719
 
                if (if ((m == ""))
682
720
 
                    then (a == "")
683
721
 
                    else false)
684
-
                    then acc
722
+
                    then $Tuple2((j + 1), acc._2)
685
723
 
                    else {
686
-
                        let tmpM = slotsGroup(m, acc, isPositive)
687
-
                        slotsGroup(a, tmpM, isPositive)
724
+
                        let tmpM = slotsGroup(m, acc._2, isPositive, j, 0)
725
+
                        $Tuple2((j + 1), slotsGroup(a, tmpM, isPositive, j, 1))
688
726
 
                        }
689
727
 
                }
690
728
 
        }
691
729
 
692
-
    let $l = segList
730
+
(    let $l = segList
693
731
 
    let $s = size($l)
694
-
    let $acc0 = pList
732
+
    let $acc0 = $Tuple2(0, pList)
695
733
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
696
734
 
        then $a
697
735
 
        else segment($a, $l[$i])
700
738
 
        then $a
701
739
 
        else throw("List size exceeds 6")
702
740
 
703
-
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
741
+
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6))._2
704
742
 
    }
705
743
 
706
744
 
1219
1257
 
1220
1258
 
1221
1259
 
func checkClaimConditions (addr,claimMode,landAssetIdIn) = {
1222
-
    let $t02720327742 = if ((claimMode == claimModeWh))
1260
+
    let $t02812328662 = if ((claimMode == claimModeWh))
1223
1261
 
        then $Tuple2(landAssetIdIn, valueOrElse(getString(keyStakedDuckByOwner(addr)), ""))
1224
1262
 
        else {
1225
1263
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
1229
1267
 
                then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
1230
1268
 
                else $Tuple2(loc[locIdxId], duckAssetId)
1231
1269
 
            }
1232
-
    let landAssetId = $t02720327742._1
1233
-
    let duckId = $t02720327742._2
1270
+
    let landAssetId = $t02812328662._1
1271
+
    let duckId = $t02812328662._2
1234
1272
 
    let asset = value(assetInfo(fromBase58String(landAssetId)))
1235
1273
 
    let timeKey = keyStakedTimeByAssetId(landAssetId)
1236
1274
 
    let savedTime = valueOrErrorMessage(getInteger(timeKey), (("Land " + asset.name) + " is not staked"))
1278
1316
 
                                let currentPack = getBackpack(bpKey)
1279
1317
 
                                let currentPackRes = split(currentPack[bpIdxRes], "_")
1280
1318
 
                                let currentWhRes = split(currentWh[whIdxRes], "_")
1281
-
                                let $t03011630987 = if ((claimMode == claimModeWh))
1319
+
                                let $t03103631907 = if ((claimMode == claimModeWh))
1282
1320
 
                                    then $Tuple4(addRes(currentWhRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), currentPack[bpIdxRes], (parseIntValue(loft[volOccupied]) + resToClaim._2), (parseIntValue(loft[volFree]) - resToClaim._2))
1283
1321
 
                                    else if ((claimMode == claimModeDuck))
1284
1322
 
                                        then $Tuple4(currentWh[whIdxRes], addRes(currentPackRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), parseIntValue(loft[volOccupied]), parseIntValue(loft[volFree]))
1287
1325
 
                                            let whAm = min([parseIntValue(loft[volFree]), resToClaim._2])
1288
1326
 
                                            $Tuple4(distr._1, distr._2, (parseIntValue(loft[volOccupied]) + whAm), (parseIntValue(loft[volFree]) - whAm))
1289
1327
 
                                            }
1290
-
                                let whRes = $t03011630987._1
1291
-
                                let bpRes = $t03011630987._2
1292
-
                                let loftO = $t03011630987._3
1293
-
                                let loftF = $t03011630987._4
1328
+
                                let whRes = $t03103631907._1
1329
+
                                let bpRes = $t03103631907._2
1330
+
                                let loftO = $t03103631907._3
1331
+
                                let loftF = $t03103631907._4
1294
1332
 
                                $Tuple5([IntegerEntry(keyStakedTimeByAssetId(c._2), newTimestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, c._2, addr), newTimestamp)], bpKey, [currentPack[bpIdxLevel], bpRes, currentPack[bpIdxMat], currentPack[bpIdxProd]], whKey, [currentWh[whIdxLevels], whRes, currentWh[whIdxMat], currentWh[whIdxProd], makeString([loft[volLocked], toString(loftO), toString(loftF), loft[volTotal]], "_")])
1295
1333
 
                                }
1296
1334
 
                        }
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
func keyLastArbTimeByUser (addr) = ("lastArbTimeUser_" + addr)
5
5
 
6
6
 
7
7
 
let SCALE8 = 100000000
8
8
 
9
9
 
let xpLevelScale = 3200
10
10
 
11
11
 
let xpLevelRecipPow = 4000
12
12
 
13
13
 
let numPointsOnLevelUp = 3
14
14
 
15
15
 
let charStrength = 0
16
16
 
17
17
 
let charAccuracy = 1
18
18
 
19
19
 
let charIntellect = 2
20
20
 
21
21
 
let charEndurance = 3
22
22
 
23
23
 
let charDexterity = 4
24
24
 
25
25
 
let NUMSEGMENTS = 6
26
26
 
27
27
 
let NUMMAINAUX = 2
28
28
 
29
29
 
let MAXSLOTS = 2
30
30
 
31
31
 
func keyDuckChars (duckAssetId) = ("duckChars_" + duckAssetId)
32
32
 
33
33
 
34
34
 
func keyDuckXP (duckAssetId) = ("duckXP_" + duckAssetId)
35
35
 
36
36
 
37
37
 
func keyDuckLevel (duckAssetId) = ("duckLevel_" + duckAssetId)
38
38
 
39
39
 
40
40
 
func keyDuckFreePoints (duckAssetId) = ("duckFreePoints_" + duckAssetId)
41
41
 
42
42
 
43
43
 
func keyDuckEquipment (duckAssetId) = ("duckEquipment_" + duckAssetId)
44
44
 
45
45
 
46
46
 
func keyUserXP (addr) = ("userXP_" + addr)
47
47
 
48
48
 
49
49
 
func keyUserLevel (addr) = ("userLevel_" + addr)
50
50
 
51
51
 
52
52
 
func keyUserFreePoints (addr) = ("userFreePoints_" + addr)
53
53
 
54
54
 
55
55
 
let xpClaim = 100000
56
56
 
57
57
 
let xpSuccessFlight = 50000
58
58
 
59
59
 
let xpFailFlight = 10000
60
60
 
61
61
 
let xpCallES = 100000
62
62
 
63
63
 
let xpCustomName = 5000000
64
64
 
65
65
 
let xpNewSLand = 50000000
66
66
 
67
67
 
let xpUpgradeInfra = 100000
68
68
 
69
69
 
let xpMerge = 10000000
70
70
 
71
71
 
let xpOnboard = 10000000
72
72
 
73
73
 
let xpHeal = 10000
74
74
 
75
75
 
func levelByXP (xp) = fraction(xpLevelScale, pow(xp, 4, xpLevelRecipPow, 4, 4, DOWN), SCALE8)
76
76
 
77
77
 
78
78
 
func maxHealth (level) = (100 + level)
79
79
 
80
80
 
81
81
 
func levelUp (currLevel,newXP) = {
82
82
 
    let newLevel = levelByXP(newXP)
83
83
 
[newLevel, (numPointsOnLevelUp * (newLevel - currLevel))]
84
84
 
    }
85
85
 
86
86
 
87
87
 
let LANDPREFIX = "LAND"
88
88
 
89
89
 
let DUCKPREFIX = "DUCK"
90
90
 
91
91
 
let ARTPRESALE = "PRESALE"
92
92
 
93
93
 
let NUMRES = 6
94
94
 
95
95
 
let DAILYRESBYPIECE = 3456000
96
96
 
97
97
 
let DAYMILLIS = 86400000
98
98
 
99
99
 
let WHMULTIPLIER = 10000000000
100
100
 
101
101
 
let DEFAULTLOCATION = "Africa_F_Africa"
102
102
 
103
103
 
let RESOURCEPRICEMIN = 39637
104
104
 
105
105
 
let ESSELLCOEF = 10
106
106
 
107
107
 
let prodTypes = ["First Aid Kit L1", "First Aid Kit L2", "First Aid Kit L3", "Backpack L1", "Backpack L2", "Backpack L3", "Food Ration L1", "Food Ration L2", "Food Ration L3", "Jet Pack L1", "Jet Pack L2", "Jet Pack L3", "Shield L1", "Shield L2", "Shield L3"]
108
108
 
109
109
 
let continents = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
110
110
 
111
111
 
let COEFF2MAT = 10000000
112
112
 
113
113
 
let productionMatrix = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_30_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_50_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_70_0,0,0,0,0,0,0_201"]
114
114
 
115
115
 
let rIdxCoeff = 6
116
+
117
+
let rIdxSlots = 10
116
118
 
117
119
 
let PRODUCTPKGSIZE = 10
118
120
 
119
121
 
let whIdxLevels = 0
120
122
 
121
123
 
let whIdxRes = 1
122
124
 
123
125
 
let whIdxMat = 2
124
126
 
125
127
 
let whIdxProd = 3
126
128
 
127
129
 
let whIdxLOFT = 4
128
130
 
129
131
 
let volLocked = 0
130
132
 
131
133
 
let volOccupied = 1
132
134
 
133
135
 
let volFree = 2
134
136
 
135
137
 
let volTotal = 3
136
138
 
137
139
 
let bpIdxLevel = 0
138
140
 
139
141
 
let bpIdxRes = 1
140
142
 
141
143
 
let bpIdxMat = 2
142
144
 
143
145
 
let bpIdxProd = 3
144
146
 
145
147
 
func keyLastTxIdByUser (addr) = ("lastTxIdByUser_" + addr)
146
148
 
147
149
 
148
150
 
func keyLandAssetIdToOwner (assetId) = ("nftOwner_" + assetId)
149
151
 
150
152
 
151
153
 
func keyLandAssetIdToCustomName (assetId) = ("landCustomNameByAssetId_" + assetId)
152
154
 
153
155
 
154
156
 
func keyStakedTimeByAssetId (assetId) = ("stakedTime_" + assetId)
155
157
 
156
158
 
157
159
 
func keyInfraLevelByAssetId (assetId) = ("infraLevel_" + assetId)
158
160
 
159
161
 
160
162
 
func keyLandArtStatusByTypeAndAssetId (type,assetId) = makeString(["landArtStatus", type, assetId], "_")
161
163
 
162
164
 
163
165
 
func keyStakedTimeByTypeAssetIdAndOwner (nftType,assetId,ownerAddr) = ((((("stakedTimeByTypeAssetIdAndOwner_" + nftType) + "_") + assetId) + "_") + ownerAddr)
164
166
 
165
167
 
166
168
 
func keyWarehouseByLand (landAssetId) = ("wareHouse_" + landAssetId)
167
169
 
168
170
 
169
171
 
func keyDuckAssetIdToCustomName (assetId) = ("duckCustomNameByAssetId_" + assetId)
170
172
 
171
173
 
172
174
 
func keyAddressToCustomName (addr) = ("accountCustomNameByAddr_" + addr)
173
175
 
174
176
 
175
177
 
func keyAddressRefBy (addr) = ("accRefBy_" + addr)
176
178
 
177
179
 
178
180
 
func keyOnboardArtActivatedOnDuck (duckAssetId) = ("onboardArtActivatedOnDuck_" + duckAssetId)
179
181
 
180
182
 
181
183
 
func keyOnboardArtDuckActivatedBy (addr) = ("onboardArtActivatedDuckBy_" + addr)
182
184
 
183
185
 
184
186
 
func keyAddressReferrals (addr) = ("accReferrals_" + addr)
185
187
 
186
188
 
187
189
 
func keyDuckIdToOwner (assetId) = ("duckOwner_" + assetId)
188
190
 
189
191
 
190
192
 
func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
191
193
 
192
194
 
193
195
 
func keyBackpackByDuck (duckAssetId) = ("backPack_" + duckAssetId)
194
196
 
195
197
 
196
198
 
func keyDuckLocation (duckAssetId) = ("duckLocation_" + duckAssetId)
197
199
 
198
200
 
199
201
 
func keyDuckHealth (duckAssetId) = ("duckHealth_" + duckAssetId)
200
202
 
201
203
 
202
204
 
func keyBlocked () = "contractsBlocked"
203
205
 
204
206
 
205
207
 
func keyUserGwlReleaseTime (userAddr) = ("%s%s__userGwlReleaseTime__" + userAddr)
206
208
 
207
209
 
208
210
 
func keyEsWarehouse () = "emergencyWarehouseProducts"
209
211
 
210
212
 
211
213
 
let locIdxType = 1
212
214
 
213
215
 
let locIdxId = 2
214
216
 
215
217
 
func getRecipeMaterials (recipe) = (parseIntValue(recipe[rIdxCoeff]) * COEFF2MAT)
216
218
 
217
219
 
218
220
 
let KSALLOWXPLEVELS = true
219
221
 
220
222
 
let chain = take(drop(this.bytes, 1), 1)
221
223
 
222
224
 
let usdtAssetId = match chain {
223
225
 
    case _ => 
224
226
 
        if ((base58'2W' == $match0))
225
227
 
            then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
226
228
 
            else if ((base58'2T' == $match0))
227
229
 
                then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
228
230
 
                else throw("Unknown chain")
229
231
 
}
230
232
 
231
233
 
let defaultRestAddressStr = match chain {
232
234
 
    case _ => 
233
235
 
        if ((base58'2W' == $match0))
234
236
 
            then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
235
237
 
            else if ((base58'2T' == $match0))
236
238
 
                then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
237
239
 
                else throw("Unknown chain")
238
240
 
}
239
241
 
240
242
 
let InfraUpgradeCostS = match chain {
241
243
 
    case _ => 
242
244
 
        if ((base58'2W' == $match0))
243
245
 
            then 10000000000
244
246
 
            else if ((base58'2T' == $match0))
245
247
 
                then 100000000
246
248
 
                else throw("Unknown chain")
247
249
 
}
248
250
 
249
251
 
let arbitrageDelay = match chain {
250
252
 
    case _ => 
251
253
 
        if ((base58'2W' == $match0))
252
254
 
            then 600000
253
255
 
            else if ((base58'2T' == $match0))
254
256
 
                then 60000
255
257
 
                else throw("Unknown chain")
256
258
 
}
257
259
 
258
260
 
let SEP = "__"
259
261
 
260
262
 
let MULT6 = 1000000
261
263
 
262
264
 
let MULT8 = 100000000
263
265
 
264
266
 
let SSIZE = 25
265
267
 
266
268
 
let MSIZE = 100
267
269
 
268
270
 
let LSIZE = 225
269
271
 
270
272
 
let XLSIZE = 400
271
273
 
272
274
 
let XXLSIZE = 625
273
275
 
274
276
 
func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
275
277
 
276
278
 
277
279
 
let IdxCfgStakingDapp = 1
278
280
 
279
281
 
let IdxCfgEconomyDapp = 2
280
282
 
281
283
 
let IdxCfgGovernanceDapp = 3
282
284
 
283
285
 
let IdxCfgWlgDapp = 4
284
286
 
285
287
 
func keyRestCfg () = "%s__restConfig"
286
288
 
287
289
 
288
290
 
func keyRestAddress () = "%s__restAddr"
289
291
 
290
292
 
291
293
 
func readRestCfgOrFail (rest) = split_4C(getStringOrFail(rest, keyRestCfg()), SEP)
292
294
 
293
295
 
294
296
 
func getContractAddressOrFail (restCfg,idx) = valueOrErrorMessage(addressFromString(restCfg[idx]), ("Rest cfg doesn't contain address at index " + toString(idx)))
295
297
 
296
298
 
297
299
 
let restContract = addressFromStringValue(valueOrElse(getString(this, keyRestAddress()), defaultRestAddressStr))
298
300
 
299
301
 
let restCfg = readRestCfgOrFail(restContract)
300
302
 
301
303
 
let stakingContract = getContractAddressOrFail(restCfg, IdxCfgStakingDapp)
302
304
 
303
305
 
let economyContract = getContractAddressOrFail(restCfg, IdxCfgEconomyDapp)
304
306
 
305
307
 
let govContract = getContractAddressOrFail(restCfg, IdxCfgGovernanceDapp)
306
308
 
307
309
 
let wlgContract = getContractAddressOrFail(restCfg, IdxCfgWlgDapp)
308
310
 
309
311
 
let recLandNum = 0
310
312
 
311
313
 
let recLandSize = 1
312
314
 
313
315
 
let recTerrains = 2
314
316
 
315
317
 
let recContinent = 3
316
318
 
317
319
 
func keyResProportions () = "resTypesProportions"
318
320
 
319
321
 
320
322
 
func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
321
323
 
322
324
 
323
325
 
func keyStakedPiecesByOwner (ownerAddr) = ("stakedPiecesByOwner_" + ownerAddr)
324
326
 
325
327
 
326
328
 
func asString (v) = match v {
327
329
 
    case s: String => 
328
330
 
        s
329
331
 
    case _ => 
330
332
 
        throw("fail to cast into String")
331
333
 
}
332
334
 
333
335
 
334
336
 
func asInt (v) = match v {
335
337
 
    case n: Int => 
336
338
 
        n
337
339
 
    case _ => 
338
340
 
        throw("fail to cast into Int")
339
341
 
}
340
342
 
341
343
 
342
344
 
func numPiecesBySize (landSize) = match landSize {
343
345
 
    case _ => 
344
346
 
        if (("S" == $match0))
345
347
 
            then SSIZE
346
348
 
            else if (("M" == $match0))
347
349
 
                then MSIZE
348
350
 
                else if (("L" == $match0))
349
351
 
                    then LSIZE
350
352
 
                    else if (("XL" == $match0))
351
353
 
                        then XLSIZE
352
354
 
                        else if (("XXL" == $match0))
353
355
 
                            then XXLSIZE
354
356
 
                            else throw("Unknown land size")
355
357
 
}
356
358
 
357
359
 
358
360
 
let incubatorAddr = match chain {
359
361
 
    case _ => 
360
362
 
        if ((base58'2W' == $match0))
361
363
 
            then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
362
364
 
            else if ((base58'2T' == $match0))
363
365
 
                then this
364
366
 
                else throw("Unknown chain")
365
367
 
}
366
368
 
367
369
 
let breederAddr = match chain {
368
370
 
    case _ => 
369
371
 
        if ((base58'2W' == $match0))
370
372
 
            then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
371
373
 
            else if ((base58'2T' == $match0))
372
374
 
                then this
373
375
 
                else throw("Unknown chain")
374
376
 
}
375
377
 
376
378
 
let pub = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
377
379
 
378
380
 
let medKitHp = [30, 60, 120]
379
381
 
380
382
 
let FIVEMINUTESMILLIS = 300000
381
383
 
382
384
 
let RENAMINGCOST = 5000000
383
385
 
384
386
 
let MAXNAMELEN = 50
385
387
 
386
388
 
let InfraUpgradeCostSUsdt = 10000000
387
389
 
388
390
 
let EXPMATERIALS = match chain {
389
391
 
    case _ => 
390
392
 
        if ((base58'2W' == $match0))
391
393
 
            then 252289527462
392
394
 
            else if ((base58'2T' == $match0))
393
395
 
                then 2522895274
394
396
 
                else throw("Unknown chain")
395
397
 
}
396
398
 
397
399
 
let EXPUSDT = match chain {
398
400
 
    case _ => 
399
401
 
        if ((base58'2W' == $match0))
400
402
 
            then 250000000
401
403
 
            else if ((base58'2T' == $match0))
402
404
 
                then 250000000
403
405
 
                else throw("Unknown chain")
404
406
 
}
405
407
 
406
408
 
let FIVEX = toBigInt(5)
407
409
 
408
410
 
let TWENTYX = toBigInt(20)
409
411
 
410
412
 
let TWENTY2X = toBigInt((20 * 20))
411
413
 
412
414
 
let TWENTY3X = toBigInt(((20 * 20) * 20))
413
415
 
414
416
 
let TWENTY4X = toBigInt((((20 * 20) * 20) * 20))
415
417
 
416
418
 
let TWENTY5X = toBigInt(((((20 * 20) * 20) * 20) * 20))
417
419
 
418
420
 
let PRESALENUMLANDS = 500
419
421
 
420
422
 
func keyNextFreeLandNum () = "nextLandNum"
421
423
 
422
424
 
423
425
 
func keyLandToAssetId (landNum) = ("landToAsset_" + landNum)
424
426
 
425
427
 
426
428
 
func keyLandCustomNameToAssetId (name) = ("landByCustomName_" + name)
427
429
 
428
430
 
429
431
 
func keyInfraLevelByAssetIdAndOwner (assetId,ownerAddr) = ((("infraLevelByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
430
432
 
431
433
 
432
434
 
func keyLandArtStatusByTypeAssetIdAndOwner (type,assetId,ownerAddr) = makeString(["landArtStatusByTypeAssetIdAndOwner", type, assetId, ownerAddr], "_")
433
435
 
434
436
 
435
437
 
func keyLandNumToOwner (landNum) = ("landOwner_" + landNum)
436
438
 
437
439
 
438
440
 
func keyDuckCustomNameToAssetId (name) = ("duckByCustomName_" + name)
439
441
 
440
442
 
441
443
 
func keyCustomNameToAddress (name) = ("accountByCustomName_" + name)
442
444
 
443
445
 
444
446
 
func keyOldies () = "oldiesList"
445
447
 
446
448
 
447
449
 
let claimModeWh = 0
448
450
 
449
451
 
let claimModeDuck = 1
450
452
 
451
453
 
let claimModeWhThenDuck = 2
452
454
 
453
455
 
let flHealth = 0
454
456
 
455
457
 
let flTimestamp = 5
456
458
 
457
459
 
let flBonus = 6
458
460
 
459
461
 
let flProdsUsed = 7
460
462
 
461
463
 
func nftName (landNum,landSize) = ((LANDPREFIX + landNum) + landSize)
462
464
 
463
465
 
464
466
 
func distributeByWeights (total,weights) = {
465
467
 
    let sum = (((((weights[0] + weights[1]) + weights[2]) + weights[3]) + weights[4]) + weights[5])
466
468
 
    if ((0 >= sum))
467
469
 
        then throw("Zero weights sum")
468
470
 
        else {
469
471
 
            let norm6 = fraction(total, MULT6, sum)
470
472
 
            func normalizer (acc,elem) =             (acc :+ fraction(elem, norm6, MULT6))
471
473
 
472
474
 
            let $l = weights
473
475
 
            let $s = size($l)
474
476
 
            let $acc0 = nil
475
477
 
            func $f0_1 ($a,$i) =             if (($i >= $s))
476
478
 
                then $a
477
479
 
                else normalizer($a, $l[$i])
478
480
 
479
481
 
            func $f0_2 ($a,$i) =             if (($i >= $s))
480
482
 
                then $a
481
483
 
                else throw("List size exceeds 6")
482
484
 
483
485
 
            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
484
486
 
            }
485
487
 
    }
486
488
 
487
489
 
488
490
 
func getNeededMaterials (total) = {
489
491
 
    let props = split(value(getString(keyResProportions())), "_")
490
492
 
    if ((size(props) != NUMRES))
491
493
 
        then throw("Wrong proportions data")
492
494
 
        else {
493
495
 
            let r = [parseIntValue(props[0]), parseIntValue(props[1]), parseIntValue(props[2]), parseIntValue(props[3]), parseIntValue(props[4]), parseIntValue(props[5])]
494
496
 
            distributeByWeights(total, r)
495
497
 
            }
496
498
 
    }
497
499
 
498
500
 
499
501
 
func subtractMaterials (shouldUseMat,has,totalNeed) = {
500
502
 
    let need = getNeededMaterials(totalNeed)
501
503
 
    func subtractor (acc,idx) =     {
502
504
 
        let result = (parseIntValue(has[idx]) - need[idx])
503
505
 
        if ((0 > result))
504
506
 
            then throw(((((("Not enough material idx=" + toString(idx)) + ", you have ") + has[idx]) + ", but need ") + toString(need[idx])))
505
507
 
            else (acc :+ toString(result))
506
508
 
        }
507
509
 
508
510
 
    if (shouldUseMat)
509
511
 
        then {
510
512
 
            let $l = [0, 1, 2, 3, 4, 5]
511
513
 
            let $s = size($l)
512
514
 
            let $acc0 = nil
513
515
 
            func $f0_1 ($a,$i) =             if (($i >= $s))
514
516
 
                then $a
515
517
 
                else subtractor($a, $l[$i])
516
518
 
517
519
 
            func $f0_2 ($a,$i) =             if (($i >= $s))
518
520
 
                then $a
519
521
 
                else throw("List size exceeds 6")
520
522
 
521
523
 
            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
522
524
 
            }
523
525
 
        else has
524
526
 
    }
525
527
 
526
528
 
527
529
 
func subtractProducts (pHas,pUsed) = if ((pUsed == ""))
528
530
 
    then pHas
529
531
 
    else {
530
532
 
        let pList = if ((pHas == ""))
531
533
 
            then nil
532
534
 
            else split(pHas, "_")
533
535
 
        func subP (acc,item) =         {
534
536
 
            let j = acc._1
535
537
 
            func checkUsed (ac,idxAmt) =             {
536
538
 
                let parts = split(idxAmt, ",")
537
539
 
                if ((size(parts) != 2))
538
540
 
                    then throw("Incorrect format, should be index,amount")
539
541
 
                    else {
540
542
 
                        let idx = parseIntValue(parts[0])
541
543
 
                        if (if ((0 > idx))
542
544
 
                            then true
543
545
 
                            else (idx >= size(productionMatrix)))
544
546
 
                            then throw("Unknown product idx")
545
547
 
                            else if ((idx != j))
546
548
 
                                then ac
547
549
 
                                else {
548
550
 
                                    let amt = parseIntValue(parts[1])
549
551
 
                                    if ((0 >= amt))
550
552
 
                                        then throw("Pass only positive amounts")
551
553
 
                                        else (ac + amt)
552
554
 
                                    }
553
555
 
                        }
554
556
 
                }
555
557
 
556
558
 
            let a = {
557
559
 
                let $l = split(pUsed, "_")
558
560
 
                let $s = size($l)
559
561
 
                let $acc0 = 0
560
562
 
                func $f0_1 ($a,$i) =                 if (($i >= $s))
561
563
 
                    then $a
562
564
 
                    else checkUsed($a, $l[$i])
563
565
 
564
566
 
                func $f0_2 ($a,$i) =                 if (($i >= $s))
565
567
 
                    then $a
566
568
 
                    else throw("List size exceeds 10")
567
569
 
568
570
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
569
571
 
                }
570
572
 
            let curr = if ((size(pList) > j))
571
573
 
                then parseIntValue(pList[j])
572
574
 
                else 0
573
575
 
            let newAmt = if ((curr >= a))
574
576
 
                then (curr - a)
575
577
 
                else throw(((((("You have " + toString(curr)) + " of ") + prodTypes[j]) + ", but tried to use ") + toString(a)))
576
578
 
            $Tuple2((j + 1), (acc._2 :+ toString(newAmt)))
577
579
 
            }
578
580
 
579
581
 
        let newProd = {
580
582
 
            let $l = productionMatrix
581
583
 
            let $s = size($l)
582
584
 
            let $acc0 = $Tuple2(0, nil)
583
585
 
            func $f0_1 ($a,$i) =             if (($i >= $s))
584
586
 
                then $a
585
587
 
                else subP($a, $l[$i])
586
588
 
587
589
 
            func $f0_2 ($a,$i) =             if (($i >= $s))
588
590
 
                then $a
589
591
 
                else throw("List size exceeds 50")
590
592
 
591
593
 
            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
592
594
 
            }
593
595
 
        makeString(newProd._2, "_")
594
596
 
        }
595
597
 
596
598
 
597
-
func addProd (idxCnt,pList,isPositive) = {
599
+
func addProd (idxCnt,pList,isPositive,segment,mainAux,slot) = {
598
600
 
    let parts = split(idxCnt, ":")
599
601
 
    if ((size(parts) != 2))
600
602
 
        then throw("Incorrect format, should be index:amount")
601
603
 
        else {
602
604
 
            let productIdx = parseIntValue(parts[0])
603
605
 
            let count = parseIntValue(parts[1])
604
606
 
            if (if ((0 > productIdx))
605
607
 
                then true
606
608
 
                else (productIdx >= size(productionMatrix)))
607
609
 
                then throw("Unknown product idx")
608
610
 
                else if ((0 > count))
609
611
 
                    then throw("Count can't be negative")
610
612
 
                    else if ((count == 0))
611
-
                        then pList
613
+
                        then $Tuple2(pList, false)
612
614
 
                        else {
613
615
 
                            func addP (acc,item) =                             {
614
616
 
                                let j = acc._1
615
617
 
                                let curr = if ((size(pList) > j))
616
618
 
                                    then parseIntValue(pList[j])
617
619
 
                                    else 0
618
620
 
                                if (if (!(isPositive))
619
621
 
                                    then (count > curr)
620
622
 
                                    else false)
621
623
 
                                    then throw(((((("You have " + toString(curr)) + " of ") + prodTypes[j]) + ", but tried to use ") + toString(count)))
622
-
                                    else $Tuple2((j + 1), (acc._2 :+ toString(if ((productIdx != j))
623
-
                                        then curr
624
-
                                        else (curr + (if (isPositive)
625
-
                                            then count
626
-
                                            else -(count))))))
624
+
                                    else {
625
+
                                        let isBig = if (!(isPositive))
626
+
                                            then {
627
+
                                                let compat = split(item, "_")[rIdxSlots]
628
+
                                                if ((compat == ""))
629
+
                                                    then throw("Item cannot be equipped")
630
+
                                                    else {
631
+
                                                        let c = parseIntValue(compat)
632
+
                                                        let cSeg = (c / 100)
633
+
                                                        if ((segment != cSeg))
634
+
                                                            then throw("Segment incompatible")
635
+
                                                            else {
636
+
                                                                let cMainAux = ((c % 100) / 10)
637
+
                                                                if ((mainAux != cMainAux))
638
+
                                                                    then throw("Slot incompatible")
639
+
                                                                    else {
640
+
                                                                        let cNumSlots = (c % 10)
641
+
                                                                        if (if ((slot != 0))
642
+
                                                                            then (cNumSlots > 1)
643
+
                                                                            else false)
644
+
                                                                            then throw("Big items should occupy slot 0")
645
+
                                                                            else (cNumSlots > 1)
646
+
                                                                        }
647
+
                                                                }
648
+
                                                        }
649
+
                                                }
650
+
                                            else false
651
+
                                        $Tuple3((j + 1), (acc._2 :+ toString(if ((productIdx != j))
652
+
                                            then curr
653
+
                                            else (curr + (if (isPositive)
654
+
                                                then count
655
+
                                                else -(count))))), if (acc._3)
656
+
                                            then true
657
+
                                            else isBig)
658
+
                                        }
627
659
 
                                }
628
660
 
629
-
(                            let $l = productionMatrix
630
-
                            let $s = size($l)
631
-
                            let $acc0 = $Tuple2(0, nil)
632
-
                            func $f0_1 ($a,$i) =                             if (($i >= $s))
633
-
                                then $a
634
-
                                else addP($a, $l[$i])
635
-
636
-
                            func $f0_2 ($a,$i) =                             if (($i >= $s))
637
-
                                then $a
638
-
                                else throw("List size exceeds 42")
639
-
640
-
                            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42))._2
661
+
                            let result = {
662
+
                                let $l = productionMatrix
663
+
                                let $s = size($l)
664
+
                                let $acc0 = $Tuple3(0, nil, false)
665
+
                                func $f0_1 ($a,$i) =                                 if (($i >= $s))
666
+
                                    then $a
667
+
                                    else addP($a, $l[$i])
668
+
669
+
                                func $f0_2 ($a,$i) =                                 if (($i >= $s))
670
+
                                    then $a
671
+
                                    else throw("List size exceeds 27")
672
+
673
+
                                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27)
674
+
                                }
675
+
                            $Tuple2(result._2, result._3)
641
676
 
                            }
642
677
 
            }
643
678
 
    }
644
679
 
645
680
 
646
-
func slotsGroup (g,bpIn,isPositive) = if ((g != ""))
681
+
func slotsGroup (g,bpIn,isPositive,segment,mainAux) = if ((g != ""))
647
682
 
    then {
648
683
 
        let slots = split(g, ",")
649
684
 
        if ((size(slots) > MAXSLOTS))
650
685
 
            then throw("Wrong slots format")
651
686
 
            else {
652
687
 
                let s0 = slots[0]
653
688
 
                let s1 = if ((size(slots) > 1))
654
689
 
                    then slots[1]
655
690
 
                    else ""
656
691
 
                if (if ((s0 == ""))
657
692
 
                    then (s1 == "")
658
693
 
                    else false)
659
694
 
                    then bpIn
660
695
 
                    else {
661
696
 
                        let tmpS0 = if ((s0 != ""))
662
-
                            then addProd(s0, bpIn, isPositive)
663
-
                            else bpIn
697
+
                            then addProd(s0, bpIn, isPositive, segment, mainAux, 0)
698
+
                            else $Tuple2(bpIn, false)
664
699
 
                        if ((s1 != ""))
665
-
                            then addProd(s1, tmpS0, isPositive)
666
-
                            else tmpS0
700
+
                            then if (tmpS0._2)
701
+
                                then throw("Big item already occupies slot")
702
+
                                else addProd(s1, tmpS0._1, isPositive, segment, mainAux, 1)._1
703
+
                            else tmpS0._1
667
704
 
                        }
668
705
 
                }
669
706
 
        }
670
707
 
    else bpIn
671
708
 
672
709
 
673
710
 
func dress (segList,pList,isPositive) = {
674
711
 
    func segment (acc,seg) =     {
712
+
        let j = acc._1
675
713
 
        let mainAux = split(seg, ";")
676
714
 
        if ((size(mainAux) != NUMMAINAUX))
677
715
 
            then throw("Wrong segment format")
678
716
 
            else {
679
717
 
                let m = mainAux[0]
680
718
 
                let a = mainAux[1]
681
719
 
                if (if ((m == ""))
682
720
 
                    then (a == "")
683
721
 
                    else false)
684
-
                    then acc
722
+
                    then $Tuple2((j + 1), acc._2)
685
723
 
                    else {
686
-
                        let tmpM = slotsGroup(m, acc, isPositive)
687
-
                        slotsGroup(a, tmpM, isPositive)
724
+
                        let tmpM = slotsGroup(m, acc._2, isPositive, j, 0)
725
+
                        $Tuple2((j + 1), slotsGroup(a, tmpM, isPositive, j, 1))
688
726
 
                        }
689
727
 
                }
690
728
 
        }
691
729
 
692
-
    let $l = segList
730
+
(    let $l = segList
693
731
 
    let $s = size($l)
694
-
    let $acc0 = pList
732
+
    let $acc0 = $Tuple2(0, pList)
695
733
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
696
734
 
        then $a
697
735
 
        else segment($a, $l[$i])
698
736
 
699
737
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
700
738
 
        then $a
701
739
 
        else throw("List size exceeds 6")
702
740
 
703
-
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
741
+
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6))._2
704
742
 
    }
705
743
 
706
744
 
707
745
 
func updateProportionsInternal (propList,terrainCounts,landSizeIndex,sign) = if ((size(propList) != NUMRES))
708
746
 
    then throw("Wrong proportions data")
709
747
 
    else {
710
748
 
        func updater (acc,i) =         {
711
749
 
            let result = (parseIntValue(propList[i]) + ((sign * terrainCounts[i]) * landSizeIndex))
712
750
 
            if ((0 > result))
713
751
 
                then throw(((((((("Panic! Pieces of type=" + toString(i)) + ", sign=") + toString(sign)) + ",  terrainCounts[i]=") + toString(terrainCounts[i])) + ", landSizeIndex=") + toString(landSizeIndex)))
714
752
 
                else (acc :+ toString(result))
715
753
 
            }
716
754
 
717
755
 
        let r = {
718
756
 
            let $l = [0, 1, 2, 3, 4, 5]
719
757
 
            let $s = size($l)
720
758
 
            let $acc0 = nil
721
759
 
            func $f0_1 ($a,$i) =             if (($i >= $s))
722
760
 
                then $a
723
761
 
                else updater($a, $l[$i])
724
762
 
725
763
 
            func $f0_2 ($a,$i) =             if (($i >= $s))
726
764
 
                then $a
727
765
 
                else throw("List size exceeds 6")
728
766
 
729
767
 
            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
730
768
 
            }
731
769
 
        makeString(r, "_")
732
770
 
        }
733
771
 
734
772
 
735
773
 
func updateProportions (terrainCounts,landSizeIndex,sign) = {
736
774
 
    let propList = split(valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0"), "_")
737
775
 
    updateProportionsInternal(propList, terrainCounts, landSizeIndex, sign)
738
776
 
    }
739
777
 
740
778
 
741
779
 
func countTerrains (terrains) = [(size(split(terrains, "A")) - 1), (size(split(terrains, "B")) - 1), (size(split(terrains, "C")) - 1), (size(split(terrains, "D")) - 1), (size(split(terrains, "E")) - 1), (size(split(terrains, "F")) - 1)]
742
780
 
743
781
 
744
782
 
func addRes (currentRes,terrainCounts,deltaTime,landSizeIndex,dailyByPieceWithBonuses) = {
745
783
 
    func adder (acc,i) =     {
746
784
 
        let resOfType = ((fraction(deltaTime, dailyByPieceWithBonuses, DAYMILLIS) * terrainCounts[i]) * landSizeIndex)
747
785
 
        (acc :+ toString((parseIntValue(currentRes[i]) + resOfType)))
748
786
 
        }
749
787
 
750
788
 
    let r = {
751
789
 
        let $l = [0, 1, 2, 3, 4, 5]
752
790
 
        let $s = size($l)
753
791
 
        let $acc0 = nil
754
792
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
755
793
 
            then $a
756
794
 
            else adder($a, $l[$i])
757
795
 
758
796
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
759
797
 
            then $a
760
798
 
            else throw("List size exceeds 6")
761
799
 
762
800
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
763
801
 
        }
764
802
 
    makeString(r, "_")
765
803
 
    }
766
804
 
767
805
 
768
806
 
func virtClaim (terrainCounts,deltaTime,landSizeIndex,dailyByPieceWithBonuses) = {
769
807
 
    func adder (acc,i) =     {
770
808
 
        let resOfType = ((fraction(deltaTime, dailyByPieceWithBonuses, DAYMILLIS) * terrainCounts[i]) * landSizeIndex)
771
809
 
        $Tuple2((acc._1 :+ resOfType), (acc._2 + resOfType))
772
810
 
        }
773
811
 
774
812
 
    let $l = [0, 1, 2, 3, 4, 5]
775
813
 
    let $s = size($l)
776
814
 
    let $acc0 = $Tuple2(nil, 0)
777
815
 
    func $f0_1 ($a,$i) =     if (($i >= $s))
778
816
 
        then $a
779
817
 
        else adder($a, $l[$i])
780
818
 
781
819
 
    func $f0_2 ($a,$i) =     if (($i >= $s))
782
820
 
        then $a
783
821
 
        else throw("List size exceeds 6")
784
822
 
785
823
 
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
786
824
 
    }
787
825
 
788
826
 
789
827
 
func distributeRes (currentWhRes,currentPackRes,resToClaim,whSpaceLeft) = {
790
828
 
    let resListToClaim = resToClaim._1
791
829
 
    let resAmToClaim = resToClaim._2
792
830
 
    if ((resAmToClaim == 0))
793
831
 
        then $Tuple2(makeString(currentWhRes, "_"), makeString(currentPackRes, "_"))
794
832
 
        else if ((whSpaceLeft >= resAmToClaim))
795
833
 
            then {
796
834
 
                func addLists (acc,i) =                 (acc :+ toString((parseIntValue(currentWhRes[i]) + resListToClaim[i])))
797
835
 
798
836
 
                let r = {
799
837
 
                    let $l = [0, 1, 2, 3, 4, 5]
800
838
 
                    let $s = size($l)
801
839
 
                    let $acc0 = nil
802
840
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
803
841
 
                        then $a
804
842
 
                        else addLists($a, $l[$i])
805
843
 
806
844
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
807
845
 
                        then $a
808
846
 
                        else throw("List size exceeds 6")
809
847
 
810
848
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
811
849
 
                    }
812
850
 
                $Tuple2(makeString(r, "_"), makeString(currentPackRes, "_"))
813
851
 
                }
814
852
 
            else {
815
853
 
                func addPartLists (acc,i) =                 {
816
854
 
                    let whPart = fraction(resListToClaim[i], whSpaceLeft, resAmToClaim)
817
855
 
                    $Tuple2((acc._1 :+ toString((parseIntValue(currentWhRes[i]) + whPart))), (acc._2 :+ toString(((parseIntValue(currentPackRes[i]) + resListToClaim[i]) - whPart))))
818
856
 
                    }
819
857
 
820
858
 
                let r = {
821
859
 
                    let $l = [0, 1, 2, 3, 4, 5]
822
860
 
                    let $s = size($l)
823
861
 
                    let $acc0 = $Tuple2(nil, nil)
824
862
 
                    func $f0_1 ($a,$i) =                     if (($i >= $s))
825
863
 
                        then $a
826
864
 
                        else addPartLists($a, $l[$i])
827
865
 
828
866
 
                    func $f0_2 ($a,$i) =                     if (($i >= $s))
829
867
 
                        then $a
830
868
 
                        else throw("List size exceeds 6")
831
869
 
832
870
 
                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
833
871
 
                    }
834
872
 
                $Tuple2(makeString(r._1, "_"), makeString(r._2, "_"))
835
873
 
                }
836
874
 
    }
837
875
 
838
876
 
839
877
 
func abs (x) = if ((x >= toBigInt(0)))
840
878
 
    then x
841
879
 
    else -(x)
842
880
 
843
881
 
844
882
 
let freq = [[6, 9, 14, 15, 16], [5, 8, 13, 14, 15], [1, 4, 9, 10, 15], [1, 6, 7, 15, 19], [4, 7, 8, 13, 18]]
845
883
 
846
884
 
func genChar (n,freqs) = {
847
885
 
    let rem = toInt((n % TWENTYX))
848
886
 
    let letter = if ((freqs[0] > rem))
849
887
 
        then "A"
850
888
 
        else if ((freqs[1] > rem))
851
889
 
            then "B"
852
890
 
            else if ((freqs[2] > rem))
853
891
 
                then "C"
854
892
 
                else if ((freqs[3] > rem))
855
893
 
                    then "D"
856
894
 
                    else if ((freqs[4] > rem))
857
895
 
                        then "E"
858
896
 
                        else "F"
859
897
 
    letter
860
898
 
    }
861
899
 
862
900
 
863
901
 
func genTerrains (seed,continentIdx) = {
864
902
 
    let f = freq[continentIdx]
865
903
 
    func terrainGenerator (acc,elem) =     $Tuple2((((((acc._1 + genChar(acc._2, f)) + genChar((acc._2 / TWENTYX), f)) + genChar((acc._2 / TWENTY2X), f)) + genChar((acc._2 / TWENTY3X), f)) + genChar((acc._2 / TWENTY4X), f)), (acc._2 / TWENTY5X))
866
904
 
867
905
 
    let t = {
868
906
 
        let $l = [1, 2, 3, 4, 5]
869
907
 
        let $s = size($l)
870
908
 
        let $acc0 = $Tuple2("", (seed / FIVEX))
871
909
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
872
910
 
            then $a
873
911
 
            else terrainGenerator($a, $l[$i])
874
912
 
875
913
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
876
914
 
            then $a
877
915
 
            else throw("List size exceeds 5")
878
916
 
879
917
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
880
918
 
        }
881
919
 
    t._1
882
920
 
    }
883
921
 
884
922
 
885
923
 
func getBackpack (bpKey) = {
886
924
 
    let p = split(valueOrElse(getString(bpKey), "0:0_0_0_0_0_0:0_0_0_0_0_0:"), ":")
887
925
 
[toString(valueOrElse(parseInt(p[bpIdxLevel]), 0)), if ((size(split(p[bpIdxRes], "_")) == NUMRES))
888
926
 
        then p[bpIdxRes]
889
927
 
        else "0_0_0_0_0_0", if ((size(split(p[bpIdxMat], "_")) == NUMRES))
890
928
 
        then p[bpIdxMat]
891
929
 
        else "0_0_0_0_0_0", p[bpIdxProd]]
892
930
 
    }
893
931
 
894
932
 
895
933
 
func getWarehouseTotalVolume (volPrefix) = {
896
934
 
    let parts = split(volPrefix, "_")
897
935
 
    ((WHMULTIPLIER * (parseIntValue(parts[1]) + 1)) * parseIntValue(parts[0]))
898
936
 
    }
899
937
 
900
938
 
901
939
 
func getWarehouseOccupiedVol (currentWh) = {
902
940
 
    let goods = currentWh[whIdxProd]
903
941
 
    func sumResMat (acc,item) =     (acc + parseIntValue(item))
904
942
 
905
943
 
    func sumProd (acc,item) =     {
906
944
 
        let idx = acc._1
907
945
 
        let pkgs = (((parseIntValue(item) + PRODUCTPKGSIZE) - 1) / PRODUCTPKGSIZE)
908
946
 
        $Tuple2((idx + 1), (acc._2 + (pkgs * MULT8)))
909
947
 
        }
910
948
 
911
949
 
    let whResVol = {
912
950
 
        let $l = split(currentWh[whIdxRes], "_")
913
951
 
        let $s = size($l)
914
952
 
        let $acc0 = 0
915
953
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
916
954
 
            then $a
917
955
 
            else sumResMat($a, $l[$i])
918
956
 
919
957
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
920
958
 
            then $a
921
959
 
            else throw("List size exceeds 6")
922
960
 
923
961
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
924
962
 
        }
925
963
 
    let whMatVol = {
926
964
 
        let $l = split(currentWh[whIdxMat], "_")
927
965
 
        let $s = size($l)
928
966
 
        let $acc0 = 0
929
967
 
        func $f1_1 ($a,$i) =         if (($i >= $s))
930
968
 
            then $a
931
969
 
            else sumResMat($a, $l[$i])
932
970
 
933
971
 
        func $f1_2 ($a,$i) =         if (($i >= $s))
934
972
 
            then $a
935
973
 
            else throw("List size exceeds 6")
936
974
 
937
975
 
        $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6)
938
976
 
        }
939
977
 
    let whGoodsVol = if ((goods == ""))
940
978
 
        then 0
941
979
 
        else (        let $l = split_4C(goods, "_")
942
980
 
        let $s = size($l)
943
981
 
        let $acc0 = $Tuple2(0, 0)
944
982
 
        func $f2_1 ($a,$i) =         if (($i >= $s))
945
983
 
            then $a
946
984
 
            else sumProd($a, $l[$i])
947
985
 
948
986
 
        func $f2_2 ($a,$i) =         if (($i >= $s))
949
987
 
            then $a
950
988
 
            else throw("List size exceeds 50")
951
989
 
952
990
 
        $f2_2($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50))._2
953
991
 
    ((whResVol + whMatVol) + whGoodsVol)
954
992
 
    }
955
993
 
956
994
 
957
995
 
func getWarehouse (whKey,landIndex,infraLevel) = {
958
996
 
    let volPrefix = ((toString(landIndex) + "_") + toString(infraLevel))
959
997
 
    let whTotal = getWarehouseTotalVolume(volPrefix)
960
998
 
    let whStr = valueOrElse(getString(whKey), (volPrefix + ":0_0_0_0_0_0:0_0_0_0_0_0::0"))
961
999
 
    let wh = split_4C(whStr, ":")
962
1000
 
    let whOccupied = getWarehouseOccupiedVol(wh)
963
1001
 
    let whLoft = if ((5 > size(wh)))
964
1002
 
        then makeString(["0", toString(whOccupied), toString((whTotal - whOccupied)), toString(whTotal)], "_")
965
1003
 
        else {
966
1004
 
            let loft = split(wh[whIdxLOFT], "_")
967
1005
 
            let whLocked = parseIntValue(loft[volLocked])
968
1006
 
            let occ = if ((size(loft) > 1))
969
1007
 
                then parseIntValue(loft[volOccupied])
970
1008
 
                else whOccupied
971
1009
 
            makeString([toString(whLocked), toString(occ), toString(((whTotal - whLocked) - occ)), toString(whTotal)], "_")
972
1010
 
            }
973
1011
 
[wh[whIdxLevels], if ((size(split(wh[whIdxRes], "_")) == NUMRES))
974
1012
 
        then wh[whIdxRes]
975
1013
 
        else "0_0_0_0_0_0", if ((size(split(wh[whIdxMat], "_")) == NUMRES))
976
1014
 
        then wh[whIdxMat]
977
1015
 
        else "0_0_0_0_0_0", wh[whIdxProd], whLoft]
978
1016
 
    }
979
1017
 
980
1018
 
981
1019
 
func getWarehouseSpaceLeft (currentWh) = {
982
1020
 
    let occupiedVol = getWarehouseOccupiedVol(currentWh)
983
1021
 
    let currWhLockedVol = parseIntValue(split(currentWh[whIdxLOFT], "_")[volLocked])
984
1022
 
    ((getWarehouseTotalVolume(currentWh[whIdxLevels]) - occupiedVol) - currWhLockedVol)
985
1023
 
    }
986
1024
 
987
1025
 
988
1026
 
func toVolume (amount,pkgSize) = {
989
1027
 
    let pkgs = if ((amount >= 0))
990
1028
 
        then (((amount + pkgSize) - 1) / pkgSize)
991
1029
 
        else -((((-(amount) + pkgSize) - 1) / pkgSize))
992
1030
 
    (pkgs * MULT8)
993
1031
 
    }
994
1032
 
995
1033
 
996
1034
 
func moveStuff (cargoParts,currentWh,currentPack) = if ((size(cargoParts) != 3))
997
1035
 
    then throw("cargoListStr should contain exactly 2 ':' separators")
998
1036
 
    else {
999
1037
 
        let resParts = split(cargoParts[0], "_")
1000
1038
 
        let matParts = split(cargoParts[1], "_")
1001
1039
 
        let prodParts = if ((cargoParts[2] == ""))
1002
1040
 
            then nil
1003
1041
 
            else split(cargoParts[2], "_")
1004
1042
 
        if ((size(resParts) != NUMRES))
1005
1043
 
            then throw("All 6 resources should be passed")
1006
1044
 
            else if ((size(matParts) != NUMRES))
1007
1045
 
                then throw("All 6 materials should be passed")
1008
1046
 
                else {
1009
1047
 
                    let whSpaceLeft = getWarehouseSpaceLeft(currentWh)
1010
1048
 
                    let currWhRes = split(currentWh[whIdxRes], "_")
1011
1049
 
                    let currWhMat = split(currentWh[whIdxMat], "_")
1012
1050
 
                    let currWhProd = if ((currentWh[whIdxProd] == ""))
1013
1051
 
                        then nil
1014
1052
 
                        else split(currentWh[whIdxProd], "_")
1015
1053
 
                    let currentPackRes = split(currentPack[bpIdxRes], "_")
1016
1054
 
                    let currentPackMat = split(currentPack[bpIdxMat], "_")
1017
1055
 
                    let currentPackProd = if ((currentPack[bpIdxProd] == ""))
1018
1056
 
                        then nil
1019
1057
 
                        else split(currentPack[bpIdxProd], "_")
1020
1058
 
                    func mvR (acc,item) =                     {
1021
1059
 
                        let i = acc._1
1022
1060
 
                        let am = parseIntValue(item)
1023
1061
 
                        let whr = parseIntValue(currWhRes[i])
1024
1062
 
                        let bpr = parseIntValue(currentPackRes[i])
1025
1063
 
                        if ((am == 0))
1026
1064
 
                            then $Tuple4((i + 1), (acc._2 :+ currWhRes[i]), (acc._3 :+ currentPackRes[i]), acc._4)
1027
1065
 
                            else if ((am > 0))
1028
1066
 
                                then if ((am > bpr))
1029
1067
 
                                    then throw((((("Attempt to take " + item) + " from backpack, but only ") + toString(bpr)) + " available"))
1030
1068
 
                                    else $Tuple4((i + 1), (acc._2 :+ toString((whr + am))), (acc._3 :+ toString((bpr - am))), (acc._4 + am))
1031
1069
 
                                else if ((-(am) > whr))
1032
1070
 
                                    then throw((((("Attempt to take " + toString(-(am))) + " from warehouse, but only ") + toString(whr)) + " available"))
1033
1071
 
                                    else $Tuple4((i + 1), (acc._2 :+ toString((whr + am))), (acc._3 :+ toString((bpr - am))), (acc._4 + am))
1034
1072
 
                        }
1035
1073
 
1036
1074
 
                    let r = {
1037
1075
 
                        let $l = resParts
1038
1076
 
                        let $s = size($l)
1039
1077
 
                        let $acc0 = $Tuple4(0, nil, nil, 0)
1040
1078
 
                        func $f0_1 ($a,$i) =                         if (($i >= $s))
1041
1079
 
                            then $a
1042
1080
 
                            else mvR($a, $l[$i])
1043
1081
 
1044
1082
 
                        func $f0_2 ($a,$i) =                         if (($i >= $s))
1045
1083
 
                            then $a
1046
1084
 
                            else throw("List size exceeds 6")
1047
1085
 
1048
1086
 
                        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
1049
1087
 
                        }
1050
1088
 
                    func mvM (acc,item) =                     {
1051
1089
 
                        let i = acc._1
1052
1090
 
                        let am = parseIntValue(item)
1053
1091
 
                        let whm = parseIntValue(currWhMat[i])
1054
1092
 
                        let bpm = parseIntValue(currentPackMat[i])
1055
1093
 
                        if ((am == 0))
1056
1094
 
                            then $Tuple4((i + 1), (acc._2 :+ currWhMat[i]), (acc._3 :+ currentPackMat[i]), acc._4)
1057
1095
 
                            else if ((am > 0))
1058
1096
 
                                then if ((am > bpm))
1059
1097
 
                                    then throw((((("Attempt to take " + item) + " from backpack, but only ") + toString(bpm)) + " available"))
1060
1098
 
                                    else $Tuple4((i + 1), (acc._2 :+ toString((whm + am))), (acc._3 :+ toString((bpm - am))), (acc._4 + am))
1061
1099
 
                                else if ((-(am) > whm))
1062
1100
 
                                    then throw((((("Attempt to take " + toString(-(am))) + " from warehouse, but only ") + toString(whm)) + " available"))
1063
1101
 
                                    else $Tuple4((i + 1), (acc._2 :+ toString((whm + am))), (acc._3 :+ toString((bpm - am))), (acc._4 + am))
1064
1102
 
                        }
1065
1103
 
1066
1104
 
                    let m = {
1067
1105
 
                        let $l = matParts
1068
1106
 
                        let $s = size($l)
1069
1107
 
                        let $acc0 = $Tuple4(0, nil, nil, r._4)
1070
1108
 
                        func $f1_1 ($a,$i) =                         if (($i >= $s))
1071
1109
 
                            then $a
1072
1110
 
                            else mvM($a, $l[$i])
1073
1111
 
1074
1112
 
                        func $f1_2 ($a,$i) =                         if (($i >= $s))
1075
1113
 
                            then $a
1076
1114
 
                            else throw("List size exceeds 6")
1077
1115
 
1078
1116
 
                        $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6)
1079
1117
 
                        }
1080
1118
 
                    func mvP (acc,item) =                     {
1081
1119
 
                        let i = acc._1
1082
1120
 
                        let am = parseIntValue(item)
1083
1121
 
                        let whp = if ((size(currWhProd) > i))
1084
1122
 
                            then parseIntValue(currWhProd[i])
1085
1123
 
                            else 0
1086
1124
 
                        let bpp = if ((size(currentPackProd) > i))
1087
1125
 
                            then parseIntValue(currentPackProd[i])
1088
1126
 
                            else 0
1089
1127
 
                        if ((am == 0))
1090
1128
 
                            then $Tuple4((i + 1), (acc._2 :+ toString(whp)), (acc._3 :+ toString(bpp)), acc._4)
1091
1129
 
                            else if ((am > 0))
1092
1130
 
                                then if ((am > bpp))
1093
1131
 
                                    then throw((((("Attempt to take " + item) + " from backpack, but only ") + toString(bpp)) + " available"))
1094
1132
 
                                    else {
1095
1133
 
                                        let deltaVol = (toVolume((whp + am), PRODUCTPKGSIZE) - toVolume(whp, PRODUCTPKGSIZE))
1096
1134
 
                                        $Tuple4((i + 1), (acc._2 :+ toString((whp + am))), (acc._3 :+ toString((bpp - am))), (acc._4 + deltaVol))
1097
1135
 
                                        }
1098
1136
 
                                else if ((-(am) > whp))
1099
1137
 
                                    then throw((((("Attempt to take " + toString(-(am))) + " from warehouse, but only ") + toString(whp)) + " available"))
1100
1138
 
                                    else {
1101
1139
 
                                        let deltaVol = (toVolume((whp + am), PRODUCTPKGSIZE) - toVolume(whp, PRODUCTPKGSIZE))
1102
1140
 
                                        $Tuple4((i + 1), (acc._2 :+ toString((whp + am))), (acc._3 :+ toString((bpp - am))), (acc._4 + deltaVol))
1103
1141
 
                                        }
1104
1142
 
                        }
1105
1143
 
1106
1144
 
                    let p = if ((size(prodParts) != 0))
1107
1145
 
                        then {
1108
1146
 
                            let $l = prodParts
1109
1147
 
                            let $s = size($l)
1110
1148
 
                            let $acc0 = $Tuple4(0, nil, nil, m._4)
1111
1149
 
                            func $f2_1 ($a,$i) =                             if (($i >= $s))
1112
1150
 
                                then $a
1113
1151
 
                                else mvP($a, $l[$i])
1114
1152
 
1115
1153
 
                            func $f2_2 ($a,$i) =                             if (($i >= $s))
1116
1154
 
                                then $a
1117
1155
 
                                else throw("List size exceeds 50")
1118
1156
 
1119
1157
 
                            $f2_2($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
1120
1158
 
                            }
1121
1159
 
                        else $Tuple4(0, currWhProd, currentPackProd, m._4)
1122
1160
 
                    let volSaldo = p._4
1123
1161
 
                    if ((volSaldo > whSpaceLeft))
1124
1162
 
                        then throw((((("Attempt to put total " + toString(volSaldo)) + " stuff, but only ") + toString(whSpaceLeft)) + " warehouse space left"))
1125
1163
 
                        else $Tuple7(makeString(r._2, "_"), makeString(m._2, "_"), makeString(p._2, "_"), makeString(r._3, "_"), makeString(m._3, "_"), makeString(p._3, "_"), volSaldo)
1126
1164
 
                    }
1127
1165
 
        }
1128
1166
 
1129
1167
 
1130
1168
 
func expeditionInternal (caller,txId) = {
1131
1169
 
    let userAddr = toString(caller)
1132
1170
 
    let bigNum = abs(toBigInt(txId))
1133
1171
 
    let freeNum = valueOrElse(getInteger(keyNextFreeLandNum()), (PRESALENUMLANDS + 1))
1134
1172
 
    let landNum = toString(freeNum)
1135
1173
 
    let continentIdx = toInt((bigNum % FIVEX))
1136
1174
 
    let terrains = genTerrains(bigNum, continentIdx)
1137
1175
 
    let continent = continents[continentIdx]
1138
1176
 
    let issue = Issue(nftName(landNum, "S"), makeString([landNum, "S", terrains, continent], "_"), 1, 0, false)
1139
1177
 
    let assetId = calculateAssetId(issue)
1140
1178
 
    let id = toBase58String(assetId)
1141
1179
 
    $Tuple2([IntegerEntry(keyNextFreeLandNum(), (freeNum + 1)), issue, StringEntry(keyLandToAssetId(landNum), id), StringEntry(keyLandAssetIdToOwner(id), userAddr), StringEntry(keyLandNumToOwner(landNum), userAddr), IntegerEntry(keyInfraLevelByAssetId(id), 0), IntegerEntry(keyInfraLevelByAssetIdAndOwner(id, userAddr), 0), ScriptTransfer(caller, 1, assetId)], $Tuple2(id, continent))
1142
1180
 
    }
1143
1181
 
1144
1182
 
1145
1183
 
func flightCommon (userAddr,message,sig) = if (!(sigVerify_8Kb(message, sig, pub)))
1146
1184
 
    then throw("signature does not match")
1147
1185
 
    else {
1148
1186
 
        let parts = split(toUtf8String(message), ";")
1149
1187
 
        let flightLog = split(parts[0], "|")
1150
1188
 
        let hp = split(flightLog[flHealth], "_")
1151
1189
 
        let curHP = parseIntValue(hp[0])
1152
1190
 
        let newHP = parseIntValue(hp[1])
1153
1191
 
        let newLocTxVer = split(parts[1], ":")
1154
1192
 
        let newLocation = newLocTxVer[0]
1155
1193
 
        let time = parseIntValue(flightLog[flTimestamp])
1156
1194
 
        if (if ((time > (lastBlock.timestamp + FIVEMINUTESMILLIS)))
1157
1195
 
            then true
1158
1196
 
            else ((lastBlock.timestamp - FIVEMINUTESMILLIS) > time))
1159
1197
 
            then throw(((("signature outdated: logTime=" + toString(time)) + ", bcTime=") + toString(lastBlock.timestamp)))
1160
1198
 
            else {
1161
1199
 
                let txFromMsg = newLocTxVer[1]
1162
1200
 
                let lastTx = valueOrElse(getString(keyLastTxIdByUser(userAddr)), "")
1163
1201
 
                if ((lastTx != txFromMsg))
1164
1202
 
                    then throw(((("Tx ids don't match! In state: " + lastTx) + ", in msg: ") + txFromMsg))
1165
1203
 
                    else {
1166
1204
 
                        let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(userAddr)), "You don't have a duck staked")
1167
1205
 
                        let keyHealth = keyDuckHealth(duckAssetId)
1168
1206
 
                        let maxHP = maxHealth(valueOrElse(getInteger(keyDuckLevel(duckAssetId)), 0))
1169
1207
 
                        let oldFromState = valueOrElse(getInteger(keyHealth), maxHP)
1170
1208
 
                        if ((oldFromState != curHP))
1171
1209
 
                            then throw(((("oldHealth=" + toString(oldFromState)) + " from state does not match one from flight log=") + toString(curHP)))
1172
1210
 
                            else if ((0 >= curHP))
1173
1211
 
                                then throw("You can't fly with zero health")
1174
1212
 
                                else {
1175
1213
 
                                    let bonus = if ((size(flightLog) > flBonus))
1176
1214
 
                                        then flightLog[flBonus]
1177
1215
 
                                        else ""
1178
1216
 
                                    let prodUsed = if ((size(flightLog) > flProdsUsed))
1179
1217
 
                                        then flightLog[flProdsUsed]
1180
1218
 
                                        else ""
1181
1219
 
                                    let sentAmount = if (if ((newHP > 0))
1182
1220
 
                                        then (bonus == "$")
1183
1221
 
                                        else false)
1184
1222
 
                                        then asInt(invoke(restContract, "sendUsdtPrize", [userAddr], nil))
1185
1223
 
                                        else 0
1186
1224
 
                                    $Tuple5(newHP, duckAssetId, sentAmount, newLocation, prodUsed)
1187
1225
 
                                    }
1188
1226
 
                        }
1189
1227
 
                }
1190
1228
 
        }
1191
1229
 
1192
1230
 
1193
1231
 
func expeditionCommon (caller,txId,message,sig) = {
1194
1232
 
    let userAddr = toString(caller)
1195
1233
 
    let f = flightCommon(userAddr, message, sig)
1196
1234
 
    let keyHealth = keyDuckHealth(f._2)
1197
1235
 
    let bpKey = keyBackpackByDuck(f._2)
1198
1236
 
    let currentPack = getBackpack(bpKey)
1199
1237
 
    let mList = split(currentPack[bpIdxMat], "_")
1200
1238
 
    let newMat = makeString(subtractMaterials(true, mList, EXPMATERIALS), "_")
1201
1239
 
    let newProd = subtractProducts(currentPack[bpIdxProd], f._5)
1202
1240
 
    if ((0 >= f._1))
1203
1241
 
        then $Tuple3([IntegerEntry(keyHealth, 0), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], currentPack[bpIdxRes], currentPack[bpIdxMat], newProd], ":"))], "", 0)
1204
1242
 
        else {
1205
1243
 
            let e = expeditionInternal(caller, txId)
1206
1244
 
            let id = e._2._1
1207
1245
 
            $Tuple3((((e._1 :+ StringEntry(keyDuckLocation(f._2), makeString([e._2._2, "L", id], "_"))) :+ IntegerEntry(keyHealth, f._1)) :+ StringEntry(bpKey, makeString([currentPack[bpIdxLevel], currentPack[bpIdxRes], newMat, newProd], ":"))), id, f._3)
1208
1246
 
            }
1209
1247
 
    }
1210
1248
 
1211
1249
 
1212
1250
 
func applyBonuses (landAssetId,pieces) = {
1213
1251
 
    let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
1214
1252
 
    let artPieces = valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), 0)
1215
1253
 
    let add6 = (infraLevel / 6)
1216
1254
 
    let add7 = (infraLevel / 7)
1217
1255
 
    ((DAILYRESBYPIECE + fraction(DAILYRESBYPIECE, ((infraLevel + add6) + (2 * add7)), 5)) + fraction(DAILYRESBYPIECE, artPieces, (pieces * 5)))
1218
1256
 
    }
1219
1257
 
1220
1258
 
1221
1259
 
func checkClaimConditions (addr,claimMode,landAssetIdIn) = {
1222
-
    let $t02720327742 = if ((claimMode == claimModeWh))
1260
+
    let $t02812328662 = if ((claimMode == claimModeWh))
1223
1261
 
        then $Tuple2(landAssetIdIn, valueOrElse(getString(keyStakedDuckByOwner(addr)), ""))
1224
1262
 
        else {
1225
1263
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
1226
1264
 
            let curLocation = valueOrElse(getString(keyDuckLocation(duckAssetId)), DEFAULTLOCATION)
1227
1265
 
            let loc = split(value(curLocation), "_")
1228
1266
 
            if ((loc[locIdxType] != "L"))
1229
1267
 
                then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
1230
1268
 
                else $Tuple2(loc[locIdxId], duckAssetId)
1231
1269
 
            }
1232
-
    let landAssetId = $t02720327742._1
1233
-
    let duckId = $t02720327742._2
1270
+
    let landAssetId = $t02812328662._1
1271
+
    let duckId = $t02812328662._2
1234
1272
 
    let asset = value(assetInfo(fromBase58String(landAssetId)))
1235
1273
 
    let timeKey = keyStakedTimeByAssetId(landAssetId)
1236
1274
 
    let savedTime = valueOrErrorMessage(getInteger(timeKey), (("Land " + asset.name) + " is not staked"))
1237
1275
 
    let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(landAssetId)), (("NFT " + asset.name) + " is orphaned"))
1238
1276
 
    if ((owner != addr))
1239
1277
 
        then throw((LANDPREFIX + " is not yours"))
1240
1278
 
        else {
1241
1279
 
            let d = split(asset.description, "_")
1242
1280
 
            $Tuple4(duckId, landAssetId, d, savedTime)
1243
1281
 
            }
1244
1282
 
    }
1245
1283
 
1246
1284
 
1247
1285
 
func claimResInternal (addr,amount,claimMode,landAssetIdIn) = if ((0 > amount))
1248
1286
 
    then throw("Negative amount")
1249
1287
 
    else {
1250
1288
 
        let c = checkClaimConditions(addr, claimMode, landAssetIdIn)
1251
1289
 
        let landSize = c._3[recLandSize]
1252
1290
 
        let terrainCounts = countTerrains(c._3[recTerrains])
1253
1291
 
        let deltaTime = (lastBlock.timestamp - c._4)
1254
1292
 
        if ((0 > deltaTime))
1255
1293
 
            then throw(((("Saved timestamp is in future, saved = " + toString(c._4)) + ", current = ") + toString(lastBlock.timestamp)))
1256
1294
 
            else {
1257
1295
 
                let pieces = numPiecesBySize(landSize)
1258
1296
 
                let dailyProductionByPiece = applyBonuses(c._2, pieces)
1259
1297
 
                let availRes = fraction(deltaTime, (dailyProductionByPiece * pieces), DAYMILLIS)
1260
1298
 
                if ((amount > availRes))
1261
1299
 
                    then throw(((("Not enough resources, available = " + toString(availRes)) + ", requested = ") + toString(amount)))
1262
1300
 
                    else {
1263
1301
 
                        let newDeltaTime = fraction((availRes - amount), DAYMILLIS, (dailyProductionByPiece * pieces))
1264
1302
 
                        let newTimestamp = (lastBlock.timestamp - newDeltaTime)
1265
1303
 
                        let landIndex = (pieces / SSIZE)
1266
1304
 
                        let resToClaim = virtClaim(terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece)
1267
1305
 
                        let whKey = keyWarehouseByLand(c._2)
1268
1306
 
                        let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(c._2)), 0)
1269
1307
 
                        let currentWh = getWarehouse(whKey, landIndex, infraLevel)
1270
1308
 
                        let loft = split(currentWh[whIdxLOFT], "_")
1271
1309
 
                        let whSpaceLeft = parseIntValue(loft[volFree])
1272
1310
 
                        if (if ((claimMode == claimModeWh))
1273
1311
 
                            then (amount > whSpaceLeft)
1274
1312
 
                            else false)
1275
1313
 
                            then throw((("Only " + toString(whSpaceLeft)) + " space left in warehouse"))
1276
1314
 
                            else {
1277
1315
 
                                let bpKey = keyBackpackByDuck(c._1)
1278
1316
 
                                let currentPack = getBackpack(bpKey)
1279
1317
 
                                let currentPackRes = split(currentPack[bpIdxRes], "_")
1280
1318
 
                                let currentWhRes = split(currentWh[whIdxRes], "_")
1281
-
                                let $t03011630987 = if ((claimMode == claimModeWh))
1319
+
                                let $t03103631907 = if ((claimMode == claimModeWh))
1282
1320
 
                                    then $Tuple4(addRes(currentWhRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), currentPack[bpIdxRes], (parseIntValue(loft[volOccupied]) + resToClaim._2), (parseIntValue(loft[volFree]) - resToClaim._2))
1283
1321
 
                                    else if ((claimMode == claimModeDuck))
1284
1322
 
                                        then $Tuple4(currentWh[whIdxRes], addRes(currentPackRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), parseIntValue(loft[volOccupied]), parseIntValue(loft[volFree]))
1285
1323
 
                                        else {
1286
1324
 
                                            let distr = distributeRes(currentWhRes, currentPackRes, resToClaim, whSpaceLeft)
1287
1325
 
                                            let whAm = min([parseIntValue(loft[volFree]), resToClaim._2])
1288
1326
 
                                            $Tuple4(distr._1, distr._2, (parseIntValue(loft[volOccupied]) + whAm), (parseIntValue(loft[volFree]) - whAm))
1289
1327
 
                                            }
1290
-
                                let whRes = $t03011630987._1
1291
-
                                let bpRes = $t03011630987._2
1292
-
                                let loftO = $t03011630987._3
1293
-
                                let loftF = $t03011630987._4
1328
+
                                let whRes = $t03103631907._1
1329
+
                                let bpRes = $t03103631907._2
1330
+
                                let loftO = $t03103631907._3
1331
+
                                let loftF = $t03103631907._4
1294
1332
 
                                $Tuple5([IntegerEntry(keyStakedTimeByAssetId(c._2), newTimestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, c._2, addr), newTimestamp)], bpKey, [currentPack[bpIdxLevel], bpRes, currentPack[bpIdxMat], currentPack[bpIdxProd]], whKey, [currentWh[whIdxLevels], whRes, currentWh[whIdxMat], currentWh[whIdxProd], makeString([loft[volLocked], toString(loftO), toString(loftF), loft[volTotal]], "_")])
1295
1333
 
                                }
1296
1334
 
                        }
1297
1335
 
                }
1298
1336
 
        }
1299
1337
 
1300
1338
 
1301
1339
 
func claimAll (addr,landAssetId,pieces,claimMode) = {
1302
1340
 
    let timeKey = keyStakedTimeByAssetId(landAssetId)
1303
1341
 
    let savedTime = value(getInteger(timeKey))
1304
1342
 
    let availRes = (fraction((lastBlock.timestamp - savedTime), applyBonuses(landAssetId, pieces), DAYMILLIS) * pieces)
1305
1343
 
    claimResInternal(addr, availRes, claimMode, landAssetId)
1306
1344
 
    }
1307
1345
 
1308
1346
 
1309
1347
 
func upInfraCommon (shouldUseMat,caller,paymentAmount,landAssetId) = {
1310
1348
 
    let addr = toString(caller)
1311
1349
 
    let c = checkClaimConditions(addr, claimModeWhThenDuck, landAssetId)
1312
1350
 
    let pieces = numPiecesBySize(c._3[recLandSize])
1313
1351
 
    let infraKey = keyInfraLevelByAssetId(c._2)
1314
1352
 
    let curLevel = valueOrElse(getInteger(infraKey), 0)
1315
1353
 
    if ((curLevel >= 3))
1316
1354
 
        then throw("Currently max infrastructure level = 3")
1317
1355
 
        else {
1318
1356
 
            let newLevel = (curLevel + 1)
1319
1357
 
            let cost = fraction(InfraUpgradeCostSUsdt, (pieces * newLevel), SSIZE)
1320
1358
 
            if (if (!(shouldUseMat))
1321
1359
 
                then (paymentAmount != cost)
1322
1360
 
                else false)
1323
1361
 
                then throw(("Payment attached should be " + toString(cost)))
1324
1362
 
                else {
1325
1363
 
                    let bpKey = keyBackpackByDuck(c._1)
1326
1364
 
                    let currentPack = getBackpack(bpKey)
1327
1365
 
                    let mList = split(currentPack[bpIdxMat], "_")
1328
1366
 
                    let matUsed = fraction(InfraUpgradeCostS, (pieces * newLevel), SSIZE)
1329
1367
 
                    let newMat = makeString(subtractMaterials(shouldUseMat, mList, matUsed), "_")
1330
1368
 
                    let claimResult = claimAll(addr, c._2, pieces, claimModeWhThenDuck)
1331
1369
 
                    let whData = claimResult._5
1332
1370
 
                    let oldVol = getWarehouseTotalVolume(whData[whIdxLevels])
1333
1371
 
                    let newVolData = makeString([split(whData[whIdxLevels], "_")[0], toString(newLevel)], "_")
1334
1372
 
                    let newVol = getWarehouseTotalVolume(newVolData)
1335
1373
 
                    let loft = split(whData[whIdxLOFT], "_")
1336
1374
 
                    let newLoftStr = makeString([loft[volLocked], loft[volOccupied], toString(((parseIntValue(loft[volFree]) + newVol) - oldVol)), toString(newVol)], "_")
1337
1375
 
                    $Tuple3(([IntegerEntry(infraKey, newLevel), IntegerEntry(keyInfraLevelByAssetIdAndOwner(c._2, addr), newLevel), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], claimResult._3[bpIdxRes], newMat, currentPack[bpIdxProd]], ":")), StringEntry(claimResult._4, makeString([newVolData, whData[whIdxRes], whData[whIdxMat], whData[whIdxProd], newLoftStr], ":"))] ++ claimResult._1), newLevel, matUsed)
1338
1376
 
                    }
1339
1377
 
            }
1340
1378
 
    }
1341
1379
 
1342
1380
 
1343
1381
 
func updateDuckStatsInternal (duckAssetId,deltaXP) = if (!(KSALLOWXPLEVELS))
1344
1382
 
    then $Tuple2(nil, 0)
1345
1383
 
    else {
1346
1384
 
        let lvlKey = keyDuckLevel(duckAssetId)
1347
1385
 
        let xpKey = keyDuckXP(duckAssetId)
1348
1386
 
        let xp = valueOrElse(getInteger(stakingContract, xpKey), 0)
1349
1387
 
        let newXP = (xp + deltaXP)
1350
1388
 
        let lvlPoints = levelUp(valueOrElse(getInteger(stakingContract, lvlKey), 0), newXP)
1351
1389
 
        let keyPoints = keyDuckFreePoints(duckAssetId)
1352
1390
 
        $Tuple2([IntegerEntry(lvlKey, lvlPoints[0]), IntegerEntry(xpKey, newXP), IntegerEntry(keyPoints, (valueOrElse(getInteger(keyPoints), 0) + lvlPoints[1]))], newXP)
1353
1391
 
        }
1354
1392
 
1355
1393
 
1356
1394
 
func updateAccStatsInternal (addr,deltaXP) = if (!(KSALLOWXPLEVELS))
1357
1395
 
    then $Tuple2(nil, 0)
1358
1396
 
    else {
1359
1397
 
        let lvlKey = keyUserLevel(addr)
1360
1398
 
        let xpKey = keyUserXP(addr)
1361
1399
 
        let xp = valueOrElse(getInteger(stakingContract, xpKey), 0)
1362
1400
 
        let newXP = (xp + deltaXP)
1363
1401
 
        let lvlPoints = levelUp(valueOrElse(getInteger(stakingContract, lvlKey), 0), newXP)
1364
1402
 
        let keyPoints = keyUserFreePoints(addr)
1365
1403
 
        $Tuple2([IntegerEntry(lvlKey, lvlPoints[0]), IntegerEntry(xpKey, newXP), IntegerEntry(keyPoints, (valueOrElse(getInteger(keyPoints), 0) + lvlPoints[1]))], newXP)
1366
1404
 
        }
1367
1405
 
1368
1406
 
1369
1407
 
func activateOnboardArt (addr) = {
1370
1408
 
    let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
1371
1409
 
    let refByKey = keyAddressRefBy(addr)
1372
1410
 
    let refBy = getString(refByKey)
1373
1411
 
    if (!(isDefined(refBy)))
1374
1412
 
        then throw("You are not eligible for ONBOARD artifact")
1375
1413
 
        else {
1376
1414
 
            let artKey = keyOnboardArtDuckActivatedBy(addr)
1377
1415
 
            let artDuck = getString(artKey)
1378
1416
 
            if (isDefined(artDuck))
1379
1417
 
                then throw(("You already used your ONBOARD artifact on duck " + value(artDuck)))
1380
1418
 
                else {
1381
1419
 
                    let duckActivatorKey = keyOnboardArtActivatedOnDuck(duckAssetId)
1382
1420
 
                    let duckActivator = getString(duckActivatorKey)
1383
1421
 
                    if (isDefined(duckActivator))
1384
1422
 
                        then throw(((("The duck " + duckAssetId) + " already got points from ONBOARD artifact from user ") + value(duckActivator)))
1385
1423
 
                        else ([StringEntry(artKey, duckAssetId), StringEntry(duckActivatorKey, addr)] ++ updateDuckStatsInternal(duckAssetId, xpOnboard)._1)
1386
1424
 
                    }
1387
1425
 
            }
1388
1426
 
    }
1389
1427
 
1390
1428
 
1391
1429
 
func activatePresaleArt (addr,landAssetIdIn) = {
1392
1430
 
    let c = checkClaimConditions(addr, claimModeWhThenDuck, landAssetIdIn)
1393
1431
 
    let landAssetId = c._2
1394
1432
 
    let pieces = numPiecesBySize(c._3[recLandSize])
1395
1433
 
    let activationKey = keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)
1396
1434
 
    if ((valueOrElse(getInteger(activationKey), 0) > 0))
1397
1435
 
        then throw("Presale artifact is already activated")
1398
1436
 
        else if ((parseIntValue(c._3[recLandNum]) > PRESALENUMLANDS))
1399
1437
 
            then throw((((LANDPREFIX + " ") + landAssetId) + " is not eligible for presale artifact"))
1400
1438
 
            else {
1401
1439
 
                let claimResult = claimAll(addr, landAssetId, pieces, claimModeWhThenDuck)
1402
1440
 
                ((((claimResult._1 :+ IntegerEntry(activationKey, pieces)) :+ IntegerEntry(keyLandArtStatusByTypeAssetIdAndOwner(ARTPRESALE, landAssetId, addr), pieces)) :+ StringEntry(claimResult._2, makeString(claimResult._3, ":"))) :+ StringEntry(claimResult._4, makeString(claimResult._5, ":")))
1403
1441
 
                }
1404
1442
 
    }
1405
1443
 
1406
1444
 
1407
1445
 
func mergeInternal (newLandSize,newLevel,formula,addr,landAssetIds,txId,needMat) = {
1408
1446
 
    let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
1409
1447
 
    func checkMerge (acc,landAssetId) =     {
1410
1448
 
        let asset = value(assetInfo(fromBase58String(landAssetId)))
1411
1449
 
        let timeKey = keyStakedTimeByAssetId(landAssetId)
1412
1450
 
        let savedTime = valueOrErrorMessage(getInteger(timeKey), (("NFT " + asset.name) + " is not staked"))
1413
1451
 
        let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(landAssetId)), (("NFT " + asset.name) + " is orphaned"))
1414
1452
 
        if ((owner != addr))
1415
1453
 
            then throw((LANDPREFIX + " is not yours"))
1416
1454
 
            else {
1417
1455
 
                let d = split(asset.description, "_")
1418
1456
 
                let continent = d[recContinent]
1419
1457
 
                if (if ((acc._3 != ""))
1420
1458
 
                    then (acc._3 != continent)
1421
1459
 
                    else false)
1422
1460
 
                    then throw("Lands should be on the same continent to merge")
1423
1461
 
                    else {
1424
1462
 
                        let landSize = d[recLandSize]
1425
1463
 
                        let sizesIn = acc._1
1426
1464
 
                        let i = valueOrErrorMessage(indexOf(sizesIn, landSize), "You haven't passed all the lands needed")
1427
1465
 
                        let sizesOut = (take(sizesIn, i) + drop(sizesIn, (i + 1)))
1428
1466
 
                        let pieces = numPiecesBySize(landSize)
1429
1467
 
                        let arts = (acc._2 + valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), 0))
1430
1468
 
                        let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
1431
1469
 
                        let reqLevel =                         match landSize {
1432
1470
 
                            case _ => 
1433
1471
 
                                if (("S" == $match0))
1434
1472
 
                                    then 3
1435
1473
 
                                    else if (("M" == $match0))
1436
1474
 
                                        then 4
1437
1475
 
                                        else if (("L" == $match0))
1438
1476
 
                                            then 5
1439
1477
 
                                            else if (("XL" == $match0))
1440
1478
 
                                                then 6
1441
1479
 
                                                else throw("Only S, M, L, XL can merge")
1442
1480
 
                        }
1443
1481
 
                        if ((infraLevel != reqLevel))
1444
1482
 
                            then throw("All lands should be maxed to merge")
1445
1483
 
                            else {
1446
1484
 
                                let landNum = d[recLandNum]
1447
1485
 
                                let terrainCounts = countTerrains(d[recTerrains])
1448
1486
 
                                let deltaTime = (lastBlock.timestamp - savedTime)
1449
1487
 
                                if ((0 > deltaTime))
1450
1488
 
                                    then throw(((("Saved timestamp is in future, saved = " + toString(savedTime)) + ", current = ") + toString(lastBlock.timestamp)))
1451
1489
 
                                    else {
1452
1490
 
                                        let dailyProductionByPiece = applyBonuses(landAssetId, pieces)
1453
1491
 
                                        let landIndex = (pieces / SSIZE)
1454
1492
 
                                        let bpRes = addRes(split(acc._4, "_"), terrainCounts, deltaTime, landIndex, dailyProductionByPiece)
1455
1493
 
                                        let props = updateProportionsInternal(split(acc._6, "_"), terrainCounts, landIndex, -1)
1456
1494
 
                                        let lands = acc._7
1457
1495
 
                                        let idx = indexOf(lands, landAssetId)
1458
1496
 
                                        if (!(isDefined(idx)))
1459
1497
 
                                            then throw(("Your staked lands don't contain " + landAssetId))
1460
1498
 
                                            else {
1461
1499
 
                                                let customKey = keyLandAssetIdToCustomName(landAssetId)
1462
1500
 
                                                let customName = valueOrElse(getString(customKey), "")
1463
1501
 
                                                $Tuple8(sizesOut, arts, continent, bpRes, (((((((((((((acc._5 :+ DeleteEntry(keyStakedTimeByAssetId(landAssetId))) :+ DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, addr))) :+ DeleteEntry(keyLandToAssetId(landNum))) :+ DeleteEntry(keyLandAssetIdToOwner(landAssetId))) :+ DeleteEntry(keyInfraLevelByAssetId(landAssetId))) :+ DeleteEntry(keyInfraLevelByAssetIdAndOwner(landAssetId, addr))) :+ DeleteEntry(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId))) :+ DeleteEntry(keyLandArtStatusByTypeAssetIdAndOwner(ARTPRESALE, landAssetId, addr))) :+ DeleteEntry(keyLandNumToOwner(landNum))) :+ DeleteEntry(keyWarehouseByLand(landAssetId))) :+ DeleteEntry(customKey)) :+ DeleteEntry(keyLandCustomNameToAssetId(customName))) :+ Burn(fromBase58String(landAssetId), 1)), props, removeByIndex(lands, value(idx)), (acc._8 + pieces))
1464
1502
 
                                                }
1465
1503
 
                                        }
1466
1504
 
                                }
1467
1505
 
                        }
1468
1506
 
                }
1469
1507
 
        }
1470
1508
 
1471
1509
 
    let bpKey = keyBackpackByDuck(duckAssetId)
1472
1510
 
    let currentPack = getBackpack(bpKey)
1473
1511
 
    let propStr = valueOrElse(getString(keyResProportions()), "0_0_0_0_0_0")
1474
1512
 
    let landsKey = keyStakedLandsByOwner(addr)
1475
1513
 
    let landsStr = getString(landsKey)
1476
1514
 
    let landsIn = if (isDefined(landsStr))
1477
1515
 
        then split_51C(value(landsStr), "_")
1478
1516
 
        else nil
1479
1517
 
    let r = {
1480
1518
 
        let $l = landAssetIds
1481
1519
 
        let $s = size($l)
1482
1520
 
        let $acc0 = $Tuple8(formula, 0, "", currentPack[bpIdxRes], nil, propStr, landsIn, 0)
1483
1521
 
        func $f0_1 ($a,$i) =         if (($i >= $s))
1484
1522
 
            then $a
1485
1523
 
            else checkMerge($a, $l[$i])
1486
1524
 
1487
1525
 
        func $f0_2 ($a,$i) =         if (($i >= $s))
1488
1526
 
            then $a
1489
1527
 
            else throw("List size exceeds 5")
1490
1528
 
1491
1529
 
        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
1492
1530
 
        }
1493
1531
 
    let continent = r._3
1494
1532
 
    let continentIdx = valueOrErrorMessage(indexOf(continents, continent), ("Unknown continent: " + continent))
1495
1533
 
    let terrains = genTerrains(abs(toBigInt(txId)), continentIdx)
1496
1534
 
    let freeNum = valueOrElse(getInteger(keyNextFreeLandNum()), (PRESALENUMLANDS + 1))
1497
1535
 
    let newLandNum = toString(freeNum)
1498
1536
 
    let issue = Issue(nftName(newLandNum, newLandSize), makeString([newLandNum, newLandSize, terrains, continent], "_"), 1, 0, false)
1499
1537
 
    let assetId = calculateAssetId(issue)
1500
1538
 
    let newLandAssetId = toBase58String(assetId)
1501
1539
 
    let newMat = makeString(subtractMaterials((needMat > 0), split(currentPack[bpIdxMat], "_"), needMat), "_")
1502
1540
 
    let piecesKey = keyStakedPiecesByOwner(addr)
1503
1541
 
    let stakedPieces = valueOrElse(getInteger(piecesKey), 0)
1504
1542
 
    $Tuple2((((((((((((((((r._5 :+ (if ((size(r._7) > 0))
1505
1543
 
        then StringEntry(landsKey, makeString_11C(r._7, "_"))
1506
1544
 
        else DeleteEntry(landsKey))) :+ IntegerEntry(piecesKey, if ((r._8 > stakedPieces))
1507
1545
 
        then 0
1508
1546
 
        else (stakedPieces - r._8))) :+ IntegerEntry(keyNextFreeLandNum(), (freeNum + 1))) :+ issue) :+ StringEntry(keyLandToAssetId(newLandNum), newLandAssetId)) :+ StringEntry(keyLandAssetIdToOwner(newLandAssetId), addr)) :+ StringEntry(keyLandNumToOwner(newLandNum), addr)) :+ IntegerEntry(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, newLandAssetId), r._2)) :+ IntegerEntry(keyLandArtStatusByTypeAssetIdAndOwner(ARTPRESALE, newLandAssetId, addr), r._2)) :+ IntegerEntry(keyInfraLevelByAssetId(newLandAssetId), newLevel)) :+ IntegerEntry(keyInfraLevelByAssetIdAndOwner(newLandAssetId, addr), newLevel)) :+ StringEntry(bpKey, makeString([currentPack[bpIdxLevel], r._4, newMat, currentPack[bpIdxProd]], ":"))) :+ StringEntry(keyResProportions(), r._6)) :+ StringEntry(keyDuckLocation(duckAssetId), makeString([continent, "L", newLandAssetId], "_"))) :+ ScriptTransfer(addressFromStringValue(addr), 1, assetId)), newLandAssetId)
1509
1547
 
    }
1510
1548
 
1511
1549
 
1512
1550
 
func s2m (addr,landAssetIds,txId) = mergeInternal("M", 3, "SSSS", addr, landAssetIds, txId, 0)
1513
1551
 
1514
1552
 
1515
1553
 
func m2l (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
1516
1554
 
    let cost = (InfraUpgradeCostSUsdt * 4)
1517
1555
 
    if (if (!(shouldUseMat))
1518
1556
 
        then (paymentAmount != cost)
1519
1557
 
        else false)
1520
1558
 
        then throw(("Payment attached should be " + toString(cost)))
1521
1559
 
        else mergeInternal("L", 4, "SMM", addr, landAssetIds, txId, (InfraUpgradeCostS * 4))
1522
1560
 
    }
1523
1561
 
1524
1562
 
1525
1563
 
func l2xl (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
1526
1564
 
    let cost = (InfraUpgradeCostSUsdt * 47)
1527
1565
 
    if (if (!(shouldUseMat))
1528
1566
 
        then (paymentAmount != cost)
1529
1567
 
        else false)
1530
1568
 
        then throw(("Payment attached should be " + toString(cost)))
1531
1569
 
        else mergeInternal("XL", 5, "SSSML", addr, landAssetIds, txId, (InfraUpgradeCostS * 47))
1532
1570
 
    }
1533
1571
 
1534
1572
 
1535
1573
 
func xl2xxl (addr,landAssetIds,txId,shouldUseMat,paymentAmount) = {
1536
1574
 
    let cost = (InfraUpgradeCostSUsdt * 54)
1537
1575
 
    if (if (!(shouldUseMat))
1538
1576
 
        then (paymentAmount != cost)
1539
1577
 
        else false)
1540
1578
 
        then throw(("Payment attached should be " + toString(cost)))
1541
1579
 
        else mergeInternal("XXL", 6, "LXL", addr, landAssetIds, txId, (InfraUpgradeCostS * 54))
1542
1580
 
    }
1543
1581
 
1544
1582
 
1545
1583
 
func mergeCommon (shouldUseMat,addr,paymentAmount,landAssetIds,txId) = {
1546
1584
 
    let mergeResult =     match size(landAssetIds) {
1547
1585
 
        case _ => 
1548
1586
 
            if ((4 == $match0))
1549
1587
 
                then s2m(addr, landAssetIds, txId)
1550
1588
 
                else if ((3 == $match0))
1551
1589
 
                    then m2l(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
1552
1590
 
                    else if ((5 == $match0))
1553
1591
 
                        then l2xl(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
1554
1592
 
                        else if ((2 == $match0))
1555
1593
 
                            then xl2xxl(addr, landAssetIds, txId, shouldUseMat, paymentAmount)
1556
1594
 
                            else throw("Unknown merge")
1557
1595
 
    }
1558
1596
 
    mergeResult
1559
1597
 
    }
1560
1598
 
1561
1599
 
1562
1600
 
func prolog (i) = if (if ((i.originCaller != restContract))
1563
1601
 
    then valueOrElse(getBoolean(keyBlocked()), false)
1564
1602
 
    else false)
1565
1603
 
    then throw("Contracts are under maintenance")
1566
1604
 
    else StringEntry(keyLastTxIdByUser(toString(i.originCaller)), toBase58String(i.transactionId))
1567
1605
 
1568
1606
 
1569
1607
 
@Callable(i)
1570
1608
 
func constructorV1 (restAddr) = if ((i.caller != this))
1571
1609
 
    then throw("Permission denied")
1572
1610
 
    else [StringEntry(keyRestAddress(), restAddr)]
1573
1611
 
1574
1612
 
1575
1613
 
1576
1614
 
@Callable(i)
1577
1615
 
func setBlocked (isBlocked) = if ((i.caller != this))
1578
1616
 
    then throw("permission denied")
1579
1617
 
    else [BooleanEntry(keyBlocked(), isBlocked)]
1580
1618
 
1581
1619
 
1582
1620
 
1583
1621
 
@Callable(i)
1584
1622
 
func stakeLand () = {
1585
1623
 
    let prologAction = prolog(i)
1586
1624
 
    if ((size(i.payments) != 1))
1587
1625
 
        then throw("Exactly one payment required")
1588
1626
 
        else {
1589
1627
 
            let pmt = value(i.payments[0])
1590
1628
 
            let assetId = value(pmt.assetId)
1591
1629
 
            let address = toString(i.caller)
1592
1630
 
            if ((pmt.amount != 1))
1593
1631
 
                then throw((("NFT " + LANDPREFIX) + " token should be attached as payment"))
1594
1632
 
                else {
1595
1633
 
                    let asset = value(assetInfo(assetId))
1596
1634
 
                    if ((asset.issuer != this))
1597
1635
 
                        then throw("Unknown issuer of token")
1598
1636
 
                        else if (!(contains(asset.name, LANDPREFIX)))
1599
1637
 
                            then throw((("Only NFT " + LANDPREFIX) + " tokens are accepted"))
1600
1638
 
                            else {
1601
1639
 
                                let landNumSize = drop(asset.name, 4)
1602
1640
 
                                let landNum = if (contains(landNumSize, "XXL"))
1603
1641
 
                                    then dropRight(landNumSize, 3)
1604
1642
 
                                    else if (contains(landNumSize, "XL"))
1605
1643
 
                                        then dropRight(landNumSize, 2)
1606
1644
 
                                        else dropRight(landNumSize, 1)
1607
1645
 
                                if (!(isDefined(parseInt(landNum))))
1608
1646
 
                                    then throw(("Cannot parse land number from " + asset.name))
1609
1647
 
                                    else {
1610
1648
 
                                        let landAssetId = toBase58String(assetId)
1611
1649
 
                                        let timeKey = keyStakedTimeByAssetId(landAssetId)
1612
1650
 
                                        if (isDefined(getInteger(timeKey)))
1613
1651
 
                                            then throw((("NFT " + asset.name) + " is already staked"))
1614
1652
 
                                            else {
1615
1653
 
                                                let d = split(asset.description, "_")
1616
1654
 
                                                let terrainCounts = countTerrains(d[recTerrains])
1617
1655
 
                                                let pieces = numPiecesBySize(d[recLandSize])
1618
1656
 
                                                let props = updateProportions(terrainCounts, (pieces / SSIZE), 1)
1619
1657
 
                                                let artPieces = valueOrElse(getInteger(keyLandArtStatusByTypeAndAssetId(ARTPRESALE, landAssetId)), 0)
1620
1658
 
                                                let landsKey = keyStakedLandsByOwner(address)
1621
1659
 
                                                let landsStr = getString(landsKey)
1622
1660
 
                                                let lands = if (isDefined(landsStr))
1623
1661
 
                                                    then split_51C(value(landsStr), "_")
1624
1662
 
                                                    else nil
1625
1663
 
                                                if (containsElement(lands, landAssetId))
1626
1664
 
                                                    then throw(("Your staked lands already contain " + landAssetId))
1627
1665
 
                                                    else {
1628
1666
 
                                                        let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
1629
1667
 
                                                        let piecesKey = keyStakedPiecesByOwner(address)
1630
1668
 
                                                        let oldPieces = valueOrElse(getInteger(piecesKey), 0)
1631
1669
 
                                                        let wlgResult = asInt(invoke(wlgContract, "onStakeUnstakeLand", [address], nil))
1632
1670
 
                                                        $Tuple2([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, address), lastBlock.timestamp), StringEntry(landsKey, makeString_11C((lands :+ landAssetId), "_")), IntegerEntry(piecesKey, (oldPieces + pieces)), StringEntry(keyLandAssetIdToOwner(landAssetId), address), StringEntry(keyLandNumToOwner(landNum), address), IntegerEntry(keyLandArtStatusByTypeAssetIdAndOwner(ARTPRESALE, landAssetId, address), artPieces), IntegerEntry(keyInfraLevelByAssetIdAndOwner(landAssetId, address), infraLevel), StringEntry(keyResProportions(), props), prologAction], wlgResult)
1633
1671
 
                                                        }
1634
1672
 
                                                }
1635
1673
 
                                        }
1636
1674
 
                                }
1637
1675
 
                    }
1638
1676
 
            }
1639
1677
 
    }
1640
1678
 
1641
1679
 
1642
1680
 
1643
1681
 
@Callable(i)
1644
1682
 
func unstakeLand (landAssetIdIn) = {
1645
1683
 
    let prologAction = prolog(i)
1646
1684
 
    if ((size(i.payments) != 0))
1647
1685
 
        then throw("No payments required")
1648
1686
 
        else {
1649
1687
 
            let addr = toString(i.caller)
1650
1688
 
            let c = checkClaimConditions(addr, claimModeDuck, landAssetIdIn)
1651
1689
 
            let landAssetId = c._2
1652
1690
 
            let landsKey = keyStakedLandsByOwner(addr)
1653
1691
 
            let terrainCounts = countTerrains(c._3[recTerrains])
1654
1692
 
            let pieces = numPiecesBySize(c._3[recLandSize])
1655
1693
 
            let props = updateProportions(terrainCounts, (pieces / SSIZE), -1)
1656
1694
 
            let claimResult = claimAll(addr, landAssetId, pieces, claimModeDuck)
1657
1695
 
            let lands = split_51C(valueOrElse(getString(landsKey), ""), "_")
1658
1696
 
            let idx = indexOf(lands, landAssetId)
1659
1697
 
            if (!(isDefined(idx)))
1660
1698
 
                then throw(("Your staked lands don't contain " + landAssetId))
1661
1699
 
                else {
1662
1700
 
                    let now = lastBlock.timestamp
1663
1701
 
                    let govReleaseTime = valueOrElse(getInteger(govContract, keyUserGwlReleaseTime(addr)), 0)
1664
1702
 
                    if ((govReleaseTime >= now))
1665
1703
 
                        then throw(("Your gWL are taking part in voting, cannot unstake until " + toString(govReleaseTime)))
1666
1704
 
                        else {
1667
1705
 
                            let arbReleaseTime = (valueOrElse(getInteger(wlgContract, keyLastArbTimeByUser(addr)), 0) + arbitrageDelay)
1668
1706
 
                            if ((arbReleaseTime > now))
1669
1707
 
                                then throw(("Your staked lands took part in arbitrage, cannot unstake until " + toString(arbReleaseTime)))
1670
1708
 
                                else {
1671
1709
 
                                    let piecesKey = keyStakedPiecesByOwner(addr)
1672
1710
 
                                    let stakedPieces = valueOrElse(getInteger(piecesKey), 0)
1673
1711
 
                                    let newPieces = if ((pieces > stakedPieces))
1674
1712
 
                                        then 0
1675
1713
 
                                        else (stakedPieces - pieces)
1676
1714
 
                                    let wlgResult = asInt(invoke(wlgContract, "onStakeUnstakeLand", [addr], nil))
1677
1715
 
                                    $Tuple2([ScriptTransfer(i.caller, 1, fromBase58String(landAssetId)), DeleteEntry(keyStakedTimeByAssetId(landAssetId)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(LANDPREFIX, landAssetId, addr)), StringEntry(keyResProportions(), props), StringEntry(claimResult._2, makeString(claimResult._3, ":")), if ((size(lands) > 1))
1678
1716
 
                                        then StringEntry(landsKey, makeString_11C(removeByIndex(lands, value(idx)), "_"))
1679
1717
 
                                        else DeleteEntry(landsKey), IntegerEntry(piecesKey, newPieces), prologAction], wlgResult)
1680
1718
 
                                    }
1681
1719
 
                            }
1682
1720
 
                    }
1683
1721
 
            }
1684
1722
 
    }
1685
1723
 
1686
1724
 
1687
1725
 
1688
1726
 
@Callable(i)
1689
1727
 
func stakeDuck () = {
1690
1728
 
    let prologAction = prolog(i)
1691
1729
 
    if ((size(i.payments) != 1))
1692
1730
 
        then throw("Exactly one payment required")
1693
1731
 
        else {
1694
1732
 
            let pmt = value(i.payments[0])
1695
1733
 
            let assetId = value(pmt.assetId)
1696
1734
 
            let address = toString(i.caller)
1697
1735
 
            if ((pmt.amount != 1))
1698
1736
 
                then throw((("NFT " + DUCKPREFIX) + " token should be attached as payment"))
1699
1737
 
                else {
1700
1738
 
                    let asset = value(assetInfo(assetId))
1701
1739
 
                    if (if ((asset.issuer != incubatorAddr))
1702
1740
 
                        then (asset.issuer != breederAddr)
1703
1741
 
                        else false)
1704
1742
 
                        then throw((("Unknown issuer of " + DUCKPREFIX) + " token"))
1705
1743
 
                        else if (!(contains(asset.name, DUCKPREFIX)))
1706
1744
 
                            then throw((("Only NFT " + DUCKPREFIX) + " tokens are accepted"))
1707
1745
 
                            else {
1708
1746
 
                                let assetIdStr = toBase58String(assetId)
1709
1747
 
                                let timeKey = keyStakedTimeByAssetId(assetIdStr)
1710
1748
 
                                if (isDefined(getInteger(timeKey)))
1711
1749
 
                                    then throw((("NFT " + asset.name) + " is already staked"))
1712
1750
 
                                    else if (isDefined(getString(keyStakedDuckByOwner(address))))
1713
1751
 
                                        then throw(("You already staked one duck: " + asset.name))
1714
1752
 
                                        else {
1715
1753
 
                                            let locKey = keyDuckLocation(assetIdStr)
1716
1754
 
                                            let location = getString(locKey)
1717
1755
 
                                            let bpKey = keyBackpackByDuck(assetIdStr)
1718
1756
 
                                            let backpack = getString(bpKey)
1719
1757
 
                                            let keyHealth = keyDuckHealth(assetIdStr)
1720
1758
 
                                            let maxHP = maxHealth(valueOrElse(getInteger(keyDuckLevel(assetIdStr)), 0))
1721
1759
 
                                            let curHealth = valueOrElse(getInteger(keyHealth), maxHP)
1722
1760
 
                                            ([IntegerEntry(timeKey, lastBlock.timestamp), IntegerEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, toBase58String(assetId), address), lastBlock.timestamp), StringEntry(keyDuckIdToOwner(assetIdStr), address), StringEntry(keyStakedDuckByOwner(address), assetIdStr)] ++ (if (isDefined(location))
1723
1761
 
                                                then nil
1724
1762
 
                                                else ([StringEntry(locKey, DEFAULTLOCATION)] ++ (if (isDefined(backpack))
1725
1763
 
                                                    then nil
1726
1764
 
                                                    else (([StringEntry(bpKey, "0:0_0_0_0_0_0:0_0_0_0_0_0:")] :+ IntegerEntry(keyHealth, curHealth)) :+ prologAction)))))
1727
1765
 
                                            }
1728
1766
 
                                }
1729
1767
 
                    }
1730
1768
 
            }
1731
1769
 
    }
1732
1770
 
1733
1771
 
1734
1772
 
1735
1773
 
@Callable(i)
1736
1774
 
func unstakeDuck (assetIdStr) = {
1737
1775
 
    let prologAction = prolog(i)
1738
1776
 
    if ((size(i.payments) != 0))
1739
1777
 
        then throw("No payments required")
1740
1778
 
        else {
1741
1779
 
            let assetId = fromBase58String(assetIdStr)
1742
1780
 
            let address = toString(i.caller)
1743
1781
 
            let asset = value(assetInfo(assetId))
1744
1782
 
            let timeKey = keyStakedTimeByAssetId(toBase58String(assetId))
1745
1783
 
            if (!(isDefined(getInteger(timeKey))))
1746
1784
 
                then throw((("NFT " + asset.name) + " is not staked"))
1747
1785
 
                else if (!(isDefined(getString(keyStakedDuckByOwner(address)))))
1748
1786
 
                    then throw((("The duck " + asset.name) + " is not staked"))
1749
1787
 
                    else {
1750
1788
 
                        let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(toBase58String(assetId))), (("NFT " + asset.name) + " is orphaned"))
1751
1789
 
                        if ((owner != address))
1752
1790
 
                            then throw("Staked NFT is not yours")
1753
1791
 
                            else {
1754
1792
 
                                let keyHealth = keyDuckHealth(assetIdStr)
1755
1793
 
                                let maxHP = maxHealth(valueOrElse(getInteger(keyDuckLevel(assetIdStr)), 0))
1756
1794
 
                                let health = valueOrElse(getInteger(keyHealth), maxHP)
1757
1795
 
                                if ((maxHP > health))
1758
1796
 
                                    then throw((("Please heal your duck to " + toString(maxHP)) + "hp before unstaking"))
1759
1797
 
                                    else [ScriptTransfer(i.caller, 1, assetId), DeleteEntry(timeKey), DeleteEntry(keyHealth), DeleteEntry(keyDuckLocation(assetIdStr)), DeleteEntry(keyDuckIdToOwner(assetIdStr)), DeleteEntry(keyStakedTimeByTypeAssetIdAndOwner(DUCKPREFIX, assetIdStr, address)), DeleteEntry(keyStakedDuckByOwner(address)), prologAction]
1760
1798
 
                                }
1761
1799
 
                        }
1762
1800
 
            }
1763
1801
 
    }
1764
1802
 
1765
1803
 
1766
1804
 
1767
1805
 
@Callable(i)
1768
1806
 
func claimRes (amount,landAssetIdStr) = {
1769
1807
 
    let prologAction = prolog(i)
1770
1808
 
    if ((size(i.payments) != 0))
1771
1809
 
        then throw("No payments required")
1772
1810
 
        else {
1773
1811
 
            let addr = toString(i.originCaller)
1774
1812
 
            let result = claimResInternal(addr, amount, claimModeDuck, landAssetIdStr)
1775
1813
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
1776
1814
 
            $Tuple2(((((result._1 ++ updateDuckStatsInternal(duckAssetId, fraction(xpClaim, amount, MULT8))._1) :+ StringEntry(result._2, makeString(result._3, ":"))) :+ StringEntry(result._4, makeString(result._5, ":"))) :+ prologAction), result._3[bpIdxRes])
1777
1815
 
            }
1778
1816
 
    }
1779
1817
 
1780
1818
 
1781
1819
 
1782
1820
 
@Callable(i)
1783
1821
 
func claimResToWH (amount,landAssetIdStr) = {
1784
1822
 
    let prologAction = prolog(i)
1785
1823
 
    if ((size(i.payments) != 0))
1786
1824
 
        then throw("No payments required")
1787
1825
 
        else {
1788
1826
 
            let addr = toString(i.originCaller)
1789
1827
 
            let result = claimResInternal(addr, amount, claimModeWh, landAssetIdStr)
1790
1828
 
            $Tuple2(((((result._1 ++ updateAccStatsInternal(addr, fraction(xpClaim, amount, MULT8))._1) :+ StringEntry(result._2, makeString(result._3, ":"))) :+ StringEntry(result._4, makeString(result._5, ":"))) :+ prologAction), result._5[whIdxRes])
1791
1829
 
            }
1792
1830
 
    }
1793
1831
 
1794
1832
 
1795
1833
 
1796
1834
 
@Callable(i)
1797
1835
 
func flight (message,sig) = {
1798
1836
 
    let prologAction = prolog(i)
1799
1837
 
    if ((size(i.payments) != 0))
1800
1838
 
        then throw("No payments required")
1801
1839
 
        else {
1802
1840
 
            let userAddr = toString(i.caller)
1803
1841
 
            let f = flightCommon(userAddr, message, sig)
1804
1842
 
            let duckAssetId = f._2
1805
1843
 
            let locKey = keyDuckLocation(duckAssetId)
1806
1844
 
            let curLocation = valueOrElse(getString(locKey), DEFAULTLOCATION)
1807
1845
 
            if ((f._4 == curLocation))
1808
1846
 
                then throw("You can't fly to the same location")
1809
1847
 
                else {
1810
1848
 
                    let bpKey = keyBackpackByDuck(duckAssetId)
1811
1849
 
                    let currentPack = getBackpack(bpKey)
1812
1850
 
                    let newProd = subtractProducts(currentPack[bpIdxProd], f._5)
1813
1851
 
                    $Tuple2(([StringEntry(locKey, if ((f._1 > 0))
1814
1852
 
                        then f._4
1815
1853
 
                        else curLocation), StringEntry(bpKey, makeString([currentPack[bpIdxLevel], currentPack[bpIdxRes], currentPack[bpIdxMat], newProd], ":")), IntegerEntry(keyDuckHealth(duckAssetId), f._1), prologAction] ++ updateDuckStatsInternal(duckAssetId, if ((f._1 > 0))
1816
1854
 
                        then xpSuccessFlight
1817
1855
 
                        else xpFailFlight)._1), f._3)
1818
1856
 
                    }
1819
1857
 
            }
1820
1858
 
    }
1821
1859
 
1822
1860
 
1823
1861
 
1824
1862
 
@Callable(i)
1825
1863
 
func heal (quantityL1,quantityL2,quantityL3) = {
1826
1864
 
    let prologAction = prolog(i)
1827
1865
 
    if (if (if ((0 > quantityL1))
1828
1866
 
        then true
1829
1867
 
        else (0 > quantityL2))
1830
1868
 
        then true
1831
1869
 
        else (0 > quantityL3))
1832
1870
 
        then throw("Quantity cannot be negative")
1833
1871
 
        else {
1834
1872
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
1835
1873
 
            let qts = [quantityL1, quantityL2, quantityL3]
1836
1874
 
            let keyHealth = keyDuckHealth(duckAssetId)
1837
1875
 
            let maxHP = maxHealth(valueOrElse(getInteger(keyDuckLevel(duckAssetId)), 0))
1838
1876
 
            let oldHealth = valueOrElse(getInteger(keyHealth), maxHP)
1839
1877
 
            if ((oldHealth >= maxHP))
1840
1878
 
                then throw((("HP should be < " + toString(maxHP)) + " to heal"))
1841
1879
 
                else {
1842
1880
 
                    let bpKey = keyBackpackByDuck(duckAssetId)
1843
1881
 
                    let currentPack = getBackpack(bpKey)
1844
1882
 
                    let prodList = if ((currentPack[bpIdxProd] == ""))
1845
1883
 
                        then nil
1846
1884
 
                        else split(currentPack[bpIdxProd], "_")
1847
1885
 
                    func iterateProd (acc,ignoredItem) =                     {
1848
1886
 
                        let n = acc._2
1849
1887
 
                        let x = if ((size(prodList) > n))
1850
1888
 
                            then parseIntValue(prodList[n])
1851
1889
 
                            else 0
1852
1890
 
                        if ((3 > n))
1853
1891
 
                            then {
1854
1892
 
                                let q = qts[n]
1855
1893
 
                                if ((q > x))
1856
1894
 
                                    then throw(((("You have only " + toString(x)) + " of ") + prodTypes[n]))
1857
1895
 
                                    else $Tuple3((acc._1 :+ toString((x - q))), (n + 1), (acc._3 + (medKitHp[n] * q)))
1858
1896
 
                                }
1859
1897
 
                            else $Tuple3((acc._1 :+ toString(x)), (n + 1), acc._3)
1860
1898
 
                        }
1861
1899
 
1862
1900
 
                    let result = {
1863
1901
 
                        let $l = productionMatrix
1864
1902
 
                        let $s = size($l)
1865
1903
 
                        let $acc0 = $Tuple3(nil, 0, 0)
1866
1904
 
                        func $f0_1 ($a,$i) =                         if (($i >= $s))
1867
1905
 
                            then $a
1868
1906
 
                            else iterateProd($a, $l[$i])
1869
1907
 
1870
1908
 
                        func $f0_2 ($a,$i) =                         if (($i >= $s))
1871
1909
 
                            then $a
1872
1910
 
                            else throw("List size exceeds 50")
1873
1911
 
1874
1912
 
                        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
1875
1913
 
                        }
1876
1914
 
                    let newHealth = min([maxHP, (oldHealth + result._3)])
1877
1915
 
                    $Tuple2(([IntegerEntry(keyHealth, newHealth), StringEntry(bpKey, makeString_2C([currentPack[bpIdxLevel], currentPack[bpIdxRes], currentPack[bpIdxMat], makeString(result._1, "_")], ":")), prologAction] ++ updateDuckStatsInternal(duckAssetId, (xpHeal * ((quantityL1 + quantityL2) + quantityL3)))._1), newHealth)
1878
1916
 
                    }
1879
1917
 
            }
1880
1918
 
    }
1881
1919
 
1882
1920
 
1883
1921
 
1884
1922
 
@Callable(i)
1885
1923
 
func healES () = {
1886
1924
 
    let prologAction = prolog(i)
1887
1925
 
    if ((size(i.payments) != 1))
1888
1926
 
        then throw("Exactly one payment required")
1889
1927
 
        else {
1890
1928
 
            let pmt = value(i.payments[0])
1891
1929
 
            if ((pmt.assetId != usdtAssetId))
1892
1930
 
                then throw("Allowed USDT payment only!")
1893
1931
 
                else {
1894
1932
 
                    let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
1895
1933
 
                    let keyHealth = keyDuckHealth(duckAssetId)
1896
1934
 
                    let maxHP = maxHealth(valueOrElse(getInteger(keyDuckLevel(duckAssetId)), 0))
1897
1935
 
                    let oldHealth = valueOrElse(getInteger(keyHealth), maxHP)
1898
1936
 
                    if ((oldHealth > 0))
1899
1937
 
                        then throw("HP should be 0 to call Emergency Service")
1900
1938
 
                        else {
1901
1939
 
                            let bpKey = keyBackpackByDuck(duckAssetId)
1902
1940
 
                            let currentPack = getBackpack(bpKey)
1903
1941
 
                            let prodList = if ((currentPack[bpIdxProd] == ""))
1904
1942
 
                                then nil
1905
1943
 
                                else split(currentPack[bpIdxProd], "_")
1906
1944
 
                            let medKitAmount1 = if ((size(prodList) > 0))
1907
1945
 
                                then parseIntValue(prodList[0])
1908
1946
 
                                else 0
1909
1947
 
                            let medKitAmount2 = if ((size(prodList) > 1))
1910
1948
 
                                then parseIntValue(prodList[1])
1911
1949
 
                                else 0
1912
1950
 
                            let medKitAmount3 = if ((size(prodList) > 2))
1913
1951
 
                                then parseIntValue(prodList[2])
1914
1952
 
                                else 0
1915
1953
 
                            if (if (if ((medKitAmount1 > 0))
1916
1954
 
                                then true
1917
1955
 
                                else (medKitAmount2 > 0))
1918
1956
 
                                then true
1919
1957
 
                                else (medKitAmount3 > 0))
1920
1958
 
                                then throw("You have to use own Medical Kit")
1921
1959
 
                                else {
1922
1960
 
                                    let existStr = getString(economyContract, keyEsWarehouse())
1923
1961
 
                                    let existAmounts = if (isDefined(existStr))
1924
1962
 
                                        then split(value(existStr), "_")
1925
1963
 
                                        else nil
1926
1964
 
                                    let existAmount = if ((size(existAmounts) > 0))
1927
1965
 
                                        then parseIntValue(existAmounts[0])
1928
1966
 
                                        else 0
1929
1967
 
                                    if ((0 >= existAmount))
1930
1968
 
                                        then throw("There are no Medical Kits L1 at Emergency Service storage")
1931
1969
 
                                        else {
1932
1970
 
                                            let newHealth = (oldHealth + medKitHp[0])
1933
1971
 
                                            let newES = makeString([toString((existAmount - 1)), removeByIndex(existAmounts, 0)], "_")
1934
1972
 
                                            let recipe = split(productionMatrix[0], "_")
1935
1973
 
                                            let totalMat = getRecipeMaterials(recipe)
1936
1974
 
                                            let sellPrice = fraction((totalMat * ESSELLCOEF), RESOURCEPRICEMIN, (10 * PRODUCTPKGSIZE))
1937
1975
 
                                            if ((pmt.amount != sellPrice))
1938
1976
 
                                                then throw(("Payment attached should be " + toString(sellPrice)))
1939
1977
 
                                                else {
1940
1978
 
                                                    let result = asString(invoke(economyContract, "updateEsStorage", [newES], [AttachedPayment(usdtAssetId, sellPrice)]))
1941
1979
 
                                                    $Tuple2(([IntegerEntry(keyHealth, newHealth), prologAction] ++ updateDuckStatsInternal(duckAssetId, xpCallES)._1), result)
1942
1980
 
                                                    }
1943
1981
 
                                            }
1944
1982
 
                                    }
1945
1983
 
                            }
1946
1984
 
                    }
1947
1985
 
            }
1948
1986
 
    }
1949
1987
 
1950
1988
 
1951
1989
 
1952
1990
 
@Callable(i)
1953
1991
 
func updateBackpack (duckAssetId,newPack) = if ((i.caller != economyContract))
1954
1992
 
    then throw("permission denied")
1955
1993
 
    else $Tuple2([StringEntry(keyBackpackByDuck(duckAssetId), newPack)], newPack)
1956
1994
 
1957
1995
 
1958
1996
 
1959
1997
 
@Callable(i)
1960
1998
 
func buySLand () = {
1961
1999
 
    let prologAction = prolog(i)
1962
2000
 
    if ((size(i.payments) != 1))
1963
2001
 
        then throw("Exactly one payment required")
1964
2002
 
        else {
1965
2003
 
            let pmt = value(i.payments[0])
1966
2004
 
            if ((pmt.assetId != usdtAssetId))
1967
2005
 
                then throw("Allowed USDT payment only!")
1968
2006
 
                else if ((pmt.amount != EXPUSDT))
1969
2007
 
                    then throw(("Payment attached should be " + toString(EXPUSDT)))
1970
2008
 
                    else {
1971
2009
 
                        let result = expeditionInternal(i.caller, i.transactionId)
1972
2010
 
                        $Tuple2((((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdtAssetId)) ++ updateAccStatsInternal(toString(i.caller), xpNewSLand)._1) :+ prologAction), result._2._1)
1973
2011
 
                        }
1974
2012
 
            }
1975
2013
 
    }
1976
2014
 
1977
2015
 
1978
2016
 
1979
2017
 
@Callable(i)
1980
2018
 
func expedition (message,sig) = {
1981
2019
 
    let prologAction = prolog(i)
1982
2020
 
    if ((size(i.payments) != 0))
1983
2021
 
        then throw("No payments required")
1984
2022
 
        else {
1985
2023
 
            let result = expeditionCommon(i.caller, i.transactionId, message, sig)
1986
2024
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
1987
2025
 
            $Tuple2(((result._1 ++ updateDuckStatsInternal(duckAssetId, xpNewSLand)._1) :+ prologAction), $Tuple2(result._2, result._3))
1988
2026
 
            }
1989
2027
 
    }
1990
2028
 
1991
2029
 
1992
2030
 
1993
2031
 
@Callable(i)
1994
2032
 
func upgradeInfra (landAssetId) = {
1995
2033
 
    let prologAction = prolog(i)
1996
2034
 
    if ((size(i.payments) != 0))
1997
2035
 
        then throw("No payments required")
1998
2036
 
        else {
1999
2037
 
            let result = upInfraCommon(true, i.caller, 0, landAssetId)
2000
2038
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
2001
2039
 
            $Tuple2(((result._1 :+ prologAction) ++ updateDuckStatsInternal(duckAssetId, fraction(xpUpgradeInfra, result._3, MULT8))._1), result._2)
2002
2040
 
            }
2003
2041
 
    }
2004
2042
 
2005
2043
 
2006
2044
 
2007
2045
 
@Callable(i)
2008
2046
 
func upgradeInfraUsdt (landAssetId) = if ((i.caller != this))
2009
2047
 
    then throw("Permission denied")
2010
2048
 
    else {
2011
2049
 
        let prologAction = prolog(i)
2012
2050
 
        if ((size(i.payments) != 1))
2013
2051
 
            then throw("Exactly one payment required")
2014
2052
 
            else {
2015
2053
 
                let pmt = value(i.payments[0])
2016
2054
 
                if ((pmt.assetId != usdtAssetId))
2017
2055
 
                    then throw("Allowed USDT payment only!")
2018
2056
 
                    else {
2019
2057
 
                        let result = upInfraCommon(false, i.caller, pmt.amount, landAssetId)
2020
2058
 
                        $Tuple2(((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdtAssetId)) :+ prologAction), result._2)
2021
2059
 
                        }
2022
2060
 
                }
2023
2061
 
        }
2024
2062
 
2025
2063
 
2026
2064
 
2027
2065
 
@Callable(i)
2028
2066
 
func activateArtifact (artName,landAssetIdOpt) = {
2029
2067
 
    let prologAction = prolog(i)
2030
2068
 
    if ((size(i.payments) != 0))
2031
2069
 
        then throw("No payments required")
2032
2070
 
        else {
2033
2071
 
            let addr = toString(i.caller)
2034
2072
 
            let result =             match artName {
2035
2073
 
                case _ => 
2036
2074
 
                    if (("PRESALE" == $match0))
2037
2075
 
                        then activatePresaleArt(addr, landAssetIdOpt)
2038
2076
 
                        else if (("ONBOARD" == $match0))
2039
2077
 
                            then activateOnboardArt(addr)
2040
2078
 
                            else throw("Unknown artifact")
2041
2079
 
            }
2042
2080
 
            (result :+ prologAction)
2043
2081
 
            }
2044
2082
 
    }
2045
2083
 
2046
2084
 
2047
2085
 
2048
2086
 
@Callable(i)
2049
2087
 
func mergeLands (landAssetIds) = {
2050
2088
 
    let prologAction = prolog(i)
2051
2089
 
    if ((size(i.payments) != 0))
2052
2090
 
        then throw("No payments required")
2053
2091
 
        else {
2054
2092
 
            let result = mergeCommon(true, toString(i.caller), 0, landAssetIds, i.transactionId)
2055
2093
 
            $Tuple2(((result._1 :+ prologAction) ++ updateAccStatsInternal(toString(i.caller), xpMerge)._1), result._2)
2056
2094
 
            }
2057
2095
 
    }
2058
2096
 
2059
2097
 
2060
2098
 
2061
2099
 
@Callable(i)
2062
2100
 
func mergeLandsUsdt (landAssetIds) = {
2063
2101
 
    let prologAction = prolog(i)
2064
2102
 
    if ((size(i.payments) != 1))
2065
2103
 
        then throw("Exactly one payment required")
2066
2104
 
        else {
2067
2105
 
            let pmt = value(i.payments[0])
2068
2106
 
            if ((pmt.assetId != usdtAssetId))
2069
2107
 
                then throw("Allowed USDT payment only!")
2070
2108
 
                else {
2071
2109
 
                    let result = mergeCommon(false, toString(i.caller), pmt.amount, landAssetIds, i.transactionId)
2072
2110
 
                    $Tuple2(((result._1 :+ ScriptTransfer(economyContract, pmt.amount, usdtAssetId)) :+ prologAction), result._2)
2073
2111
 
                    }
2074
2112
 
            }
2075
2113
 
    }
2076
2114
 
2077
2115
 
2078
2116
 
2079
2117
 
@Callable(i)
2080
2118
 
func cargoExchange (cargoListStr,landAssetId) = {
2081
2119
 
    let prologAction = prolog(i)
2082
2120
 
    if ((size(i.payments) != 0))
2083
2121
 
        then throw("No payments required")
2084
2122
 
        else {
2085
2123
 
            let cargoParts = split_4C(cargoListStr, ":")
2086
2124
 
            let addr = toString(i.originCaller)
2087
2125
 
            let asset = value(assetInfo(fromBase58String(landAssetId)))
2088
2126
 
            let timeKey = keyStakedTimeByAssetId(landAssetId)
2089
2127
 
            if (!(isDefined(getInteger(timeKey))))
2090
2128
 
                then throw((asset.name + " is not staked"))
2091
2129
 
                else {
2092
2130
 
                    let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(landAssetId)), (("NFT " + asset.name) + " is orphaned"))
2093
2131
 
                    if ((owner != addr))
2094
2132
 
                        then throw((LANDPREFIX + " is not yours"))
2095
2133
 
                        else {
2096
2134
 
                            let landIndex = (numPiecesBySize(split(asset.description, "_")[recLandSize]) / SSIZE)
2097
2135
 
                            let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
2098
2136
 
                            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
2099
2137
 
                            let curLocation = valueOrElse(getString(keyDuckLocation(duckAssetId)), DEFAULTLOCATION)
2100
2138
 
                            let loc = split(value(curLocation), "_")
2101
2139
 
                            if ((loc[locIdxType] != "L"))
2102
2140
 
                                then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
2103
2141
 
                                else if ((loc[locIdxId] != landAssetId))
2104
2142
 
                                    then throw(("Duck should be on the land " + landAssetId))
2105
2143
 
                                    else {
2106
2144
 
                                        let whKey = keyWarehouseByLand(landAssetId)
2107
2145
 
                                        let currentWh = getWarehouse(whKey, landIndex, infraLevel)
2108
2146
 
                                        let bpKey = keyBackpackByDuck(duckAssetId)
2109
2147
 
                                        let currentPack = getBackpack(bpKey)
2110
2148
 
                                        let result = moveStuff(cargoParts, currentWh, currentPack)
2111
2149
 
                                        let loft = split(currentWh[whIdxLOFT], "_")
2112
2150
 
                                        let loftO = (parseIntValue(loft[volOccupied]) + result._7)
2113
2151
 
                                        let loftF = (parseIntValue(loft[volFree]) - result._7)
2114
2152
 
[StringEntry(bpKey, makeString_2C([currentPack[bpIdxLevel], result._4, result._5, result._6], ":")), StringEntry(whKey, makeString_2C([currentWh[whIdxLevels], result._1, result._2, result._3, makeString([loft[volLocked], toString(loftO), toString(loftF), loft[volTotal]], "_")], ":")), prologAction]
2115
2153
 
                                        }
2116
2154
 
                            }
2117
2155
 
                    }
2118
2156
 
            }
2119
2157
 
    }
2120
2158
 
2121
2159
 
2122
2160
 
2123
2161
 
@Callable(i)
2124
2162
 
func saveWarehouse (whStr,landAssetId) = if ((i.caller != economyContract))
2125
2163
 
    then throw("Access denied")
2126
2164
 
    else {
2127
2165
 
        let whKey = keyWarehouseByLand(landAssetId)
2128
2166
 
        let wh = split_4C(whStr, ":")
2129
2167
 
        if ((size(wh) != 5))
2130
2168
 
            then throw("warehouse string should contain 4 ':' separators")
2131
2169
 
            else {
2132
2170
 
                let loftL = split(wh[whIdxLOFT], "_")[volLocked]
2133
2171
 
                let loftO = getWarehouseOccupiedVol(wh)
2134
2172
 
                let loftT = getWarehouseTotalVolume(wh[whIdxLevels])
2135
2173
 
                let loftF = ((loftT - parseIntValue(loftL)) - loftO)
2136
2174
 
                let newWhStr = makeString_2C([wh[whIdxLevels], wh[whIdxRes], wh[whIdxMat], wh[whIdxProd], makeString([loftL, toString(loftO), toString(loftF), toString(loftT)], "_")], ":")
2137
2175
 
                $Tuple2([StringEntry(whKey, newWhStr)], newWhStr)
2138
2176
 
                }
2139
2177
 
        }
2140
2178
 
2141
2179
 
2142
2180
 
2143
2181
 
@Callable(i)
2144
2182
 
func fixWarehouseFormat (landAssetId) = if ((i.caller != restContract))
2145
2183
 
    then throw("Access denied")
2146
2184
 
    else {
2147
2185
 
        let whKey = keyWarehouseByLand(landAssetId)
2148
2186
 
        let asset = value(assetInfo(fromBase58String(landAssetId)))
2149
2187
 
        let landIndex = (numPiecesBySize(split(asset.description, "_")[recLandSize]) / SSIZE)
2150
2188
 
        let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
2151
2189
 
        let wh = getWarehouse(whKey, landIndex, infraLevel)
2152
2190
 
        let loftL = asInt(invoke(economyContract, "recalcLockedVolumeREADONLY", [landAssetId, wh], nil))
2153
2191
 
        let loftO = getWarehouseOccupiedVol(wh)
2154
2192
 
        let loftT = getWarehouseTotalVolume(wh[whIdxLevels])
2155
2193
 
        let loftF = ((loftT - loftL) - loftO)
2156
2194
 
        let newWhStr = makeString_2C([wh[whIdxLevels], wh[whIdxRes], wh[whIdxMat], wh[whIdxProd], makeString([toString(loftL), toString(loftO), toString(loftF), toString(loftT)], "_")], ":")
2157
2195
 
        $Tuple2([StringEntry(whKey, newWhStr)], newWhStr)
2158
2196
 
        }
2159
2197
 
2160
2198
 
2161
2199
 
2162
2200
 
@Callable(i)
2163
2201
 
func fixStakedPieces (address) = if ((i.caller != restContract))
2164
2202
 
    then throw("Access denied")
2165
2203
 
    else {
2166
2204
 
        let stakedPieces = if ((address == ""))
2167
2205
 
            then 0
2168
2206
 
            else {
2169
2207
 
                let landsStr = getString(stakingContract, keyStakedLandsByOwner(address))
2170
2208
 
                let lands = if (isDefined(landsStr))
2171
2209
 
                    then split_51C(value(landsStr), "_")
2172
2210
 
                    else nil
2173
2211
 
                func oneLand (acc,landAssetId) =                 {
2174
2212
 
                    let asset = value(assetInfo(fromBase58String(landAssetId)))
2175
2213
 
                    let landSize = split(asset.description, "_")[recLandSize]
2176
2214
 
                    (acc + numPiecesBySize(landSize))
2177
2215
 
                    }
2178
2216
 
2179
2217
 
                let $l = lands
2180
2218
 
                let $s = size($l)
2181
2219
 
                let $acc0 = 0
2182
2220
 
                func $f0_1 ($a,$i) =                 if (($i >= $s))
2183
2221
 
                    then $a
2184
2222
 
                    else oneLand($a, $l[$i])
2185
2223
 
2186
2224
 
                func $f0_2 ($a,$i) =                 if (($i >= $s))
2187
2225
 
                    then $a
2188
2226
 
                    else throw("List size exceeds 100")
2189
2227
 
2190
2228
 
                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
2191
2229
 
                }
2192
2230
 
        $Tuple2([IntegerEntry(keyStakedPiecesByOwner(address), stakedPieces)], stakedPieces)
2193
2231
 
        }
2194
2232
 
2195
2233
 
2196
2234
 
2197
2235
 
@Callable(i)
2198
2236
 
func setCustomName (assetId,customName,type) = {
2199
2237
 
    let prologAction = prolog(i)
2200
2238
 
    if ((size(i.payments) != 1))
2201
2239
 
        then throw("Exactly one payment required")
2202
2240
 
        else {
2203
2241
 
            let pmt = value(i.payments[0])
2204
2242
 
            if ((pmt.assetId != usdtAssetId))
2205
2243
 
                then throw("Allowed USDT payment only!")
2206
2244
 
                else if ((pmt.amount != RENAMINGCOST))
2207
2245
 
                    then throw(("Payment should be " + toString(RENAMINGCOST)))
2208
2246
 
                    else if (contains(customName, "__"))
2209
2247
 
                        then throw(("Name should not contain '__': " + customName))
2210
2248
 
                        else if ((size(customName) > MAXNAMELEN))
2211
2249
 
                            then throw(("Name too long, maxLength=" + toString(MAXNAMELEN)))
2212
2250
 
                            else {
2213
2251
 
                                let addr = toString(i.originCaller)
2214
2252
 
                                let actions =                                 match type {
2215
2253
 
                                    case _ => 
2216
2254
 
                                        if (("ACCOUNT" == $match0))
2217
2255
 
                                            then {
2218
2256
 
                                                let reverseKey = keyCustomNameToAddress(customName)
2219
2257
 
                                                let nameOwner = getString(reverseKey)
2220
2258
 
                                                if (isDefined(nameOwner))
2221
2259
 
                                                    then throw(("Name already registered: " + customName))
2222
2260
 
                                                    else {
2223
2261
 
                                                        let addrToNameKey = keyAddressToCustomName(addr)
2224
2262
 
                                                        let oldName = getString(addrToNameKey)
2225
2263
 
                                                        let freeOld = if (isDefined(oldName))
2226
2264
 
                                                            then [DeleteEntry(keyCustomNameToAddress(value(oldName)))]
2227
2265
 
                                                            else nil
2228
2266
 
                                                        (((freeOld :+ StringEntry(addrToNameKey, customName)) :+ StringEntry(reverseKey, addr)) ++ updateAccStatsInternal(addr, xpCustomName)._1)
2229
2267
 
                                                        }
2230
2268
 
                                                }
2231
2269
 
                                            else if (("LAND" == $match0))
2232
2270
 
                                                then {
2233
2271
 
                                                    let asset = value(assetInfo(fromBase58String(assetId)))
2234
2272
 
                                                    let timeKey = keyStakedTimeByAssetId(assetId)
2235
2273
 
                                                    if (!(isDefined(getInteger(timeKey))))
2236
2274
 
                                                        then throw((asset.name + " is not staked"))
2237
2275
 
                                                        else {
2238
2276
 
                                                            let owner = valueOrErrorMessage(getString(keyLandAssetIdToOwner(assetId)), (("NFT " + asset.name) + " is orphaned"))
2239
2277
 
                                                            if ((owner != addr))
2240
2278
 
                                                                then throw((LANDPREFIX + " is not yours"))
2241
2279
 
                                                                else {
2242
2280
 
                                                                    let reverseKey = keyLandCustomNameToAssetId(customName)
2243
2281
 
                                                                    let nameOwner = getString(reverseKey)
2244
2282
 
                                                                    if (isDefined(nameOwner))
2245
2283
 
                                                                        then throw(("Name already registered: " + customName))
2246
2284
 
                                                                        else {
2247
2285
 
                                                                            let assetToNameKey = keyLandAssetIdToCustomName(assetId)
2248
2286
 
                                                                            let oldName = getString(assetToNameKey)
2249
2287
 
                                                                            let freeOld = if (isDefined(oldName))
2250
2288
 
                                                                                then [DeleteEntry(keyLandCustomNameToAssetId(value(oldName)))]
2251
2289
 
                                                                                else nil
2252
2290
 
                                                                            (((freeOld :+ StringEntry(assetToNameKey, customName)) :+ StringEntry(reverseKey, assetId)) ++ updateAccStatsInternal(addr, xpCustomName)._1)
2253
2291
 
                                                                            }
2254
2292
 
                                                                    }
2255
2293
 
                                                            }
2256
2294
 
                                                    }
2257
2295
 
                                                else if (("DUCK" == $match0))
2258
2296
 
                                                    then {
2259
2297
 
                                                        let asset = value(assetInfo(fromBase58String(assetId)))
2260
2298
 
                                                        let timeKey = keyStakedTimeByAssetId(assetId)
2261
2299
 
                                                        if (if (!(isDefined(getInteger(timeKey))))
2262
2300
 
                                                            then true
2263
2301
 
                                                            else !(isDefined(getString(keyStakedDuckByOwner(addr)))))
2264
2302
 
                                                            then throw((asset.name + " is not staked"))
2265
2303
 
                                                            else {
2266
2304
 
                                                                let owner = valueOrErrorMessage(getString(keyDuckIdToOwner(assetId)), (("NFT " + asset.name) + " is orphaned"))
2267
2305
 
                                                                if ((owner != addr))
2268
2306
 
                                                                    then throw((DUCKPREFIX + " is not yours"))
2269
2307
 
                                                                    else {
2270
2308
 
                                                                        let reverseKey = keyDuckCustomNameToAssetId(customName)
2271
2309
 
                                                                        let nameOwner = getString(reverseKey)
2272
2310
 
                                                                        if (isDefined(nameOwner))
2273
2311
 
                                                                            then throw(("Name already registered: " + customName))
2274
2312
 
                                                                            else {
2275
2313
 
                                                                                let assetToNameKey = keyDuckAssetIdToCustomName(assetId)
2276
2314
 
                                                                                let oldName = getString(assetToNameKey)
2277
2315
 
                                                                                let freeOld = if (isDefined(oldName))
2278
2316
 
                                                                                    then [DeleteEntry(keyDuckCustomNameToAssetId(value(oldName)))]
2279
2317
 
                                                                                    else nil
2280
2318
 
                                                                                (((freeOld :+ StringEntry(assetToNameKey, customName)) :+ StringEntry(reverseKey, assetId)) ++ updateDuckStatsInternal(assetId, xpCustomName)._1)
2281
2319
 
                                                                                }
2282
2320
 
                                                                        }
2283
2321
 
                                                                }
2284
2322
 
                                                        }
2285
2323
 
                                                    else throw("Unknown entity type")
2286
2324
 
                                }
2287
2325
 
                                $Tuple2(((actions :+ ScriptTransfer(economyContract, pmt.amount, usdtAssetId)) :+ prologAction), 0)
2288
2326
 
                                }
2289
2327
 
            }
2290
2328
 
    }
2291
2329
 
2292
2330
 
2293
2331
 
2294
2332
 
@Callable(i)
2295
2333
 
func setReferrals (oldPlayer,newPlayer) = if ((i.callerPublicKey != pub))
2296
2334
 
    then throw("Permission denied")
2297
2335
 
    else {
2298
2336
 
        let prologAction = prolog(i)
2299
2337
 
        if ((size(i.payments) != 0))
2300
2338
 
            then throw("No payments required")
2301
2339
 
            else if (!(isDefined(addressFromString(oldPlayer))))
2302
2340
 
                then throw(("Invalid address: " + oldPlayer))
2303
2341
 
                else if (!(isDefined(addressFromString(newPlayer))))
2304
2342
 
                    then throw(("Invalid address: " + newPlayer))
2305
2343
 
                    else {
2306
2344
 
                        let oldsKey = keyOldies()
2307
2345
 
                        let olds = getString(oldsKey)
2308
2346
 
                        let oldies = if (isDefined(olds))
2309
2347
 
                            then split_4C(value(olds), "_")
2310
2348
 
                            else nil
2311
2349
 
                        if (containsElement(oldies, newPlayer))
2312
2350
 
                            then throw((newPlayer + " is not newbie (already has referrals)"))
2313
2351
 
                            else {
2314
2352
 
                                let refByKey = keyAddressRefBy(newPlayer)
2315
2353
 
                                let refBy = getString(refByKey)
2316
2354
 
                                if (if (isDefined(refBy))
2317
2355
 
                                    then isDefined(addressFromString(value(refBy)))
2318
2356
 
                                    else false)
2319
2357
 
                                    then throw(((newPlayer + " already has refBy: ") + value(refBy)))
2320
2358
 
                                    else {
2321
2359
 
                                        let refsKey = keyAddressReferrals(oldPlayer)
2322
2360
 
                                        let refs = getString(refsKey)
2323
2361
 
                                        let refsArray = if (isDefined(refs))
2324
2362
 
                                            then split_4C(value(refs), "_")
2325
2363
 
                                            else nil
2326
2364
 
                                        if (containsElement(refsArray, newPlayer))
2327
2365
 
                                            then throw((((oldPlayer + " already contains ") + newPlayer) + " within referrals"))
2328
2366
 
                                            else {
2329
2367
 
                                                let newRefs = makeString_2C((refsArray :+ newPlayer), "_")
2330
2368
 
                                                let newOlds = if (containsElement(oldies, oldPlayer))
2331
2369
 
                                                    then value(olds)
2332
2370
 
                                                    else makeString_2C((oldies :+ oldPlayer), "_")
2333
2371
 
                                                $Tuple2([StringEntry(refByKey, oldPlayer), StringEntry(refsKey, newRefs), StringEntry(oldsKey, newOlds), prologAction], 0)
2334
2372
 
                                                }
2335
2373
 
                                        }
2336
2374
 
                                }
2337
2375
 
                        }
2338
2376
 
        }
2339
2377
 
2340
2378
 
2341
2379
 
2342
2380
 
@Callable(i)
2343
2381
 
func distributePoints (strength,accuracy,intellect,endurance,dexterity) = {
2344
2382
 
    let prologAction = prolog(i)
2345
2383
 
    if ((size(i.payments) != 0))
2346
2384
 
        then throw("No payments required")
2347
2385
 
        else {
2348
2386
 
            let addr = toString(i.originCaller)
2349
2387
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
2350
2388
 
            let freeKeyAcc = keyUserFreePoints(addr)
2351
2389
 
            let freePointsAcc = valueOrElse(getInteger(stakingContract, freeKeyAcc), 0)
2352
2390
 
            let freeKeyDuck = keyDuckFreePoints(duckAssetId)
2353
2391
 
            let freePointsDuck = valueOrElse(getInteger(stakingContract, freeKeyDuck), 0)
2354
2392
 
            let sumFree = (freePointsAcc + freePointsDuck)
2355
2393
 
            let sumToDistribute = ((((strength + accuracy) + intellect) + endurance) + dexterity)
2356
2394
 
            if ((sumToDistribute > sumFree))
2357
2395
 
                then throw((("There are only " + toString(sumFree)) + " free points to distribute"))
2358
2396
 
                else {
2359
2397
 
                    let charsKey = keyDuckChars(duckAssetId)
2360
2398
 
                    let chars = split(valueOrElse(getString(stakingContract, charsKey), "0_0_0_0_0"), "_")
2361
2399
 
                    let newAcc = (freePointsAcc - sumToDistribute)
2362
2400
 
                    $Tuple2([IntegerEntry(freeKeyAcc, if ((0 > newAcc))
2363
2401
 
                        then 0
2364
2402
 
                        else newAcc), IntegerEntry(freeKeyDuck, if ((0 > newAcc))
2365
2403
 
                        then (freePointsDuck + newAcc)
2366
2404
 
                        else freePointsDuck), StringEntry(charsKey, makeString([toString((parseIntValue(chars[charStrength]) + strength)), toString((parseIntValue(chars[charAccuracy]) + accuracy)), toString((parseIntValue(chars[charIntellect]) + intellect)), toString((parseIntValue(chars[charEndurance]) + endurance)), toString((parseIntValue(chars[charDexterity]) + dexterity))], "_")), prologAction], 0)
2367
2405
 
                    }
2368
2406
 
            }
2369
2407
 
    }
2370
2408
 
2371
2409
 
2372
2410
 
2373
2411
 
@Callable(i)
2374
2412
 
func splitByGlobalWeightsREADONLY (amount) = $Tuple2(nil, getNeededMaterials(amount))
2375
2413
 
2376
2414
 
2377
2415
 
2378
2416
 
@Callable(i)
2379
2417
 
func splitByGlobalAndLocalWeightsREADONLY (matAmount,resAmount,terrains) = {
2380
2418
 
    let terrainCounts = countTerrains(terrains)
2381
2419
 
    $Tuple2(nil, $Tuple2(getNeededMaterials(matAmount), distributeByWeights(resAmount, terrainCounts)))
2382
2420
 
    }
2383
2421
 
2384
2422
 
2385
2423
 
2386
2424
 
@Callable(i)
2387
2425
 
func getBackpackREADONLY (duckAssetId) = $Tuple2(nil, makeString(getBackpack(keyBackpackByDuck(duckAssetId)), ":"))
2388
2426
 
2389
2427
 
2390
2428
 
2391
2429
 
@Callable(i)
2392
2430
 
func getWarehouseREADONLY (landAssetId) = {
2393
2431
 
    let asset = value(assetInfo(fromBase58String(landAssetId)))
2394
2432
 
    let landIndex = (numPiecesBySize(split(asset.description, "_")[recLandSize]) / SSIZE)
2395
2433
 
    let infraLevel = valueOrElse(getInteger(keyInfraLevelByAssetId(landAssetId)), 0)
2396
2434
 
    $Tuple2(nil, makeString_2C(getWarehouse(keyWarehouseByLand(landAssetId), landIndex, infraLevel), ":"))
2397
2435
 
    }
2398
2436
 
2399
2437
 
2400
2438
 
2401
2439
 
@Callable(i)
2402
2440
 
func saveLastTx () = if (if ((i.caller != wlgContract))
2403
2441
 
    then (i.caller != economyContract)
2404
2442
 
    else false)
2405
2443
 
    then throw("Access denied")
2406
2444
 
    else $Tuple2([prolog(i)], 42)
2407
2445
 
2408
2446
 
2409
2447
 
2410
2448
 
@Callable(i)
2411
2449
 
func updateDuckStats (duckAssetId,deltaXP) = if ((i.caller != economyContract))
2412
2450
 
    then throw("Access denied")
2413
2451
 
    else updateDuckStatsInternal(duckAssetId, deltaXP)
2414
2452
 
2415
2453
 
2416
2454
 
2417
2455
 
@Callable(i)
2418
2456
 
func updateAccStats (addr,deltaXP) = if ((i.caller != economyContract))
2419
2457
 
    then throw("Access denied")
2420
2458
 
    else updateAccStatsInternal(addr, deltaXP)
2421
2459
 
2422
2460
 
2423
2461
 
2424
2462
 
@Callable(i)
2425
2463
 
func equipDuck (equipment) = {
2426
2464
 
    let prologAction = prolog(i)
2427
2465
 
    if ((size(i.payments) != 0))
2428
2466
 
        then throw("No payments required")
2429
2467
 
        else {
2430
2468
 
            let addr = toString(i.originCaller)
2431
2469
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
2432
2470
 
            let eqKey = keyDuckEquipment(duckAssetId)
2433
2471
 
            let currentSegs = split(valueOrElse(getString(eqKey), ",;,_,;,_,;,_,;,_,;,_,;,"), "_")
2434
2472
 
            let bpKey = keyBackpackByDuck(duckAssetId)
2435
2473
 
            let currentPack = getBackpack(bpKey)
2436
2474
 
            let newEq = split(equipment, "_")
2437
2475
 
            if ((size(newEq) != NUMSEGMENTS))
2438
2476
 
                then throw("Wrong equipment string")
2439
2477
 
                else {
2440
2478
 
                    let bpProd = currentPack[bpIdxProd]
2441
2479
 
                    let pList = if ((bpProd == ""))
2442
2480
 
                        then nil
2443
2481
 
                        else split(bpProd, "_")
2444
2482
 
                    let tempProd = dress(currentSegs, pList, true)
2445
2483
 
                    let newProd = dress(newEq, tempProd, false)
2446
2484
 
                    $Tuple2([StringEntry(eqKey, equipment), StringEntry(bpKey, makeString_2C([currentPack[bpIdxLevel], currentPack[bpIdxRes], currentPack[bpIdxMat], makeString(newProd, "_")], ":")), prologAction], 0)
2447
2485
 
                    }
2448
2486
 
            }
2449
2487
 
    }
2450
2488
 
2451
2489