overlook-csgo 0.2.0

data/lib/overlook/csgo.rb

@@ -0,0 +1,9 @@
+require 'overlook/csgo/sharecode_decoder'
+require 'overlook/csgo/match_info_decoder'
+
+require 'overlook/csgo/demo'
+
+module Overlook
+  module Csgo
+  end
+end

data/lib/overlook/csgo/demo.rb

@@ -0,0 +1,33 @@
+require 'overlook/csgo/demo/base'
+
+require 'overlook/csgo/demo/packet'
+require 'overlook/csgo/demo/command'
+require 'overlook/csgo/demo/header'
+
+require 'overlook/csgo/demo/parser'
+
+require 'overlook/csgo/demo/key_reader'
+
+require 'overlook/csgo/demo/packet_handler'
+
+require 'overlook/csgo/demo/user_message_message_handler'
+require 'overlook/csgo/demo/game_event_list_message_handler'
+require 'overlook/csgo/demo/game_event_message_handler'
+require 'overlook/csgo/demo/encrypted_data_handler'
+
+require 'overlook/csgo/demo/command_factory'
+require 'overlook/csgo/demo/packet_factory'
+
+module Overlook
+  module Csgo
+    module Demo
+      class << self
+        def open(io)
+          Base.new(io)
+        end
+
+        alias :new :open
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/base.rb

@@ -0,0 +1,20 @@
+
+module Overlook
+  module Csgo
+    module Demo
+      class Base
+        def initialize(io)
+          @parser = Parser.new(io)
+        end
+
+        def subscribe(subscriber)
+          @parser.subscribe(subscriber)
+        end
+
+        def parse
+          @parser.parse
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/command.rb

@@ -0,0 +1,67 @@
+
+
+module Overlook
+  module Csgo
+    module Demo
+      class Command
+
+        module TYPE
+          SIGNON       = 1
+          PACKET       = 2
+          SYNCTICK     = 3
+          CONSOLECMD   = 4
+          USERCMD      = 5
+          DATATABLES   = 6
+          STOP         = 7
+          CUSTOMDATA   = 8
+          STRINGTABLES = 9
+          LASTCMD      = STRINGTABLES
+        end
+
+        attr_accessor :type, :tick, :slot
+
+        def initialize(type, tick, slot)
+          @type = type
+          @tick = tick
+          @slot = slot
+          @tick = 0 unless packet?
+        end
+
+        def type
+          case @type
+          when Command::TYPE::PACKET, Command::TYPE::SIGNON
+            :packet
+          when Command::TYPE::CUSTOMDATA, Command::TYPE::STRINGTABLES, Command::TYPE::DATATABLES
+            :skipable
+          when Command::TYPE::SYNCTICK
+            :sync
+          when Command::TYPE::STOP
+            :stop
+          else
+            :unknown
+          end
+        end
+
+        def unknown?
+          type == :stop
+        end
+
+        def stop?
+          type == :stop
+        end
+
+        def sync?
+          type == :sync
+        end
+
+        def packet?
+          type == :packet
+        end
+
+        def skipable?
+          type == :skipable
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/command_factory.rb

@@ -0,0 +1,15 @@
+module Overlook
+  module Csgo
+    module Demo
+      class CommandFactory
+        def self.from_io(reader)
+          cmd         = reader.byte
+          tick        = reader.signed_int32
+          slot        = reader.byte
+
+          Command.new(cmd, tick, slot)
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/encrypted_data_handler.rb

@@ -0,0 +1,16 @@
+module Overlook
+  module Csgo
+    module Demo
+      class EncryptedDataHandler
+        def initialize(parser)
+          @parser = parser
+        end
+
+        def handle(message)
+          # nop
+        end
+      end
+    end
+  end
+end
+

data/lib/overlook/csgo/demo/game_event_list_message_handler.rb

@@ -0,0 +1,19 @@
+module Overlook
+  module Csgo
+    module Demo
+      class GameEventListMessageHandler
+        def initialize(parser)
+          @parser = parser
+        end
+
+        def handle(message)
+          game_event_list_message = CSVCMsg_GameEventList.decode(message)
+
+          game_event_list_message.descriptors.each do |descriptor|
+            @parser.descriptors[descriptor.eventid] ||= descriptor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/game_event_message_handler.rb

@@ -0,0 +1,35 @@
+module Overlook
+  module Csgo
+    module Demo
+      class GameEventMessageHandler
+        def initialize(parser)
+          @parser = parser
+        end
+
+        def handle(message)
+          game_event_message = CSVCMsg_GameEvent.decode(message)
+          descriptor = @parser.descriptors[game_event_message.eventid]
+          event_keys = game_event_message.keys || []
+
+          keys = descriptor.keys
+          key_reader = KeyReader.new
+          attributes = event_keys.each_with_index.inject({}) do |memo, (key, index)|
+            memo[keys[index].name] = key_reader.read(key)
+            memo
+          end
+
+          case descriptor.name
+          when 'player_connect', 'player_connect_full'
+            # @parser.emit ...
+          when 'player_hurt'
+          when 'weapon_fire'
+          when 'bomb_beginplant', 'bomb_abortplant', 'bomb_planted', 'bomb_defused', 'bomb_exploded'
+          when 'round_end'
+          when 'begin_new_match'
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/overlook/csgo/demo/header.rb

