tx · 824xxgQAk3VUU8QcSWzZ1DQ9s1cDp4QyFrhxF2HaGxpr

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.09900000 Waves

2023.11.23 23:34 [2856531] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "824xxgQAk3VUU8QcSWzZ1DQ9s1cDp4QyFrhxF2HaGxpr",
    "fee": 9900000,
    "feeAssetId": null,
    "timestamp": 1700771696954,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "24XndcDE99edSQQ7wWBrMcWcYacaFHMZ1dwkVist2aLEjocozmLzBrYQpNmedA6YddeD53nWqpcwCEVgLF2XmqT3"
    ],
    "script": "base64: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",
    "height": 2856531,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: AvcsySzhYmHuF2C9zKs3pA79hSTp6TY4GpQPiGXMvuSb
Next: 84hSJSUsFz5TzRshvvc4PKzqAEdMikmAA7cXovQQBH7i

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