w8 · tx · EVG···5Fz

tx · EVGcPNgzU5CiDQXJXp9hoZLTvX2vxw2Pyjv9sBtdm5Fz

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.09700000 Waves

2023.09.03 16:56 [2739274] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EVGcPNgzU5CiDQXJXp9hoZLTvX2vxw2Pyjv9sBtdm5Fz",
    "fee": 9700000,
    "feeAssetId": null,
    "timestamp": 1693749376031,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "5keCy7ACfLsG2UQPssZuXHb3TRE4vAWNATsj2f25FzsfPZK5CnKr7Q2JMcMdZa7q1G3exK7KHrSFY9BrBhMePoFh"
    ],
    "script": "base64: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",
    "height": 2739274,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EnginzPSY87j6qyDybBdkg5rFi3qKdb3j9sNVRG9bZSK
Next: CEH1Hg3UTFkq4m5UykNRJZnbDnAhKPL76pKDvsntgocF

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

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

github/deemru/w8io/873ac7e 
453.05 ms ◑