tx · 35mBsE268SdDuVVp2dhn3VKmnfALrJAeYBcmKASWp5Lt

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.06600000 Waves

2023.07.08 01:08 [2656045] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "35mBsE268SdDuVVp2dhn3VKmnfALrJAeYBcmKASWp5Lt",
    "fee": 6600000,
    "feeAssetId": null,
    "timestamp": 1688767696616,
    "version": 2,
    "chainId": 84,
    "sender": "3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm",
    "senderPublicKey": "EVooykMNV691Venwp1dHUTBd7KWequzUcda57Wd3LQEX",
    "proofs": [
        "5NqRr66KM5sMuSpEPPLbuzHBiy1WpVmGQxA8jPeRvwuSp4AqcZtmuBQMXuRLa9oWhFzHBdeUhjiVPEVn4dByeeN9"
    ],
    "script": "base64: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",
    "height": 2656045,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EwejSD1u6h8vHdktNygmbmoJ2n7qHUvVbnVSCjhapQ4F
Next: 5oFNKKeHzSC14fGPLHQEMiQ1U493WFhnpeD9rfdwRSRv

Diff: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
+
let charStrength = 0
5
+
6
+
let charAccuracy = 1
7
+
8
+
let charIntellect = 2
9
+
10
+
let charEndurance = 3
11
+
12
+
let charDexterity = 4
13
+
14
+
func keyDuckChars (duckAssetId) = ("duckChars_" + duckAssetId)
15
+
16
+
17
+
func keyUserFreePoints (addr) = ("userFreePoints_" + addr)
18
+
19
+
4
20
 
let LANDPREFIX = "LAND"
5
21
 
6
22
 
let DUCKPREFIX = "DUCK"
1026
1042
 
1027
1043
 
1028
1044
 
func checkClaimConditions (addr,claimMode,landAssetIdIn) = {
1029
-
    let $t02444624985 = if ((claimMode == claimModeWh))
1045
+
    let $t02449525034 = if ((claimMode == claimModeWh))
1030
1046
 
        then $Tuple2(landAssetIdIn, valueOrElse(getString(keyStakedDuckByOwner(addr)), ""))
1031
1047
 
        else {
1032
1048
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
1036
1052
 
                then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
1037
1053
 
                else $Tuple2(loc[locIdxId], duckAssetId)
1038
1054
 
            }
1039
-
    let landAssetId = $t02444624985._1
1040
-
    let duckId = $t02444624985._2
1055
+
    let landAssetId = $t02449525034._1
1056
+
    let duckId = $t02449525034._2
1041
1057
 
    let asset = value(assetInfo(fromBase58String(landAssetId)))
1042
1058
 
    let timeKey = keyStakedTimeByAssetId(landAssetId)
1043
1059
 
    let savedTime = valueOrErrorMessage(getInteger(timeKey), (("Land " + asset.name) + " is not staked"))
1085
1101
 
                                let currentPack = getBackpack(bpKey)
1086
1102
 
                                let currentPackRes = split(currentPack[bpIdxRes], "_")
1087
1103
 
                                let currentWhRes = split(currentWh[whIdxRes], "_")
1088
-
                                let $t02735928230 = if ((claimMode == claimModeWh))
1104
+
                                let $t02740828279 = if ((claimMode == claimModeWh))
1089
1105
 
                                    then $Tuple4(addRes(currentWhRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), currentPack[bpIdxRes], (parseIntValue(loft[volOccupied]) + resToClaim._2), (parseIntValue(loft[volFree]) - resToClaim._2))
1090
1106
 
                                    else if ((claimMode == claimModeDuck))
1091
1107
 
                                        then $Tuple4(currentWh[whIdxRes], addRes(currentPackRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), parseIntValue(loft[volOccupied]), parseIntValue(loft[volFree]))
1094
1110
 
                                            let whAm = min([parseIntValue(loft[volFree]), resToClaim._2])
1095
1111
 
                                            $Tuple4(distr._1, distr._2, (parseIntValue(loft[volOccupied]) + whAm), (parseIntValue(loft[volFree]) - whAm))
1096
1112
 
                                            }
1097
-
                                let whRes = $t02735928230._1
1098
-
                                let bpRes = $t02735928230._2
1099
-
                                let loftO = $t02735928230._3
1100
-
                                let loftF = $t02735928230._4
1113
+
                                let whRes = $t02740828279._1
1114
+
                                let bpRes = $t02740828279._2
1115
+
                                let loftO = $t02740828279._3
1116
+
                                let loftF = $t02740828279._4
1101
1117
 
                                $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]], "_")])
1102
1118
 
                                }
1103
1119
 
                        }
2085
2101
 
2086
2102
 
2087
2103
 
@Callable(i)
2104
+
func distributePoints (strength,accuracy,intellect,endurance,dexterity) = {
2105
+
    let prologAction = prolog(i)
2106
+
    if ((size(i.payments) != 0))
2107
+
        then throw("No payments required")
2108
+
        else {
2109
+
            let addr = toString(i.originCaller)
2110
+
            let freeKey = keyUserFreePoints(addr)
2111
+
            let freePoints = valueOrElse(getInteger(stakingContract, freeKey), 0)
2112
+
            let sumToDistribute = ((((strength + accuracy) + intellect) + endurance) + dexterity)
2113
+
            if ((sumToDistribute > freePoints))
2114
+
                then throw((("There are only " + toString(freePoints)) + " free points to distribute"))
2115
+
                else {
2116
+
                    let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
2117
+
                    let charsKey = keyDuckChars(duckAssetId)
2118
+
                    let chars = split(valueOrElse(getString(stakingContract, charsKey), "0_0_0_0_0"), "_")
2119
+
                    $Tuple2([IntegerEntry(freeKey, (freePoints - sumToDistribute)), StringEntry(charsKey, makeString([toString((parseIntValue(chars[charStrength]) + strength)), toString((parseIntValue(chars[charAccuracy]) + accuracy)), toString((parseIntValue(chars[charIntellect]) + intellect)), toString((parseIntValue(chars[charEndurance]) + endurance)), toString((parseIntValue(chars[charDexterity]) + dexterity))], "_")), prologAction], 0)
2120
+
                    }
2121
+
            }
2122
+
    }
2123
+
2124
+
2125
+
2126
+
@Callable(i)
2088
2127
 
func splitByGlobalWeightsREADONLY (amount) = $Tuple2(nil, getNeededMaterials(amount))
2089
2128
 
2090
2129
 

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