Server Umbau zwischenversion.

gocode/src/gameserver/dispatcher.go

@@ -32,21 +32,23 @@ package gameserver
 
 import (
 	"log"
+	"pokerth"
 	"sync/atomic"
 )
 
 type Dispatcher struct {
-	handler       PacketHandler
-	receiver      chan SessionPacket
+	receiver      chan SessionPokerTHMessage
+	authChan      chan SessionAuthMessage
+	lobbyChan     chan SessionLobbyMessage
 	lastSessionId uint32
 }
 
-func NewDispatcher(handler PacketHandler) *Dispatcher {
-	return &Dispatcher{handler, make(chan SessionPacket, RECV_DISPATCHER_NUM_PACKET_BUF), 0}
+func NewDispatcher(authChan chan SessionAuthMessage, lobbyChan chan SessionLobbyMessage) *Dispatcher {
+	return &Dispatcher{make(chan SessionPokerTHMessage, RECV_DISPATCHER_NUM_PACKET_BUF), authChan, lobbyChan, 0}
 }
 
-func (d *Dispatcher) GetReceiver() *chan SessionPacket {
-	return &d.receiver
+func (d *Dispatcher) GetReceiver() chan SessionPokerTHMessage {
+	return d.receiver
 }
 
 func (d *Dispatcher) GetNextSessionId() uint32 {
@@ -54,12 +56,19 @@ func (d *Dispatcher) GetNextSessionId() uint32 {
 }
 
 func (d *Dispatcher) Run() {
-	var sessionPacket SessionPacket
+	var sessionMsg SessionPokerTHMessage
 	for {
 		select {
-		case sessionPacket = <-d.receiver:
-			log.Printf("Packet in dispatcher session %d type %d", sessionPacket.session.id, sessionPacket.packet.GetMessageType())
-			d.handler.HandlePacket(sessionPacket.session, sessionPacket.packet)
+		case sessionMsg = <-d.receiver:
+			log.Printf("Packet in dispatcher session %d type %d", sessionMsg.session.id, sessionMsg.packet.GetMessageType())
+			switch sessionMsg.packet.GetMessageType() {
+			case pokerth.PokerTHMessage_Type_AuthMessage:
+				d.authChan <- SessionAuthMessage{sessionMsg.session, sessionMsg.packet.GetAuthMessage()}
+			case pokerth.PokerTHMessage_Type_LobbyMessage:
+				d.lobbyChan <- SessionLobbyMessage{sessionMsg.session, sessionMsg.packet.GetLobbyMessage()}
+			default:
+				log.Print("Unknown packet type")
+			}
 		}
 	}
 }

gocode/src/gameserver/lobby.go

@@ -37,16 +37,17 @@ import (
 	"pokerth"
 )
 
-type PacketHandler interface {
-	HandlePacket(session *Session, packet *pokerth.PokerTHMessage)
-}
-
 type Lobby struct {
+	receiver chan SessionLobbyMessage
 	sessions *list.List
 }
 
 func NewLobby() *Lobby {
-	return &Lobby{list.New()}
+	return &Lobby{make(chan SessionLobbyMessage, RECV_LOBBY_NUM_PACKET_BUF), list.New()}
+}
+
+func (l *Lobby) GetReceiver() chan SessionLobbyMessage {
+	return l.receiver
 }
 
 func (l *Lobby) AddSession(session *Session) {
@@ -71,6 +72,12 @@ func (l *Lobby) AddSession(session *Session) {
 	session.sender <- announce
 }
 
-func (l *Lobby) HandlePacket(session *Session, packet *pokerth.PokerTHMessage) {
-	log.Print("packet")
+func (l *Lobby) Run() {
+	var lobbyMsg SessionLobbyMessage
+	for {
+		select {
+		case lobbyMsg = <-l.receiver:
+			log.Printf("Lobby packet %d", lobbyMsg.packet.GetMessageType())
+		}
+	}
 }

gocode/src/gameserver/session.go

@@ -47,21 +47,37 @@ const RECV_BUF_SIZE uint32 = 4 * MAX_PACKET_SIZE
 const SEND_BUF_SIZE uint32 = 2 * MAX_PACKET_SIZE
 const SEND_NUM_PACKET_BUF = 2048
 const RECV_DISPATCHER_NUM_PACKET_BUF = 2048
+const RECV_LOBBY_NUM_PACKET_BUF = 2048
 
 type Session struct {
 	id uint32
 	PacketSerializer
 	Connection net.Conn
 	sender     chan *pokerth.PokerTHMessage
-	receiver   *chan SessionPacket
+	receiver   chan SessionPokerTHMessage
 }
 
-type SessionPacket struct {
+type SessionPokerTHMessage struct {
 	session *Session
 	packet  *pokerth.PokerTHMessage
 }
 
-func NewSession(id uint32, serializer PacketSerializer, conn net.Conn, receiver *chan SessionPacket) *Session {
+type SessionAuthMessage struct {
+	session *Session
+	packet  *pokerth.AuthMessage
+}
+
+type SessionLobbyMessage struct {
+	session *Session
+	packet  *pokerth.LobbyMessage
+}
+
+type SessionGameMessage struct {
+	session *Session
+	packet  *pokerth.GameMessage
+}
+
+func NewSession(id uint32, serializer PacketSerializer, conn net.Conn, receiver chan SessionPokerTHMessage) *Session {
 	return &Session{id, serializer, conn, make(chan *pokerth.PokerTHMessage, SEND_NUM_PACKET_BUF), receiver}
 }
 
@@ -93,7 +109,7 @@ func (s *Session) handleReceive() {
 				log.Print("Invalid packet")
 			} else {
 				log.Printf("Packet in: %d\n", packet.GetMessageType())
-				*s.receiver <- SessionPacket{s, packet}
+				s.receiver <- SessionPokerTHMessage{s, packet}
 				remainingBytes := bufPos - bytesScanned
 				if remainingBytes > 0 {
 					copy(buf[0:], buf[bytesScanned:remainingBytes])

gocode/src/main/main.go

@@ -43,7 +43,8 @@ var dispatcher *gameserver.Dispatcher
 
 func main() {
 	lobby = gameserver.NewLobby()
-	dispatcher = gameserver.NewDispatcher(lobby)
+	dispatcher = gameserver.NewDispatcher(nil, lobby.GetReceiver())
+	go lobby.Run()
 	go dispatcher.Run()
 
 	listener, err := net.Listen("tcp", ":7234")