w8 · tx · T17···qPA

tx · T17cQTMoKJ1yQuKApiukm1nbtWkCKSkagziUc6FiqPA

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.07000000 Waves

2023.07.09 16:20 [2658416] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

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

View: original | compacted
Prev: bWDtGfESbZWFDykZ2G2y88PoNEraLLphU3PtESE9Yp2
Next: 3uLT3xvFJrum9EA7hYyaUd43BpUtujSvq8wZD9vBFFpU

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

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4		-	let xpLevelRecipScale = 31250
5		-
6		-	let xpLevelPow = 25000
	4	+	let SCALE8 = 100000000
	5	+
	6	+	let xpLevelScale = 3200
	7	+
	8	+	let xpLevelRecipPow = 4000
7	9
8	10		let numPointsOnLevelUp = 3
9	11

58	60
59	61		let xpHeal = 10000
60	62
61		-	func xpByLevel (level) = pow((level * xpLevelRecipScale), 4, xpLevelPow, 4, 4, HALFUP)
62		-
63		-
64		-	func levelUp (currLevel,newXP) = if ((newXP >= xpByLevel((currLevel + 1))))
65		-	then [(currLevel + 1), numPointsOnLevelUp]
66		-	else [currLevel, 0]
	63	+	func levelByXP (xp) = fraction(xpLevelScale, pow(xp, 4, xpLevelRecipPow, 4, 4, DOWN), SCALE8)
	64	+
	65	+
	66	+	func levelUp (currLevel,newXP) = {
	67	+	let newLevel = levelByXP(newXP)
	68	+	[newLevel, (numPointsOnLevelUp * (newLevel - currLevel))]
	69	+	}
67	70
68	71
69	72		let LANDPREFIX = "LAND"

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

github/deemru/w8io/873ac7e 
285.88 ms ◑