@@ -0,0 +1,45 @@
+
+module Overlook
+  module Csgo
+    module Demo
+      class Header
+        MAX_STRING_LENGTH = 260.freeze
+
+        attr_accessor :map_name
+
+        def initialize(map_name)
+          raise ArgumentError 'map_name can\'t be nil' if map_name.nil?
+
+          @map_name       = map_name
+        end
+
+        def to_hash
+          { map_name: map_name }
+        end
+
+        def map_name
+          @map_name.split("\x00").first
+        end
+
+        def self.from_io(reader)
+          stamp            = reader.read(8)
+          demo_protocol    = reader.signed_int32
+          network_protocol = reader.signed_int32
+          server_name      = reader.string(MAX_STRING_LENGTH)
+          client_name      = reader.string(MAX_STRING_LENGTH)
+          map_name         = reader.string(MAX_STRING_LENGTH)
+          game_directory   = reader.string(MAX_STRING_LENGTH)
+          playtime         = reader.float
+          ticks            = reader.signed_int32
+          frames           = reader.signed_int32
+          signon_length    = reader.signed_int32
+
+          raise InvalidDemo, "#{self.class.name} only supports HL2DEMO, got #{stamp}" if stamp !~ /hl2demo/i
+          raise InvalidDemo, "#{self.class.name} only supports Valve demo files." if server_name !~ /valve/i
+
+          new(map_name)
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/key_reader.rb

@@ -0,0 +1,18 @@
+module Overlook
+  module Csgo
+    module Demo
+      class KeyReader
+        def read(key)
+          {
+            1 => key.val_string,
+            2 => key.val_float,
+            3 => key.val_long,
+            4 => key.val_short,
+            5 => key.val_byte,
+            6 => key.val_bool
+          }[key.type]
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/packet.rb

@@ -0,0 +1,16 @@
+
+module Overlook
+  module Csgo
+    module Demo
+      class Packet
+        attr_accessor :size, :data, :command_info
+
+        def initialize(size, data, command_info)
+          @size         = size
+          @data         = data
+          @command_info = command_info
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/packet_factory.rb

@@ -0,0 +1,22 @@
+module Overlook
+  module Csgo
+    module Demo
+      # Allows creation of Packet objects
+      class PacketFactory
+        COMMAND_INFO_SIZE = 160.freeze
+
+        # Creates a packet from an io stream.
+        #
+        # @return [Packet] The created packet object
+        def self.from_io(io)
+          command_info = io.read(COMMAND_INFO_SIZE)
+          size         = io.signed_int32
+          data         = StringIO.new(io.read(size))
+
+          Packet.new(size,
+                      data, command_info)
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/packet_handler.rb

@@ -0,0 +1,50 @@
+module Overlook
+  module Csgo
+    module Demo
+      # Determines which handler to use to read a packet and yields that
+      # handler along with the message to the block
+      class PacketHandler
+        module MessageTypes
+          USER_MESSAGE_MESSAGE_ID    = 23
+          GAME_EVENT_MESSAGE_ID      = 25
+          GAME_EVENT_LIST_MESSAGE_ID = 30
+          ENCRYPTED_DATA_ID          = 35
+        end
+
+        attr_reader :parser
+
+        def initialize(_parser)
+          @parser = _parser
+        end
+
+        def handle(packet)
+          reader = BitReader.new(packet.data)
+
+          loop do
+            message_type  = reader.var_int32
+            message_size  = reader.var_int32
+
+            if handler = handlers[message_type]
+              handler.handle(reader.bytes(message_size))
+            else
+              reader.skip(message_size)
+            end
+
+            break if reader.eof?
+          end
+        end
+
+        private
+
+        def handlers
+          {
+            MessageTypes::USER_MESSAGE_MESSAGE_ID => UserMessageMessageHandler.new(parser),
+            MessageTypes::GAME_EVENT_LIST_MESSAGE_ID => GameEventListMessageHandler.new(parser),
+            MessageTypes::GAME_EVENT_MESSAGE_ID => GameEventMessageHandler.new(parser),
+            MessageTypes::ENCRYPTED_DATA_ID => EncryptedDataHandler.new(parser),
+          }
+        end
+      end
+    end
+  end
+end

data/lib/overlook/csgo/demo/parser.rb

@@ -0,0 +1,66 @@
+require 'wisper'
+
+module Overlook
+  module Csgo
+    module Demo
+      class Parser
+        include Wisper::Publisher
+
+        Exception = Class.new(StandardError)
+        InvalidDemo = Class.new(Exception)
+
+        attr_reader   :reader
+        attr_accessor :descriptors
+
+        def initialize(io)
+          @reader  = ByteReader.new(io)
+          @header  = nil
+          @descriptors = {}
+        end
+
+        def parse
+          header
+          packets
+          done
+        end
+
+        def emit(event, data = {})
+          broadcast(event.to_sym, data)
+        end
+
+        private
+
+        def header
+          emit(:header,
+               Header.from_io(reader).to_hash)
+        end
+
+        def done
+          emit(:done)
+          true
+        end
+
+        def packets
+          packet_handler = PacketHandler.new(self)
+
+          loop do
+            command = CommandFactory.from_io(reader)
+
+            next if command.sync?
+            break if command.stop?
+            raise "Unknown Command: #{command.type}" if command.unknown?
+
+            if command.packet?
+              packet = PacketFactory.from_io(reader)
+              packet_handler.handle(packet)
+            elsif command.skipable?
+              reader.read(reader.signed_int32)
+            else
+              raise "Unknown Command #{command.type}"
+            end
+          end
+        end
+      end
+    end
+  end
+end