[ADD] Help User

Author: Hamza MADAD

back/game/game.go

@@ -96,7 +96,16 @@ func (game *Game) ProccessRules(initialStone *inter.Node) (*pb.CheckRulesRespons
 	return res, nil
 }
 
-func (game *Game) PlayIA(in *inter.Node) *inter.Node {
+func (game *Game) PlayIA(in *inter.Node, isHelp bool) *inter.Node {
+	if isHelp == true {
+		depth := game.IA.Depth
+		game.IA.PlayerIndex = player.GetOpposentPlayer(game.IA.PlayerIndex)
+		game.IA.Depth = 3
+		defer func() {
+			game.IA.PlayerIndex = player.GetOpposentPlayer(game.IA.PlayerIndex)
+			game.IA.Depth = depth
+		}()
+	}
 	fmt.Println("LEN => ", len(game.IA.SearchZone))
 	return game.IA.Play(game.board, game.players)
 }

back/manegeGame/manegeGame.go

@@ -60,11 +60,11 @@ func (CurrentGames *Games) ProccessRules(in *pb.StonePlayed) (*pb.CheckRulesResp
 }
 
 // PlayedAI choose the best move for win
-func (CurrentGames *Games) PlayedIA(in *pb.StonePlayed) (*pb.StonePlayed, error) {
+func (CurrentGames *Games) PlayedIA(in *pb.StonePlayed, isHelp bool) (*pb.StonePlayed, error) {
 	CurrentGames.rwmux.Lock()
 	defer CurrentGames.rwmux.Unlock()
 	if game, ok := CurrentGames.game[in.GameID]; ok == true {
-		return &pb.StonePlayed{CurrentPlayerMove: game.PlayIA(inter.NewNode(in.CurrentPlayerMove)).Convert()}, nil
+		return &pb.StonePlayed{CurrentPlayerMove: game.PlayIA(inter.NewNode(in.CurrentPlayerMove), isHelp).Convert()}, nil
 	}
 	return nil, errors.New("Partie not found")
 }

back/server/pb/buffer.pb.go

@@ -46,7 +46,19 @@ func (s *Server) CDGame(ctx context.Context, in *pb.CDGameRequest) (res *pb.CDGa
 // Played ...
 func (s *Server) Played(ctx context.Context, in *pb.StonePlayed) (res *pb.StonePlayed, err error) {
 	fmt.Println("END +> ", res)
-	res, err = manegeGame.CurrentGames.PlayedIA(in)
+	res, err = manegeGame.CurrentGames.PlayedIA(in, false)
+	select {
+	case <-ctx.Done():
+		return nil, nil
+	default:
+		return res, err
+	}
+}
+
+// Played ...
+func (s *Server) PlayedHelp(ctx context.Context, in *pb.StonePlayed) (res *pb.StonePlayed, err error) {
+	fmt.Println("END +> ", res)
+	res, err = manegeGame.CurrentGames.PlayedIA(in, true)
 	select {
 	case <-ctx.Done():
 		return nil, nil

back/server/server.go

@@ -48,16 +48,16 @@ func (ia *IA) Play(board *board.Board, players player.Players) *inter.Node {
 	createListMoves(&listMoves, ia.ListMoves)
 	if len(ia.SearchZone) != 0 {
 		start := time.Now()
-		_, best = ia.MinMax(*board, listMoves, inter.Node{Player: player.GetOpposentPlayer(ia.playerIndex)}, ia.depth, -100000, 1000000, len(ia.ListMoves), true)
+		_, best = ia.MinMax(*board, listMoves, inter.Node{Player: player.GetOpposentPlayer(ia.PlayerIndex)}, ia.Depth, -100000, 1000000, len(ia.ListMoves), true)
 		t := time.Now()
 		fmt.Println(t.Sub(start))
 	} else {
 		r := rand.New(rand.NewSource(time.Now().UnixNano()))
 		best.X = r.Intn(13) + 3
 		best.Y = r.Intn(13) + 3
-		best.Player = ia.playerIndex
+		best.Player = ia.PlayerIndex
 	}
-	best.Player = ia.playerIndex
+	best.Player = ia.PlayerIndex
 	return &best
 }
 
@@ -72,8 +72,8 @@ func (ia *IA) MinMax(board board.Board, list [sizeListMoves]inter.Node, move int
 		for _, move = range ia.SearchZone {
 			if board[move.X][move.Y] == 0 {
 
-				board[move.X][move.Y] = ia.playerIndex
-				move.Player = ia.playerIndex
+				board[move.X][move.Y] = ia.PlayerIndex
+				move.Player = ia.PlayerIndex
 				list[index] = move
 				score, _ := ia.MinMax(board, list, move, depth-1, alpha, beta, index+1, false)
 				board[move.X][move.Y] = 0
@@ -92,7 +92,7 @@ func (ia *IA) MinMax(board board.Board, list [sizeListMoves]inter.Node, move int
 		}
 	} else {
 		current = math.MaxInt64
-		playerIndex := player.GetOpposentPlayer(ia.playerIndex)
+		playerIndex := player.GetOpposentPlayer(ia.PlayerIndex)
 		for _, move = range ia.SearchZone {
 			if board[move.X][move.Y] == 0 {
 				board[move.X][move.Y] = playerIndex

back/solver/algorithm.go

@@ -32,7 +32,7 @@ func (ia *IA) HeuristicScore(board board.Board, list [sizeListMoves]inter.Node,
 			return 0
 		}
 		switch node.Player {
-		case ia.playerIndex:
+		case ia.PlayerIndex:
 			value += tmp
 		default:
 			value -= tmp
@@ -53,15 +53,15 @@ func (ia *IA) isWin(board board.Board, depth int, move inter.Node) int {
 	if report.Report.PartyFinish == true {
 		if len(report.Report.WinOrLose[0]) == 0 {
 			switch move.Player {
-			case ia.playerIndex:
+			case ia.PlayerIndex:
 				return 10000 + depth
 			default:
 				return -10000 - depth
 			}
 		}
 	} else if ia.playersScore[move.Player-1] == 8 && len(report.Report.ListCapturedStone) != 0 {
 		switch move.Player {
-		case ia.playerIndex:
+		case ia.PlayerIndex:
 			return 10000 + depth
 		default:
 			return -10000 - depth

back/solver/heuristic.go

@@ -32,7 +32,7 @@ type IA struct {
 	reportWin          map[int]rules.Schema
 	reportEval         map[int]rules.Schema
 	playersScore       [2]int
-	playerIndex, depth int
+	PlayerIndex, Depth int
 }
 
 // New ...
@@ -41,7 +41,7 @@ func New(config pb.ConfigRules, playerIndex int) *IA {
 		reportWin:  make(map[int]rules.Schema),
 		reportEval: make(map[int]rules.Schema),
 	}
-	regis.playerIndex = playerIndex
+	regis.PlayerIndex = playerIndex
 	config.IsActiveRuleAlignment = true
 	config.IsActiveRuleBlock = true
 	if config.IsActiveRuleCapture == true {
@@ -52,8 +52,8 @@ func New(config pb.ConfigRules, playerIndex int) *IA {
 		IsActiveRuleWin:     config.IsActiveRuleWin,
 		IsActiveRuleCapture: config.IsActiveRuleCapture,
 	}
-	regis.depth = int(config.DepthIA)
-	regis.playerIndex = int(config.PlayerIndexIA)
+	regis.Depth = int(config.DepthIA)
+	regis.PlayerIndex = int(config.PlayerIndexIA)
 	regis.reportWin[1] = rules.New(1, 2, configWin)
 	regis.reportWin[2] = rules.New(2, 1, configWin)
 	regis.reportEval[1] = rules.New(1, 2, config)