w8 · tx · 61r···xhE

tx · 61rX2aXwZSWwHyZEfcsDU7BKk3wQP2Jk8WLFsZZZxhE

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.07800000 Waves

2023.08.02 01:21 [2692103] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "61rX2aXwZSWwHyZEfcsDU7BKk3wQP2Jk8WLFsZZZxhE",
    "fee": 7800000,
    "feeAssetId": null,
    "timestamp": 1690928497371,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "44vRVqCm6jNSegqWc8TePu4wjhZGRoPcnqCiFqH98z8NUboVzznnH19RCg829YrY536zRio3dtoidTN4YY6RYKbN"
    ],
    "script": "base64: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",
    "height": 2692103,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GBGmSXEn9t27ENGEPPCS7QkViLs4GDdxJhrURJr5a7NW
Next: 782QZyhfPAaagZJAXE7bpu9NQB3bvY7fhm8bBhPWjUg5

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

Old	New		Differences
1017	1017		let val = if ((idx == maxIdx))
1018	1018		then (arr[idx] - delta)
1019	1019		else arr[idx]
1020		-	let zeroes = split(drop(toString(pow(10, 0, val, 0, 0, DOWN)), 1), "")
1021		-	func listGen (ac,e) = (ac :+ TCHARS[idx])
	1020	+	let zeroes = if ((val == 0))
	1021	+	then nil
	1022	+	else split(drop(toString(pow(10, 0, val, 0, 0, DOWN)), 1), "")
	1023	+	let c = TCHARS[idx]
	1024	+	func listGen (ac,e) = (ac :+ c)
1022	1025
1023	1026		let z = {
1024	1027		let $l = zeroes

1395	1398
1396	1399
1397	1400		func checkClaimConditions (addr,claimMode,landAssetIdIn) = {
1398		-	let $~~t03077831317~~ = if ((claimMode == claimModeWh))
	1401	+	let $t03081031349 = if ((claimMode == claimModeWh))
1399	1402		then $Tuple2(landAssetIdIn, valueOrElse(getString(keyStakedDuckByOwner(addr)), ""))
1400	1403		else {
1401	1404		let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")

1405	1408		then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
1406	1409		else $Tuple2(loc[locIdxId], duckAssetId)
1407	1410		}
1408		-	let landAssetId = $~~t03077831317~~._1
1409		-	let duckId = $~~t03077831317~~._2
	1411	+	let landAssetId = $t03081031349._1
	1412	+	let duckId = $t03081031349._2
1410	1413		let asset = value(assetInfo(fromBase58String(landAssetId)))
1411	1414		let timeKey = keyStakedTimeByAssetId(landAssetId)
1412	1415		let savedTime = valueOrErrorMessage(getInteger(timeKey), (("Land " + asset.name) + " is not staked"))

1454	1457		let currentPack = getBackpack(bpKey)
1455	1458		let currentPackRes = split(currentPack[bpIdxRes], "_")
1456	1459		let currentWhRes = split(currentWh[whIdxRes], "_")
1457		-	let $~~t03369134562~~ = if ((claimMode == claimModeWh))
	1460	+	let $t03372334594 = if ((claimMode == claimModeWh))
1458	1461		then $Tuple4(addRes(currentWhRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), currentPack[bpIdxRes], (parseIntValue(loft[volOccupied]) + resToClaim._2), (parseIntValue(loft[volFree]) - resToClaim._2))
1459	1462		else if ((claimMode == claimModeDuck))
1460	1463		then $Tuple4(currentWh[whIdxRes], addRes(currentPackRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), parseIntValue(loft[volOccupied]), parseIntValue(loft[volFree]))

1463	1466		let whAm = min([parseIntValue(loft[volFree]), resToClaim._2])
1464	1467		$Tuple4(distr._1, distr._2, (parseIntValue(loft[volOccupied]) + whAm), (parseIntValue(loft[volFree]) - whAm))
1465	1468		}
1466		-	let whRes = $~~t03369134562~~._1
1467		-	let bpRes = $~~t03369134562~~._2
1468		-	let loftO = $~~t03369134562~~._3
1469		-	let loftF = $~~t03369134562~~._4
	1469	+	let whRes = $t03372334594._1
	1470	+	let bpRes = $t03372334594._2
	1471	+	let loftO = $t03372334594._3
	1472	+	let loftF = $t03372334594._4
1470	1473		$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]], "_")])
1471	1474		}
1472	1475		}

