Pre-First test POC

Author: benjojo

birdc.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"bytes"
 	"encoding/binary"
 	"flag"
 	"fmt"
@@ -12,7 +11,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/nareix/bits"
+	"github.com/bamiaux/iobit"
 )
 
 type bgpCommunity struct {
@@ -58,13 +57,13 @@ S = Hit or Miss on last move
 +-------------------------------+
 */
 
-func numberToBitReader(in uint16) *bits.Reader {
+func numberToBitReader(in uint16) iobit.Reader {
 	actually := uint16(in)
 
 	bits2 := make([]byte, 2)
 
-	binary.LittleEndian.PutUint16(bits2, actually)
-	return &bits.Reader{R: bytes.NewReader(bits2)}
+	binary.BigEndian.PutUint16(bits2, actually)
+	return iobit.NewReader(bits2)
 }
 
 var errNotEnoughData = fmt.Errorf("Not enough data to make a move")
@@ -80,7 +79,7 @@ func readBGP() (gameIncrementor, X, Y, HitOrMissOnLast int, err error) {
 		if community.AS == uint16(*communityAS) {
 			// okay, so we are now interested!
 			r := numberToBitReader(community.Data)
-			t, _ := r.ReadBits(2)
+			t := r.Uint8(2)
 
 			if t == 1 {
 				// Counter
@@ -89,7 +88,7 @@ func readBGP() (gameIncrementor, X, Y, HitOrMissOnLast int, err error) {
 					return 0, 0, 0, 0, errDupeType
 				}
 				readCounter = true
-				c, _ := r.ReadBits(14)
+				c := r.Uint16(14)
 				gameIncrementor = int(c)
 
 			} else if t == 2 {
@@ -98,11 +97,11 @@ func readBGP() (gameIncrementor, X, Y, HitOrMissOnLast int, err error) {
 					return 0, 0, 0, 0, errDupeType
 				}
 				readPosition = true
-				xp, _ := r.ReadBits(4)
+				xp := r.Uint16(4)
 				X = int(xp)
-				yp, _ := r.ReadBits(4)
+				yp := r.Uint16(4)
 				Y = int(yp)
-				hs, _ := r.ReadBits(1)
+				hs := r.Uint16(1)
 				HitOrMissOnLast = int(hs)
 
 			} else {
@@ -120,34 +119,32 @@ func readBGP() (gameIncrementor, X, Y, HitOrMissOnLast int, err error) {
 func writeBGP(gameIncrementor, X, Y, HitOrMissOnLast int) error {
 
 	counternumberbytes := make([]byte, 2)
-	counternumberbytesbuffer := bytes.NewBuffer(counternumberbytes)
-	counternumberbits := bits.Writer{
-		W: counternumberbytesbuffer,
-	}
+	counternumberbits := iobit.NewWriter(counternumberbytes)
 
-	counternumberbits.WriteBits(1, 2)
-	counternumberbits.WriteBits(uint(gameIncrementor), 14)
+	counternumberbits.PutUint16(2, 0x1)
+	counternumberbits.PutUint16(14, uint16(gameIncrementor))
+	counternumberbits.Flush()
 
-	counterCommunity := binary.LittleEndian.Uint16(counternumberbytes)
+	counterCommunity := binary.BigEndian.Uint16(counternumberbytes)
 
 	positionnumberbytes := make([]byte, 2)
-	positionnumberbytesbuffer := bytes.NewBuffer(positionnumberbytes)
-	positionnumberbits := bits.Writer{
-		W: positionnumberbytesbuffer,
-	}
+	positionnumberbits := iobit.NewWriter(positionnumberbytes)
+
+	positionnumberbits.PutUint16(2, 0x2)
+	positionnumberbits.PutUint16(4, uint16(X))
+	positionnumberbits.PutUint16(4, uint16(Y))
+	positionnumberbits.PutBit(HitOrMissOnLast == 1)
+	positionnumberbits.Flush()
 
-	positionnumberbits.WriteBits(2, 2)
-	positionnumberbits.WriteBits(uint(X), 4)
-	positionnumberbits.WriteBits(uint(Y), 4)
-	positionnumberbits.WriteBits(uint(HitOrMissOnLast), 1)
+	fmt.Printf("%x/%x", counternumberbytes, positionnumberbytes)
 
-	positionCommunity := binary.LittleEndian.Uint16(positionnumberbytes)
+	positionCommunity := binary.BigEndian.Uint16(positionnumberbytes)
 
 	// Now we have the two community strings counterCommunity and positionCommunity
 
 	templatestring := fmt.Sprintf(
 		"\nbgp_community.add((%d,%d));\nbgp_community.add((%d,%d));\n",
-		communityAS, positionCommunity, communityAS, counterCommunity)
+		*communityAS, positionCommunity, *communityAS, counterCommunity)
 
 	templateBytes, err := ioutil.ReadFile(*templatePath)
 	if err != nil {
@@ -170,7 +167,7 @@ func writeBGP(gameIncrementor, X, Y, HitOrMissOnLast int) error {
 
 	defer conn.Close()
 
-	conn.Write([]byte(fmt.Sprintf("reload all\n")))
+	conn.Write([]byte(fmt.Sprintf("configure\n")))
 
 	buffer := make([]byte, 90000)
 	_, err = conn.Read(buffer)

board.go

@@ -1,7 +1,11 @@
 package main
 
 import (
+	cr "crypto/rand"
 	"fmt"
+	"math"
+	"math/big"
+	"math/rand"
 	"strconv"
 	"strings"
 
@@ -23,16 +27,18 @@ type battleShipBoard struct {
 	Board [10][10]boardState
 }
 
-func (b *battleShipBoard) Draw() {
-	fmt.Print("_|A|B|C|D|E|F|G|H|I|J|_\n")
+func (b *battleShipBoard) Draw() string {
+	str := ""
+	str += fmt.Sprint("_|A|B|C|D|E|F|G|H|I|J|_\n")
 	for y, stripe := range b.Board {
-		fmt.Printf("%d|", y)
+		str += fmt.Sprintf("%d|", y)
 		for _, x := range stripe {
-			fmt.Printf("%s|", x.Draw())
+			str += fmt.Sprintf("%s|", x.Draw())
 		}
-		fmt.Printf("%d\n", y)
+		str += fmt.Sprintf("%d\n", y)
 	}
-	fmt.Print("_|A|B|C|D|E|F|G|H|I|J|_\n")
+	str += fmt.Sprint("_|A|B|C|D|E|F|G|H|I|J|_\n")
+	return str
 }
 
 var cblack = ansi.ColorCode("black+h:black")
@@ -76,3 +82,72 @@ func cordsToNumbers(in string) (X, Y int) {
 	}
 	return -1, -1
 }
+
+func combineBoard(b1, b2 battleShipBoard) string {
+	b1r, b2r := b1.Draw(), b2.Draw()
+
+	b1rs, b2rs := strings.Split(b1r, "\n"), strings.Split(b2r, "\n")
+
+	str := ""
+	for k, _ := range b1rs {
+		str += fmt.Sprintf("%s     %s\n", b1rs[k], b2rs[k])
+	}
+
+	return str
+}
+
+func makeBoard() battleShipBoard {
+	a := battleShipBoard{}
+	ri, _ := cr.Int(cr.Reader, big.NewInt(math.MaxInt64))
+	rand.Seed(ri.Int64())
+
+	a = placeShip(5, a)
+	a = placeShip(4, a)
+	a = placeShip(3, a)
+	a = placeShip(3, a)
+	a = placeShip(2, a)
+	return a
+}
+
+func placeShip(size int, bo battleShipBoard) battleShipBoard {
+
+	for {
+		board := bo
+		sideways := rand.Int() % 2
+
+		if sideways == 0 { // ship goes up
+			X := rand.Int() % 10
+			Y := rand.Int() % 10
+			if Y+size > 10 {
+				continue
+			}
+
+			for y := Y; y < Y+size; y++ {
+				if board.Board[y][X] != stateEmpty {
+					continue
+				}
+				board.Board[y][X] = stateShip
+			}
+			bo = board
+			break
+		} else {
+			X := rand.Int() % 10
+			Y := rand.Int() % 10
+
+			if X+size > 10 {
+				continue
+			}
+
+			for x := X; x < X+size; x++ {
+				if board.Board[Y][x] != stateEmpty {
+					continue
+				}
+				board.Board[Y][x] = stateShip
+			}
+			bo = board
+			break
+		}
+	}
+
+	return bo
+}

main.go

@@ -6,35 +6,88 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"time"
 )
 
 func main() {
+	startfirst := flag.Bool("startfirst", false, "set this if you are starting first")
 	flag.Parse()
 	log.Printf("yup")
 
-	LocalB := battleShipBoard{}
-	// RemoteB := battleShipBoard{}
-
-	LocalB.Board[1][5] = stateShip
-	LocalB.Board[1][2] = stateHit
-	LocalB.Board[2][2] = stateAttempt
+	LocalB := makeBoard()
+	RemoteB := battleShipBoard{}
 
 	LocalB.Draw()
 
+	gameCounter := 0
+	hitmiss := 0
+
+	fmt.Print("Your Side                   Player Two\n")
+	fmt.Print(combineBoard(LocalB, RemoteB))
+
 	reader := bufio.NewReader(os.Stdin)
 	for {
-		fmt.Print("Next Move> ")
-		text, _ := reader.ReadString('\n')
-		if len(text) != 3 {
-			log.Printf("wrong length of command %d", len(text))
-			continue
+		var text string
+		var x, y int
+		if *startfirst {
+			fmt.Printf("[%06d] Next Move> ", gameCounter)
+			text, _ = reader.ReadString('\n')
+			if len(text) != 3 {
+				log.Printf("wrong length of command %d", len(text))
+				continue
+			}
+			x, y = cordsToNumbers(text)
+			if x == -1 || y == -1 {
+				continue
+			}
+
+			fmt.Printf("Firing on %s...", text)
+			writeBGP(gameCounter, x, y, hitmiss)
 		}
-		x, y := cordsToNumbers(text)
-		if x == -1 || y == -1 {
-			continue
+
+		*startfirst = true
+
+		fmt.Printf("waiting on players responce...\n")
+
+		for {
+			time.Sleep(time.Second)
+			var err error
+			var nx, ny int
+			tempgameCounter := 0
+			tempgameCounter, nx, ny, hitmiss, err = readBGP()
+			if err != nil {
+				fmt.Print(".")
+				continue
+			}
+			fmt.Print("!")
+
+			if tempgameCounter > gameCounter {
+				gameCounter = tempgameCounter + 1
+				// !! New move has happened
+
+				// First, process if we got a hit or not.
+				if hitmiss == 1 {
+					RemoteB.Board[y][x] = stateHit
+					log.Printf("It's a Hit!")
+				} else {
+					RemoteB.Board[y][x] = stateAttempt
+					log.Printf("It's a Miss!")
+				}
+
+				// Now... did we get hit?
+				if LocalB.Board[ny][nx] == stateShip {
+					hitmiss = 1
+					LocalB.Board[ny][nx] = stateHit
+				} else {
+					hitmiss = 0
+					LocalB.Board[ny][nx] = stateAttempt
+				}
+				break
+			}
 		}
-		LocalB.Board[y][x] = stateHit
-		LocalB.Draw()
+
+		fmt.Print("Your Side                   Player Two\n")
+		fmt.Print(combineBoard(LocalB, RemoteB))
 	}
 
 }