package d2server import ( "context" "encoding/json" "errors" "fmt" "log" "net" "sync" "time" "github.com/robertkrimen/otto" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum" "github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset" "github.com/OpenDiablo2/OpenDiablo2/d2core/d2hero" "github.com/OpenDiablo2/OpenDiablo2/d2core/d2map/d2mapengine" "github.com/OpenDiablo2/OpenDiablo2/d2core/d2map/d2mapgen" "github.com/OpenDiablo2/OpenDiablo2/d2networking/d2netpacket" "github.com/OpenDiablo2/OpenDiablo2/d2networking/d2netpacket/d2netpackettype" "github.com/OpenDiablo2/OpenDiablo2/d2networking/d2server/d2tcpclientconnection" "github.com/OpenDiablo2/OpenDiablo2/d2script" ) const ( port = "6669" chunkSize int = 4096 subtilesPerTile = 5 middleOfTileOffset = 3 ) var ( errPlayerAlreadyExists = errors.New("player already exists") errServerFull = errors.New("server full") // Server currently at maximum TCP connections ) // GameServer manages a copy of the map and entities as well as manages packet routing and connections. // It can accept connections from localhost as well remote clients. It can also be started in a standalone mode. type GameServer struct { sync.RWMutex connections map[string]ClientConnection listener net.Listener networkServer bool ctx context.Context cancel context.CancelFunc asset *d2asset.AssetManager mapEngines []*d2mapengine.MapEngine scriptEngine *d2script.ScriptEngine seed int64 maxConnections int packetManagerChan chan []byte } //nolint:gochecknoglobals // currently singleton by design var singletonServer *GameServer // NewGameServer builds a new GameServer that can be started // // ctx: required context item // networkServer: true = 0.0.0.0 | false = 127.0.0.1 // maxConnections (default: 8): maximum number of TCP connections allowed open func NewGameServer(asset *d2asset.AssetManager, networkServer bool, maxConnections ...int) (*GameServer, error) { if len(maxConnections) == 0 { maxConnections = []int{8} } ctx, cancel := context.WithCancel(context.Background()) gameServer := &GameServer{ ctx: ctx, cancel: cancel, asset: asset, connections: make(map[string]ClientConnection), networkServer: networkServer, maxConnections: maxConnections[0], packetManagerChan: make(chan []byte), mapEngines: make([]*d2mapengine.MapEngine, 0), scriptEngine: d2script.CreateScriptEngine(), seed: time.Now().UnixNano(), } // TODO: In order to support dedicated mode we need to load the levels txt and files. Revisit this once this we can // load files independent of the app. mapEngine := d2mapengine.CreateMapEngine(asset) mapEngine.SetSeed(gameServer.seed) mapEngine.ResetMap(d2enum.RegionAct1Town, 100, 100) // TODO: Mapgen - Needs levels.txt stuff mapGen, err := d2mapgen.NewMapGenerator(asset, mapEngine) if err != nil { return nil, err } mapGen.GenerateAct1Overworld() gameServer.mapEngines = append(gameServer.mapEngines, mapEngine) gameServer.scriptEngine.AddFunction("getMapEngines", func(call otto.FunctionCall) otto.Value { val, err := gameServer.scriptEngine.ToValue(singletonServer.mapEngines) if err != nil { fmt.Print(err.Error()) } return val }) // TODO: Temporary hack to work around local connections. Possible that we can move away from the singleton pattern here // but for now this will work. singletonServer = gameServer return gameServer, nil } // Start essentially starts all of the game server go routines as well as begins listening for connection. This will // return an error if it is unable to bind to a socket. func (g *GameServer) Start() error { listenerAddress := "127.0.0.1:" + port if g.networkServer { listenerAddress = "0.0.0.0:" + port } log.Printf("Starting Game Server @ %s\n", listenerAddress) l, err := net.Listen("tcp4", listenerAddress) if err != nil { return err } g.listener = l go g.packetManager() go func() { for { c, err := g.listener.Accept() if err != nil { log.Printf("Unable to accept connection: %s\n", err) return } go g.handleConnection(c) } }() return nil } // Stop stops the game server func (g *GameServer) Stop() { g.Lock() g.cancel() if err := g.listener.Close(); err != nil { log.Printf("failed to close the listener %s, err: %v\n", g.listener.Addr(), err) } } // packetManager is meant to be started as a Goroutine and is used to manage routing of packets to clients. func (g *GameServer) packetManager() { defer close(g.packetManagerChan) for { select { // If the server is stopped we need to clean up the packet manager goroutine case <-g.ctx.Done(): return case p := <-g.packetManagerChan: switch d2netpacket.InspectPacketType(p) { case d2netpackettype.PlayerConnectionRequest: player, err := d2netpacket.UnmarshalNetPacket(p) if err != nil { log.Printf("Unable to unmarshal PlayerConnectionRequestPacket: %s\n", err) } g.sendPacketToClients(player) case d2netpackettype.MovePlayer: move, err := d2netpacket.UnmarshalNetPacket(p) if err != nil { log.Println(err) continue } g.sendPacketToClients(move) case d2netpackettype.CastSkill: castSkill, err := d2netpacket.UnmarshalNetPacket(p) if err != nil { log.Println(err) continue } g.sendPacketToClients(castSkill) case d2netpackettype.SpawnItem: item, err := d2netpacket.UnmarshalNetPacket(p) if err != nil { log.Println(err) continue } g.sendPacketToClients(item) case d2netpackettype.ServerClosed: g.Stop() } } } } func (g *GameServer) sendPacketToClients(packet d2netpacket.NetPacket) { for _, c := range g.connections { if err := c.SendPacketToClient(packet); err != nil { log.Printf("GameServer: error sending packet: %s to client %s: %s", packet.PacketType, c.GetUniqueID(), err) } } } // handleConnection accepts an individual connection and starts pooling for new packets. It is recommended this is called // via Go Routine. Context should be a property of the GameServer Struct. func (g *GameServer) handleConnection(conn net.Conn) { var connected int var packet d2netpacket.NetPacket log.Printf("Accepting connection: %s\n", conn.RemoteAddr().String()) defer func() { if err := conn.Close(); err != nil { log.Printf("failed to close the connection: %s\n", conn.RemoteAddr()) } }() decoder := json.NewDecoder(conn) for { err := decoder.Decode(&packet) if err != nil { log.Println(err) return // exit this connection as we could not read the first packet } // If this is the first packet we are seeing from this specific connection we first need to see if the client // is sending a valid request. If this is a valid request, we will register it and flip the connected switch // to. if connected == 0 { if packet.PacketType != d2netpackettype.PlayerConnectionRequest { log.Printf("Closing connection with %s: did not receive new player connection request...\n", conn.RemoteAddr().String()) } // TODO: I do not think this error check actually works. Need to retrofit with Errors.Is(). if err := g.registerConnection(packet.PacketData, conn); err != nil { switch err { case errServerFull: // Server is currently full and not accepting new connections. // TODO: Need to create a new Server Full packet to return to clients. log.Println(err) return case errPlayerAlreadyExists: // Player is already registered and did not disconnection correctly. log.Println(err) return } } connected = 1 } select { case <-g.ctx.Done(): return default: g.packetManagerChan <- packet.PacketData } } } // registerConnection accepts a PlayerConnectionRequestPacket and thread safely updates the connection pool // // Errors: // - errServerFull // - errPlayerAlreadyExists func (g *GameServer) registerConnection(b []byte, conn net.Conn) error { g.Lock() // check to see if the server is full if len(g.connections) >= g.maxConnections { return errServerFull } // if it is not full, unmarshal the playerConnectionRequest packet, err := d2netpacket.UnmarshalPlayerConnectionRequest(b) if err != nil { log.Printf("Failed to unmarshal PlayerConnectionRequest: %s\n", err) } // check to see if the player is already registered if _, ok := g.connections[packet.ID]; ok { return errPlayerAlreadyExists } // Client a new TCP Client Connection and add it to the connections map client := d2tcpclientconnection.CreateTCPClientConnection(conn, packet.ID) client.SetPlayerState(packet.PlayerState) log.Printf("Client connected with an id of %s", client.GetUniqueID()) g.connections[client.GetUniqueID()] = client // Temporary position hack -------------------------------------------- sx, sy := g.mapEngines[0].GetStartPosition() // TODO: Another temporary hack clientPlayerState := client.GetPlayerState() clientPlayerState.X = sx clientPlayerState.Y = sy // --------- // This really should be deferred however to much time will be spend holding a lock when we attempt to send a packet g.Unlock() handleClientConnection(g, client, sx, sy) return nil } // OnClientConnected initializes the given ClientConnection. It sends the // following packets to the newly connected client: UpdateServerInfoPacket, // GenerateMapPacket, AddPlayerPacket. // // It also sends AddPlayerPackets for each other player entity to the new // player and vice versa, so all player entities exist on all clients. // // For more information, see d2networking.d2netpacket. func OnClientConnected(client ClientConnection) { // Temporary position hack -------------------------------------------- sx, sy := singletonServer.mapEngines[0].GetStartPosition() // TODO: Another temporary hack clientPlayerState := client.GetPlayerState() clientPlayerState.X = sx clientPlayerState.Y = sy // -------------------------------------------------------------------- log.Printf("Client connected with an id of %s", client.GetUniqueID()) singletonServer.connections[client.GetUniqueID()] = client handleClientConnection(singletonServer, client, sx, sy) } func handleClientConnection(gameServer *GameServer, client ClientConnection, x, y float64) { err := client.SendPacketToClient(d2netpacket.CreateUpdateServerInfoPacket(gameServer.seed, client.GetUniqueID())) if err != nil { log.Printf("GameServer: error sending UpdateServerInfoPacket to client %s: %s", client.GetUniqueID(), err) } err = client.SendPacketToClient(d2netpacket.CreateGenerateMapPacket(d2enum.RegionAct1Town)) if err != nil { log.Printf("GameServer: error sending GenerateMapPacket to client %s: %s", client.GetUniqueID(), err) } playerState := client.GetPlayerState() // these are in subtiles playerX := int(x*subtilesPerTile) + middleOfTileOffset playerY := int(y*subtilesPerTile) + middleOfTileOffset d2hero.HydrateSkills(playerState.Skills, gameServer.asset) createPlayerPacket := d2netpacket.CreateAddPlayerPacket( client.GetUniqueID(), playerState.HeroName, playerX, playerY, playerState.HeroType, playerState.Stats, playerState.Skills, playerState.Equipment, ) for _, connection := range gameServer.connections { err := connection.SendPacketToClient(createPlayerPacket) if err != nil { log.Printf("GameServer: error sending %T to client %s: %s", createPlayerPacket, connection.GetUniqueID(), err) } if connection.GetUniqueID() == client.GetUniqueID() { continue } conPlayerState := connection.GetPlayerState() playerX := int(conPlayerState.X*subtilesPerTile) + middleOfTileOffset playerY := int(conPlayerState.Y*subtilesPerTile) + middleOfTileOffset err = client.SendPacketToClient( d2netpacket.CreateAddPlayerPacket( connection.GetUniqueID(), conPlayerState.HeroName, playerX, playerY, conPlayerState.HeroType, conPlayerState.Stats, conPlayerState.Skills, conPlayerState.Equipment, ), ) if err != nil { log.Printf("GameServer: error sending CreateAddPlayerPacket to client %s: %s", connection.GetUniqueID(), err) } } } // OnClientDisconnected removes the given client from the list // of client connections. func OnClientDisconnected(client ClientConnection) { log.Printf("Client disconnected with an id of %s", client.GetUniqueID()) delete(singletonServer.connections, client.GetUniqueID()) } // OnPacketReceived is called by the local client to 'send' a packet to the server. func OnPacketReceived(client ClientConnection, packet d2netpacket.NetPacket) error { switch packet.PacketType { case d2netpackettype.MovePlayer: movePacket, err := d2netpacket.UnmarshalMovePlayer(packet.PacketData) if err != nil { return err } // TODO: This needs to be verified on the server (here) before sending to other clients.... // TODO: Hacky, this should be updated in realtime ---------------- // TODO: Verify player id playerState := singletonServer.connections[client.GetUniqueID()].GetPlayerState() playerState.X = movePacket.DestX playerState.Y = movePacket.DestY // ---------------------------------------------------------------- for _, player := range singletonServer.connections { err := player.SendPacketToClient(packet) if err != nil { log.Printf("GameServer: error sending %T to client %s: %s", packet, player.GetUniqueID(), err) } } case d2netpackettype.CastSkill: for _, player := range singletonServer.connections { err := player.SendPacketToClient(packet) if err != nil { log.Printf("GameServer: error sending %T to client %s: %s", packet, player.GetUniqueID(), err) } } case d2netpackettype.SpawnItem: for _, player := range singletonServer.connections { err := player.SendPacketToClient(packet) if err != nil { log.Printf("GameServer: error sending %T to client %s: %s", packet, player.GetUniqueID(), err) } } default: log.Printf("GameServer: received unknown packet %T", packet) } return nil }