Old	New	Differences
1	1	{-# STDLIB_VERSION 6 #-}
2	2	{-# SCRIPT_TYPE ACCOUNT #-}
3	3	{-# CONTENT_TYPE DAPP #-}
4	4	func keyLastArbTimeByUser (addr) = ("lastArbTimeUser_" + addr)
5	5
6	6
7	7	let SCALE8 = 100000000
8	8
9	9	let xpLevelScale = 3200
10	10
11	11	let xpLevelRecipPow = 4000
12	12
13	13	let numPointsOnLevelUp = 3
14	14
15	15	let requirements = ["Strength", "Accuracy", "Intellect", "Endurance", "Dexterity", "Level", "Health"]
16	16
17	17	let charStrength = 0
18	18
19	19	let charAccuracy = 1
20	20
21	21	let charIntellect = 2
22	22
23	23	let charEndurance = 3
24	24
25	25	let charDexterity = 4
26	26
27	27	let NUMSEGMENTS = 6
28	28
29	29	let NUMMAINAUX = 2
30	30
31	31	let MAXSLOTS = 2
32	32
33	33	let MAXPRODINSLOT = 30
34	34
35	35	func keyDuckHealth (duckAssetId) = ("duckHealth_" + duckAssetId)
36	36
37	37
38	38	func keyDuckChars (duckAssetId) = ("duckChars_" + duckAssetId)
39	39
40	40
41	41	func keyDuckXP (duckAssetId) = ("duckXP_" + duckAssetId)
42	42
43	43
44	44	func keyDuckLevel (duckAssetId) = ("duckLevel_" + duckAssetId)
45	45
46	46
47	47	func keyDuckFreePoints (duckAssetId) = ("duckFreePoints_" + duckAssetId)
48	48
49	49
50	50	func keyDuckEquipment (duckAssetId) = ("duckEquipment_" + duckAssetId)
51	51
52	52
53	53	func keyUserXP (addr) = ("userXP_" + addr)
54	54
55	55
56	56	func keyUserLevel (addr) = ("userLevel_" + addr)
57	57
58	58
59	59	func keyUserFreePoints (addr) = ("userFreePoints_" + addr)
60	60
61	61
62	62	let xpClaim = 10000
63	63
64	64	let xpSuccessFlight = 10000
65	65
66	66	let xpFailFlight = 2000
67	67
68	68	let xpCallES = 100000
69	69
70	70	let xpCustomName = 1000000
71	71
72	72	let xpNewSLand = 5000000
73	73
74	74	let xpUpgradeInfra = 10000
75	75
76	76	let xpMerge = 1000000
77	77
78	78	let xpOnboard = 1000000
79	79
80	80	let xpHeal = 10000
81	81
82	82	func levelByXP (xp) = fraction(xpLevelScale, pow(xp, 4, xpLevelRecipPow, 4, 4, DOWN), SCALE8)
83	83
84	84
85	85	func maxHealth (level) = (100 + level)
86	86
87	87
88	88	func levelUp (currLevel,newXP) = {
89	89	let newLevel = levelByXP(newXP)
90	90	[newLevel, (numPointsOnLevelUp * (newLevel - currLevel))]
91	91	}
92	92
93	93
94	94	func getDuckStats (stakingContract,duckAssetId) = {
95	95	let chars = split(valueOrElse(getString(stakingContract, keyDuckChars(duckAssetId)), "0_0_0_0_0"), "_")
96	96	let lvl = valueOrElse(getInteger(stakingContract, keyDuckLevel(duckAssetId)), 0)
97	97	let health = valueOrElse(getInteger(stakingContract, keyDuckHealth(duckAssetId)), maxHealth(lvl))
98	98	[parseIntValue(chars[charStrength]), parseIntValue(chars[charAccuracy]), parseIntValue(chars[charIntellect]), parseIntValue(chars[charEndurance]), parseIntValue(chars[charDexterity]), lvl, health]
99	99	}
100	100
101	101
102	102	let LANDPREFIX = "LAND"
103	103
104	104	let DUCKPREFIX = "DUCK"
105	105
106	106	let ARTPRESALE = "PRESALE"
107	107
108	108	let NUMRES = 6
109	109
110	110	let DAILYRESBYPIECE = 3456000
111	111
112	112	let DAYMILLIS = 86400000
113	113
114	114	let WHMULTIPLIER = 10000000000
115	115
116	116	let DEFAULTLOCATION = "Africa_F_Africa"
117	117
118	118	let RESOURCEPRICEMIN = 39637
119	119
120	120	let ESSELLCOEF = 10
121	121
122	122	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"]
123	123
124	124	let continents = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
125	125
126	126	let COEFF2MAT = 10000000
127	127
128	128	let productionMatrix = ["8_8_8_17_17_42_12_0_30_0,0,0,0,0,0,0_", "8_8_8_17_17_42_24_0_60_0,0,5,2,0,0,0_", "8_8_8_17_17_42_36_0_120_0,0,10,4,0,0,0_", "8_19_19_8_27_19_26_1_20_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_52_1_40_0,0,0,0,0,0,0_001", "8_19_19_8_27_19_78_1_80_0,0,0,0,0,0,0_001", "8_8_8_8_8_60_13_2_2_0,0,0,0,0,0,0_", "8_8_8_8_8_60_26_2_4_0,0,0,0,0,0,0_", "8_8_8_8_8_60_39_2_8_0,0,0,0,0,0,0_", "30_30_3_17_17_3_30_3_30_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_60_3_50_0,0,0,0,0,0,0_111", "30_30_3_17_17_3_90_3_70_0,0,0,0,0,0,0_111", "18_18_10_18_18_18_11_4_30_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_22_4_50_0,0,0,0,0,0,0_201", "18_18_10_18_18_18_33_4_70_0,0,0,0,0,0,0_201"]
129	129
130	130	let rIdxCoeff = 6
131	131
132	132	let rIdxRequirements = 9
133	133
134	134	let rIdxSlots = 10
135	135
136	136	let PRODUCTPKGSIZE = 10
137	137
138	138	let whIdxLevels = 0
139	139
140	140	let whIdxRes = 1
141	141
142	142	let whIdxMat = 2
143	143
144	144	let whIdxProd = 3
145	145
146	146	let whIdxLOFT = 4
147	147
148	148	let volLocked = 0
149	149
150	150	let volOccupied = 1
151	151
152	152	let volFree = 2
153	153
154	154	let volTotal = 3
155	155
156	156	let bpIdxLevel = 0
157	157
158	158	let bpIdxRes = 1
159	159
160	160	let bpIdxMat = 2
161	161
162	162	let bpIdxProd = 3
163	163
164	164	func keyLastTxIdByUser (addr) = ("lastTxIdByUser_" + addr)
165	165
166	166
167	167	func keyLandAssetIdToOwner (assetId) = ("nftOwner_" + assetId)
168	168
169	169
170	170	func keyLandAssetIdToCustomName (assetId) = ("landCustomNameByAssetId_" + assetId)
171	171
172	172
173	173	func keyStakedTimeByAssetId (assetId) = ("stakedTime_" + assetId)
174	174
175	175
176	176	func keyInfraLevelByAssetId (assetId) = ("infraLevel_" + assetId)
177	177
178	178
179	179	func keyLandArtStatusByTypeAndAssetId (type,assetId) = makeString(["landArtStatus", type, assetId], "_")
180	180
181	181
182	182	func keyStakedTimeByTypeAssetIdAndOwner (nftType,assetId,ownerAddr) = ((((("stakedTimeByTypeAssetIdAndOwner_" + nftType) + "_") + assetId) + "_") + ownerAddr)
183	183
184	184
185	185	func keyWarehouseByLand (landAssetId) = ("wareHouse_" + landAssetId)
186	186
187	187
188	188	func keyDuckAssetIdToCustomName (assetId) = ("duckCustomNameByAssetId_" + assetId)
189	189
190	190
191	191	func keyAddressToCustomName (addr) = ("accountCustomNameByAddr_" + addr)
192	192
193	193
194	194	func keyAddressRefBy (addr) = ("accRefBy_" + addr)
195	195
196	196
197	197	func keyOnboardArtActivatedOnDuck (duckAssetId) = ("onboardArtActivatedOnDuck_" + duckAssetId)
198	198
199	199
200	200	func keyOnboardArtDuckActivatedBy (addr) = ("onboardArtActivatedDuckBy_" + addr)
201	201
202	202
203	203	func keyAddressReferrals (addr) = ("accReferrals_" + addr)
204	204
205	205
206	206	func keyDuckIdToOwner (assetId) = ("duckOwner_" + assetId)
207	207
208	208
209	209	func keyStakedDuckByOwner (ownerAddr) = ("stakedDuckByOwner_" + ownerAddr)
210	210
211	211
212	212	func keyBackpackByDuck (duckAssetId) = ("backPack_" + duckAssetId)
213	213
214	214
215	215	func keyDuckLocation (duckAssetId) = ("duckLocation_" + duckAssetId)
216	216
217	217
218	218	func keyBlocked () = "contractsBlocked"
219	219
220	220
221	221	func keyUserGwlReleaseTime (userAddr) = ("%s%s__userGwlReleaseTime__" + userAddr)
222	222
223	223
224	224	func keyEsWarehouse () = "emergencyWarehouseProducts"
225	225
226	226
227	227	let locIdxType = 1
228	228
229	229	let locIdxId = 2
230	230
231	231	func getRecipeMaterials (recipe) = (parseIntValue(recipe[rIdxCoeff]) * COEFF2MAT)
232	232
233	233
234	234	let KSALLOWXPLEVELS = false
235	235
236	236	let chain = take(drop(this.bytes, 1), 1)
237	237
238	238	let usdtAssetId = match chain {
239	239	case _ =>
240	240	if ((base58'2W' == $match0))
241	241	then base58'9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi'
242	242	else if ((base58'2T' == $match0))
243	243	then base58'6mWwf9mZBjVgkC54idpyaZLQfAosD914wT8fGf2iiY63'
244	244	else throw("Unknown chain")
245	245	}
246	246
247	247	let defaultRestAddressStr = match chain {
248	248	case _ =>
249	249	if ((base58'2W' == $match0))
250	250	then "3PQCuvFbvh4LkPUnrnU1z3jnbA1p9m3WNhv"
251	251	else if ((base58'2T' == $match0))
252	252	then "3MumkGGztCKAXpWDqxkddofqXSUbqQkvSJy"
253	253	else throw("Unknown chain")
254	254	}
255	255
256	256	let InfraUpgradeCostS = match chain {
257	257	case _ =>
258	258	if ((base58'2W' == $match0))
259	259	then 10000000000
260	260	else if ((base58'2T' == $match0))
261	261	then 100000000
262	262	else throw("Unknown chain")
263	263	}
264	264
265	265	let arbitrageDelay = match chain {
266	266	case _ =>
267	267	if ((base58'2W' == $match0))
268	268	then 600000
269	269	else if ((base58'2T' == $match0))
270	270	then 60000
271	271	else throw("Unknown chain")
272	272	}
273	273
274	274	let SEP = "__"
275	275
276	276	let MULT6 = 1000000
277	277
278	278	let MULT8 = 100000000
279	279
280	280	let SSIZE = 25
281	281
282	282	let MSIZE = 100
283	283
284	284	let LSIZE = 225
285	285
286	286	let XLSIZE = 400
287	287
288	288	let XXLSIZE = 625
289	289
290	290	let ITER6 = [0, 1, 2, 3, 4, 5]
291	291
292	292	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
293	293
294	294
295	295	let IdxCfgStakingDapp = 1
296	296
297	297	let IdxCfgEconomyDapp = 2
298	298
299	299	let IdxCfgGovernanceDapp = 3
300	300
301	301	let IdxCfgWlgDapp = 4
302	302
303	303	func keyRestCfg () = "%s__restConfig"
304	304
305	305
306	306	func keyRestAddress () = "%s__restAddr"
307	307
308	308
309	309	func readRestCfgOrFail (rest) = split_4C(getStringOrFail(rest, keyRestCfg()), SEP)
310	310
311	311
312	312	func getContractAddressOrFail (restCfg,idx) = valueOrErrorMessage(addressFromString(restCfg[idx]), ("Rest cfg doesn't contain address at index " + toString(idx)))
313	313
314	314
315	315	let restContract = addressFromStringValue(valueOrElse(getString(this, keyRestAddress()), defaultRestAddressStr))
316	316
317	317	let restCfg = readRestCfgOrFail(restContract)
318	318
319	319	let stakingContract = getContractAddressOrFail(restCfg, IdxCfgStakingDapp)
320	320
321	321	let economyContract = getContractAddressOrFail(restCfg, IdxCfgEconomyDapp)
322	322
323	323	let govContract = getContractAddressOrFail(restCfg, IdxCfgGovernanceDapp)
324	324
325	325	let wlgContract = getContractAddressOrFail(restCfg, IdxCfgWlgDapp)
326	326
327	327	let recLandNum = 0
328	328
329	329	let recLandSize = 1
330	330
331	331	let recTerrains = 2
332	332
333	333	let recContinent = 3
334	334
335	335	let randomDelay = 2
336	336
337	337	func keyCommitOp (address) = ("commitOperation_" + address)
338	338
339	339
340	340	func keyCommit (address) = ("finishBlockForAddr_" + address)
341	341
342	342
343	343	func keyResProportions () = "resTypesProportions"
344	344
345	345
346	346	func keyStakedLandsByOwner (ownerAddr) = ("stakedLandsByOwner_" + ownerAddr)
347	347
348	348
349	349	func keyStakedPiecesByOwner (ownerAddr) = ("stakedPiecesByOwner_" + ownerAddr)
350	350
351	351
352	352	func asString (v) = match v {
353	353	case s: String =>
354	354	s
355	355	case _ =>
356	356	throw("fail to cast into String")
357	357	}
358	358
359	359
360	360	func asInt (v) = match v {
361	361	case n: Int =>
362	362	n
363	363	case _ =>
364	364	throw("fail to cast into Int")
365	365	}
366	366
367	367
368	368	func numPiecesBySize (landSize) = match landSize {
369	369	case _ =>
370	370	if (("S" == $match0))
371	371	then SSIZE
372	372	else if (("M" == $match0))
373	373	then MSIZE
374	374	else if (("L" == $match0))
375	375	then LSIZE
376	376	else if (("XL" == $match0))
377	377	then XLSIZE
378	378	else if (("XXL" == $match0))
379	379	then XXLSIZE
380	380	else throw("Unknown land size")
381	381	}
382	382
383	383
384	384	func isDigit (s) = isDefined(parseInt(s))
385	385
386	386
387	387	let incubatorAddr = match chain {
388	388	case _ =>
389	389	if ((base58'2W' == $match0))
390	390	then addressFromStringValue("3PEktVux2RhchSN63DsDo4b4mz4QqzKSeDv")
391	391	else if ((base58'2T' == $match0))
392	392	then this
393	393	else throw("Unknown chain")
394	394	}
395	395
396	396	let breederAddr = match chain {
397	397	case _ =>
398	398	if ((base58'2W' == $match0))
399	399	then addressFromStringValue("3PDVuU45H7Eh5dmtNbnRNRStGwULA7NY6Hb")
400	400	else if ((base58'2T' == $match0))
401	401	then this
402	402	else throw("Unknown chain")
403	403	}
404	404
405	405	let pub = base58'6LfPuKJjLgekmncBhMg2LZyMTNVzZBccXR28ySXm9uXD'
406	406
407	407	let medKitHp = [30, 60, 120]
408	408
409	409	let FIVEMINUTESMILLIS = 300000
410	410
411	411	let RENAMINGCOST = 5000000
412	412
413	413	let MAXNAMELEN = 50
414	414
415	415	let InfraUpgradeCostSUsdt = 10000000
416	416
417	417	let EXPMATERIALS = match chain {
418	418	case _ =>
419	419	if ((base58'2W' == $match0))
420	420	then 252289527462
421	421	else if ((base58'2T' == $match0))
422	422	then 2522895274
423	423	else throw("Unknown chain")
424	424	}
425	425
426	426	let EXPUSDT = match chain {
427	427	case _ =>
428	428	if ((base58'2W' == $match0))
429	429	then 250000000
430	430	else if ((base58'2T' == $match0))
431	431	then 250000000
432	432	else throw("Unknown chain")
433	433	}
434	434
435	435	let FIVEX = toBigInt(5)
436	436
437	437	let TWENTYX = toBigInt(20)
438	438
439	439	let TWENTY2X = toBigInt((20 * 20))
440	440
441	441	let TWENTY3X = toBigInt(((20 * 20) * 20))
442	442
443	443	let TWENTY4X = toBigInt((((20 * 20) * 20) * 20))
444	444
445	445	let TWENTY5X = toBigInt(((((20 * 20) * 20) * 20) * 20))
446	446
447	447	let PRESALENUMLANDS = 500
448	448
449	449	func keyNextFreeLandNum () = "nextLandNum"
450	450
451	451
452	452	func keyLandToAssetId (landNum) = ("landToAsset_" + landNum)
453	453
454	454
455	455	func keyLandCustomNameToAssetId (name) = ("landByCustomName_" + name)
456	456
457	457
458	458	func keyInfraLevelByAssetIdAndOwner (assetId,ownerAddr) = ((("infraLevelByAssetIdAndOwner_" + assetId) + "_") + ownerAddr)
459	459
460	460
461	461	func keyLandArtStatusByTypeAssetIdAndOwner (type,assetId,ownerAddr) = makeString(["landArtStatusByTypeAssetIdAndOwner", type, assetId, ownerAddr], "_")
462	462
463	463
464	464	func keyLandNumToOwner (landNum) = ("landOwner_" + landNum)
465	465
466	466
467	467	func keyDuckCustomNameToAssetId (name) = ("duckByCustomName_" + name)
468	468
469	469
470	470	func keyCustomNameToAddress (name) = ("accountByCustomName_" + name)
471	471
472	472
473	473	func keyOldies () = "oldiesList"
474	474
475	475
476	476	let claimModeWh = 0
477	477
478	478	let claimModeDuck = 1
479	479
480	480	let claimModeWhThenDuck = 2
481	481
482	482	let flHealth = 0
483	483
484	484	let flTimestamp = 5
485	485
486	486	let flBonus = 6
487	487
488	488	let flProdsUsed = 7
489	489
490	490	func nftName (landNum,landSize) = ((LANDPREFIX + landNum) + landSize)
491	491
492	492
493	493	func distributeByWeights (total,weights) = {
494	494	let sum = (((((weights[0] + weights[1]) + weights[2]) + weights[3]) + weights[4]) + weights[5])
495	495	if ((0 >= sum))
496	496	then throw("Zero weights sum")
497	497	else {
498	498	let norm6 = fraction(total, MULT6, sum)
499	499	func normalizer (acc,elem) = (acc :+ fraction(elem, norm6, MULT6))
500	500

github/deemru/w8io/169f3d6 
224.45 ms ◑