pokeplot 0.2.0beta

data/lib/pokeplot/miner.rb

@@ -0,0 +1,241 @@
+require 'pokeplot/helpers/math'
+require 'pokeplot/helpers/array'
+require 'pokeplot/api'
+module Pokeplot
+  class Miner
+
+    include Database
+
+    attr_accessor :miner, :db
+
+    def initialize(accounts, lat, lng, range = 20, interval = 600, pokemon = true, forts = true, threaded = false, encryption = '', log = true, apilog = true)
+      @apis     = []
+      @accounts = accounts
+      @lat      = lat
+      @lng      = lng
+      @db       = Database.mongo
+      @range    = range
+      @interval = interval
+      @pokemon  = pokemon
+      @forts    = forts
+      @threaded = threaded
+      @encryption = encryption
+      @logging  = log
+      @apilog   = apilog
+      @miner    = nil
+      @coords   = []
+
+      get_all_coords
+    end
+
+    def start
+      if !@miner.is_a?(Thread)
+        @miner = Thread.new {
+          puts "[+] Starting miner on new thread" if @logging
+
+          puts "[+] #{@coords.count} coords to scan using #{@accounts.count} accounts" if @logging
+          puts "[+] Logging in all accounts" if @logging
+
+          if @threaded
+            @threads = []
+            @accounts.each_with_index do |account, index|
+              @threads << Thread.new do
+                api = API.new(@lat, @lng, @encryption, @apilog)
+                api.login(account['username'], account['password'], account['provider'])
+                sleep(1)
+
+                loop do
+                  current_time = Time.now.to_i
+
+                  groups = @coords.in_groups(@accounts.count)
+
+                  groups[index].each do |coord|
+                    api.set_location(coord[:lat], coord[:lng])
+                    response = api.map_heartbeat
+                    parse_map_objects(response)
+                    sleep(10)
+                  end
+                  scan_time = Time.now.to_i - current_time
+                  puts "[+] Scan finnished for account #{account['username']} in #{scan_time} seconds" if @logging
+                  sleep_time = @interval - scan_time
+                  sleep_time = [sleep_time, 0].max
+                  puts "[+] Thread sleeping for #{sleep_time} seconds..." if @logging
+                  sleep(sleep_time)
+                end
+
+              end
+            end
+
+          else #NOT THEADED
+
+            @accounts.each do |account|
+              api = API.new(@lat, @lng, @encryption, @apilog)
+              api.login(account['username'], account['password'], account['provider'])
+              @apis.push(api)
+              sleep(2)
+            end
+
+            loop do
+              current_time = Time.now.to_i
+
+              groups = @coords.in_groups(@apis.count)
+              diff   = groups.first.count - groups.last.count
+              groups.last.push(*([0] * diff)) if diff > 0
+
+              groups = groups.transpose
+              groups.each_with_index do |group, n|
+                puts "[+] Starting group #{n + 1} of #{groups.count}" if @logging
+                group_time = Time.now.to_i
+                group.each_with_index do |coord, index|
+                  if coord.is_a?(Hash)
+                    api = @apis[index]
+                    api.set_location(coord[:lat], coord[:lng])
+                    response = api.map_heartbeat
+                    parse_map_objects(response)
+                  end
+                end
+                group_time = Time.now.to_i - group_time
+                puts "[+] Group finnished in #{group_time} seconds" if @logging
+              end
+
+              scan_time = Time.now.to_i - current_time
+              puts "[+] Scan Time: #{scan_time} s'" if @logging
+              sleep_time = @interval - scan_time
+              sleep_time = [sleep_time, 0].max
+              puts "[+] Sleeping for #{sleep_time} seconds..." if @logging
+              sleep(sleep_time)
+            end
+          end
+        }
+      end
+    end
+
+    def stop
+      Thread.kill(@miner) if @miner.is_a?(Thread)
+      if @threads.is_a?(Array)
+        @threads.each {|t| Thread.kill(t) if t.is_a?(Thread) }
+      end
+      @miner = nil
+    end
+
+    private
+
+    def get_all_coords
+      origin = {:lat => @lat, :lng => @lng}
+      @coords = [origin]
+
+      float_lat = @lat
+      float_lng = @lng
+
+      latrad = Helpers::Math.deg_to_rad(float_lat)
+
+      hex_r = 70.0 #range of detection for pokemon = 100m || changed to 70
+      hex_m = 3.0**(0.5)/2.0*hex_r
+
+      (1...(@range+1)).to_a.each do |a|
+        (0...(a*6)).to_a.each do |i|
+          x_un=1.5*hex_r/Helpers::Math.get_earth_radius(float_lat)/Math.cos(latrad)*180/Math::PI
+          y_un=1.0*hex_m/Helpers::Math.get_earth_radius(float_lat)*180/Math::PI
+          if i < a
+              lat = float_lat+y_un*(-2*a+i)
+              lng = float_lng+x_un*i
+          elsif i < 2*a
+              lat = float_lat+y_un*(-3*a+2*i)
+              lng = float_lng+x_un*a
+          elsif i < 3*a
+              lat = float_lat+y_un*(-a+i)
+              lng = float_lng+x_un*(3*a-i)
+          elsif i < 4*a
+              lat = float_lat+y_un*(5*a-i)
+              lng = float_lng+x_un*(3*a-i)
+          elsif i < 5*a
+              lat = float_lat+y_un*(9*a-2*i)
+              lng = float_lng+x_un*-a
+          else
+              lat = float_lat+y_un*(4*a-i)
+              lng = float_lng+x_un*(-6*a+i)
+          end
+          @coords << {:lat => lat, :lng => lng}
+        end
+      end
+      @coords
+    end
+
+    def parse_map_objects(response)
+      if response[:GET_MAP_OBJECTS][:status] == :SUCCESS
+        response[:GET_MAP_OBJECTS][:map_cells].each do |cell|
+
+          cell[:wild_pokemons].each do |pokemon|
+            if pokemon[:time_till_hidden_ms] < 0
+              puts "[+] Saving possible long spawn: #{pokemon[:spawn_point_id]}" if @logging
+              longspawn(cell, pokemon)
+            else
+              if new_encounter?(pokemon[:encounter_id].to_s, pokemon[:spawn_point_id], pokemon[:latitude].to_s, pokemon[:longitude].to_s) && @pokemon
+                @db[:encounters].insert_one({
+                  cell_id:              cell[:s2_cell_id].to_s,
+                  current_timestamp_ms: cell[:current_timestamp_ms].to_s,
+                  encounter_id:         pokemon[:encounter_id].to_s,
+                  latitude:             pokemon[:latitude].to_s,
+                  longitude:            pokemon[:longitude].to_s,
+                  spawn_point_id:       pokemon[:spawn_point_id],
+                  pokemon:              pokemon[:pokemon_data][:pokemon_id].to_s,
+                  time_till_hidden_ms:  pokemon[:time_till_hidden_ms].to_s
+                })
+                puts "[+] Found a \e[36m#{pokemon[:pokemon_data][:pokemon_id]}\e[0m" if @logging
+              end
+            end
+          end
+
+          cell[:forts].each do |fort|
+            if new_fort?(fort[:id].to_s) && @forts
+              @db[:forts].insert_one({
+                cell_id:              cell[:s2_cell_id].to_s,
+                current_timestamp_ms: cell[:current_timestamp_ms].to_s,
+                fort_id:              fort[:id],
+                enabled:              fort[:enabled].to_s,
+                latitude:             fort[:latitude].to_s,
+                longitude:            fort[:longitude].to_s,
+                type:                 fort[:type].to_s
+              })
+              puts "[+] Found a fort: #{fort[:type]}" if @logging
+            end
+          end
+
+        end
+      else
+        puts "[-] UNSUCCESSFUL RESPONSE STATUS #{response[:GET_MAP_OBJECTS][:status]}" if @logging
+      end
+    end
+
+    def new_encounter?(encounter_id, spawn_point_id, lat, lng)
+      if @db[:encounters].find({encounter_id: encounter_id, spawn_point_id: spawn_point_id, latitude: lat, longitude: lng}).count == 0
+        true
+      else
+        false
+      end
+    end
+
+    def new_fort?(fort_id)
+      if @db[:forts].find({fort_id: fort_id}).count == 0
+        true
+      else
+        false
+      end
+    end
+
+    def longspawn(cell, pokemon)
+      @db[:longspawn].insert_one({
+        cell_id:              cell[:s2_cell_id].to_s,
+        current_timestamp_ms: cell[:current_timestamp_ms].to_s,
+        encounter_id:         pokemon[:encounter_id].to_s,
+        latitude:             pokemon[:latitude].to_s,
+        longitude:            pokemon[:longitude].to_s,
+        spawn_point_id:       pokemon[:spawn_point_id],
+        pokemon:              pokemon[:pokemon_data][:pokemon_id].to_s,
+        time_till_hidden_ms:  pokemon[:time_till_hidden_ms].to_s
+      })
+      puts "[+] Found a \e[36m#{pokemon[:pokemon_data][:pokemon_id]}\e[0m (Long spawn)" if @logging
+    end
+
+  end
+end

