gitea=>gogs

ai_random/init.go

@@ -1,7 +0,0 @@
-package ai_random
-
-import "fmt"
-
-func init() {
-	fmt.Println("AI Random Initialized")
-}

game/GameStart.go

@@ -0,0 +1,37 @@
+package game
+
+import (
+	"fmt"
+	"log"
+)
+
+// Start the game
+func GameStart() {
+	fmt.Println("Initializing game")
+
+	game, err := initialize()
+	if err != nil {
+		log.Fatalln("Initilization error: ", err)
+	}
+
+	go game.gameDirector()
+	game.keyboardProcessor()
+
+	// Quit the screen
+	quit(&game)
+
+	fmt.Println("Game over!")
+
+	switch game.gameover {
+	case 1:
+		fmt.Println("Player quit")
+	case 2:
+		fmt.Println("Player Lost")
+	case 3:
+		fmt.Println("Player won")
+	}
+
+	for _, log := range game.logs {
+		fmt.Println(log)
+	}
+}

game/ai.go

@@ -1,7 +0,0 @@
-package game
-
-import "fmt"
-
-func (game *Game) initAI() {
-	fmt.Println("AI Initialized")
-}

game/doAction.go

@@ -0,0 +1,7 @@
+package game
+
+import "fmt"
+
+func (game *Game) doAction(action int) {
+	fmt.Println("Did a thing!")
+}

game/drawBoard.go

@@ -0,0 +1,13 @@
+package game
+
+func (game *Game) drawBoard(x, y, size int) {
+
+	// Draw borders
+	// Draw sea
+	// Draw boats
+	// Draw hits
+	// Draw misses
+
+	game.drawBorder(x, y, size)
+	game.drawSea(x, y, size)
+}

game/drawBorder.go

@@ -0,0 +1,73 @@
+package game
+
+import (
+	"strconv"
+
+	"github.com/gdamore/tcell/v3"
+)
+
+func (game *Game) drawBorder(x, y, size int) {
+
+	// Rulers
+	var rulerx int
+	rulerx = 1
+	var rulery int
+	rulery = 1
+
+	for row := x; row < x+size+2; row++ {
+
+		for col := y; col < y+size+2; col++ {
+
+			// Draw the lines
+			if row == x+size+1 && col != y && col != y+size+1 {
+				game.screen.Put(row, col, string(tcell.RuneVLine), game.style.text)
+			}
+
+			if col == y+size+1 && row != x && row != x+size+1 {
+				game.screen.Put(row, col, string(tcell.RuneHLine), game.style.text)
+			}
+
+			// Doing corner cases
+			if row == x && col == y {
+				game.screen.Put(row, col, string(tcell.RuneULCorner), game.style.text)
+			}
+
+			if row == x+size+1 && col == y {
+				game.screen.Put(row, col, string(tcell.RuneURCorner), game.style.text)
+			}
+
+			if row == x && col == y+size+1 {
+				game.screen.Put(row, col, string(tcell.RuneLLCorner), game.style.text)
+			}
+
+			if row == x+size+1 && col == y+size+1 {
+				game.screen.Put(row, col, string(tcell.RuneLRCorner), game.style.text)
+			}
+
+			// Printing parms
+			// X
+			if col == y && row != x && row != x+size+1 {
+				game.screen.Put(row, col, strconv.Itoa(rulerx), game.style.text)
+				rulerx++
+			}
+
+			// Y
+			if row == x && col != y && col != y+size+1 {
+				game.screen.Put(row, col, strconv.Itoa(rulery), game.style.text)
+				rulery++
+			}
+
+			// This doesn't work
+			if rulerx == 10 {
+				rulerx = 0
+			}
+
+			// But this works
+			if rulery == 10 {
+				rulery = 0
+			}
+
+		}
+
+	}
+}

game/drawScreen.go

@@ -0,0 +1,9 @@
+package game
+
+func (game *Game) drawScreen() {
+	// Draw left board
+	game.drawBoard(0, 0, 14)
+
+	// Draw right board
+	game.drawBoard(30, 0, 14)
+}

game/drawSea.go

