mirrors/Unciv
1
0
Fork 0
mirror of https://github.com/yairm210/Unciv.git synced 2025-07-12 00:39:56 +07:00
Code Issues Packages Projects Releases Wiki Activity

Fixed a couple warnings reported by code analysis (#9364)

Browse Source 
* fix: resolve EmptyCatchBlock warnings

* fix: resolve PrintStackTrace warnings

* fix: resolve SwallowedException warnings

* fix: resolve ThrowingExceptionsWithoutMessageOrCause warnings

* fix: resolve ConstructorParameterNaming warnings

* fix: resolve FunctionParameterNaming warnings

* fix: resolve InvalidPackageDeclaration warnings

* fix: resolve ForEachOnRange warnings

* fix: resolve ImplicitDefaultLocale warnings

* fix: resolve MayBeConst warnings

* fix: resolve NewLineAtEndOfFile warnings

* fix: resolve UnusedParameter warnings

* fix: resolve UtilityClassWithPublicConstructor warnings

* fix: resolve WildcardImport warnings
This commit is contained in:
alexban011
2023-05-10 11:43:53 +03:00
committed by GitHub
parent 1df7ee46ac
commit f3e80a4021
102 changed files with 466 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
core/src/com/unciv/logic/BackwardCompatibility.kt
View File

@ -1,8 +1,9 @@
package com.unciv.logic
import com.unciv.Constants
import com.unciv.logic.automation.civilization.BarbarianManager
import com.unciv.logic.city.CityConstructions
import com.unciv.logic.city.PerpetualConstruction
import com.unciv.models.ruleset.PerpetualConstruction
import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
import com.unciv.logic.civilization.diplomacy.DiplomacyManager
import com.unciv.logic.civilization.managers.TechManager

1
core/src/com/unciv/logic/GameInfo.kt
View File

@ -9,6 +9,7 @@ import com.unciv.logic.BackwardCompatibility.migrateToTileHistory
import com.unciv.logic.BackwardCompatibility.removeMissingModReferences
import com.unciv.logic.GameInfo.Companion.CURRENT_COMPATIBILITY_NUMBER
import com.unciv.logic.GameInfo.Companion.FIRST_WITHOUT
import com.unciv.logic.automation.civilization.BarbarianManager
import com.unciv.logic.city.City
import com.unciv.logic.civilization.Civilization
import com.unciv.logic.civilization.CivilizationInfoPreview

2
core/src/com/unciv/logic/automation/Automation.kt
View File

@ -2,7 +2,7 @@ package com.unciv.logic.automation
import com.unciv.logic.city.City
import com.unciv.logic.city.CityFocus
import com.unciv.logic.city.INonPerpetualConstruction
import com.unciv.models.ruleset.INonPerpetualConstruction
import com.unciv.logic.civilization.Civilization
import com.unciv.logic.map.BFS
import com.unciv.logic.map.TileMap

4
core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt
View File

@ -3,8 +3,8 @@ package com.unciv.logic.automation.city
import com.unciv.logic.automation.Automation
import com.unciv.logic.automation.civilization.NextTurnAutomation
import com.unciv.logic.city.CityConstructions
import com.unciv.logic.city.INonPerpetualConstruction
import com.unciv.logic.city.PerpetualConstruction
import com.unciv.models.ruleset.INonPerpetualConstruction
import com.unciv.models.ruleset.PerpetualConstruction
import com.unciv.logic.civilization.CityAction
import com.unciv.logic.civilization.NotificationCategory
import com.unciv.logic.civilization.NotificationIcon

4
core/src/com/unciv/logic/automation/civilization/BarbarianManager.kt
View File

@ -1,8 +1,10 @@
package com.unciv.logic
package com.unciv.logic.automation.civilization
import com.badlogic.gdx.math.Vector2
import com.unciv.Constants
import com.unciv.json.HashMapVector2
import com.unciv.logic.GameInfo
import com.unciv.logic.IsPartOfGameInfoSerialization
import com.unciv.logic.civilization.NotificationCategory
import com.unciv.logic.civilization.NotificationIcon
import com.unciv.logic.map.tile.Tile

4
core/src/com/unciv/logic/automation/civilization/NextTurnAutomation.kt
View File

@ -8,8 +8,8 @@ import com.unciv.logic.battle.BattleDamage
import com.unciv.logic.battle.CityCombatant
import com.unciv.logic.battle.MapUnitCombatant
import com.unciv.logic.city.City
import com.unciv.logic.city.INonPerpetualConstruction
import com.unciv.logic.city.PerpetualConstruction
import com.unciv.models.ruleset.INonPerpetualConstruction
import com.unciv.models.ruleset.PerpetualConstruction
import com.unciv.logic.civilization.AlertType
import com.unciv.logic.civilization.Civilization
import com.unciv.logic.civilization.NotificationCategory

2
core/src/com/unciv/logic/automation/civilization/ReligionAutomation.kt
View File

@ -2,7 +2,7 @@ package com.unciv.logic.automation.civilization
import com.unciv.Constants
import com.unciv.logic.city.City
import com.unciv.logic.city.INonPerpetualConstruction
import com.unciv.models.ruleset.INonPerpetualConstruction
import com.unciv.logic.civilization.Civilization
import com.unciv.logic.civilization.managers.ReligionState
import com.unciv.logic.map.tile.Tile

242
core/src/com/unciv/logic/automation/unit/CityLocationTileRanker.kt
View File

@ -8,138 +8,136 @@ import com.unciv.logic.map.tile.Tile
import com.unciv.models.ruleset.tile.ResourceType
import com.unciv.models.ruleset.tile.TileResource
class CityLocationTileRanker {
companion object {
fun getBestTilesToFoundCity(unit: MapUnit): Sequence<Pair<Tile, Float>> {
val modConstants = unit.civ.gameInfo.ruleset.modOptions.constants
val tilesNearCities = sequence {
for (city in unit.civ.gameInfo.getCities()) {
val center = city.getCenterTile()
if (unit.civ.knows(city.civ) &&
// If the CITY OWNER knows that the UNIT OWNER agreed not to settle near them
city.civ.getDiplomacyManager(unit.civ)
.hasFlag(DiplomacyFlags.AgreedToNotSettleNearUs)
) {
yieldAll(
center.getTilesInDistance(6)
.filter { canUseTileForRanking(it, unit.civ) })
continue
}
object CityLocationTileRanker {
fun getBestTilesToFoundCity(unit: MapUnit): Sequence<Pair<Tile, Float>> {
val modConstants = unit.civ.gameInfo.ruleset.modOptions.constants
val tilesNearCities = sequence {
for (city in unit.civ.gameInfo.getCities()) {
val center = city.getCenterTile()
if (unit.civ.knows(city.civ) &&
// If the CITY OWNER knows that the UNIT OWNER agreed not to settle near them
city.civ.getDiplomacyManager(unit.civ)
.hasFlag(DiplomacyFlags.AgreedToNotSettleNearUs)
) {
yieldAll(
center.getTilesInDistance(modConstants.minimalCityDistance)
.filter { canUseTileForRanking(it, unit.civ) }
.filter { it.getContinent() == center.getContinent() }
)
yieldAll(
center.getTilesInDistance(modConstants.minimalCityDistanceOnDifferentContinents)
.filter { canUseTileForRanking(it, unit.civ) }
.filter { it.getContinent() != center.getContinent() }
)
center.getTilesInDistance(6)
.filter { canUseTileForRanking(it, unit.civ) })
continue
}
}.toSet()
yieldAll(
center.getTilesInDistance(modConstants.minimalCityDistance)
.filter { canUseTileForRanking(it, unit.civ) }
.filter { it.getContinent() == center.getContinent() }
)
yieldAll(
center.getTilesInDistance(modConstants.minimalCityDistanceOnDifferentContinents)
.filter { canUseTileForRanking(it, unit.civ) }
.filter { it.getContinent() != center.getContinent() }
)
}
}.toSet()
// This is to improve performance - instead of ranking each tile in the area up to 19 times, do it once.
val nearbyTileRankings = getNearbyTileRankings(unit.getTile(), unit.civ)
// This is to improve performance - instead of ranking each tile in the area up to 19 times, do it once.
val nearbyTileRankings = getNearbyTileRankings(unit.getTile(), unit.civ)
val distanceFromHome = if (unit.civ.cities.isEmpty()) 0
else unit.civ.cities.minOf { it.getCenterTile().aerialDistanceTo(unit.getTile()) }
val range = (8 - distanceFromHome).coerceIn(
1,
5
) // Restrict vision when far from home to avoid death marches
val distanceFromHome = if (unit.civ.cities.isEmpty()) 0
else unit.civ.cities.minOf { it.getCenterTile().aerialDistanceTo(unit.getTile()) }
val range = (8 - distanceFromHome).coerceIn(
1,
5
) // Restrict vision when far from home to avoid death marches
val possibleCityLocations = unit.getTile().getTilesInDistance(range)
.filter { canUseTileForRanking(it, unit.civ) }
.filter {
val tileOwner = it.getOwner()
it.isLand && !it.isImpassible() && (tileOwner == null || tileOwner == unit.civ) // don't allow settler to settle inside other civ's territory
&& (unit.currentTile == it || unit.movement.canMoveTo(it))
&& it !in tilesNearCities
}
val possibleCityLocations = unit.getTile().getTilesInDistance(range)
.filter { canUseTileForRanking(it, unit.civ) }
.filter {
val tileOwner = it.getOwner()
it.isLand && !it.isImpassible() && (tileOwner == null || tileOwner == unit.civ) // don't allow settler to settle inside other civ's territory
&& (unit.currentTile == it || unit.movement.canMoveTo(it))
&& it !in tilesNearCities
}
val luxuryResourcesInCivArea = getLuxuryResourcesInCivArea(unit.civ)
val luxuryResourcesInCivArea = getLuxuryResourcesInCivArea(unit.civ)
return possibleCityLocations
.map {
Pair(
return possibleCityLocations
.map {
Pair(
it,
rankTileAsCityCenterWithCachedValues(
it,
rankTileAsCityCenterWithCachedValues(
it,
nearbyTileRankings,
luxuryResourcesInCivArea,
unit.civ
),
nearbyTileRankings,
luxuryResourcesInCivArea,
unit.civ
),
)
}
.sortedByDescending { it.second }
}
fun rankTileAsCityCenter(tile: Tile, civ: Civilization): Float {
val nearbyTileRankings = getNearbyTileRankings(tile, civ)
val luxuryResourcesInCivArea = getLuxuryResourcesInCivArea(civ)
return rankTileAsCityCenterWithCachedValues(
tile,
nearbyTileRankings,
luxuryResourcesInCivArea,
civ
)
}
private fun canUseTileForRanking(
tile: Tile,
civ: Civilization
) =
// The AI is allowed to cheat and act like it knows the whole map.
tile.isExplored(civ) || civ.isAI()
private fun getNearbyTileRankings(
tile: Tile,
civ: Civilization
): Map<Tile, Float> {
return tile.getTilesInDistance(7)
.filter { canUseTileForRanking(it, civ) }
.associateBy({ it }, { Automation.rankTile(it, civ) })
}
private fun getLuxuryResourcesInCivArea(civ: Civilization): Sequence<TileResource> {
return civ.cities.asSequence()
.flatMap { it.getTiles().asSequence() }.filter { it.resource != null }
.map { it.tileResource }.filter { it.resourceType == ResourceType.Luxury }
.distinct()
}
private fun rankTileAsCityCenterWithCachedValues(
tile: Tile, nearbyTileRankings: Map<Tile, Float>,
luxuryResourcesInCivArea: Sequence<TileResource>,
civ: Civilization
): Float {
val bestTilesFromOuterLayer = tile.getTilesAtDistance(2)
.filter { canUseTileForRanking(it, civ) }
.sortedByDescending { nearbyTileRankings[it] }.take(2)
val top5Tiles =
(tile.neighbors.filter {
canUseTileForRanking(
it,
civ
)
}
.sortedByDescending { it.second }
}
} + bestTilesFromOuterLayer)
.sortedByDescending { nearbyTileRankings[it] }
.take(5)
var rank = top5Tiles.map { nearbyTileRankings.getValue(it) }.sum()
if (tile.isCoastalTile()) rank += 5
fun rankTileAsCityCenter(tile: Tile, civ: Civilization): Float {
val nearbyTileRankings = getNearbyTileRankings(tile, civ)
val luxuryResourcesInCivArea = getLuxuryResourcesInCivArea(civ)
return rankTileAsCityCenterWithCachedValues(
tile,
nearbyTileRankings,
luxuryResourcesInCivArea,
civ
)
}
val luxuryResourcesInCityArea =
tile.getTilesAtDistance(2).filter { canUseTileForRanking(it, civ) }
.filter { it.resource != null }
.map { it.tileResource }.filter { it.resourceType == ResourceType.Luxury }
.distinct()
val luxuryResourcesAlreadyInCivArea =
luxuryResourcesInCivArea.map { it.name }.toHashSet()
val luxuryResourcesNotYetInCiv = luxuryResourcesInCityArea
.count { it.name !in luxuryResourcesAlreadyInCivArea }
rank += luxuryResourcesNotYetInCiv * 10
private fun canUseTileForRanking(
tile: Tile,
civ: Civilization
) =
// The AI is allowed to cheat and act like it knows the whole map.
tile.isExplored(civ) || civ.isAI()
private fun getNearbyTileRankings(
tile: Tile,
civ: Civilization
): Map<Tile, Float> {
return tile.getTilesInDistance(7)
.filter { canUseTileForRanking(it, civ) }
.associateBy({ it }, { Automation.rankTile(it, civ) })
}
private fun getLuxuryResourcesInCivArea(civ: Civilization): Sequence<TileResource> {
return civ.cities.asSequence()
.flatMap { it.getTiles().asSequence() }.filter { it.resource != null }
.map { it.tileResource }.filter { it.resourceType == ResourceType.Luxury }
.distinct()
}
private fun rankTileAsCityCenterWithCachedValues(
tile: Tile, nearbyTileRankings: Map<Tile, Float>,
luxuryResourcesInCivArea: Sequence<TileResource>,
civ: Civilization
): Float {
val bestTilesFromOuterLayer = tile.getTilesAtDistance(2)
.filter { canUseTileForRanking(it, civ) }
.sortedByDescending { nearbyTileRankings[it] }.take(2)
val top5Tiles =
(tile.neighbors.filter {
canUseTileForRanking(
it,
civ
)
} + bestTilesFromOuterLayer)
.sortedByDescending { nearbyTileRankings[it] }
.take(5)
var rank = top5Tiles.map { nearbyTileRankings.getValue(it) }.sum()
if (tile.isCoastalTile()) rank += 5
val luxuryResourcesInCityArea =
tile.getTilesAtDistance(2).filter { canUseTileForRanking(it, civ) }
.filter { it.resource != null }
.map { it.tileResource }.filter { it.resourceType == ResourceType.Luxury }
.distinct()
val luxuryResourcesAlreadyInCivArea =
luxuryResourcesInCivArea.map { it.name }.toHashSet()
val luxuryResourcesNotYetInCiv = luxuryResourcesInCityArea
.count { it.name !in luxuryResourcesAlreadyInCivArea }
rank += luxuryResourcesNotYetInCiv * 10
return rank
}
return rank
}
}

4
core/src/com/unciv/logic/city/CityConstructions.kt
View File

@ -13,6 +13,10 @@ import com.unciv.logic.map.mapunit.MapUnit
import com.unciv.logic.map.tile.Tile
import com.unciv.logic.multiplayer.isUsersTurn
import com.unciv.models.ruleset.Building
import com.unciv.models.ruleset.IConstruction
import com.unciv.models.ruleset.INonPerpetualConstruction
import com.unciv.models.ruleset.PerpetualConstruction
import com.unciv.models.ruleset.RejectionReasonType
import com.unciv.models.ruleset.Ruleset
import com.unciv.models.ruleset.unique.LocalUniqueCache
import com.unciv.models.ruleset.unique.StateForConditionals

4
core/src/com/unciv/logic/city/CityStats.kt
View File

@ -5,6 +5,8 @@ import com.unciv.logic.map.tile.RoadStatus
import com.unciv.models.Counter
import com.unciv.models.ruleset.Building
import com.unciv.models.ruleset.GlobalUniques
import com.unciv.models.ruleset.IConstruction
import com.unciv.models.ruleset.INonPerpetualConstruction
import com.unciv.models.ruleset.ModOptionsConstants
import com.unciv.models.ruleset.unique.LocalUniqueCache
import com.unciv.models.ruleset.unique.StateForConditionals
@ -476,7 +478,7 @@ class CityStats(val city: City) {
fun update(currentConstruction: IConstruction = city.cityConstructions.getCurrentConstruction(),
updateTileStats:Boolean = true,
updateCivStats:Boolean = true) {
updateCivStats:Boolean = true) {
if (updateTileStats) updateTileStats()
// We need to compute Tile yields before happiness

2
core/src/com/unciv/logic/civilization/CivConstructions.kt
View File

@ -1,7 +1,7 @@
package com.unciv.logic.civilization
import com.unciv.logic.IsPartOfGameInfoSerialization
import com.unciv.logic.city.INonPerpetualConstruction
import com.unciv.models.ruleset.INonPerpetualConstruction
import com.unciv.models.Counter
import com.unciv.models.ruleset.Building
import com.unciv.models.ruleset.unique.UniqueType

4
core/src/com/unciv/logic/civilization/diplomacy/DiplomacyManager.kt
View File

@ -149,9 +149,9 @@ class DiplomacyManager() : IsPartOfGameInfoSerialization {
return toReturn
}
constructor(civilization: Civilization, OtherCivName: String) : this() {
constructor(civilization: Civilization, mOtherCivName: String) : this() {
civInfo = civilization
otherCivName = OtherCivName
otherCivName = mOtherCivName
updateHasOpenBorders()
}

2
core/src/com/unciv/logic/civilization/managers/TechManager.kt
View File

@ -135,7 +135,7 @@ class TechManager : IsPartOfGameInfoSerialization {
return if (techsToResearch.isEmpty()) null else techsToResearch[0]
}
fun researchOfTech(TechName: String?) = techsInProgress[TechName] ?: 0
fun researchOfTech(techName: String?) = techsInProgress[techName] ?: 0
// Was once duplicated as fun scienceSpentOnTech(tech: String): Int
fun remainingScienceToTech(techName: String): Int {

2
core/src/com/unciv/logic/civilization/managers/TurnManager.kt
View File

@ -19,6 +19,7 @@ import com.unciv.models.ruleset.unique.UniqueType
import com.unciv.models.ruleset.unique.endTurn
import com.unciv.models.stats.Stats
import com.unciv.ui.components.MayaCalendar
import com.unciv.utils.Log
import java.util.*
import kotlin.math.max
import kotlin.math.min
@ -167,6 +168,7 @@ class TurnManager(val civInfo: Civilization) {
// The first test in `updateRevolts` should prevent getting here in a no-barbarians game, but it has been shown to still occur
civInfo.gameInfo.getBarbarianCivilization()
} catch (ex: NoSuchElementException) {
Log.error("Barbarian civilization not found", ex)
civInfo.removeFlag(CivFlags.RevoltSpawning.name)
return
}

14
core/src/com/unciv/logic/files/UncivFiles.kt
View File

@ -8,13 +8,18 @@ import com.badlogic.gdx.utils.SerializationException
import com.unciv.UncivGame
import com.unciv.json.fromJsonFile
import com.unciv.json.json
import com.unciv.logic.*
import com.unciv.logic.CompatibilityVersion
import com.unciv.logic.GameInfo
import com.unciv.logic.GameInfoPreview
import com.unciv.logic.GameInfoSerializationVersion
import com.unciv.logic.HasGameInfoSerializationVersion
import com.unciv.logic.UncivShowableException
import com.unciv.models.metadata.GameSettings
import com.unciv.models.metadata.doMigrations
import com.unciv.models.metadata.isMigrationNecessary
import com.unciv.ui.screens.savescreens.Gzip
import com.unciv.utils.Log
import com.unciv.utils.concurrency.Concurrency
import com.unciv.utils.Concurrency
import com.unciv.utils.debug
import kotlinx.coroutines.Job
import java.io.File
@ -140,8 +145,8 @@ class UncivFiles(
//endregion
//region Saving
fun saveGame(game: GameInfo, GameName: String, saveCompletionCallback: (Exception?) -> Unit = { if (it != null) throw it }): FileHandle {
val file = getSave(GameName)
fun saveGame(game: GameInfo, gameName: String, saveCompletionCallback: (Exception?) -> Unit = { if (it != null) throw it }): FileHandle {
val file = getSave(gameName)
saveGame(game, file, saveCompletionCallback)
return file
}
@ -402,6 +407,7 @@ class UncivFiles(
try {
saveGame(gameInfo, AUTOSAVE_FILE_NAME)
} catch (oom: OutOfMemoryError) {
Log.error("Ran out of memory during autosave", oom)
return // not much we can do here
}

10
core/src/com/unciv/logic/map/HexMath.kt
View File

@ -2,7 +2,15 @@ package com.unciv.logic.map
import com.badlogic.gdx.math.Vector2
import com.badlogic.gdx.math.Vector3
import kotlin.math.*
import kotlin.math.abs
import kotlin.math.cos
import kotlin.math.round
import kotlin.math.roundToInt
import kotlin.math.sign
import kotlin.math.sin
import kotlin.math.sqrt
import kotlin.math.max
import kotlin.math.min
@Suppress("MemberVisibilityCanBePrivate", "unused") // this is a library offering optional services
object HexMath {

2
core/src/com/unciv/logic/map/mapgenerator/MapGenerator.kt
View File

@ -964,6 +964,6 @@ class MapGenerationRandomness {
}
}
// unreachable due to last loop iteration always returning and initialDistance >= 1
throw Exception()
throw Exception("Unreachable code reached!")
}
}

2
core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt
View File

@ -1,6 +1,6 @@
package com.unciv.logic.map.mapunit
import com.unciv.logic.city.RejectionReasonType
import com.unciv.models.ruleset.RejectionReasonType
import com.unciv.models.ruleset.unique.StateForConditionals
import com.unciv.models.ruleset.unique.UniqueType
import com.unciv.models.ruleset.unit.BaseUnit

10
core/src/com/unciv/logic/multiplayer/OnlineMultiplayer.kt
View File

@ -16,10 +16,10 @@ import com.unciv.logic.multiplayer.storage.OnlineMultiplayerFiles
import com.unciv.ui.components.extensions.isLargerThan
import com.unciv.logic.multiplayer.storage.SimpleHttp
import com.unciv.utils.Log
import com.unciv.utils.concurrency.Concurrency
import com.unciv.utils.concurrency.Dispatcher
import com.unciv.utils.concurrency.launchOnThreadPool
import com.unciv.utils.concurrency.withGLContext
import com.unciv.utils.Concurrency
import com.unciv.utils.Dispatcher
import com.unciv.utils.launchOnThreadPool
import com.unciv.utils.withGLContext
import com.unciv.utils.debug
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.coroutineScope
@ -343,7 +343,7 @@ class OnlineMultiplayer {
featureSet = try {
json().fromJson(ServerFeatureSet::class.java, result)
} catch (ex: Exception) {
Log.error("${UncivGame.Current.settings.multiplayer.server} does not support server feature set")
Log.error("${UncivGame.Current.settings.multiplayer.server} does not support server feature set", ex)
ServerFeatureSet()
}
}

6
core/src/com/unciv/logic/multiplayer/OnlineMultiplayerGame.kt
View File

@ -10,8 +10,8 @@ import com.unciv.logic.multiplayer.GameUpdateResult.Type.UNCHANGED
import com.unciv.logic.multiplayer.storage.FileStorageRateLimitReached
import com.unciv.logic.multiplayer.storage.OnlineMultiplayerFiles
import com.unciv.ui.components.extensions.isLargerThan
import com.unciv.utils.concurrency.launchOnGLThread
import com.unciv.utils.concurrency.withGLContext
import com.unciv.utils.launchOnGLThread
import com.unciv.utils.withGLContext
import com.unciv.utils.debug
import kotlinx.coroutines.coroutineScope
import java.time.Duration
@ -97,7 +97,7 @@ class OnlineMultiplayerGame(
error = null
MultiplayerGameUpdateUnchanged(name, updateResult.status)
}
else -> throw IllegalStateException()
else -> throw IllegalStateException("Unknown update event")
}
launchOnGLThread {
EventBus.send(updateEvent)

14
core/src/com/unciv/logic/multiplayer/storage/DropBox.kt
View File

@ -134,13 +134,13 @@ object DropBox: FileStorage {
throw FileStorageRateLimitReached(remainingRateLimitSeconds)
}
fun fileExists(fileName: String): Boolean = try {
dropboxApi("https://api.dropboxapi.com/2/files/get_metadata",
"{\"path\":\"$fileName\"}", "application/json")
true
} catch (ex: MultiplayerFileNotFoundException) {
false
}
// fun fileExists(fileName: String): Boolean = try {
// dropboxApi("https://api.dropboxapi.com/2/files/get_metadata",
// "{\"path\":\"$fileName\"}", "application/json")
// true
// } catch (ex: MultiplayerFileNotFoundException) {
// false
// }
//
// fun createTemplate(): String {

2
core/src/com/unciv/logic/multiplayer/storage/SimpleHttp.kt
View File

@ -2,6 +2,7 @@ package com.unciv.logic.multiplayer.storage
import com.badlogic.gdx.Net
import com.unciv.UncivGame
import com.unciv.utils.Log
import com.unciv.utils.debug
import java.io.BufferedReader
import java.io.DataOutputStream
@ -28,6 +29,7 @@ object SimpleHttp {
try {
urlObj = uri.toURL()
} catch (t: Throwable) {
Log.debug("Bad URL", t)
action(false, "Bad URL", null)
return
}