WIP: BOBs_Waifu_Hunt: last run dump. xD

[noxiouscardiumdimidium]

(base) piguy@X-Pi:/media/piguy/STABLE-DIFFUSION/Github/gpt-engineer$ python main.py Bobs_Waifu_Hunt/
Model gpt-4 not available for provided API key. Reverting to gpt-3.5-turbo. Sign up for the GPT-4 wait list here: https://openai.com/waitlist/gpt-4-api
Program Specification:

The program is a simple game that consists of a 50x50 map, using emojis as sprites and map tiles. The game has the following features:

1. A single button at the top right corner "Save and Exit" to save the score and close the app.
2. Keyboard control for the main character "Bob".
3. The main character "Bob" has an array of "heroic" emojis, he can randomly spawn as at the start.
4. Every time Bob steps, there is a 5% chance to spawn a pretty girl or woman emoji, and receive the message "You Rescued a Loli! Her Waifu mamma is happy! +1 tokens". Increment "Tokens:" score by 1.
5. If Bob reaches 100 from rescued lolis, Bob wins the game, and receives the message "You Won The Favor Of Waifu! She Agrees To Go On A Date With You!" Game over, save score. All Bobs with a score of 100 have the title of "GigaChad!" All other Bobs are rank ordered by score. Add timestamp of death/win to scoreboard.
6. Every time Bob steps there is also a 5% chance to spawn an ugly emoji, and receive the message "You Were Attacked While Camping! -1 HP!" Base HP=25.
7. Newly spawned loli/waifus and monsters impede Bob's movement.

Core Classes, Functions, and Methods:

1. Game: This class will handle the game logic and control the game flow.

   • init(self): Initializes the game and sets up the game board.
   • start(self): Starts the game.
   • update(self): Updates the game state.
   • draw(self): Draws the game board.
   • handle_input(self, key): Handles the keyboard input.
   • spawn_pretty_girl(self): Spawns a pretty girl or woman emoji.
   • spawn_ugly_emoji(self): Spawns an ugly emoji.
   • save_score(self): Saves the score and closes the app.
   • check_win_condition(self): Checks if Bob has won the game.
   • check_lose_condition(self): Checks if Bob has lost the game.
   • update_scoreboard(self): Updates the scoreboard with the current score and timestamp.

2. Character: This class will represent the main character "Bob".

   • init(self, name, emojis): Initializes the character with a name and an array of "heroic" emojis.
   • move(self, direction): Moves the character in the specified direction.
   • check_collision(self, x, y): Checks if the character collides with an object at the specified position.

3. Emoji: This class will represent the emojis used in the game.

   • init(self, emoji, x, y): Initializes the emoji with the specified emoji and position.
   • move(self, direction): Moves the emoji in the specified direction.

Non-Standard Dependencies:

1. Golang standard library

2. "github.com/nsf/termbox-go" - A library for creating cross-platform text-based interfaces.
   Here are some sample tests based on the given specification:

3. Test Game Initialization:

func TestGameInitialization(t *testing.T) {
    game := NewGame()
    assert.NotNil(t, game.board)
    assert.NotNil(t, game.bob)
    assert.NotNil(t, game.scoreboard)
    assert.Equal(t, 0, game.score)
    assert.Equal(t, 25, game.hp)
}

2. Test Bob Movement:

func TestBobMovement(t *testing.T) {
    game := NewGame()
    game.handle_input(termbox.KeyArrowRight)
    assert.Equal(t, 1, game.bob.x)
    assert.Equal(t, 0, game.bob.y)
    game.handle_input(termbox.KeyArrowDown)
    assert.Equal(t, 1, game.bob.x)
    assert.Equal(t, 1, game.bob.y)
}

3. Test Pretty Girl Spawn:

func TestPrettyGirlSpawn(t *testing.T) {
    game := NewGame()
    game.spawn_pretty_girl()
    assert.Equal(t, 1, len(game.emojis))
    assert.Equal(t, "pretty girl", game.emojis[0].emoji)
}

4. Test Ugly Emoji Spawn:

func TestUglyEmojiSpawn(t *testing.T) {
    game := NewGame()
    game.spawn_ugly_emoji()
    assert.Equal(t, 1, len(game.emojis))
    assert.Equal(t, "ugly emoji", game.emojis[0].emoji)
}