@@ -0,0 +1,11 @@
+package game
+
+func (game *Game) drawSea(x, y, size int) {
+
+	for row := x + 1; row < x+size+1; row++ {
+		for col := y + 1; col < y+size+1; col++ {
+			game.screen.Put(row, col, "~", game.style.sea)
+		}
+	}
+
+}

game/game.go

@@ -1,7 +0,0 @@
-package game
-
-import "fmt"
-
-func GameStart() {
-	fmt.Println("Game Initialized")
-}

game/gameDirector.go

@@ -0,0 +1,47 @@
+package game
+
+import "fmt"
+
+func (game *Game) gameDirector() {
+	defer quit(game)
+
+	// Gameflow stages
+	// 1. Place ships
+	// 2. Fire shots
+	// 3. Win/Lose
+
+	var stage int
+
+	for game.gameover == 0 {
+		fmt.Print("Do things")
+
+		stage = 1
+
+		// if stage 1: place ships
+		if stage == 1 {
+			game.drawScreen()
+			// Iterate through Shipsets
+			// Place ships in game.leftShips
+			for _, ship := range game.shipsets {
+				valid := false
+
+				for !valid {
+					x, y := 7, 7
+					orientation := updown
+					game.shipPlace(ship, x, y, orientation)
+
+					game.drawScreen()
+					game.doAction(<-game.keypresses)
+				}
+
+			}
+		}
+
+		// if stage 2: fire shots
+		if stage == 2 {
+			game.drawScreen()
+			fmt.Println("Fire shots")
+		}
+
+	}
+}

game/initialize.go

@@ -0,0 +1,41 @@
+package game
+
+import (
+	"log"
+
+	"github.com/gdamore/tcell/v3"
+)
+
+func initialize() (Game, error) {
+
+	var err error
+
+	screen, err := tcell.NewScreen()
+	if err != nil {
+		log.Println("Error creating screen: ", err)
+	}
+
+	err = screen.Init()
+	if err != nil {
+		log.Fatalln("Error initializing screen: ", err)
+	}
+
+	game := Game{
+		screen:      screen,
+		style:       setStyles(),
+		keypresses:  make(chan int),
+		score:       0,
+		shipsets:    setShipsets(),
+		leftBoard:   board{},
+		leftShips:   make(ships, 14),
+		rightBoard:  board{},
+		rightShips:  make(ships, 14),
+		gameover:    0,
+		stats_score: 0,
+		stats_miss:  0,
+		stats_hits:  0,
+	}
+
+	return game, err
+
+}

game/keyboardProcessor.go

@@ -0,0 +1,52 @@
+package game
+
+import "github.com/gdamore/tcell/v3"
+
+func (game *Game) keyboardProcessor() {
+	defer close(game.keypresses)
+
+	for game.gameover == 0 {
+
+		// Poll for an event
+		ev := <-game.screen.EventQ()
+
+		// Fetch the type, and check if any other actions are required.
+		switch ev := ev.(type) {
+
+		case *tcell.EventResize:
+			game.screen.Sync()
+
+		case *tcell.EventKey:
+			// Keys to bug out
+			if ev.Key() == tcell.KeyEscape || ev.Key() == tcell.KeyCtrlC {
+				game.gameover = 1
+				return
+			} else if ev.Key() == tcell.KeyCtrlL {
+				game.screen.Sync()
+			} else if ev.Key() == 'q' {
+				game.keypresses <- upleft
+			} else if ev.Key() == 'e' {
+				game.keypresses <- upright
+			} else if ev.Key() == 'z' {
+				game.keypresses <- downleft
+			} else if ev.Key() == 'c' {
+				game.keypresses <- downright
+			} else if ev.Key() == tcell.KeyUp || ev.Key() == 'w' {
+				game.keypresses <- up
+			} else if ev.Key() == tcell.KeyRight || ev.Key() == 'd' {
+				game.keypresses <- right
+			} else if ev.Key() == tcell.KeyDown || ev.Key() == 's' || ev.Key() == 'x' {
+				game.keypresses <- down
+			} else if ev.Key() == tcell.KeyLeft || ev.Key() == 'a' {
+				game.keypresses <- left
+			} else if ev.Key() == 'r' {
+				game.keypresses <- rotateleft
+			} else if ev.Key() == 't' {
+				game.keypresses <- rotateright
+			} else if ev.Key() == tcell.Key(0x2c) { // Spacebar?
+				game.keypresses <- action
+			}
+		}
+
+	}
+}

