tx · AdZyetDQHzA1mV1Ub2ViNqAgtLJJWZp1hL4L5LegRPbL

3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm:  -0.06000000 Waves

2023.06.08 21:15 [2614047] smart account 3NDCyBG5q85JuaRiigUeEtainyjCQT3XpZm > SELF 0.00000000 Waves

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

View: original | compacted
Prev: EwAf4iHzMFaopRxmMcHubW67YQzWxpHAuhjFjehHoSgA
Next: AbdkkurWE4w3L9aAashDwqj8ymv99ipfxZiDgiAgBZ9d

Diff: 
Old
New
Differences
62
62
 
63
63
 
let DEFAULTLOCATION = "Africa_F_Africa"
64
64
 
65
+
let RESOURCEPRICEMIN = 39637
66
+
67
+
let ESSELLCOEF = 10
68
+
65
69
 
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"]
66
70
 
67
71
 
let continents = ["Americas", "Europe", "Asia", "Africa", "Oceania"]
197
201
 
func keyUserGwlReleaseTime (userAddr) = ("%s%s__userGwlReleaseTime__" + userAddr)
198
202
 
199
203
 
204
+
func keyEsWarehouse () = "emergencyWarehouseProducts"
205
+
206
+
200
207
 
let locIdxType = 1
201
208
 
202
209
 
let locIdxId = 2
210
+
211
+
func asString (v) = match v {
212
+
    case s: String => 
213
+
        s
214
+
    case _ => 
215
+
        throw("fail to cast into String")
216
+
}
217
+
203
218
 
204
219
 
func asInt (v) = match v {
205
220
 
    case n: Int => 
223
238
 
                            then XXLSIZE
224
239
 
                            else throw("Unknown land size")
225
240
 
}
241
+
242
+
243
+
func getRecipeMaterials (recipe) = {
244
+
    func addMat (ac,j) =     (ac + parseIntValue(recipe[j]))
245
+
246
+
    let $l = [0, 1, 2, 3, 4, 5]
247
+
    let $s = size($l)
248
+
    let $acc0 = 0
249
+
    func $f0_1 ($a,$i) =     if (($i >= $s))
250
+
        then $a
251
+
        else addMat($a, $l[$i])
252
+
253
+
    func $f0_2 ($a,$i) =     if (($i >= $s))
254
+
        then $a
255
+
        else throw("List size exceeds 6")
256
+
257
+
    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
258
+
    }
226
259
 
227
260
 
228
261
 
let incubatorAddr = match chain {
895
928
 
896
929
 
897
930
 
func checkClaimConditions (addr,claimMode,landAssetIdIn) = {
898
-
    let $t03172932268 = if ((claimMode == claimModeWh))
931
+
    let $t03189632435 = if ((claimMode == claimModeWh))
899
932
 
        then $Tuple2(landAssetIdIn, valueOrElse(getString(keyStakedDuckByOwner(addr)), ""))
900
933
 
        else {
901
934
 
            let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(addr)), "You don't have a duck staked")
905
938
 
                then throw((("Duck location type is " + loc[locIdxType]) + ", but should be L"))
906
939
 
                else $Tuple2(loc[locIdxId], duckAssetId)
907
940
 
            }
908
-
    let landAssetId = $t03172932268._1
909
-
    let duckId = $t03172932268._2
941
+
    let landAssetId = $t03189632435._1
942
+
    let duckId = $t03189632435._2
910
943
 
    let asset = value(assetInfo(fromBase58String(landAssetId)))
911
944
 
    let timeKey = keyStakedTimeByAssetId(landAssetId)
912
945
 
    let savedTime = valueOrErrorMessage(getInteger(timeKey), (("Land " + asset.name) + " is not staked"))
954
987
 
                                let currentPack = getBackpack(bpKey)
955
988
 
                                let currentPackRes = split(currentPack[bpIdxRes], "_")
956
989
 
                                let currentWhRes = split(currentWh[whIdxRes], "_")
957
-
                                let $t03464235513 = if ((claimMode == claimModeWh))
990
+
                                let $t03480935680 = if ((claimMode == claimModeWh))
958
991
 
                                    then $Tuple4(addRes(currentWhRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), currentPack[bpIdxRes], (parseIntValue(loft[volOccupied]) + resToClaim._2), (parseIntValue(loft[volFree]) - resToClaim._2))
959
992
 
                                    else if ((claimMode == claimModeDuck))
960
993
 
                                        then $Tuple4(currentWh[whIdxRes], addRes(currentPackRes, terrainCounts, (deltaTime - newDeltaTime), landIndex, dailyProductionByPiece), parseIntValue(loft[volOccupied]), parseIntValue(loft[volFree]))