5. Test Loli Rescue:

func TestLoliRescue(t *testing.T) {
    game := NewGame()
    game.spawn_pretty_girl()
    game.handle_input(termbox.KeyArrowRight)
    assert.Equal(t, 1, game.score)
    assert.Equal(t, "You Rescued a Loli! Her Waifu mamma is happy! +1 tokens", game.message)
}

6. Test Win Condition:

func TestWinCondition(t *testing.T) {
    game := NewGame()
    for i := 0; i < 100; i++ {
        game.spawn_pretty_girl()
        game.handle_input(termbox.KeyArrowRight)
    }
    assert.Equal(t, "You Won The Favor Of Waifu! She Agrees To Go On A Date With You!", game.message)
    assert.Equal(t, "GigaChad!", game.bob.title)
}

7. Test Lose Condition:

func TestLoseCondition(t *testing.T) {
    game := NewGame()
    for i := 0; i < 5; i++ {
        game.spawn_ugly_emoji()
        game.handle_input(termbox.KeyArrowRight)
    }
    assert.Equal(t, 20, game.hp)
    assert.Equal(t, "You Were Attacked While Camping! -1 HP!", game.message)
}

8. Test Scoreboard Update:

func TestScoreboardUpdate(t *testing.T) {
    game := NewGame()
    game.score = 50
    game.update_scoreboard()
    assert.Equal(t, 1, len(game.scoreboard))
    assert.Equal(t, "50", game.scoreboard[0].score)
}

Note: These tests are not exhaustive and may not cover all edge cases. It is important to write additional tests as needed to ensure full coverage of the code.
Based on the given specification, the following files and their contents are necessary:

1. main.go - This is the entrypoint file that initializes the game and starts it.

package main

import (
	"github.com/nsf/termbox-go"
)

func main() {
	err := termbox.Init()
	if err != nil {
		panic(err)
	}
	defer termbox.Close()

	game := NewGame()
	game.start()

	termbox.Flush()
}

2. game.go - This file contains the Game class that handles the game logic and control the game flow.

package main

import (
	"fmt"
	"github.com/nsf/termbox-go"
	"math/rand"
	"time"
)

type Game struct {
	board      [][]string
	bob        *Character
	emojis     []*Emoji
	scoreboard []*ScoreboardEntry
	score      int
	hp         int
	message    string
}

func NewGame() *Game {
	game := &Game{
		board: make([][]string, 50),
		bob: &Character{
			name:   "Bob",
			emojis: []string{"🦸‍♂️", "🦸‍♂️", "🦸‍♂️"},
			x:      0,
			y:      0,
			title:  "",
		},
		emojis:     []*Emoji{},
		scoreboard: []*ScoreboardEntry{},
		score:      0,
		hp:         25,
		message:    "",
	}

	for i := range game.board {
		game.board[i] = make([]string, 50)
		for j := range game.board[i] {
			game.board[i][j] = "🌲"
		}
	}

	game.board[0][0] = game.bob.emojis[0]

	return game
}

func (g *Game) start() {
	g.draw()

	for {
		switch ev := termbox.PollEvent(); ev.Type {
		case termbox.EventKey:
			if ev.Key == termbox.KeyEsc {
				g.save_score()
				return
			}
			g.handle_input(ev.Key)
			g.update()
			g.draw()
		case termbox.EventError:
			panic(ev.Err)
		}
	}
}

func (g *Game) update() {
	g.check_collision()
	g.check_win_condition()
	g.check_lose_condition()
	g.update_scoreboard()

	if rand.Float64() < 0.05 {
		g.spawn_pretty_girl()
	}

	if rand.Float64() < 0.05 {
		g.spawn_ugly_emoji()
	}
}

