[WIP] new api

build.gradle

@@ -55,8 +55,17 @@ configurations {
 dependencies {
     //compile files('../PokeGOAPI-Java/library/build/libs/PokeGOAPI-library-all-0.3.0.jar')
 
+    compile files('lib/api-0.0.1.jar')
+
     // TODO: Wait for jitpack to fix itself...
-    compile 'com.github.Grover-c13:PokeGOAPI-Java:Development-SNAPSHOT'
+    //compile 'com.github.Grover-c13:PokeGOAPI-Java:Development-SNAPSHOT'
+
+    compile 'com.squareup.okhttp3:okhttp:3.4.1'
+    compile 'io.reactivex:rxkotlin:0.60.0'
+    compile 'svarzee.gps:gpsoauth:0.3'
+    compile 'com.squareup.moshi:moshi:1.2.0'
+    compile 'net.jpountz.lz4:lz4:1.3.0'
+    compile 'com.google.protobuf:protobuf-java:3.0.0-beta-3'
 
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     compile "com.corundumstudio.socketio:netty-socketio:1.7.7"

src/main/kotlin/ink/abb/pogo/scraper/Bot.kt

@@ -11,18 +11,14 @@ package ink.abb.pogo.scraper
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.google.common.util.concurrent.AtomicDouble
 import com.google.maps.GeoApiContext
-import com.pokegoapi.api.PokemonGo
-import com.pokegoapi.api.map.MapObjects
-import com.pokegoapi.api.map.fort.Pokestop
-import com.pokegoapi.api.player.PlayerProfile
-import com.pokegoapi.api.pokemon.Pokemon
+import ink.abb.pogo.api.PoGoApi
+import ink.abb.pogo.api.cache.BagPokemon
+import ink.abb.pogo.api.cache.Pokestop
 import ink.abb.pogo.scraper.controllers.ProgramController
 import ink.abb.pogo.scraper.gui.SocketServer
 import ink.abb.pogo.scraper.tasks.*
 import ink.abb.pogo.scraper.util.Log
-import ink.abb.pogo.scraper.util.cachedInventories
 import ink.abb.pogo.scraper.util.directions.RouteProviderEnum
-import ink.abb.pogo.scraper.util.inventory.size
 import ink.abb.pogo.scraper.util.pokemon.getIv
 import ink.abb.pogo.scraper.util.pokemon.getIvPercentage
 import java.io.File
@@ -37,7 +33,7 @@ import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.concurrent.thread
 
-class Bot(val api: PokemonGo, val settings: Settings) {
+class Bot(val api: PoGoApi, val settings: Settings) {
 
     private var runningLatch = CountDownLatch(0)
     var prepareWalkBack = AtomicBoolean(false)
@@ -52,10 +48,9 @@ class Bot(val api: PokemonGo, val settings: Settings) {
     lateinit private var phaser: Phaser
     var ctx = Context(
             api,
-            api.playerProfile,
             AtomicDouble(settings.latitude),
             AtomicDouble(settings.longitude),
-            AtomicLong(api.playerProfile.stats.experience),
+            AtomicLong(api.inventory.playerStats.experience),
             LocalDateTime.now(),
             Pair(AtomicInteger(0), AtomicInteger(0)),
             AtomicInteger(0),
@@ -78,32 +73,36 @@ class Bot(val api: PokemonGo, val settings: Settings) {
     fun start() {
         if (isRunning()) return
 
-        if (settings.saveLocationOnShutdown && settings.savedLatitude!=0.0 && settings.savedLongitude!=0.0) {
+        if (settings.saveLocationOnShutdown && settings.savedLatitude != 0.0 && settings.savedLongitude != 0.0) {
             ctx.lat.set(settings.savedLatitude)
             ctx.lng.set(settings.savedLongitude)
-            Log.normal("Loaded last saved location (${settings.savedLatitude}, ${settings.savedLatitude})")
+            Log.normal("Loaded last saved location (${settings.savedLatitude}, ${settings.savedLongitude})")
         }
 
         ctx.walking.set(false)
 
-        Log.normal("Name: ${ctx.profile.playerData.username} - Team: ${ctx.profile.playerData.team.name}")
-        Log.normal("Level ${ctx.profile.stats.level}, Experience ${ctx.profile.stats.experience}; Pokecoin: ${ctx.profile.currencies[PlayerProfile.Currency.POKECOIN]}")
-        Log.normal("Pokebank ${ctx.api.cachedInventories.pokebank.pokemons.size + ctx.api.inventories.hatchery.eggs.size}/${ctx.profile.playerData.maxPokemonStorage}; Stardust: ${ctx.profile.currencies[PlayerProfile.Currency.STARDUST]}; Inventory ${ctx.api.cachedInventories.itemBag.size()}/${ctx.profile.playerData.maxItemStorage}")
+        Log.normal("Name: ${api.playerData.username} - Team: ${api.playerData.team.name}")
+        Log.normal("Level ${api.inventory.playerStats.level} - " +
+                "Experience ${api.inventory.playerStats.experience}; " +
+                "Pokecoin: ${api.inventory.currencies.getOrPut("POKECOIN", { AtomicInteger(0) }).get()}")
+        Log.normal("Pokebank ${api.inventory.pokemon.size + api.inventory.eggs.size}/${api.playerData.maxPokemonStorage}; " +
+                "Stardust: ${api.inventory.currencies.getOrPut("STARDUST", { AtomicInteger(0) }).get()}; " +
+                "Inventory ${api.inventory.size}/${api.playerData.maxItemStorage}")
 
-        val compareName = Comparator<Pokemon> { a, b ->
-            a.pokemonId.name.compareTo(b.pokemonId.name)
+        val compareName = Comparator<BagPokemon> { a, b ->
+            a.pokemonData.pokemonId.name.compareTo(b.pokemonData.pokemonId.name)
         }
-        val compareIv = Comparator<Pokemon> { a, b ->
+        val compareIv = Comparator<BagPokemon> { a, b ->
             // compare b to a to get it descending
             if (settings.sortByIv) {
-                b.getIv().compareTo(a.getIv())
+                b.pokemonData.getIv().compareTo(a.pokemonData.getIv())
             } else {
-                b.cp.compareTo(a.cp)
+                b.pokemonData.cp.compareTo(a.pokemonData.cp)
             }
         }
-        api.cachedInventories.pokebank.pokemons.sortedWith(compareName.thenComparing(compareIv)).map {
-            val pnickname = if (!it.nickname.isEmpty()) " (${it.nickname})" else ""
-            "Have ${it.pokemonId.name}$pnickname with ${it.cp}/${it.maxCpForPlayer} ${it.cpInPercentageActualPlayerLevel}% CP and IV (${it.individualAttack}-${it.individualDefense}-${it.individualStamina}) ${it.getIvPercentage()}% "
+        api.inventory.pokemon.map { it.value }.sortedWith(compareName.thenComparing(compareIv)).map {
+            val pnickname = if (!it.pokemonData.nickname.isEmpty()) " (${it.pokemonData.nickname})" else ""
+            "Have ${it.pokemonData.pokemonId.name}$pnickname with ${it.pokemonData.cp} CP and IV  (${it.pokemonData.individualAttack}-${it.pokemonData.individualDefense}-${it.pokemonData.individualStamina}) ${it.pokemonData.getIvPercentage()}%"
         }.forEach { Log.normal(it) }
 
         val keepalive = GetMapRandomDirection()
@@ -121,34 +120,11 @@ class Bot(val api: PokemonGo, val settings: Settings) {
         task(keepalive)
         Log.normal("Getting initial pokestops...")
 
-        val sleepTimeout = 10L
-        val originalInitialMapSize = settings.initialMapSize
-        var retries = 0
-        var reply: MapObjects?
-        do {
-            reply = api.map.getMapObjects(settings.initialMapSize)
-            Log.normal("Got ${reply.pokestops.size} pokestops")
-            if (reply == null || reply.pokestops.size == 0) {
-                retries++
-                if (retries % 3 == 0) {
-                    if (settings.initialMapSize > 1) {
-                        settings.initialMapSize -= 2
-                        Log.red("Decreasing initialMapSize to ${settings.initialMapSize}")
-                    } else {
-                        Log.red("Cannot decrease initialMapSize even further. Are your sure your latitude/longitude is correct?")
-                        Log.yellow("This is what I am trying to fetch: " +
-                                "https://www.google.com/maps/@${settings.latitude},${settings.longitude},15z")
-                    }
-                }
-                Log.red("Retrying in $sleepTimeout seconds...")
-                Thread.sleep(sleepTimeout * 1000)
-            }
-        } while (reply == null || reply.pokestops.size == 0)
-        if (originalInitialMapSize != settings.initialMapSize) {
-            Log.red("Too high initialMapSize ($originalInitialMapSize) found, " +
-                    "please change the setting in your config to ${settings.initialMapSize}")
+        while (api.map.getPokestops(api.latitude, api.longitude, settings.initialMapSize).size == 0) {
+            Thread.sleep(1000)
         }
-        val process = ProcessPokestops(reply.pokestops)
+
+        val process = ProcessPokestops(api.map.getPokestops(api.latitude, api.longitude, settings.initialMapSize))
 
         runningLatch = CountDownLatch(1)
         phaser = Phaser(1)
@@ -183,7 +159,7 @@ class Bot(val api: PokemonGo, val settings: Settings) {
                 task(process)
             else if (!ctx.walking.get())
                 task(WalkToStartPokestop(process.startPokestop as Pokestop))
-            if(checkForPlannedStop()){
+            if (checkForPlannedStop()) {
                 stop()
             }
         }
@@ -280,25 +256,25 @@ class Bot(val api: PokemonGo, val settings: Settings) {
         task.run(this, ctx, settings)
     }
 
-    fun checkForPlannedStop():Boolean {
-        val timeDiff:Long = ChronoUnit.MINUTES.between(ctx.startTime, LocalDateTime.now())
-        val pokemonCatched:Int = ctx.pokemonStats.first.get()
-        val pokestopsVisited:Int = ctx.pokestops.get()
+    fun checkForPlannedStop(): Boolean {
+        val timeDiff: Long = ChronoUnit.MINUTES.between(ctx.startTime, LocalDateTime.now())
+        val pokemonCatched: Int = ctx.pokemonStats.first.get()
+        val pokestopsVisited: Int = ctx.pokestops.get()
         //Log.red("time: ${timeDiff}, pokemon: ${pokemonCatched}, pokestops: ${pokestopsVisited}")
-        if(settings.botTimeoutAfterMinutes <= timeDiff && settings.botTimeoutAfterMinutes != -1){
+        if (settings.botTimeoutAfterMinutes <= timeDiff && settings.botTimeoutAfterMinutes != -1) {
             Log.red("Bot timed out as declared in the settings (after ${settings.botTimeoutAfterMinutes} minutes)")
             return true
-        } else if(settings.botTimeoutAfterCatchingPokemon <= pokemonCatched && settings.botTimeoutAfterCatchingPokemon != -1){
+        } else if (settings.botTimeoutAfterCatchingPokemon <= pokemonCatched && settings.botTimeoutAfterCatchingPokemon != -1) {
             Log.red("Bot timed out as declared in the settings (after catching ${settings.botTimeoutAfterCatchingPokemon} pokemon)")
             return true
-        } else if(settings.botTimeoutAfterVisitingPokestops <= pokestopsVisited && settings.botTimeoutAfterVisitingPokestops != -1){
+        } else if (settings.botTimeoutAfterVisitingPokestops <= pokestopsVisited && settings.botTimeoutAfterVisitingPokestops != -1) {
             Log.red("Bot timed out as declared in the settings (after visiting ${settings.botTimeoutAfterVisitingPokestops} pokestops)")
             return true
         }
         return false
     }
 
-    fun terminateApplication(){
+    fun terminateApplication() {
         phaser.forceTermination()
         ProgramController.stopAllApplications()
     }

src/main/kotlin/ink/abb/pogo/scraper/Context.kt

@@ -9,18 +9,16 @@
 package ink.abb.pogo.scraper
 
 import com.google.common.util.concurrent.AtomicDouble
+import ink.abb.pogo.api.PoGoApi
 import com.google.maps.GeoApiContext
-import com.pokegoapi.api.PokemonGo
-import com.pokegoapi.api.player.PlayerProfile
 import ink.abb.pogo.scraper.gui.SocketServer
 import java.time.LocalDateTime
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicLong
 
 data class Context(
-        val api: PokemonGo,
-        val profile: PlayerProfile,
+        val api: PoGoApi,
         val lat: AtomicDouble,
         val lng: AtomicDouble,