Add more test coverage

Author: maxproske

game/game_test.go

@@ -35,12 +35,14 @@ func createTestLevel() *Level {
 	level.Player = &Player{
 		Character: Character{
 			Entity: Entity{
-				Pos:  Pos{X: 7, Y: 7}, // Center of 15x15 grid
+				Pos:  Pos{X: 7, Y: 7},
 				Name: "You",
 				Rune: '@',
 			},
 			Hitpoints:  100,
-			SightRange: 3, // Reduced to match test map size
+			SightRange: 3,
+			Speed:      1.0,
+			PatternRNG: mrand.New(mrand.NewSource(0)),
 		},
 	}
 	level.Monsters = make(map[Pos]*Monster)
@@ -1385,3 +1387,134 @@ func TestMoveWithPortal(t *testing.T) {
 		t.Error("Move should set player to target position")
 	}
 }
+
+func TestHandleInputMovement(t *testing.T) {
+	game := createTestGame()
+	initialPos := game.CurrentLevel.Player.Pos
+	input := &Input{Typ: Up}
+	game.handleInput(input)
+	newPos := game.CurrentLevel.Player.Pos
+	expectedPos := Pos{initialPos.X, initialPos.Y - 1}
+	if newPos != expectedPos {
+		t.Errorf("Expected player position %v, got %v", expectedPos, newPos)
+	}
+}
+
+func TestHandleInputTakeItem(t *testing.T) {
+	game := createTestGame()
+	level := game.CurrentLevel
+	pos := level.Player.Pos
+	item := NewSword(pos)
+	level.Items[pos] = append(level.Items[pos], item)
+
+	input := &Input{Typ: TakeItem, Item: item}
+	game.handleInput(input)
+
+	if len(level.Player.Items) != 1 || level.Player.Items[0] != item {
+		t.Error("Item not added to player's inventory")
+	}
+	if len(level.Items[pos]) != 0 {
+		t.Error("Item not removed from level")
+	}
+}
+
+func TestHandleInputDropItem(t *testing.T) {
+	game := createTestGame()
+	level := game.CurrentLevel
+	player := level.Player
+	item := NewSword(player.Pos)
+	player.Items = append(player.Items, item)
+
+	input := &Input{Typ: DropItem, Item: item}
+	game.handleInput(input)
+
+	if len(player.Items) != 0 {
+		t.Error("Item not removed from inventory")
+	}
+	if len(level.Items[player.Pos]) != 1 || level.Items[player.Pos][0] != item {
+		t.Error("Item not added to level")
+	}
+}
+
+func TestHandleInputCombatBurst(t *testing.T) {
+	game := createTestGame()
+	level := game.CurrentLevel
+	player := level.Player
+	monsterPos := Pos{7, 6}
+	monster := NewRat(monsterPos)
+	level.Monsters[monsterPos] = monster
+	level.Attack(&player.Character, &monster.Character)
+	player.Burst = &Burst{Notes: []int{2}, MaxCombo: 1, Combo: 0} // Assuming 2 corresponds to Up
+	player.Stamina = 1
+
+	input := &Input{Typ: Up}
+	game.handleInput(input)
+
+	if len(player.Burst.Notes) != 0 {
+		t.Error("Burst note not consumed")
+	}
+	if player.Stamina != 0 {
+		t.Error("Stamina not decremented")
+	}
+}
+
+func TestHandleInputCloseWindow(t *testing.T) {
+	game := createTestGame()
+	initialChannels := len(game.LevelChans)
+	testChan := game.LevelChans[0]
+	input := &Input{Typ: CloseWindow, LevelChannel: testChan}
+	game.handleInput(input)
+
+	if len(game.LevelChans) != initialChannels-1 {
+		t.Error("Level channel not removed")
+	}
+}
+
+func TestRunProcessesInput(t *testing.T) {
+	game := createTestGame()
+	levelChan := make(chan *Level, 1)
+	game.LevelChans = []chan *Level{levelChan}
+
+	go game.Run()
+	defer close(game.InputChan)
+
+	initialPos := game.CurrentLevel.Player.Pos
+	game.InputChan <- &Input{Typ: Up}
+
+	updatedLevel := <-levelChan
+	newPos := updatedLevel.Player.Pos
+	expectedPos := Pos{initialPos.X, initialPos.Y - 1}
+	if newPos != expectedPos {
+		t.Errorf("Expected player position %v after Run, got %v", expectedPos, newPos)
+	}
+}
+
+func TestRunUpdatesMonsters(t *testing.T) {
+	game := createTestGame()
+	level := game.CurrentLevel
+	monsterPos := Pos{7, 6}
+	monster := NewRat(monsterPos)
+	monster.ActionPoints = 0.0
+	level.Monsters[monsterPos] = monster
+
+	levelChan := make(chan *Level, 1)
+	game.LevelChans = []chan *Level{levelChan}
+
+	go game.Run()
+	defer close(game.InputChan)
+
+	<-levelChan // Discard initial state sent on Run start
+
+	// Send dummy input to trigger game loop processing
+	game.InputChan <- &Input{Typ: None}
+
+	updatedLevel := <-levelChan // Get state after update
+	updatedMonster, exists := updatedLevel.Monsters[monsterPos]
+	if !exists {
+		t.Fatal("Monster not found in level")
+	}
+	// Correct the expected value from 1.5 to 0.5
+	if updatedMonster.ActionPoints != 0.5 {
+		t.Errorf("Expected monster ActionPoints 0.5, got %f", updatedMonster.ActionPoints)
+	}
+}