func (g *Game) draw() {
	termbox.Clear(termbox.ColorDefault, termbox.ColorDefault)

	for i := range g.board {
		for j := range g.board[i] {
			termbox.SetCell(j, i, []rune(g.board[i][j])[0], termbox.ColorDefault, termbox.ColorDefault)
		}
	}

	for _, emoji := range g.emojis {
		termbox.SetCell(emoji.x, emoji.y, []rune(emoji.emoji)[0], termbox.ColorDefault, termbox.ColorDefault)
	}

	termbox.SetCell(g.bob.x, g.bob.y, []rune(g.bob.emojis[0])[0], termbox.ColorDefault, termbox.ColorDefault)

	termbox.SetCell(49, 0, []rune("S")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 1, []rune("a")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 2, []rune("v")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 3, []rune("e")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 4, []rune(" ")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 5, []rune("&")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 6, []rune(" ")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 7, []rune("E")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 8, []rune("x")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 9, []rune("i")[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(49, 10, []rune("t")[0], termbox.ColorDefault, termbox.ColorDefault)

	termbox.SetCell(0, 50, []rune(fmt.Sprintf("Tokens: %d", g.score))[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(20, 50, []rune(fmt.Sprintf("HP: %d", g.hp))[0], termbox.ColorDefault, termbox.ColorDefault)
	termbox.SetCell(40, 50, []rune(g.message)[0], termbox.ColorDefault, termbox.ColorDefault)

	termbox.Flush()
}

func (g *Game) handle_input(key termbox.Key) {
	switch key {
	case termbox.KeyArrowUp:
		g.bob.move("up")
	case termbox.KeyArrowDown:
		g.bob.move("down")
	case termbox.KeyArrowLeft:
		g.bob.move("left")
	case termbox.KeyArrowRight:
		g.bob.move("right")
	}
}

func (g *Game) spawn_pretty_girl() {
	x := rand.Intn(50)
	y := rand.Intn(50)

	if g.board[y][x] == "🌲" {
		g.emojis = append(g.emojis, &Emoji{
			emoji: "👧",
			x:     x,
			y:     y,
		})
	}
}

func (g *Game) spawn_ugly_emoji() {
	x := rand.Intn(50)
	y := rand.Intn(50)

	if g.board[y][x] == "🌲" {
		g.emojis = append(g.emojis, &Emoji{
			emoji: "👹",
			x:     x,
			y:     y,
		})
	}
}

func (g *Game) check_collision() {
	for _, emoji := range g.emojis {
		if g.bob.x == emoji.x && g.bob.y == emoji.y {
			if emoji.emoji == "👧" {
				g.score++
				g.message = "You Rescued a Loli! Her Waifu mamma is happy! +1 tokens"
			} else if emoji.emoji == "👹" {
				g.hp--
				g.message = "You Were Attacked While Camping! -1 HP!"
			}

			emoji.x = -1
			emoji.y = -1
		}
	}
}

func (g *Game) check_win_condition() {
	if g.score >= 100 {
		g.message = "You Won The Favor Of Waifu! She Agrees To Go On A Date With You!"
		g.bob.title = "GigaChad!"
		g.update_scoreboard()
		g.save_score()
	}
}

func (g *Game) check_lose_condition() {
	if g.hp <= 0 {
		g.message = "You Died! Game Over!"
		g.update_scoreboard()
		g.save_score()
	}
}

func (g *Game) update_scoreboard() {
	entry := &Scoreboard
To install dependencies, run the following commands:

go mod init
go mod tidy

To run the codebase, run the following command:

go run main.go

Do you want to execute this code?

go mod init
go mod tidy

go run main.go


If yes, press enter. Otherwise, type "no"


Executing the code...

2023/06/19 19:13:24.666101 system_key.go:129: cannot determine nfs usage in generateSystemKey: cannot parse /etc/fstab: expected between 3 and 6 fields, found 7
go: /media/piguy/STABLE-DIFFUSION/Github/gpt-engineer/Bobs_Waifu_Hunt/workspace/go.mod already exists
2023/06/19 19:13:25.151299 system_key.go:129: cannot determine nfs usage in generateSystemKey: cannot parse /etc/fstab: expected between 3 and 6 fields, found 7
2023/06/19 19:13:25.218200 system_key.go:129: cannot determine nfs usage in generateSystemKey: cannot parse /etc/fstab: expected between 3 and 6 fields, found 7
# command-line-arguments
./main.go:18:10: undefined: Game
./main.go:19:9: undefined: Map
./main.go:20:15: undefined: Character
./main.go:22:14: undefined: Position
./main.go:26:11: undefined: Token
./main.go:27:16: undefined: Scoreboard

[TGANDTechnologies]

Interesting..