w8 · tx · EPe···DkE

tx · EPehuPFhgStfmrQBUvLrbvvi4MRHyDE8RryK3iCaKDkE

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.09100000 Waves

2023.08.23 22:21 [2723700] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EPehuPFhgStfmrQBUvLrbvvi4MRHyDE8RryK3iCaKDkE",
    "fee": 9100000,
    "feeAssetId": null,
    "timestamp": 1692818543579,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "4NNumfLGP48gsP4QMUnYmtDCnWapBGBu1cLFjpchYPjgkLrWkMXGWhKi3QBVWHymYuW9uj4frsvYf6cExTEvtyfV"
    ],
    "script": "base64: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",
    "height": 2723700,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8yBi9ULgn4jyeywRT41spXRUyDbgWET2BT9nmWYGjEhZ
Next: EiNWspRUTnBdWA83KEWNiSNjTWE1AVj5MATqwVoJrVMD

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

Old	New		Differences
3001	3001
3002	3002
3003	3003		@Callable(i)
3004		-	func ~~exitTournaments~~ () = {
	3004	+	func breakAttempt () = {
3005	3005		let prologAction = prolog(i)
3006	3006		let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
3007	3007		let curLocKey = keyDuckLocation(duckAssetId)

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

github/deemru/w8io/026f985 
241.95 ms ◑