D2core logger

d2app/app.go

@@ -138,7 +138,7 @@ func (a *App) startDedicatedServer() error {
 	srvChanIn := make(chan int)
 	srvChanLog := make(chan string)
 
-	srvErr := d2networking.StartDedicatedServer(a.asset, srvChanIn, srvChanLog, maxPlayers)
+	srvErr := d2networking.StartDedicatedServer(a.asset, srvChanIn, srvChanLog, a.config.LogLevel, maxPlayers)
 	if srvErr != nil {
 		return srvErr
 	}
@@ -931,7 +931,7 @@ func (a *App) ToSelectHero(connType d2clientconnectiontype.ClientConnectionType,
 
 // ToCreateGame forces the game to transition to the Create Game screen
 func (a *App) ToCreateGame(filePath string, connType d2clientconnectiontype.ClientConnectionType, host string) {
-	gameClient, err := d2client.Create(connType, a.asset, a.scriptEngine)
+	gameClient, err := d2client.Create(connType, a.asset, a.config.LogLevel, a.scriptEngine)
 	if err != nil {
 		a.logger.Error(err.Error())
 	}

d2core/d2gui/label_button.go

@@ -1,7 +1,6 @@
 package d2gui
 
 import (
-	"fmt"
 	"image/color"
 
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
@@ -68,13 +67,13 @@ func (lb *LabelButton) Load(renderer d2interface.Renderer, asset *d2asset.AssetM
 
 	mainLayout.SetMouseEnterHandler(func(event d2interface.MouseMoveEvent) {
 		if err := l.SetIsHovered(true); err != nil {
-			lb.Error(fmt.Sprintf("could not change label to hover state: %v", err))
+			lb.Errorf("could not change label to hover state: %v", err)
 		}
 	})
 
 	mainLayout.SetMouseLeaveHandler(func(event d2interface.MouseMoveEvent) {
 		if err := l.SetIsHovered(false); err != nil {
-			lb.Error(fmt.Sprintf("could not change label to hover state: %v", err))
+			lb.Errorf("could not change label to hover state: %v", err)
 		}
 	})
 

d2core/d2map/d2mapengine/engine.go

@@ -1,7 +1,6 @@
 package d2mapengine
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2records"
@@ -100,7 +99,7 @@ func (m *MapEngine) addDT1(fileName string) {
 
 	fileData, err := m.asset.LoadFile("/data/global/tiles/" + fileName)
 	if err != nil {
-		m.Fatal(fmt.Sprintf("Could not load /data/global/tiles/%s", fileName))
+		m.Fatalf("Could not load /data/global/tiles/%s", fileName)
 		return
 	}
 
@@ -148,7 +147,7 @@ func (m *MapEngine) LevelType() d2records.LevelTypeRecord {
 
 // SetSeed sets the seed of the map for generation.
 func (m *MapEngine) SetSeed(seed int64) {
-	m.Info(fmt.Sprintf("Setting map engine seed to %d", seed))
+	m.Infof("Setting map engine seed to %d", seed)
 	m.seed = seed
 }
 
@@ -269,7 +268,7 @@ func (m *MapEngine) GetTiles(style, sequence int, tileType d2enum.TileType) []d2
 	}
 
 	if len(tiles) == 0 {
-		m.Warning(fmt.Sprintf("Unknown tile ID [%d %d %d]", style, sequence, tileType))
+		m.Warningf("Unknown tile ID [%d %d %d]", style, sequence, tileType)
 		return nil
 	}
 

d2core/d2map/d2mapgen/act1_overworld.go

@@ -4,7 +4,6 @@ package d2mapgen
 // is experiemental, and mapgen will likely change dramatically in the future.
 
 import (
-	"fmt"
 	"math/rand"
 	"strings"
 
@@ -49,7 +48,7 @@ func (g *MapGenerator) GenerateAct1Overworld() {
 	townStamp.RegionPath()
 	townSize := townStamp.Size()
 
-	g.Info(fmt.Sprintf("Region Path: %s", townStamp.RegionPath()))
+	g.Infof("Region Path: %s", townStamp.RegionPath())
 
 	switch {
 	case strings.Contains(townStamp.RegionPath(), "E1"):

d2core/d2map/d2maprenderer/renderer.go

@@ -2,7 +2,6 @@ package d2maprenderer
 
 import (
 	"errors"
-	"fmt"
 	"image/color"
 	"math"
 
@@ -93,15 +92,15 @@ func CreateMapRenderer(asset *d2asset.AssetManager, renderer d2interface.Rendere
 	})
 
 	if err != nil {
-		result.Error(fmt.Sprintf("could not bind the mapdebugvis action, err: %v", err))
+		result.Errorf("could not bind the mapdebugvis action, err: %v", err)
 	}
 
 	err = term.BindAction("entitydebugvis", "set entity debug visualization level", func(level int) {
 		result.entityDebugVisLevel = level
 	})
 
 	if err != nil {
-		result.Error(fmt.Sprintf("could not bind the entitydebugvis action, err: %v", err))
+		result.Errorf("could not bind the entitydebugvis action, err: %v", err)
 	}
 
 	if mapEngine.LevelType().ID != 0 {
@@ -372,7 +371,7 @@ func (mr *MapRenderer) renderFloor(tile d2ds1.FloorShadowRecord, target d2interf
 	}
 
 	if img == nil {
-		mr.Warning(fmt.Sprintf("Render called on uncached floor {%v,%v}", tile.Style, tile.Sequence))
+		mr.Warningf("Render called on uncached floor {%v,%v}", tile.Style, tile.Sequence)
 		return
 	}
 
@@ -388,7 +387,7 @@ func (mr *MapRenderer) renderFloor(tile d2ds1.FloorShadowRecord, target d2interf
 func (mr *MapRenderer) renderWall(tile d2ds1.WallRecord, viewport *Viewport, target d2interface.Surface) {
 	img := mr.getImageCacheRecord(tile.Style, tile.Sequence, tile.Type, tile.RandomIndex)
 	if img == nil {
-		mr.Warning(fmt.Sprintf("Render called on uncached wall {%v,%v,%v}", tile.Style, tile.Sequence, tile.Type))
+		mr.Warningf("Render called on uncached wall {%v,%v,%v}", tile.Style, tile.Sequence, tile.Type)
 		return
 	}
 
@@ -404,7 +403,7 @@ func (mr *MapRenderer) renderWall(tile d2ds1.WallRecord, viewport *Viewport, tar
 func (mr *MapRenderer) renderShadow(tile d2ds1.FloorShadowRecord, target d2interface.Surface) {
 	img := mr.getImageCacheRecord(tile.Style, tile.Sequence, 13, tile.RandomIndex)
 	if img == nil {
-		mr.Warning(fmt.Sprintf("Render called on uncached shadow {%v,%v}", tile.Style, tile.Sequence))
+		mr.Warningf("Render called on uncached shadow {%v,%v}", tile.Style, tile.Sequence)
 		return
 	}
 

d2core/d2map/d2maprenderer/tile_cache.go

@@ -1,8 +1,6 @@
 package d2maprenderer
 
 import (
-	"fmt"
-
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2ds1"
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2dt1"
@@ -61,7 +59,7 @@ func (mr *MapRenderer) generateFloorCache(tile *d2ds1.FloorShadowRecord) {
 	var tileData []*d2dt1.Tile
 
 	if tileOptions == nil {
-		mr.Error(fmt.Sprintf("Could not locate tile Style:%d, Seq: %d, Type: %d", tile.Style, tile.Sequence, 0))
+		mr.Errorf("Could not locate tile Style:%d, Seq: %d, Type: %d", tile.Style, tile.Sequence, 0)
 
 		tileData = append(tileData, &d2dt1.Tile{})
 		tileData[0].Width = defaultFloorTileWidth

d2core/d2records/record_manager.go

@@ -410,7 +410,7 @@ func (r *RecordManager) initObjectRecords(lookups []ObjectLookupRecord) {
 func (r *RecordManager) LookupObject(act, typ, id int) *ObjectLookupRecord {
 	object := r.lookupObject(act, typ, id)
 	if object == nil {
-		r.Fatal(fmt.Sprintf("Failed to look up object Act: %d, Type: %d, ID: %d", act, typ, id))
+		r.Fatalf("Failed to look up object Act: %d, Type: %d, ID: %d", act, typ, id)
 	}
 
 	return object

d2core/d2screen/screen_manager.go

@@ -1,8 +1,6 @@
 package d2screen
 
 import (
-	"fmt"
-
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2interface"
 	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2util"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2gui"
@@ -55,7 +53,7 @@ func (sm *ScreenManager) Advance(elapsed float64) error {
 		}
 
 		if load.err != nil {
-			sm.logger.Error(fmt.Sprintf("PROBLEM LOADING THE SCREEN: %v", load.err))
+			sm.logger.Errorf("PROBLEM LOADING THE SCREEN: %v", load.err)
 			return load.err
 		}
 

d2core/d2ui/ui_manager.go

@@ -1,7 +1,6 @@
 package d2ui
 
 import (
-	"fmt"
 	"sort"
 
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
@@ -37,13 +36,13 @@ type UIManager struct {
 func (ui *UIManager) Initialize() {
 	sfx, err := ui.audio.LoadSound(d2resource.SFXButtonClick, false, false)
 	if err != nil {
-		ui.Fatal(fmt.Sprintf("failed to initialize ui: %v", err))
+		ui.Fatalf("failed to initialize ui: %v", err)
 	}
 
 	ui.clickSfx = sfx
 
 	if err := ui.inputManager.BindHandler(ui); err != nil {
-		ui.Fatal(fmt.Sprintf("failed to initialize ui: %v", err))
+		ui.Fatalf("failed to initialize ui: %v", err)
 	}
 }
 

d2networking/d2client/d2localclient/local_client_connection.go

@@ -3,6 +3,7 @@ package d2localclient
 import (
 	"github.com/google/uuid"
 
+	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2util"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2hero"
 
@@ -22,16 +23,18 @@ type LocalClientConnection struct {
 	openNetworkServer bool                        // True if this is a server
 	playerState       *d2hero.HeroState           // Local player state
 	gameServer        *d2server.GameServer        // Game Server
+
+	logLevel d2util.LogLevel
 }
 
 // GetUniqueID returns LocalClientConnection.uniqueID.
-func (l LocalClientConnection) GetUniqueID() string {
+func (l *LocalClientConnection) GetUniqueID() string {
 	return l.uniqueID
 }
 
 // GetConnectionType returns an enum representing the connection type.
 // See: d2clientconnectiontype
-func (l LocalClientConnection) GetConnectionType() d2clientconnectiontype.ClientConnectionType {
+func (l *LocalClientConnection) GetConnectionType() d2clientconnectiontype.ClientConnectionType {
 	return d2clientconnectiontype.Local
 }
 
@@ -42,7 +45,10 @@ func (l *LocalClientConnection) SendPacketToClient(packet d2netpacket.NetPacket)
 
 // Create constructs a new LocalClientConnection and returns
 // a pointer to it.
-func Create(asset *d2asset.AssetManager, openNetworkServer bool) (*LocalClientConnection, error) {
+func Create(
+	asset *d2asset.AssetManager,
+	l d2util.LogLevel,
+	openNetworkServer bool) (*LocalClientConnection, error) {
 	heroStateFactory, err := d2hero.NewHeroStateFactory(asset)
 	if err != nil {
 		return nil, err
@@ -53,6 +59,7 @@ func Create(asset *d2asset.AssetManager, openNetworkServer bool) (*LocalClientCo
 		asset:             asset,
 		uniqueID:          uuid.New().String(),
 		openNetworkServer: openNetworkServer,
+		logLevel:          l,
 	}
 
 	return result, nil
@@ -64,7 +71,7 @@ func (l *LocalClientConnection) Open(_, saveFilePath string) error {
 
 	l.SetPlayerState(l.heroState.LoadHeroState(saveFilePath))
 
-	l.gameServer, err = d2server.NewGameServer(l.asset, l.openNetworkServer, 30)
+	l.gameServer, err = d2server.NewGameServer(l.asset, l.openNetworkServer, l.logLevel, 30)
 	if err != nil {
 		return err
 	}

d2networking/d2client/d2remoteclient/remote_client_connection.go

@@ -3,12 +3,12 @@ package d2remoteclient
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"net"
 	"strings"
 
 	"github.com/google/uuid"
 
+	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2util"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2asset"
 	"github.com/OpenDiablo2/OpenDiablo2/d2core/d2hero"
 	"github.com/OpenDiablo2/OpenDiablo2/d2networking"
@@ -17,6 +17,8 @@ import (
 	"github.com/OpenDiablo2/OpenDiablo2/d2networking/d2netpacket/d2netpackettype"
 )
 
+const logPrefix = "Remote Client"
+
 // RemoteClientConnection is the implementation of ClientConnection
 // for a remote client.
 type RemoteClientConnection struct {
@@ -26,11 +28,13 @@ type RemoteClientConnection struct {
 	uniqueID       string                      // Unique ID generated on construction
 	tcpConnection  *net.TCPConn                // UDP connection to the server
 	active         bool                        // The connection is currently open
+
+	*d2util.Logger
 }
 
 // Create constructs a new RemoteClientConnection
 // and returns a pointer to it.
-func Create(asset *d2asset.AssetManager) (*RemoteClientConnection, error) {
+func Create(l d2util.LogLevel, asset *d2asset.AssetManager) (*RemoteClientConnection, error) {
 	heroStateFactory, err := d2hero.NewHeroStateFactory(asset)
 	if err != nil {
 		return nil, err
@@ -42,6 +46,10 @@ func Create(asset *d2asset.AssetManager) (*RemoteClientConnection, error) {
 		uniqueID:  uuid.New().String(),
 	}
 
+	result.Logger = d2util.NewLogger()
+	result.Logger.SetPrefix(logPrefix)
+	result.Logger.SetLevel(l)
+
 	return result, nil
 }
 
@@ -66,14 +74,14 @@ func (r *RemoteClientConnection) Open(connectionString, saveFilePath string) err
 	r.active = true
 	go r.serverListener()
 
-	log.Printf("Connected to server at %s", r.tcpConnection.RemoteAddr().String())
+	r.Infof("Connected to server at %s", r.tcpConnection.RemoteAddr().String())
 
 	gameState := r.heroState.LoadHeroState(saveFilePath)
 	packet := d2netpacket.CreatePlayerConnectionRequestPacket(r.GetUniqueID(), gameState)
 	err = r.SendPacketToServer(packet)
 
 	if err != nil {
-		log.Print("RemoteClientConnection: error sending PlayerConnectionRequestPacket to server.")
+		r.Errorf("RemoteClientConnection: error sending PlayerConnectionRequestPacket to server.")
 		return err
 	}
 
@@ -134,18 +142,18 @@ func (r *RemoteClientConnection) serverListener() {
 	for {
 		err := decoder.Decode(&packet)
 		if err != nil {
-			log.Printf("failed to decode the packet, err: %v\n", err)
+			r.Errorf("failed to decode the packet, err: %v\n", err)
 			return
 		}
 
 		p, err := r.decodeToPacket(packet.PacketType, string(packet.PacketData))
 		if err != nil {
-			log.Println(packet.PacketType, err)
+			r.Error(fmt.Sprintln(packet.PacketType, err))
 		}
 
 		err = r.clientListener.OnPacketReceived(p)
 		if err != nil {
-			log.Println(packet.PacketType, err)
+			r.Error(fmt.Sprintln(packet.PacketType, err))
 		}
 	}
 }