Class: GameMachine::Endpoints::UdpIncoming

Inherits:
Actor::Base
  • Object
show all
Defined in:
lib/game_machine/endpoints/udp_incoming.rb

Constant Summary

Constants inherited from Actor::Base

Actor::Base::ON_RECEIVE_HOOKS

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Actor::Base

aspect, aspects, find, find_by_address, find_distributed, find_distributed_local, find_remote, hashring, local_path, model_filter, #onReceive, player_controller, #receive_message, #schedule_message, #sender, set_player_controller

Instance Attribute Details

#clients ⇒ Object (readonly)

Returns the value of attribute clients.



13
14
15
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 13

def clients
  @clients
end

#game_handler ⇒ Object (readonly)

Returns the value of attribute game_handler.



13
14
15
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 13

def game_handler
  @game_handler
end

#server ⇒ Object (readonly)

Returns the value of attribute server.



13
14
15
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 13

def server
  @server
end

Class Method Details

.clients ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 5

def self.clients
  if @clients
    @clients
  else
    @clients = java.util.concurrent.ConcurrentHashMap.new
  end
end

Instance Method Details

#client_connection_type(connection_type) ⇒ Object

region and cluster connections are for when you have dedicated region servers. If you do not the connection type can be left out by the client and it will default to combined.



97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 97

def client_connection_type(connection_type)
  if connection_type.nil?
    'combined'
  else
    if connection_type == 1
      'region'
    elsif connection_type == 2
      'cluster'
    else
      'combined'
    end
  end
end

#client_id_from_message(message) ⇒ Object 



27
28
29
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 27

def client_id_from_message(message)
  "#{message.host}:#{message.port}"
end

#create_child(protocol, client_connection, client, server, player_id) ⇒ Object 



84
85
86
87
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 84

def create_child(protocol,client_connection,client,server,player_id)
  builder = Actor::Builder.new(Endpoints::UdpOutgoing,client_connection,client,server,player_id,protocol)
  builder.with_name(player_id).start
end

#create_client_connection(client_id, connection_type) ⇒ Object 



111
112
113
114
115
116
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 111

def create_client_connection(client_id,connection_type)
  MessageLib::ClientConnection.new.set_id(client_id).
    set_gateway(self.class.name).
    set_server(Application.config.name).
    set_type(client_connection_type(connection_type))
end

#destroy_child(player_id) ⇒ Object 



89
90
91
92
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 89

def destroy_child(player_id)
  Actor::Base.find(player_id).tell(JavaLib::PoisonPill.get_instance)
  GameMachine.logger.info "Player gateway sent poison pill to #{player_id}"
end

#handle_incoming(message) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 31

def handle_incoming(message)
  client_id = client_id_from_message(message)
  if message.protocol == 0
    client_message = MessageLib::ClientMessage.parse_from(message.bytes)
  elsif message.protocol == 2
    client_message = message.clientMessage
  else
    raise "Unknown protocol"
  end

  client_connection = create_client_connection(
    client_id,client_message.connection_type
  )
  client_message.set_client_connection(client_connection)

  # Ensure we kill the player gateway actor on logout or on new connection
  if client_message.has_player_logout || client_message.has_player_connect

    # Ensure valid authtoken before doing anything
    unless @auth_handler.valid_authtoken?(client_message.player)
      if client_message.has_player_logout
        GameMachine.logger.info "Unauthenticated client #{client_message.player.id} attempting to logout"
      elsif client_message.has_player_connect
        GameMachine.logger.info "Unauthenticated client #{client_message.player.id} attempting to login"
      end
      return
    end

    destroy_child(client_message.player.id)
    self.class.clients.delete(client_message.player.id)
    
    if client_message.has_player_connect
      unless self.class.clients.has_key?(client_message.player.id)
        client = {
          :host => message.host,
          :port => message.port,
          :address => message.address,
          :ctx => message.ctx,
          :client_connection => client_connection
        }
        self.class.clients[client_message.player.id] = client
        create_child(message.protocol,client_connection,client,@server,client_message.player.id)
      end
    end
  end

  game_handler.send_message(
    client_message, :sender => get_self
  )
rescue Exception => e
  GameMachine.logger.error "#{self.class.name} #{e.to_s}"
end

#on_receive(message) ⇒ Object 



21
22
23
24
25
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 21

def on_receive(message)
  if message.is_a?(JavaLib::NetMessage)
    handle_incoming(message)
  end
end

#post_init(*args) ⇒ Object 



14
15
16
17
18
19
 
# File 'lib/game_machine/endpoints/udp_incoming.rb', line 14

def post_init(*args)
  @game_handler = GameMachine::Handlers::Request.find
  @server = JavaLib::UdpServer.getUdpServer
  @server_handler = @server.getHandler
  @auth_handler = Handlers::Authentication.new
end