tx · BUxSUsbptrTHZL3yqV6sJ8hNLZ67wcDXoTCtHthELV6A

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.07000000 Waves

2023.07.12 16:54 [2662772] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BUxSUsbptrTHZL3yqV6sJ8hNLZ67wcDXoTCtHthELV6A",
    "fee": 7000000,
    "feeAssetId": null,
    "timestamp": 1689170118996,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "Cr1jynwNrK6QAhW2AupYKbMzyEn6AcYfN8F7W1PPYwngS7vjCY74FCPSuF4MbpGahUBU9zZjduEmSQXqDP85rnW"
    ],
    "script": "base64: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",
    "height": 2662772,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 4eRjkh2Nm7d2njTXmhbT9TWycuBhb8mWqAJrYiZqqnCN
Next: AKrYaZYNJbYnuPbEEjVYPpgbZRhyA2ZSsLRF8qfVQqVJ

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