data/lib/pokeplot/pushbullet.rb

@@ -0,0 +1,41 @@
+require 'washbullet'
+require 'pokeplot/helpers/time'
+
+module Pokeplot
+  class Pushbullet
+
+    def initialize(api_key, pokemon = [])
+      @pokemon = pokemon
+      @client = Washbullet::Client.new(api_key)
+    end
+
+    def started(event)
+      if event.command.has_key?('insert')
+        if event.command.fetch('insert') == 'encounters'
+          if @pokemon.include?(event.command.fetch('documents')[0][:pokemon])
+            text = "Found a #{event.command.fetch('documents')[0][:pokemon]}! "
+            time = Helpers::Time.to_s(Time.now.to_i - ((event.command.fetch('documents')[0][:current_timestamp_ms].to_i / 1000) -(event.command.fetch('documents')[0][:time_till_hidden_ms].to_i / 1000)))
+            text += "It expires in #{time}. "
+            text += "Google maps: http://www.google.com/maps/place/#{event.command.fetch('documents')[0][:latitude]},#{event.command.fetch('documents')[0][:longitude]}"
+
+
+            @client.devices.each do |device|
+              @client.push_note(
+                receiver:   :device,
+                identifier: device.body['iden'],
+                params: {
+                  title: 'Pokeplot',
+                  body:  text
+                }
+              )
+            end
+          end
+        end
+      end
+    end
+
+    def failed(_); end
+    def succeeded(_); end
+
+  end
+end

