Negamax Not Working For Python Chess Engine

Question

I'm making a very simple Python chess engine using the standard Python chess library with a very simple evaluation function; the sum of the total black piece weights (positive) plus the sum of the total white piece weights (negative). The engine always plays as black.

I used the Negamax Wikipedia page for guidance and the depth is to the fourth ply. I don't expect grandmaster performance, but the engine makes very questionable moves, for example: e2e4 and f1c4 for white causes the engine to freely give up it's pawn via b7b5.

Can anyone help me out? I'm completely lost as to what I did wrong. The negamax (called search) and the evaluation function is shown below:

import chess
import time
import math
from time import sleep
from chessboard import display

scoreMovePair = {}

def colorMap(color):
    if color == True:
        return -1
    return 1

def pieceMap(pieceNum):
    if pieceNum == 1:
        return 1
    elif pieceNum == 2:
        return 3
    elif pieceNum == 3:
        return 3
    elif pieceNum == 4:
        return 5
    elif pieceNum == 5:
        return 9
    return pieceNum

def posEval(board):
    
    score = 0
    
    for i in range(0, 64):
        piece = board.piece_at(i)
        if piece != None:
            score = score + pieceMap(piece.piece_type)*colorMap(piece.color)
    
    return score

def search(board, level, a, b, moveSet, color):

    if level == 4:
        score = posEval(board)
        scoreMovePair[score] = moveSet[0]
        return score*color
    if board.is_checkmate():
        return 1000*colorMap(board.turn)

    value = -10000

    for move in board.legal_moves:
        board.push(move)
        moveSet.append(move)
        value = max(value, -search(board, level + 1, -b, -a, moveSet, -color))
        a = max(a, value)
        moveSet.pop()
        board.pop()
        if (a >= b):
            break
    return value
    

def main():
    global scoreMovepair
    board = chess.Board()
    display.start(board.fen())
    while not display.checkForQuit():
        validMoves = list(board.legal_moves)
        if len(validMoves) == 0:
            break
        else:
            move = input("Enter move: ")
            t0 = time.time()
            move = str(move)
            myMove = chess.Move.from_uci(move)
            if myMove in validMoves:
                board.push_san(move)
                value = search(board, 0, -10000, 10000, [], 1)
                move = scoreMovePair[value]
                print(scoreMovePair)
                print("FINAL -> "+str(value))
                board.push(move)
                print(board.fen())
                display.update(board.fen())
                sleep(1)
                t1 = time.time()
                print(t1-t0)
            else:
                continue
    display.terminate()    

if __name__ == "__main__":
    main()

Answer 1

Just based on a first glance, I would say you may be missing a "quiescence search" (meaning a search for quietness). Also called "captures only search".

https://www.chessprogramming.org/Quiescence_Search

This is a search that is called instead of an evaluation function on your leaf nodes (nodes where max depth is reached). The search makes only capture moves until there are no more captures (with unlimited depth).

In short, without this search, whoever gets the last move in the search (determined by depth) will be able to do anything without consequences. This can lead to some weird results.