generate rook moves by a simple method

carokanns · carokanns · commit eb98f62e4033 · 2018-03-25T19:46:51.000+02:00
diff --git a/moves.go b/moves.go
@@ -2,14 +2,20 @@ package main
 
 // directions
 const (
-	E  = +1
-	W  = -1
-	N  = 8
-	S  = -8
-	NW = +7
-	NE = +9
-	SW = -NE
-	SE = -NW
+	E          = +1
+	W          = -1
+	N          = 8
+	S          = -8
+	NW         = +7
+	NE         = +9
+	SW         = -NE
+	SE         = -NW
+	toShift    = 6
+	p12Shift   = 6 + 6
+	cpShift    = 4 + 6 + 6
+	prShift    = 4 + 4 + 6 + 6
+	epShift    = 4 + 4 + 4 + 6 + 6
+	castlShift = 6 + 4 + 4 + 4 + 6 + 6
 )
 
 var pieceRules [nP][]int // not pawns
@@ -22,14 +28,21 @@ func init() {
 }
 
 type move uint64
+
+func (m *move) packMove(fr, to, p12, cp, pr, ep uint, castl castlings) {
+	// 6 bits (fr), 6 bits (to), 4 bits (p12), 4 bits (cp), 4 bits (pr), 6 bits (ep), 4 bits (castl), x bits value
+	*m = move(fr | (to << toShift) | (p12 | p12Shift) | (cp << cpShift) | (pr << prShift) | (ep << epShift) | uint(castl<<castlShift))
+}
+
 type moveList []move
+
 func (mvs *moveList) add(mv move) {
 	*mvs = append(*mvs, mv)
 }
 
 var ml = moveList{}
 
-/////////////////////////////// 
+///////////////////////////////
 /*
 func (m move) pack(fr, to, cp, pr, ep, castl int) move {
 	packed := uint32(0)
@@ -39,7 +52,7 @@ func (m move) pack(fr, to, cp, pr, ep, castl int) move {
 	packed |= uint32(pr)<<(6+6+4) // cp needs 4 bits (with color = p12)
 	packed |= uint32(ep)<<(6+6+4+4) // pr needs 4 bits
 	packed |= uint32(castl)<<(6+6+4+4+6) // ep needs 6 bits ( and castl needs 4)
-	// we use 6+6+4+4+6+4 = 30  That means we have 32 bits left for move value 
+	// we use 6+6+4+4+6+4 = 30  That means we have 32 bits left for move value
 	return move(packed)
 }
-*/
+*/
diff --git a/position.go b/position.go
@@ -159,7 +159,7 @@ func (b *boardStruct) setSq(p12, s int) {
 		}
 		return
 	}
-	
+
 	b.count[p12]++
 
 	p := piece(p12)
@@ -178,15 +178,78 @@ func (b *boardStruct) newGame() {
 	b.clear()
 	parseFEN(startpos)
 }
-func (b *boardStruct) genRookMoves() {
-	sd := b.stm
-	frBB := b.pieceBB[Rook] & b.wbBB[sd]
-	p12 := pc2P12(Rook, sd)
-	b.genFrMoves(p12, frBB, &ml)
+func (b *boardStruct) genRookMoves(ml *moveList, sd color) {
+	// TODO: generate rook moves with simple method - Benchmark
+	// TODO: create a non-uci-command pm (print all moves)
+	// TODO: explain magic numbers/bitboards
+	// TODO: create tables and methods to use magic numbers
+	// TODO: generate rook moves with magic bitBoards - Benchmark
+
+	allRBB := b.pieceBB[Rook] & b.wbBB[sd]
+	p12 := uint(pc2P12(Rook, color(sd)))
+	ep := uint(b.ep)
+	castl := b.castlings
+	var mv move
+	for fr := allRBB.firstOne(); fr != 64; fr = allRBB.firstOne() {
+		rk := fr / 8
+		fl := fr % 8
+		//N
+		for r := rk + 1; r < 8; r++ {
+			to := uint(r*8 + fl)
+			cp := uint(b.sq[to])
+			if cp != empty && p12Color(int(cp)) == sd {
+				break
+			}
+			mv.packMove(uint(fr), to, p12, cp, empty, ep, castl)
+			ml.add(mv)
+			if cp != empty {
+				break
+			}
+		}
+		//S
+		for r := rk - 1; r >= 0; r-- {
+			to := uint(r*8 + fl)
+			cp := uint(b.sq[to])
+			if cp != empty && p12Color(int(cp)) == sd {
+				break
+			}
+			mv.packMove(uint(fr), to, p12, cp, empty, ep, castl)
+			ml.add(mv)
+			if cp != empty {
+				break
+			}
+		}
+		//E
+		for f := fl + 1; f < 8; f++ {
+			to := uint(rk*8 + f)
+			cp := uint(b.sq[to])
+			if cp != empty && p12Color(int(cp)) == sd {
+				break
+			}
+			mv.packMove(uint(fr), to, p12, cp, empty, ep, castl)
+			ml.add(mv)
+			if cp != empty {
+				break
+			}
+		}
+		//W
+		for f := fl - 1; f <= 0; f-- {
+			to := uint(rk*8 + f)
+			cp := uint(b.sq[to])
+			if cp != empty && p12Color(int(cp)) == sd {
+				break
+			}
+			mv.packMove(uint(fr), to, p12, cp, empty, ep, castl)
+			ml.add(mv)
+			if cp != empty {
+				break
+			}
+		}
+	}
 }
 
 func (b *boardStruct) genFrMoves(p12 int, frBB bitBoard, ml *moveList) {
-	// TODO finish genRookMoves
+
 }
 
 //////////////////////////////////// my own commands - NOT UCI /////////////////////////////////////