963
996
 
                                            let whAm = min([parseIntValue(loft[volFree]), resToClaim._2])
964
997
 
                                            $Tuple4(distr._1, distr._2, (parseIntValue(loft[volOccupied]) + whAm), (parseIntValue(loft[volFree]) - whAm))
965
998
 
                                            }
966
-
                                let whRes = $t03464235513._1
967
-
                                let bpRes = $t03464235513._2
968
-
                                let loftO = $t03464235513._3
969
-
                                let loftF = $t03464235513._4
999
+
                                let whRes = $t03480935680._1
1000
+
                                let bpRes = $t03480935680._2
1001
+
                                let loftO = $t03480935680._3
1002
+
                                let loftF = $t03480935680._4
970
1003
 
                                $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]], "_")])
971
1004
 
                                }
972
1005
 
                        }
1527
1560
 
1528
1561
 
1529
1562
 
@Callable(i)
1530
-
func healES (medKitLevel,quantity) = {
1563
+
func healES () = {
1531
1564
 
    let prologAction = prolog(i)
1532
-
    $Tuple2([prologAction], 0)
1565
+
    if ((size(i.payments) != 1))
1566
+
        then throw("Exactly one payment required")
1567
+
        else {
1568
+
            let pmt = value(i.payments[0])
1569
+
            if ((pmt.assetId != usdtAssetId))
1570
+
                then throw("Allowed USDT payment only!")
1571
+
                else {
1572
+
                    let duckAssetId = valueOrErrorMessage(getString(keyStakedDuckByOwner(toString(i.caller))), "You don't have a duck staked")
1573
+
                    let keyHealth = keyDuckHealth(duckAssetId)
1574
+
                    let oldHealth = valueOrElse(getInteger(keyHealth), 100)
1575
+
                    if ((oldHealth > 0))
1576
+
                        then throw("HP should be 0 to call Emergency Service")
1577
+
                        else {
1578
+
                            let bpKey = keyBackpackByDuck(duckAssetId)
1579
+
                            let currentPack = getBackpack(bpKey)
1580
+
                            let prodList = if ((currentPack[bpIdxProd] == ""))
1581
+
                                then nil
1582
+
                                else split(currentPack[bpIdxProd], "_")
1583
+
                            let medKitAmount1 = if ((size(prodList) > 0))
1584
+
                                then parseIntValue(prodList[0])
1585
+
                                else 0
1586
+
                            let medKitAmount2 = if ((size(prodList) > 1))
1587
+
                                then parseIntValue(prodList[1])
1588
+
                                else 0
1589
+
                            let medKitAmount3 = if ((size(prodList) > 2))
1590
+
                                then parseIntValue(prodList[2])
1591
+
                                else 0
1592
+
                            if (if (if ((medKitAmount1 > 0))
1593
+
                                then true
1594
+
                                else (medKitAmount2 > 0))
1595
+
                                then true
1596
+
                                else (medKitAmount3 > 0))
1597
+
                                then throw("You have to use own Medical Kit")
1598
+
                                else {
1599
+
                                    let existStr = getString(economyContract, keyEsWarehouse())
1600
+
                                    let existAmounts = if (isDefined(existStr))
1601
+
                                        then split(value(existStr), "_")
1602
+
                                        else nil
1603
+
                                    let existAmount = if ((size(existAmounts) > 0))
1604
+
                                        then parseIntValue(existAmounts[0])
1605
+
                                        else 0
1606
+
                                    if ((0 >= existAmount))
1607
+
                                        then throw("There are no Medical Kits L1 at Emergency Service storage")
1608
+
                                        else {
1609
+
                                            let newHealth = (oldHealth + medKitHp[0])
1610
+
                                            let newES = makeString([toString((existAmount - 1)), removeByIndex(existAmounts, 0)], "_")
1611
+
                                            let recipe = split(productionMatrix[0], "_")
1612
+
                                            let totalMat = getRecipeMaterials(recipe)
1613
+
                                            let sellPrice = fraction((totalMat * ESSELLCOEF), RESOURCEPRICEMIN, 10)
1614
+
                                            if ((pmt.amount != sellPrice))
1615
+
                                                then throw(("Payment attached should be " + toString(sellPrice)))
1616
+
                                                else {
1617
+
                                                    let result = asString(invoke(economyContract, "updateEsStorage", [newES], nil))
1618
+
                                                    $Tuple2([IntegerEntry(keyHealth, newHealth), prologAction], result)
1619
+
                                                    }
1620
+
                                            }
1621
+
                                    }
1622
+
                            }
1623
+
                    }
1624
+
            }
1533
1625
 
    }
1534
1626
 
1535
1627
 

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