data/lib/pokeplot/socket.rb

@@ -0,0 +1,65 @@
+require 'em-websocket'
+require 'json'
+
+module Pokeplot
+  class Socket
+    include Database
+
+    def initialize(host = "0.0.0.0", port = 9090, log = false)
+      @clients = []
+      Thread.new do
+        EM.run do
+
+          db = Database.mongo
+          EM::WebSocket.run(:host => host, :port => port) do |ws|
+            ws.onopen do |handshake|
+              puts "[+] WebSocket connection open" if @log
+              pokemon = {:type => "count", :data => {}}
+              spawns = {:type => "spawn_points", :data => {}}
+
+              db[:encounters].find().each do |bson|
+                #get initial pokemon
+                if pokemon[:data].has_key?(bson[:pokemon])
+                  pokemon[:data][bson[:pokemon]] += 1
+                else
+                  pokemon[:data][bson[:pokemon]] = 1
+                end
+
+                #get spawn points
+                if spawns[:data].has_key?(bson[:spawn_point_id])
+                  spawns[:data][bson[:spawn_point_id]] += 1
+                else
+                  spawns[:data][bson[:spawn_point_id]] = 1
+                end
+              end
+
+              ws.send(pokemon.to_json)
+              ws.send(spawns.to_json)
+              @clients << ws
+            end
+
+            ws.onclose { @clients.delete(ws) }
+
+          end
+
+        end
+      end
+    end
+
+    #Mongo
+    def started(event)
+      if event.command.has_key?('insert')
+        if event.command.fetch('insert') == 'encounters'
+          @clients.each do |c|
+            c.send({:type => "pokemon", :data => event.command.fetch('documents')[0]}.to_json)
+          end
+        end
+      end
+    end
+
+    def failed(_); end
+    def succeeded(_); end
+
+
+  end
+end

data/lib/pokeplot/version.rb

@@ -0,0 +1,3 @@
+module Pokeplot
+  VERSION = "0.2.0beta"
+end