game/quit.go

@@ -0,0 +1,9 @@
+package game
+
+func quit(game *Game) {
+	maybePanic := recover()
+	game.screen.Fini()
+	if maybePanic != nil {
+		panic(maybePanic)
+	}
+}

game/setShipsets.go

@@ -0,0 +1,15 @@
+package game
+
+func setShipsets() []pieces {
+
+	var shipset []pieces
+
+	shipset = append(shipset, pieces{"Carrier", 5, "C"})
+	shipset = append(shipset, pieces{"Battleship", 4, "B"})
+	shipset = append(shipset, pieces{"Destroyer", 3, "D"})
+	shipset = append(shipset, pieces{"Submarine", 3, "S"})
+	shipset = append(shipset, pieces{"Patrol Boat", 2, "P"})
+
+	return shipset
+
+}

game/setStyles.go

@@ -0,0 +1,21 @@
+package game
+
+import (
+	"github.com/gdamore/tcell/v3"
+	"github.com/gdamore/tcell/v3/color"
+)
+
+func setStyles() Styles {
+
+	var styleset Styles
+
+	styleset.text = tcell.StyleDefault.Background(tcell.ColorReset).Foreground(tcell.ColorReset)
+	styleset.sea = tcell.StyleDefault.Background(tcell.ColorReset).Foreground(color.Blue)
+	styleset.ship = tcell.StyleDefault.Background(tcell.ColorReset).Foreground(color.DarkGrey)
+	styleset.miss = tcell.StyleDefault.Background(tcell.ColorReset).Foreground(color.Orange)
+	styleset.hit = tcell.StyleDefault.Background(tcell.ColorReset).Foreground(color.Red)
+	styleset.incorrect = tcell.StyleDefault.Background(color.Red).Foreground(tcell.ColorReset)
+
+	return styleset
+
+}

game/shipPlace.go

@@ -0,0 +1,17 @@
+package game
+
+func (game *Game) shipPlace(ship pieces, x int, y int, orientation int) {
+	for v := range ship.length {
+		switch orientation {
+		case updown:
+			for i := 0; i < v; i++ {
+				game.leftShips[x][y+1] = ship.abreviation
+			}
+		case leftright:
+			for i := 0; i < v; i++ {
+				game.leftShips[x+1][y] = ship.abreviation
+			}
+		}
+	}
+
+}

game/types.go

@@ -5,7 +5,7 @@ import "github.com/gdamore/tcell/v3"
 // Directions for movement and actions
 const (
 	up = iota
-	Left
+	left
 	right
 	down
 	upleft
@@ -13,21 +13,52 @@ const (
 	downleft
 	downright
 	action
+	rotateleft
+	rotateright
+)
+
+const (
+	updown    = 1
+	leftright = 2
 )
 
 // Styles holds the different styles for the game elements
 type Styles struct {
-	Default tcell.Style
-	ship    tcell.Style
-	hit     tcell.Style
-	miss    tcell.Style
-	sea     tcell.Style
+	text      tcell.Style
+	sea       tcell.Style
+	ship      tcell.Style
+	miss      tcell.Style
+	hit       tcell.Style
+	incorrect tcell.Style
+}
+
+// board stores the different boards, both water and ships.
+type board [][]int
+
+// Collection of ships
+type ships [][]string
+
+// Collection of ships
+type pieces struct {
+	name        string
+	length      int
+	abreviation string
 }
 
 // Game holds the state of the game
 type Game struct {
-	screen     tcell.Screen
-	style      Styles
-	keypresses chan int
-	score      int
+	screen      tcell.Screen
+	style       Styles
+	keypresses  chan int
+	score       int
+	leftBoard   board
+	leftShips   ships
+	rightBoard  board
+	rightShips  ships
+	shipsets    []pieces
+	gameover    int
+	stats_score int
+	stats_miss  int
+	stats_hits  int
+	logs        []string
 }