ui2d/ui2d_test.go

@@ -502,3 +502,129 @@ func TestInventoryUIEdgeCases(t *testing.T) {
 		t.Error("Should handle dropping item in full inventory")
 	}
 }
+
+func TestCheckEquippedItem(t *testing.T) {
+	ui := &ui{
+		winWidth:  800,
+		winHeight: 600,
+		draggedItem: &game.Item{
+			Typ: game.Weapon,
+		},
+	}
+
+	// Position mouse over weapon slot
+	weaponRect := ui.getWeaponSlotRect()
+	ui.currentMouseState = &mouseState{
+		pos: game.Pos{X: int(weaponRect.X) + 5, Y: int(weaponRect.Y) + 5},
+	}
+
+	// Test weapon equip
+	result := ui.CheckEquippedItem()
+	if result != ui.draggedItem {
+		t.Error("Should return weapon when dragged over weapon slot")
+	}
+
+	// Test wrong item type
+	ui.draggedItem.Typ = game.Helmet
+	result = ui.CheckEquippedItem()
+	if result != nil {
+		t.Error("Should not equip helmet in weapon slot")
+	}
+
+	// Test helmet equip
+	ui.draggedItem.Typ = game.Helmet
+	helmetRect := ui.getHelmetSlotRect()
+	ui.currentMouseState.pos = game.Pos{X: int(helmetRect.X) + 5, Y: int(helmetRect.Y) + 5}
+	result = ui.CheckEquippedItem()
+	if result != ui.draggedItem {
+		t.Error("Should return helmet when dragged over helmet slot")
+	}
+}
+
+func TestCheckInventoryItems(t *testing.T) {
+	item := &game.Item{}
+	level := &game.Level{
+		Player: &game.Player{
+			Character: game.Character{
+				Items: []*game.Item{item},
+			},
+		},
+	}
+
+	ui := &ui{
+		winWidth:  800,
+		winHeight: 600,
+		currentMouseState: &mouseState{
+			leftButton: true,
+		},
+	}
+
+	// Position mouse over first inventory slot
+	itemRect := ui.getInventoryItemRect(0)
+	ui.currentMouseState.pos = game.Pos{X: int(itemRect.X) + 5, Y: int(itemRect.Y) + 5}
+
+	// Test item pickup
+	result := ui.CheckInventoryItems(level)
+	if result != item {
+		t.Error("Should detect inventory item when clicked")
+	}
+
+	// Test no item found
+	ui.currentMouseState.pos = game.Pos{X: 0, Y: 0}
+	result = ui.CheckInventoryItems(level)
+	if result != nil {
+		t.Error("Should return nil when clicking empty area")
+	}
+}
+
+func TestGetSliceFromInt(t *testing.T) {
+	ui := &ui{}
+	tests := []struct {
+		input    int
+		expected []int
+	}{
+		{0, []int{0}},
+		{5, []int{5}},
+		{45, []int{5, 4}},
+		{123, []int{3, 2, 1}},
+		{6789, []int{9, 8, 7, 6}},
+	}
+
+	for _, tc := range tests {
+		actual := ui.getSliceFromInt(tc.input)
+		if !slicesEqual(actual, tc.expected) {
+			t.Errorf("For %d expected %v, got %v", tc.input, tc.expected, actual)
+		}
+	}
+}
+
+func slicesEqual(a, b []int) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestGetRuneFromNoteskinIndex(t *testing.T) {
+	tests := []struct {
+		input    int
+		expected rune
+	}{
+		{0, game.Receptor},
+		{1, game.Red},
+		{2, game.Blue},
+		{4, game.Yellow},
+	}
+
+	for _, tc := range tests {
+		actual := getRuneFromNoteskinIndex(tc.input)
+		if actual != tc.expected {
+			t.Errorf("For %d expected %c, got %c", tc.input, tc.expected, actual)
+		}
+	}
+}