@alepot55/chessboardjs 2.3.4 → 2.3.6

package/dist/chessboard.cjs.js

@@ -128,7 +128,6 @@ const ERROR_MESSAGES = Object.freeze({
     invalid_fadeTime: 'Invalid fadeTime: ',
     invalid_fadeAnimation: 'Invalid fadeAnimation: ',
     invalid_ratio: 'Invalid ratio: ',
-    invalid_animationStyle: 'Invalid animationStyle: ',
     animation_failed: 'Animation failed: ',
     
     // Event handlers
@@ -380,7 +379,6 @@ const VALID_VALUES = Object.freeze({
     movableColors: ['w', 'b', 'white', 'black', 'both', 'none'],
     dropOffBoard: ['snapback', 'trash'],
     easingTypes: ['linear', 'ease', 'ease-in', 'ease-out', 'ease-in-out'],
-    animationStyles: ['sequential', 'simultaneous'],
     modes: ['normal', 'creative', 'analysis'],
     promotionPieces: ['q', 'r', 'b', 'n', 'Q', 'R', 'B', 'N']
 });
@@ -709,14 +707,6 @@ class ValidationService {
         return this._validValues.easingTypes.includes(easing);
     }
 
-    /**
-     * Validates animation style
-     * @param {string} style - Animation style to validate
-     * @returns {boolean} True if valid
-     */
-    isValidAnimationStyle(style) {
-        return this._validValues.animationStyles.includes(style);
-    }
 
     /**
      * Validates CSS color format
@@ -913,11 +903,7 @@ class ValidationService {
         if (config.dropOffBoard && !this.isValidDropOffBoard(config.dropOffBoard)) {
             errors.push(ERROR_MESSAGES.invalid_dropOffBoard + config.dropOffBoard);
         }
-        
-        if (config.animationStyle && !this.isValidAnimationStyle(config.animationStyle)) {
-            errors.push(ERROR_MESSAGES.invalid_animationStyle + config.animationStyle);
-        }
-        
+                
         // Validate callbacks
         const callbacks = ['onMove', 'onMoveEnd', 'onChange', 'onDragStart', 'onDragMove', 'onDrop', 'onSnapbackEnd'];
         for (const callback of callbacks) {
@@ -1095,7 +1081,6 @@ const DEFAULT_CONFIG$1 = Object.freeze({
     fadeAnimation: 'ease',
     ratio: 0.9,
     piecesPath: '../assets/themes/default',
-    animationStyle: 'simultaneous',
     simultaneousAnimationDelay: 100,
     onMove: () => true,
     onMoveEnd: () => true,
@@ -1221,7 +1206,6 @@ class ChessboardConfig {
         this.fadeTime = this._setTime(config.fadeTime);
 
         // Animation style properties
-        this.animationStyle = this._validateAnimationStyle(config.animationStyle);
         this.simultaneousAnimationDelay = this._validateDelay(config.simultaneousAnimationDelay);
     }
 
@@ -1282,19 +1266,6 @@ class ChessboardConfig {
         return callback;
     }
 
-    /**
-     * Validates animation style
-     * @private
-     * @param {string} style - Animation style
-     * @returns {string} Validated style
-     * @throws {ConfigurationError} If style is invalid
-     */
-    _validateAnimationStyle(style) {
-        if (!this._validationService.isValidAnimationStyle(style)) {
-            throw new ConfigurationError('Invalid animation style', 'animationStyle', style);
-        }
-        return style;
-    }
 
     /**
      * Validates animation delay
@@ -1432,7 +1403,6 @@ class ChessboardConfig {
             fadeTime: this.fadeTime,
             fadeAnimation: this.fadeAnimation,
             piecesPath: this.piecesPath,
-            animationStyle: this.animationStyle,
             simultaneousAnimationDelay: this.simultaneousAnimationDelay,
             onlyLegalMoves: this.onlyLegalMoves
         };
@@ -1670,6 +1640,8 @@ class Piece {
                 if (callback) callback();
             }
         };
+        // Se l'elemento è già stato rimosso, esci subito
+        if (!this.element) { console.debug(`[Piece] fadeOut: ${this.id} - element is null (init)`); if (callback) callback(); return; }
         fade();
     }
 
@@ -1677,24 +1649,22 @@ class Piece {
         if (!this.element) { console.debug(`[Piece] setDrag: ${this.id} - element is null`); return; }
         this.element.ondragstart = (e) => { e.preventDefault(); };
         this.element.onmousedown = f;
+        this.element.ontouchstart = f; // Drag touch
         console.debug(`[Piece] setDrag: ${this.id}`);
     }
 
     destroy() {
+        if (!this.element) return; // Idempotente: già rimosso
         console.debug(`[Piece] Destroy: ${this.id}`);
         // Remove all event listeners
-        if (this.element) {
-            this.element.onmousedown = null;
-            this.element.ondragstart = null;
-
-            // Remove from DOM
-            if (this.element.parentNode) {
-                this.element.parentNode.removeChild(this.element);
-            }
-
-            // Clear references
-            this.element = null;
+        this.element.onmousedown = null;
+        this.element.ondragstart = null;
+        // Remove from DOM
+        if (this.element.parentNode) {
+            this.element.parentNode.removeChild(this.element);
         }
+        // Clear references
+        this.element = null;
     }
 
     translate(to, duration, transition_f, speed, callback = null) {
@@ -1819,8 +1789,8 @@ class Square {
         // Best practice: destroy the piece object if present
         if (this.piece && typeof this.piece.destroy === 'function') {
             this.piece.destroy();
-            this.piece = null;
         }
+        this.piece = null;
         // Remove any orphaned img.piece elements from the DOM
         const pieceElements = this.element.querySelectorAll('img.piece');
         pieceElements.forEach(element => {
@@ -2314,13 +2284,32 @@ class BoardService {
 
     /**
      * Gets a square by its ID
-     * @param {string} squareId - Square identifier (e.g., 'e4')
+     * @param {string} squareId - Square identifier (API pubblica)
      * @returns {Square|null} The square or null if not found
      */
     getSquare(squareId) {
         return this.squares[squareId] || null;
     }
 
+    /**
+     * Highlight a square (solo oggetto)
+     * @param {Square} square
+     * @param {Object} [opts]
+     */
+    highlightSquare(square, opts = {}) {
+        if (!square) throw new Error('highlightSquare richiede oggetto Square');
+        // ... logica esistente ...
+    }
+    /**
+     * Dehighlight a square (solo oggetto)
+     * @param {Square} square
+     * @param {Object} [opts]
+     */
+    dehighlightSquare(square, opts = {}) {
+        if (!square) throw new Error('dehighlightSquare richiede oggetto Square');
+        // ... logica esistente ...
+    }
+
     /**
      * Gets all squares
      * @returns {Object.<string, Square>} All squares indexed by ID
@@ -3160,24 +3149,77 @@ class EventService {
 
         // Click handler
         const handleClick = (e) => {
+            // Ghost click prevention: ignora il click se appena gestito un touch
+            if (square._ignoreNextClick) {
+                square._ignoreNextClick = false;
+                return;
+            }
             e.stopPropagation();
             if (this.config.clickable && !this.isAnimating) {
                 onSquareClick(square);
             }
         };
 
+        // --- Touch tap/drag separation ---
+        let touchMoved = false;
+        let touchStartX = 0;
+        let touchStartY = 0;
+        let touchTimeout = null;
+
+        const handleTouchStart = (e) => {
+            if (!e.touches || e.touches.length > 1) return; // solo primo dito
+            touchMoved = false;
+            touchStartX = e.touches[0].clientX;
+            touchStartY = e.touches[0].clientY;
+            // Timeout: se il dito non si muove, dopo 150ms sarà considerato tap
+            touchTimeout = setTimeout(() => {
+                if (!touchMoved) {
+                    // Prevenzione ghost click: ignora il prossimo click
+                    square._ignoreNextClick = true;
+                    setTimeout(() => { square._ignoreNextClick = false; }, 400);
+                    handleClick(e); // Tap breve = selezione
+                }
+            }, 150);
+        };
+
+        const handleTouchMove = (e) => {
+            if (!e.touches || e.touches.length > 1) return;
+            const dx = Math.abs(e.touches[0].clientX - touchStartX);
+            const dy = Math.abs(e.touches[0].clientY - touchStartY);
+            if (dx > 5 || dy > 5) {
+                touchMoved = true;
+                if (touchTimeout) {
+                    clearTimeout(touchTimeout);
+                    touchTimeout = null;
+                }
+                // Il drag vero e proprio è gestito da createDragFunction sul pezzo
+            }
+        };
+
+        const handleTouchEnd = (e) => {
+            if (touchTimeout) {
+                clearTimeout(touchTimeout);
+                touchTimeout = null;
+            }
+        };
+
         // Add listeners
         square.element.addEventListener('mouseover', throttledHover);
         square.element.addEventListener('mouseout', throttledLeave);
         square.element.addEventListener('click', handleClick);
-        square.element.addEventListener('touchstart', handleClick);
+        // Touch: separa tap e drag
+        square.element.addEventListener('touchstart', handleTouchStart);
+        square.element.addEventListener('touchmove', handleTouchMove);
+        square.element.addEventListener('touchend', handleTouchEnd);
 
         // Store listeners for cleanup
         listeners.push(
             { element: square.element, type: 'mouseover', handler: throttledHover },
             { element: square.element, type: 'mouseout', handler: throttledLeave },
             { element: square.element, type: 'click', handler: handleClick },
-            { element: square.element, type: 'touchstart', handler: handleClick }
+            { element: square.element, type: 'touchstart', handler: handleTouchStart },
+            { element: square.element, type: 'touchmove', handler: handleTouchMove },
+            { element: square.element, type: 'touchend', handler: handleTouchEnd }
         );
 
         this.eventListeners.set(square.id, listeners);
@@ -3216,14 +3258,24 @@ class EventService {
             }
 
             // Track initial position for drag threshold
+            const isTouch = event.type && event.type.startsWith('touch');
             const startX = event.clientX || (event.touches && event.touches[0]?.clientX) || 0;
             const startY = event.clientY || (event.touches && event.touches[0]?.clientY) || 0;
 
+            // --- Touch scroll lock helper ---
+            const addScrollLock = () => {
+                document.body.classList.add('chessboardjs-dragging');
+            };
+            const removeScrollLock = () => {
+                document.body.classList.remove('chessboardjs-dragging');
+            };
+
+            // --- MOVE HANDLER (mouse + touch unified) ---
             const moveAt = (event) => {
                 const boardElement = this.boardService.element;
                 const squareSize = boardElement.offsetWidth / 8;
 
-                // Get mouse coordinates
+                // Get mouse/touch coordinates
                 let clientX, clientY;
                 if (event.touches && event.touches[0]) {
                     clientX = event.touches[0].clientX;
@@ -3244,15 +3296,28 @@ class EventService {
                 return true;
             };
 
-            const onMouseMove = (event) => {
-                const currentX = event.clientX || 0;
-                const currentY = event.clientY || 0;
+            // --- DRAG MOVE (mouse + touch) ---
+            const onPointerMove = (event) => {
+                // For touch, only handle the first finger
+                if (event.touches && event.touches.length > 1) return;
+                if (event.touches && !event.touches[0]) return;
+                if (event.type && event.type.startsWith('touch')) event.preventDefault();
+
+                const currentX = event.clientX || (event.touches && event.touches[0]?.clientX) || 0;
+                const currentY = event.clientY || (event.touches && event.touches[0]?.clientY) || 0;
                 const deltaX = Math.abs(currentX - startX);
                 const deltaY = Math.abs(currentY - startY);
 
-                // Start dragging if mouse moved enough
+                // Start dragging if mouse/touch moved enough
                 if (!isDragging && (deltaX > 3 || deltaY > 3)) {
                     isDragging = true;
+                    // Inizio drag: blocca update board
+                    if (this.chessboard) this.chessboard._isDragging = true;
+
+                    // Mostra hint all'inizio del drag se attivi
+                    if (this.config.hints && typeof this.chessboard._boundOnPieceHover === 'function') {
+                        this.chessboard._boundOnPieceHover(from);
+                    }
 
                     // Set up drag state
                     if (!this.config.clickable) {
@@ -3265,7 +3330,6 @@ class EventService {
                     // Visual feedback
                     if (this.config.clickable) {
                         from.select();
-                        // Show hints would be handled by the main class
                     }
 
                     // Prepare piece for dragging
@@ -3275,6 +3339,9 @@ class EventService {
 
                     DragOptimizations.enableForDrag(img);
 
+                    // Lock scroll for touch
+                    if (isTouch) addScrollLock();
+
                     // Call drag start callback
                     if (!onDragStart(square, piece)) {
                         return;
@@ -3288,8 +3355,16 @@ class EventService {
                 // Update target square
                 const boardElement = this.boardService.element;
                 const boardRect = boardElement.getBoundingClientRect();
-                const x = event.clientX - boardRect.left;
-                const y = event.clientY - boardRect.top;
+                let clientX, clientY;
+                if (event.touches && event.touches[0]) {
+                    clientX = event.touches[0].clientX;
+                    clientY = event.touches[0].clientY;
+                } else {
+                    clientX = event.clientX;
+                    clientY = event.clientY;
+                }
+                const x = clientX - boardRect.left;
+                const y = clientY - boardRect.top;
 
                 let newTo = null;
                 if (x >= 0 && x <= boardRect.width && y >= 0 && y <= boardRect.height) {
@@ -3308,18 +3383,26 @@ class EventService {
                 }
             };
 
-            const onMouseUp = () => {
-                // Clean up visual feedback
+            // --- DRAG END (mouse + touch) ---
+            const onPointerUp = (event) => {
                 previousHighlight?.dehighlight();
-                document.removeEventListener('mousemove', onMouseMove);
-                window.removeEventListener('mouseup', onMouseUp);
+                document.removeEventListener('mousemove', onPointerMove);
+                window.removeEventListener('mouseup', onPointerUp);
+                document.removeEventListener('touchmove', onPointerMove);
+                window.removeEventListener('touchend', onPointerUp);
+                if (isTouch) removeScrollLock();
+                // Fine drag: sblocca update board
+                if (this.chessboard) this.chessboard._isDragging = false;
+
+                // Rimuovi hint alla fine del drag se attivi
+                if (this.config.hints && typeof this.chessboard._boundOnPieceLeave === 'function') {
+                    this.chessboard._boundOnPieceLeave(from);
+                }
 
-                // If this was just a click, don't interfere
                 if (!isDragging) {
                     return;
                 }
 
-                // Clean up drag state
                 img.style.zIndex = '20';
                 img.classList.remove('dragging');
                 img.style.willChange = 'auto';
@@ -3331,23 +3414,26 @@ class EventService {
                 if (isTrashDrop) {
                     this._handleTrashDrop(originalFrom, onRemove);
                 } else if (!to) {
-                    // Reset piece position instantly for snapback
                     img.style.position = '';
                     img.style.left = '';
                     img.style.top = '';
                     img.style.transform = '';
-
                     this._handleSnapback(originalFrom, piece, onSnapback);
                 } else {
-                    // Handle drop like a click - simple and reliable
                     this._handleDrop(originalFrom, to, piece, onMove, onSnapback);
                 }
             };
 
-            // Attach event listeners
-            window.addEventListener('mouseup', onMouseUp, { once: true });
-            document.addEventListener('mousemove', onMouseMove);
-            img.addEventListener('mouseup', onMouseUp, { once: true });
+            // --- Attach listeners (mouse + touch) ---
+            window.addEventListener('mouseup', onPointerUp, { once: true });
+            document.addEventListener('mousemove', onPointerMove);
+            img.addEventListener('mouseup', onPointerUp, { once: true });
+            // Touch events
+            window.addEventListener('touchend', onPointerUp, { once: true });
+            document.addEventListener('touchmove', onPointerMove, { passive: false });
+
+            // Per robustezza: se il drag parte da touch, blocca subito lo scroll
+            if (isTouch) addScrollLock();
         };
     }
 
@@ -3570,6 +3656,7 @@ class EventService {
         if (!from) {
             if (this.moveService.canMove(square)) {
                 if (this.config.clickable) {
+                    this.boardService.applyToAllSquares('removeHint'); // Rimuovi hint prima di selezionare
                     onSelect(square);
                 }
                 this.clicked = square;
@@ -3579,9 +3666,13 @@ class EventService {
             }
         }
 
-        // Clicking same square - deselect
+        // --- Touch: non deselezionare su doppio tap sulla stessa casella ---
         if (this.clicked === square) {
+            if (window.event && window.event.type && window.event.type.startsWith('touch')) {
+                return false;
+            }
             onDeselect(square);
+            this.boardService.applyToAllSquares('removeHint');
             this.clicked = null;
             return false;
         }
@@ -3590,68 +3681,52 @@ class EventService {
         if (!promotion && this.moveService.requiresPromotion(new Move$1(from, square))) {
             console.log('Move requires promotion:', from.id, '->', square.id);
 
-            // Set up promotion UI
             this.moveService.setupPromotion(
                 new Move$1(from, square),
                 this.boardService.squares,
                 (selectedPromotion) => {
                     console.log('Promotion selected:', selectedPromotion);
-
-                    // Clear promotion UI first
                     this.boardService.applyToAllSquares('removePromotion');
                     this.boardService.applyToAllSquares('removeCover');
-
-                    // Execute the move with promotion
                     const moveResult = onMove(from, square, selectedPromotion, animate);
-
                     if (moveResult) {
-                        // After a successful promotion move, we need to replace the piece
-                        // after the drop animation completes
                         this._schedulePromotionPieceReplacement(square, selectedPromotion);
-
                         onDeselect(from);
+                        this.boardService.applyToAllSquares('removeHint');
                         this.clicked = null;
                     }
                 },
                 () => {
                     console.log('Promotion cancelled');
-
-                    // Clear promotion UI on cancel
                     this.boardService.applyToAllSquares('removePromotion');
                     this.boardService.applyToAllSquares('removeCover');
-
                     onDeselect(from);
+                    this.boardService.applyToAllSquares('removeHint');
                     this.clicked = null;
                 }
             );
             return false;
         }
 
-        // Attempt to make move
         const moveResult = onMove(from, square, promotion, animate);
 
         if (moveResult) {
-            // Move successful
             onDeselect(from);
+            this.boardService.applyToAllSquares('removeHint');
             this.clicked = null;
             return true;
         } else {
-            // Move failed - check if clicked square has a piece we can move
             if (this.moveService.canMove(square)) {
-                // Deselect the previous piece
                 onDeselect(from);
-
-                // Select the new piece if clicking is enabled
+                this.boardService.applyToAllSquares('removeHint');
                 if (this.config.clickable) {
                     onSelect(square);
                 }
-
-                // Set the new piece as clicked
                 this.clicked = square;
                 return false;
             } else {
-                // Move failed and no valid piece to select
                 onDeselect(from);
+                this.boardService.applyToAllSquares('removeHint');
                 this.clicked = null;
                 return false;
             }
@@ -3915,27 +3990,27 @@ class MoveService {
      */
     canMove(square) {
         if (!square.piece) return false;
-        
+
         const { movableColors, onlyLegalMoves } = this.config;
-        
+
         if (movableColors === 'none') return false;
         if (movableColors === 'w' && square.piece.color === 'b') return false;
         if (movableColors === 'b' && square.piece.color === 'w') return false;
-        
+
         if (!onlyLegalMoves) return true;
-        
+
         // Check if position service and game are available
         if (!this.positionService || !this.positionService.getGame()) {
             return false;
         }
-        
+
         const game = this.positionService.getGame();
         return square.piece.color === game.turn();
     }
 
     /**
      * Converts various move formats to a Move instance
-     * @param {string|Move} move - Move in various formats
+     * @param {string|Move|Object} move - Move in various formats
      * @param {Object} squares - All board squares
      * @returns {Move} Move instance
      * @throws {MoveError} When move format is invalid
@@ -3944,19 +4019,22 @@ class MoveService {
         if (move instanceof Move$1) {
             return move;
         }
-        
+        if (typeof move === 'object' && move.from && move.to) {
+            // Se sono id, converto in oggetti; se sono già oggetti, li uso direttamente
+            const fromSquare = typeof move.from === 'string' ? squares[move.from] : move.from;
+            const toSquare = typeof move.to === 'string' ? squares[move.to] : move.to;
+            if (!fromSquare || !toSquare) throw new MoveError(ERROR_MESSAGES.invalid_move_format, move.from, move.to);
+            return new Move$1(fromSquare, toSquare, move.promotion);
+        }
         if (typeof move === 'string' && move.length >= 4) {
             const fromId = move.slice(0, 2);
             const toId = move.slice(2, 4);
             const promotion = move.slice(4, 5) || null;
-            
             if (!squares[fromId] || !squares[toId]) {
                 throw new MoveError(ERROR_MESSAGES.invalid_move_format, fromId, toId);
             }
-            
             return new Move$1(squares[fromId], squares[toId], promotion);
         }
-        
         throw new MoveError(ERROR_MESSAGES.invalid_move_format, 'unknown', 'unknown');
     }
 
@@ -3967,9 +4045,9 @@ class MoveService {
      */
     isLegalMove(move) {
         const legalMoves = this.getLegalMoves(move.from.id);
-        
-        return legalMoves.some(legalMove => 
-            legalMove.to === move.to.id && 
+
+        return legalMoves.some(legalMove =>
+            legalMove.to === move.to.id &&
             move.promotion === legalMove.promotion
         );
     }
@@ -3985,16 +4063,16 @@ class MoveService {
         if (!this.positionService || !this.positionService.getGame()) {
             return [];
         }
-        
+
         const game = this.positionService.getGame();
-        
+
         if (!game) return [];
-        
+
         const options = { verbose };
         if (from) {
             options.square = from;
         }
-        
+
         return game.moves(options);
     }
 
@@ -4008,115 +4086,99 @@ class MoveService {
         if (!this.positionService || !this.positionService.getGame()) {
             return [];
         }
-        
+
         const game = this.positionService.getGame();
         if (!game) return [];
-        
+
         const cacheKey = `${square.id}-${game.fen()}`;
         let moves = this._movesCache.get(cacheKey);
-        
+
         if (!moves) {
             moves = game.moves({ square: square.id, verbose: true });
             this._movesCache.set(cacheKey, moves);
-            
+
             // Clear cache after a short delay to prevent memory buildup
             if (this._cacheTimeout) {
                 clearTimeout(this._cacheTimeout);
             }
-            
+
             this._cacheTimeout = setTimeout(() => {
                 this._movesCache.clear();
             }, 1000);
         }
-        
+
         return moves;
     }
 
     /**
      * Executes a move on the game
-     * @param {Move} move - Move to execute
+     * @param {Move} move - Move to execute (deve essere oggetto Move)
      * @returns {Object|null} Move result from chess.js or null if invalid
      */
     executeMove(move) {
-        // Check if position service and game are available
+        if (!(move instanceof Move$1)) throw new Error('executeMove richiede un oggetto Move');
         if (!this.positionService || !this.positionService.getGame()) {
             return null;
         }
-        
         const game = this.positionService.getGame();
         if (!game) return null;
-        
         const moveOptions = {
             from: move.from.id,
             to: move.to.id
         };
-        
-        console.log('executeMove - move.promotion:', move.promotion);
-        console.log('executeMove - move.hasPromotion():', move.hasPromotion());
-        
         if (move.hasPromotion()) {
             moveOptions.promotion = move.promotion;
         }
-        
-        console.log('executeMove - moveOptions:', moveOptions);
-        
         const result = game.move(moveOptions);
-        console.log('executeMove - result:', result);
-        
-        // Check what's actually on the board after the move
-        if (result) {
-            const pieceOnDestination = game.get(move.to.id);
-            console.log('executeMove - piece on destination after move:', pieceOnDestination);
-        }
-        
         return result;
     }
 
     /**
-     * Checks if a move requires promotion
-     * @param {Move} move - Move to check
-     * @returns {boolean} True if promotion is required
+     * Determina se una mossa richiede promozione
+     * @param {Move} move - Deve essere oggetto Move
+     * @returns {boolean}
      */
     requiresPromotion(move) {
+        if (!(move instanceof Move$1)) throw new Error('requiresPromotion richiede un oggetto Move');
         console.log('Checking if move requires promotion:', move.from.id, '->', move.to.id);
-        
+
         if (!this.config.onlyLegalMoves) {
             console.log('Not in legal moves mode, no promotion required');
             return false;
         }
-        
+
         const game = this.positionService.getGame();
         if (!game) {
             console.log('No game instance available');
             return false;
         }
-        
+
         const piece = game.get(move.from.id);
         if (!piece || piece.type !== 'p') {
             console.log('Not a pawn move, no promotion required');
             return false;
         }
-        
+
         const targetRank = move.to.row;
         if (targetRank !== 1 && targetRank !== 8) {
             console.log('Not reaching promotion rank, no promotion required');
             return false;
         }
-        
+
         console.log('Pawn reaching promotion rank, validating move...');
-        
+
         // Additional validation: check if the pawn can actually reach this square
         if (!this._isPawnMoveValid(move.from, move.to, piece.color)) {
             console.log('Pawn move not valid, no promotion required');
             return false;
         }
-        
+
         // First check if the move is legal without promotion
         const simpleMoveObj = {
             from: move.from.id,
             to: move.to.id
         };
-        
+
         try {
             console.log('Testing move without promotion:', simpleMoveObj);
             // Test if the move is legal without promotion first
@@ -4124,25 +4186,25 @@ class MoveService {
             if (testMove) {
                 // Move was successful, but check if it was a promotion
                 const wasPromotion = testMove.promotion;
-                
+
                 // Undo the test move
                 game.undo();
-                
+
                 console.log('Move successful without promotion, was promotion:', wasPromotion !== undefined);
-                
+
                 // If it was a promotion, return true
                 return wasPromotion !== undefined;
             }
         } catch (error) {
             console.log('Move failed without promotion, trying with promotion:', error.message);
-            
+
             // If simple move fails, try with promotion
             const promotionMoveObj = {
                 from: move.from.id,
                 to: move.to.id,
                 promotion: 'q' // test with queen
             };
-            
+
             try {
                 console.log('Testing move with promotion:', promotionMoveObj);
                 const testMove = game.move(promotionMoveObj);
@@ -4158,7 +4220,7 @@ class MoveService {
                 return false;
             }
         }
-        
+
         console.log('Move validation complete, no promotion required');
         return false;
     }
@@ -4176,27 +4238,27 @@ class MoveService {
         const toRank = to.row;
         const fromFile = from.col;
         const toFile = to.col;
-        
+
         console.log(`Validating pawn move: ${from.id} -> ${to.id} (${color})`);
         console.log(`Ranks: ${fromRank} -> ${toRank}, Files: ${fromFile} -> ${toFile}`);
-        
+
         // Direction of pawn movement
         const direction = color === 'w' ? 1 : -1;
         const rankDiff = toRank - fromRank;
         const fileDiff = Math.abs(toFile - fromFile);
-        
+
         // Pawn can only move forward
         if (rankDiff * direction <= 0) {
             console.log('Invalid: Pawn cannot move backward or stay in place');
             return false;
         }
-        
+
         // Pawn can only move 1 rank at a time (except for double move from starting position)
         if (Math.abs(rankDiff) > 2) {
             console.log('Invalid: Pawn cannot move more than 2 ranks');
             return false;
         }
-        
+
         // If moving 2 ranks, must be from starting position
         if (Math.abs(rankDiff) === 2) {
             const startingRank = color === 'w' ? 2 : 7;
@@ -4205,13 +4267,13 @@ class MoveService {
                 return false;
             }
         }
-        
+
         // Pawn can only move to adjacent files (diagonal capture) or same file (forward move)
         if (fileDiff > 1) {
             console.log('Invalid: Pawn cannot move more than 1 file');
             return false;
         }
-        
+
         console.log('Pawn move validation passed');
         return true;
     }
@@ -4226,45 +4288,45 @@ class MoveService {
      */
     setupPromotion(move, squares, onPromotionSelect, onPromotionCancel) {
         if (!this.requiresPromotion(move)) return false;
-        
+
         // Check if position service and game are available
         if (!this.positionService || !this.positionService.getGame()) {
             return false;
         }
-        
+
         const game = this.positionService.getGame();
         const piece = game.get(move.from.id);
         const targetSquare = move.to;
-        
+
         // Clear any existing promotion UI
         Object.values(squares).forEach(square => {
             square.removePromotion();
             square.removeCover();
         });
-        
+
         // Always show promotion choices in a column
         this._showPromotionInColumn(targetSquare, piece, squares, onPromotionSelect, onPromotionCancel);
-        
+
         return true;
     }
-    
+
     /**
      * Shows promotion choices in a column
      * @private
      */
     _showPromotionInColumn(targetSquare, piece, squares, onPromotionSelect, onPromotionCancel) {
         console.log('Setting up promotion for', targetSquare.id, 'piece color:', piece.color);
-        
+
         // Set up promotion choices starting from border row
         PROMOTION_PIECES.forEach((pieceType, index) => {
             const choiceSquare = this._findPromotionSquare(targetSquare, index, squares);
-            
+
             if (choiceSquare) {
                 const pieceId = pieceType + piece.color;
                 const piecePath = this._getPiecePathForPromotion(pieceId);
-                
+
                 console.log('Setting up promotion choice:', pieceType, 'on square:', choiceSquare.id);
-                
+
                 choiceSquare.putPromotion(piecePath, () => {
                     console.log('Promotion choice selected:', pieceType);
                     onPromotionSelect(pieceType);
@@ -4273,7 +4335,7 @@ class MoveService {
                 console.log('Could not find square for promotion choice:', pieceType, 'index:', index);
             }
         });
-        
+
         // Set up cover squares (for cancellation)
         Object.values(squares).forEach(square => {
             if (!square.hasPromotion()) {
@@ -4282,7 +4344,7 @@ class MoveService {
                 });
             }
         });
-        
+
         return true;
     }
 
@@ -4297,9 +4359,9 @@ class MoveService {
     _findPromotionSquare(targetSquare, index, squares) {
         const col = targetSquare.col;
         const baseRow = targetSquare.row;
-        
+
         console.log('Looking for promotion square - target:', targetSquare.id, 'index:', index, 'col:', col, 'baseRow:', baseRow);
-        
+
         // Calculate row based on index and promotion direction
         // Start from the border row (1 or 8) and go inward
         let row;
@@ -4313,15 +4375,15 @@ class MoveService {
             console.log('Invalid promotion row:', baseRow);
             return null;
         }
-        
+
         console.log('Calculated row:', row);
-        
+
         // Ensure row is within bounds
         if (row < 1 || row > 8) {
             console.log('Row out of bounds:', row);
             return null;
         }
-        
+
         // Find square by row/col
         for (const square of Object.values(squares)) {
             if (square.col === col && square.row === row) {
@@ -4329,7 +4391,7 @@ class MoveService {
                 return square;
             }
         }
-        
+
         console.log('No square found for col:', col, 'row:', row);
         return null;
     }
@@ -4344,11 +4406,11 @@ class MoveService {
         // This would typically use the PieceService
         // For now, we'll use a simple implementation
         const { piecesPath } = this.config;
-        
+
         if (typeof piecesPath === 'string') {
             return `${piecesPath}/${pieceId}.svg`;
         }
-        
+
         // Fallback for other path types
         return `assets/pieces/${pieceId}.svg`;
     }
@@ -4362,20 +4424,20 @@ class MoveService {
         if (typeof moveString !== 'string' || moveString.length < 4 || moveString.length > 5) {
             return null;
         }
-        
+
         const from = moveString.slice(0, 2);
         const to = moveString.slice(2, 4);
         const promotion = moveString.slice(4, 5);
-        
+
         // Basic validation
         if (!/^[a-h][1-8]$/.test(from) || !/^[a-h][1-8]$/.test(to)) {
             return null;
         }
-        
+
         if (promotion && !['q', 'r', 'b', 'n'].includes(promotion.toLowerCase())) {
             return null;
         }
-        
+
         return {
             from: from,
             to: to,
@@ -4401,10 +4463,10 @@ class MoveService {
         if (!this.isCastle(gameMove)) {
             return null;
         }
-        
+
         const isKingSide = gameMove.isKingsideCastle();
         const isWhite = gameMove.color === 'w';
-        
+
         if (isKingSide) {
             // King side castle
             if (isWhite) {
@@ -4440,11 +4502,11 @@ class MoveService {
         if (!this.isEnPassant(gameMove)) {
             return null;
         }
-        
+
         const toSquare = gameMove.to;
         const rank = parseInt(toSquare[1]);
         const file = toSquare[0];
-        
+
         // The captured pawn is on the same file but different rank
         if (gameMove.color === 'w') {
             // White captures black pawn one rank below
@@ -4552,19 +4614,26 @@ class PieceService {
 
     /**
      * Adds a piece to a square with optional fade-in animation
-     * @param {Square} square - Target square
-     * @param {Piece} piece - Piece to add
+     * @param {Square} square - Target square (oggetto)
+     * @param {Piece} piece - Piece to add (oggetto)
      * @param {boolean} [fade=true] - Whether to fade in the piece
      * @param {Function} dragFunction - Function to handle drag events
      * @param {Function} [callback] - Callback when animation completes
      */
     addPieceOnSquare(square, piece, fade = true, dragFunction, callback) {
+        if (!square || !piece) throw new Error('addPieceOnSquare richiede oggetti Square e Piece');
         console.debug(`[PieceService] addPieceOnSquare: ${piece.id} to ${square.id}`);
         square.putPiece(piece);
 
+        // Imposta sempre il drag (touch e mouse)
         if (dragFunction) {
             piece.setDrag(dragFunction(square, piece));
         }
+        // Forza il drag touch se manca (debug/robustezza)
+        if (!piece.element.ontouchstart) {
+            piece.element.ontouchstart = dragFunction ? dragFunction(square, piece) : () => { };
+            console.debug(`[PieceService] Forzato ontouchstart su ${piece.id}`);
+        }
 
         if (fade && this.config.fadeTime > 0) {
             piece.fadeIn(
@@ -4581,14 +4650,14 @@ class PieceService {
     }
 
     /**
-     * Removes a piece from a square with optional fade-out animation
-     * @param {Square} square - Source square
-     * @param {boolean} [fade=true] - Whether to fade out the piece
-     * @param {Function} [callback] - Callback when animation completes
-     * @returns {Piece} The removed piece
-     * @throws {PieceError} When square has no piece to remove
+     * Rimuove un pezzo da una casella
+     * @param {Square} square - Oggetto Square
+     * @param {boolean} [fade=true]
+     * @param {Function} [callback]
+     * @returns {Piece} Il pezzo rimosso
      */
     removePieceFromSquare(square, fade = true, callback) {
+        if (!square) throw new Error('removePieceFromSquare richiede oggetto Square');
         console.debug(`[PieceService] removePieceFromSquare: ${square.id}`);
         square.check();
 
@@ -4622,8 +4691,8 @@ class PieceService {
      */
     movePiece(piece, targetSquare, duration, callback) {
         console.debug(`[PieceService] movePiece: ${piece.id} to ${targetSquare.id}`);
-        if (!piece) {
-            console.warn('PieceService.movePiece: piece is null, skipping animation');
+        if (!piece || !piece.element) {
+            console.warn(`[PieceService] movePiece: piece or element is null, skipping animation`);
             if (callback) callback();
             return;
         }
@@ -4679,7 +4748,7 @@ class PieceService {
         };
 
         // Check if piece is currently being dragged
-        const isDragging = move.piece.element.classList.contains('dragging');
+        const isDragging = move.piece.element && move.piece.element.classList.contains('dragging');
 
         if (isDragging) {
             // If piece is being dragged, don't animate - just move it immediately
@@ -7404,7 +7473,7 @@ let Chessboard$1 = class Chessboard {
                 const capturedPiece = move.to.piece;
 
                 // For castle moves in simultaneous mode, we need to coordinate both animations
-                if (isCastleMove && this.config.animationStyle === 'simultaneous') {
+                if (isCastleMove) {
                     // Start king animation
                     this.pieceService.translatePiece(
                         move,
@@ -7629,187 +7698,62 @@ let Chessboard$1 = class Chessboard {
     }
 
     /**
-     * Performs the actual board update
+     * Aggiorna i pezzi sulla scacchiera con animazione e delay configurabile (greedy matching)
      * @private
-     * @param {boolean} [animation=false] - Whether to animate
-     * @param {boolean} [isPositionLoad=false] - Whether this is a position load (affects delay)
+     * @param {boolean} [animation=false] - Se animare
+     * @param {boolean} [isPositionLoad=false] - Se è un caricamento posizione (delay 0)
      */
     _doUpdateBoardPieces(animation = false, isPositionLoad = false) {
-        // Skip update if we're in the middle of a promotion
-        if (this._isPromoting) {
-            console.log('Skipping board update during promotion');
-            return;
-        }
-
-        // Check if services are available
-        if (!this.positionService || !this.positionService.getGame()) {
-            console.log('Cannot update board pieces - position service not available');
-            return;
-        }
-
+        if (this._isDragging) return;
+        if (this._isPromoting) return;
+        if (!this.positionService || !this.positionService.getGame()) return;
         const squares = this.boardService.getAllSquares();
         const gameStateBefore = this.positionService.getGame().fen();
-
-        // PATCH ROBUSTA: se la board è completamente vuota, forza la rimozione di TUTTI i pezzi
         if (/^8\/8\/8\/8\/8\/8\/8\/8/.test(gameStateBefore)) {
-            console.log('Board vuota rilevata - rimozione forzata di tutti i pezzi dal DOM');
-
-            // 1. Rimuovi tutti gli elementi DOM dei pezzi dal contenitore della board
             const boardContainer = document.getElementById(this.config.id_div);
             if (boardContainer) {
                 const pieceElements = boardContainer.querySelectorAll('.piece');
-                pieceElements.forEach(element => {
-                    console.log('Rimozione forzata elemento DOM pezzo:', element);
-                    element.remove();
-                });
+                pieceElements.forEach(element => element.remove());
             }
-
-            // 2. Azzera tutti i riferimenti JS ai pezzi
-            Object.values(squares).forEach(sq => {
-                if (sq && sq.piece) {
-                    console.log('Azzero riferimento pezzo su casella:', sq.id);
-                    sq.piece = null;
-                }
-            });
-
-            // 3. Forza la pulizia di eventuali selezioni/hint
+            Object.values(squares).forEach(sq => { if (sq && sq.piece) sq.piece = null; });
             this._clearVisualState();
-
-            // 4. Aggiungi i listener e notifica il cambio
             this._addListeners();
             if (this.config.onChange) this.config.onChange(gameStateBefore);
-
-            console.log('Rimozione forzata completata');
             return;
         }
 
-        console.log('_doUpdateBoardPieces - current FEN:', gameStateBefore);
-        console.log('_doUpdateBoardPieces - animation:', animation, 'style:', this.config.animationStyle, 'isPositionLoad:', isPositionLoad);
-
-        // Determine which animation style to use
-        const useSimultaneous = this.config.animationStyle === 'simultaneous';
-        console.log('_doUpdateBoardPieces - useSimultaneous:', useSimultaneous);
-
-        if (useSimultaneous) {
-            console.log('Using simultaneous animation');
-            this._doSimultaneousUpdate(squares, gameStateBefore, isPositionLoad);
-        } else {
-            console.log('Using sequential animation');
-            this._doSequentialUpdate(squares, gameStateBefore, animation);
-        }
-    }
-
-    /**
-     * Performs sequential piece updates (original behavior)
-     * @private
-     * @param {Object} squares - All squares
-     * @param {string} gameStateBefore - Game state before update
-     * @param {boolean} animation - Whether to animate
-     */
-    _doSequentialUpdate(squares, gameStateBefore, animation) {
-        // Mappa: squareId -> expectedPieceId
-        const expectedMap = {};
-        Object.values(squares).forEach(square => {
-            expectedMap[square.id] = this.positionService.getGamePieceId(square.id);
-        });
-
-        Object.values(squares).forEach(square => {
-            const expectedPieceId = expectedMap[square.id];
-            const currentPiece = square.piece;
-            const currentPieceId = currentPiece ? currentPiece.getId() : null;
-
-            // Se il pezzo attuale e quello atteso sono identici, non fare nulla
-            if (currentPieceId === expectedPieceId) {
-                return;
-            }
-
-            // Se c'è un pezzo attuale ma non è quello atteso, rimuovilo
-            if (currentPiece && currentPieceId !== expectedPieceId) {
-                this.pieceService.removePieceFromSquare(square, animation);
-            }
-
-            // Se c'è un pezzo atteso ma non è quello attuale, aggiungilo
-            if (expectedPieceId && currentPieceId !== expectedPieceId) {
-                const newPiece = this.pieceService.convertPiece(expectedPieceId);
-                this.pieceService.addPieceOnSquare(
-                    square,
-                    newPiece,
-                    animation,
-                    this._createDragFunction.bind(this)
-                );
-            }
-        });
-
-        this._addListeners();
-        const gameStateAfter = this.positionService.getGame().fen();
-        if (gameStateBefore !== gameStateAfter) {
-            this.config.onChange(gameStateAfter);
-        }
-    }
-
-    /**
-     * Performs simultaneous piece updates
-     * @private
-     * @param {Object} squares - All squares
-     * @param {string} gameStateBefore - Game state before update
-     * @param {boolean} [isPositionLoad=false] - Whether this is a position load
-     */
-    _doSimultaneousUpdate(squares, gameStateBefore, isPositionLoad = false) {
-        // Matching greedy per distanza minima, robusto
+        // --- Matching greedy tra attuale e atteso ---
         const currentMap = {};
         const expectedMap = {};
-
         Object.values(squares).forEach(square => {
             const currentPiece = square.piece;
             const expectedPieceId = this.positionService.getGamePieceId(square.id);
             if (currentPiece) {
-                // Normalizza la chiave come 'color+type' lowercase
                 const key = (currentPiece.color + currentPiece.type).toLowerCase();
                 if (!currentMap[key]) currentMap[key] = [];
-                currentMap[key].push({ square, id: square.id });
+                currentMap[key].push({ square, id: square.id, piece: currentPiece });
             }
             if (expectedPieceId) {
-                // Normalizza la chiave come 'color+type' lowercase
                 const key = expectedPieceId.toLowerCase();
                 if (!expectedMap[key]) expectedMap[key] = [];
                 expectedMap[key].push({ square, id: square.id });
             }
         });
-
-        let animationsCompleted = 0;
+        const animationDelay = isPositionLoad ? 0 : this.config.simultaneousAnimationDelay || 0;
         let totalAnimations = 0;
-        const animationDelay = isPositionLoad ? 0 : this.config.simultaneousAnimationDelay;
-        let animationIndex = 0;
-
-        Object.keys(expectedMap).forEach(key => {
-            totalAnimations += Math.max((currentMap[key] || []).length, expectedMap[key].length);
-        });
-
-        if (totalAnimations === 0) {
-            this._addListeners();
-            const gameStateAfter = this.positionService.getGame().fen();
-            if (gameStateBefore !== gameStateAfter) {
-                this.config.onChange(gameStateAfter);
-            }
-            return;
-        }
-
-        const onAnimationComplete = () => {
-            animationsCompleted++;
-            if (animationsCompleted === totalAnimations) {
-                this._addListeners();
-                const gameStateAfter = this.positionService.getGame().fen();
-                if (gameStateBefore !== gameStateAfter) {
-                    this.config.onChange(gameStateAfter);
-                }
-            }
-        };
+        let animationsCompleted = 0;
 
+        // 1. Matching greedy: trova i movimenti
+        const moves = [];
+        const fromMatched = {};
+        const toMatched = {};
+        const unchanged = [];
         Object.keys(expectedMap).forEach(key => {
             const fromList = (currentMap[key] || []).slice();
             const toList = expectedMap[key].slice();
-
-            // 1. Costruisci matrice delle distanze
+            const localFromMatched = new Array(fromList.length).fill(false);
+            const localToMatched = new Array(toList.length).fill(false);
+            // Matrice delle distanze
             const distances = [];
             for (let i = 0; i < fromList.length; i++) {
                 distances[i] = [];
@@ -7818,18 +7762,12 @@ let Chessboard$1 = class Chessboard {
                         Math.abs(fromList[i].square.col - toList[j].square.col);
                 }
             }
-
-            // 2. Matching greedy: abbina i più vicini
-            const fromMatched = new Array(fromList.length).fill(false);
-            const toMatched = new Array(toList.length).fill(false);
-            const moves = [];
-
             while (true) {
                 let minDist = Infinity, minI = -1, minJ = -1;
                 for (let i = 0; i < fromList.length; i++) {
-                    if (fromMatched[i]) continue;
+                    if (localFromMatched[i]) continue;
                     for (let j = 0; j < toList.length; j++) {
-                        if (toMatched[j]) continue;
+                        if (localToMatched[j]) continue;
                         if (distances[i][j] < minDist) {
                             minDist = distances[i][j];
                             minI = i;
@@ -7838,58 +7776,111 @@ let Chessboard$1 = class Chessboard {
                     }
                 }
                 if (minI === -1 || minJ === -1) break;
-                // Se la posizione è la stessa, non fare nulla (pezzo unchanged)
-                if (fromList[minI].square === toList[minJ].square) {
-                    fromMatched[minI] = true;
-                    toMatched[minJ] = true;
+                // Se la posizione è la stessa E il Piece è lo stesso oggetto, non fare nulla (pezzo unchanged)
+                if (fromList[minI].square === toList[minJ].square && squares[toList[minJ].square.id].piece === fromList[minI].piece) {
+                    unchanged.push({ square: fromList[minI].square, piece: fromList[minI].piece });
+                    localFromMatched[minI] = true;
+                    localToMatched[minJ] = true;
+                    fromMatched[fromList[minI].square.id] = true;
+                    toMatched[toList[minJ].square.id] = true;
                     continue;
                 }
                 // Altrimenti, sposta il pezzo
-                moves.push({ from: fromList[minI].square, to: toList[minJ].square, piece: fromList[minI].square.piece });
-                fromMatched[minI] = true;
-                toMatched[minJ] = true;
+                moves.push({ from: fromList[minI].square, to: toList[minJ].square, piece: fromList[minI].piece });
+                localFromMatched[minI] = true;
+                localToMatched[minJ] = true;
+                fromMatched[fromList[minI].square.id] = true;
+                toMatched[toList[minJ].square.id] = true;
             }
+        });
 
-            // 3. Rimuovi i pezzi non abbinati (presenti solo in fromList)
-            for (let i = 0; i < fromList.length; i++) {
-                if (!fromMatched[i]) {
-                    setTimeout(() => {
-                        this.pieceService.removePieceFromSquare(fromList[i].square, true, onAnimationComplete);
-                    }, animationIndex * animationDelay);
-                    animationIndex++;
+        // 2. Rimozione: pezzi presenti solo in attuale (non matched)
+        const removes = [];
+        Object.keys(currentMap).forEach(key => {
+            currentMap[key].forEach(({ square, piece }) => {
+                if (!fromMatched[square.id]) {
+                    removes.push({ square, piece });
                 }
+            });
+        });
+
+        // 3. Aggiunta: pezzi presenti solo in atteso (non matched)
+        const adds = [];
+        Object.keys(expectedMap).forEach(key => {
+            expectedMap[key].forEach(({ square, id }) => {
+                if (!toMatched[square.id]) {
+                    adds.push({ square, pieceId: key });
+                }
+            });
+        });
+
+        totalAnimations = moves.length + removes.length + adds.length;
+        if (totalAnimations === 0) {
+            this._addListeners();
+            const gameStateAfter = this.positionService.getGame().fen();
+            if (gameStateBefore !== gameStateAfter) {
+                this.config.onChange(gameStateAfter);
             }
+            return;
+        }
 
-            // 4. Aggiungi i pezzi non abbinati (presenti solo in toList)
-            for (let j = 0; j < toList.length; j++) {
-                if (!toMatched[j]) {
-                    setTimeout(() => {
-                        const newPiece = this.pieceService.convertPiece(key);
-                        this.pieceService.addPieceOnSquare(
-                            toList[j].square,
-                            newPiece,
-                            true,
-                            this._createDragFunction.bind(this),
-                            onAnimationComplete
-                        );
-                    }, animationIndex * animationDelay);
-                    animationIndex++;
+        // Debug: logga i pezzi unchanged
+        if (unchanged.length > 0) {
+            console.debug('[Chessboard] Unchanged pieces:', unchanged.map(u => u.piece.id + '@' + u.square.id));
+        }
+
+        const onAnimationComplete = () => {
+            animationsCompleted++;
+            if (animationsCompleted === totalAnimations) {
+                // Pulizia finale robusta: rimuovi tutti i pezzi orfani dal DOM e dal riferimento JS
+                Object.values(this.boardService.getAllSquares()).forEach(square => {
+                    const expectedPieceId = this.positionService.getGamePieceId(square.id);
+                    if (!expectedPieceId && typeof square.forceRemoveAllPieces === 'function') {
+                        square.forceRemoveAllPieces();
+                    }
+                });
+                this._addListeners();
+                const gameStateAfter = this.positionService.getGame().fen();
+                if (gameStateBefore !== gameStateAfter) {
+                    this.config.onChange(gameStateAfter);
                 }
             }
+        };
 
-            // 5. Anima i movimenti
-            moves.forEach(move => {
-                setTimeout(() => {
-                    this.pieceService.translatePiece(
-                        move,
-                        false,
-                        true,
-                        this._createDragFunction.bind(this),
-                        onAnimationComplete
-                    );
-                }, animationIndex * animationDelay);
-                animationIndex++;
-            });
+        // 4. Esegui tutte le animazioni con delay
+        let idx = 0;
+        moves.forEach(move => {
+            setTimeout(() => {
+                this.pieceService.translatePiece(
+                    move,
+                    false,
+                    animation,
+                    this._createDragFunction.bind(this),
+                    onAnimationComplete
+                );
+            }, idx++ * animationDelay);
+        });
+        removes.forEach(op => {
+            setTimeout(() => {
+                if (typeof op.square.forceRemoveAllPieces === 'function') {
+                    op.square.forceRemoveAllPieces();
+                    onAnimationComplete();
+                } else {
+                    this.pieceService.removePieceFromSquare(op.square, animation, onAnimationComplete);
+                }
+            }, idx++ * animationDelay);
+        });
+        adds.forEach(op => {
+            setTimeout(() => {
+                const newPiece = this.pieceService.convertPiece(op.pieceId);
+                this.pieceService.addPieceOnSquare(
+                    op.square,
+                    newPiece,
+                    animation,
+                    this._createDragFunction.bind(this),
+                    onAnimationComplete
+                );
+            }, idx++ * animationDelay);
         });
     }
 
@@ -8246,6 +8237,8 @@ let Chessboard$1 = class Chessboard {
         if (this._updateBoardPieces) {
             this._updateBoardPieces(animate, true);
         }
+        // Forza la sincronizzazione dopo setPosition
+        this._updateBoardPieces(true, false);
         return true;
     }
     /**
@@ -8259,7 +8252,10 @@ let Chessboard$1 = class Chessboard {
         // Use the default starting position from config or fallback
         const startPosition = this.config && this.config.position ? this.config.position : 'start';
         this._updateBoardPieces(animate);
-        return this.setPosition(startPosition, { animate });
+        const result = this.setPosition(startPosition, { animate });
+        // Forza la sincronizzazione dopo reset
+        this._updateBoardPieces(true, false);
+        return result;
     }
     /**
      * Clear the board
@@ -8283,6 +8279,8 @@ let Chessboard$1 = class Chessboard {
         if (this._updateBoardPieces) {
             this._updateBoardPieces(animate, true);
         }
+        // Forza la sincronizzazione dopo clear
+        this._updateBoardPieces(true, false);
         return true;
     }
 
@@ -8297,7 +8295,8 @@ let Chessboard$1 = class Chessboard {
         const undone = this.positionService.getGame().undo();
         if (undone) {
             this._undoneMoves.push(undone);
-            this._updateBoardPieces(opts.animate !== false);
+            // Forza refresh completo di tutti i pezzi dopo undo
+            this._updateBoardPieces(true, true);
             return undone;
         }
         return null;
@@ -8314,7 +8313,8 @@ let Chessboard$1 = class Chessboard {
             const moveObj = { from: move.from, to: move.to };
             if (move.promotion) moveObj.promotion = move.promotion;
             const result = this.positionService.getGame().move(moveObj);
-            this._updateBoardPieces(opts.animate !== false);
+            // Forza refresh completo di tutti i pezzi dopo redo
+            this._updateBoardPieces(true, true);
             return result;
         }
         return false;
@@ -8333,17 +8333,19 @@ let Chessboard$1 = class Chessboard {
      * @returns {string|null}
      */
     getPiece(square) {
-        // Restituisce sempre 'wq' (colore prima, tipo dopo, lowercase) o null
-        const sq = this.boardService.getSquare(square);
-        if (!sq) return null;
-        const piece = sq.piece;
+        // Sempre leggi lo stato aggiornato dal boardService
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[getPiece] Parametro square non valido');
+        // Forza sync prima di leggere
+        this._updateBoardPieces(false, false);
+        const piece = squareObj.piece;
         if (!piece) return null;
         return (piece.color + piece.type).toLowerCase();
     }
     /**
      * Put a piece on a square
-     * @param {string} piece
-     * @param {string} square
+     * @param {string|Piece} piece
+     * @param {string|Square} square
      * @param {Object} [opts]
      * @param {boolean} [opts.animate=true]
      * @returns {boolean}
@@ -8354,7 +8356,6 @@ let Chessboard$1 = class Chessboard {
         if (typeof piece === 'object' && piece.type && piece.color) {
             pieceStr = (piece.color + piece.type).toLowerCase();
         } else if (typeof piece === 'string' && piece.length === 2) {
-            // Accetta sia 'wq' che 'qw', normalizza a 'wq'
             const a = piece[0].toLowerCase();
             const b = piece[1].toLowerCase();
             const types = 'kqrbnp';
@@ -8367,42 +8368,36 @@ let Chessboard$1 = class Chessboard {
                 throw new Error(`[putPiece] Invalid piece: ${piece}`);
             }
         }
-        const validSquare = this.validationService.isValidSquare(square);
-        const validPiece = this.validationService.isValidPiece(pieceStr);
-        if (!validSquare) throw new Error(`[putPiece] Invalid square: ${square}`);
-        if (!validPiece) throw new Error(`[putPiece] Invalid piece: ${pieceStr}`);
-        if (!this.positionService || !this.positionService.getGame()) {
-            throw new Error('[putPiece] No positionService or game');
-        }
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[putPiece] Parametro square non valido');
         const pieceObj = this.pieceService.convertPiece(pieceStr);
-        const squareObj = this.boardService.getSquare(square);
-        if (!squareObj) throw new Error(`[putPiece] Square not found: ${square}`);
-        squareObj.piece = pieceObj;
+        if (!pieceObj || typeof pieceObj !== 'object' || !('type' in pieceObj)) throw new Error('[putPiece] Parametro piece non valido');
+        // Aggiorna solo il motore chess.js
         const chessJsPiece = { type: pieceObj.type, color: pieceObj.color };
         const game = this.positionService.getGame();
-        const result = game.put(chessJsPiece, square);
-        if (!result) throw new Error(`[putPiece] Game.put failed for ${pieceStr} on ${square}`);
+        const result = game.put(chessJsPiece, squareObj.id);
+        if (!result) throw new Error(`[putPiece] Game.put failed for ${pieceStr} on ${squareObj.id}`);
+        // Non aggiornare direttamente square.piece!
+        // Riallinea la board JS allo stato del motore
         this._updateBoardPieces(animate);
         return true;
     }
     /**
      * Remove a piece from a square
-     * @param {string} square
+     * @param {string|Square} square
      * @param {Object} [opts]
      * @param {boolean} [opts.animate=true]
      * @returns {string|null}
      */
     removePiece(square, opts = {}) {
         const animate = opts.animate !== undefined ? opts.animate : true;
-        if (!this.validationService.isValidSquare(square)) {
-            throw new Error(`[removePiece] Invalid square: ${square}`);
-        }
-        const squareObj = this.boardService.getSquare(square);
-        if (!squareObj) return true;
-        if (!squareObj.piece) return true;
-        squareObj.piece = null;
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[removePiece] Parametro square non valido');
+        // Aggiorna solo il motore chess.js
         const game = this.positionService.getGame();
-        game.remove(square);
+        game.remove(squareObj.id);
+        // Non aggiornare direttamente square.piece!
+        // Riallinea la board JS allo stato del motore
         this._updateBoardPieces(animate);
         return true;
     }
@@ -8467,28 +8462,32 @@ let Chessboard$1 = class Chessboard {
     // --- HIGHLIGHTING & UI ---
     /**
      * Highlight a square
-     * @param {string} square
+     * @param {string|Square} square
      * @param {Object} [opts]
      */
     highlight(square, opts = {}) {
-        if (!this.validationService.isValidSquare(square)) return;
+        // API: accetta id, converte subito in oggetto
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[highlight] Parametro square non valido');
         if (this.boardService && this.boardService.highlightSquare) {
-            this.boardService.highlightSquare(square, opts);
+            this.boardService.highlightSquare(squareObj, opts);
         } else if (this.eventService && this.eventService.highlightSquare) {
-            this.eventService.highlightSquare(square, opts);
+            this.eventService.highlightSquare(squareObj, opts);
         }
     }
     /**
      * Remove highlight from a square
-     * @param {string} square
+     * @param {string|Square} square
      * @param {Object} [opts]
      */
     dehighlight(square, opts = {}) {
-        if (!this.validationService.isValidSquare(square)) return;
+        // API: accetta id, converte subito in oggetto
+        const squareObj = typeof square === 'string' ? this.boardService.getSquare(square) : square;
+        if (!squareObj || typeof squareObj !== 'object' || !('id' in squareObj)) throw new Error('[dehighlight] Parametro square non valido');
         if (this.boardService && this.boardService.dehighlightSquare) {
-            this.boardService.dehighlightSquare(square, opts);
+            this.boardService.dehighlightSquare(squareObj, opts);
         } else if (this.eventService && this.eventService.dehighlightSquare) {
-            this.eventService.dehighlightSquare(square, opts);
+            this.eventService.dehighlightSquare(squareObj, opts);
         }
     }
 
@@ -8513,6 +8512,8 @@ let Chessboard$1 = class Chessboard {
      * @returns {boolean}
      */
     isGameOver() {
+        // Forza sync prima di interrogare il motore
+        this._updateBoardPieces(false, false);
         const game = this.positionService.getGame();
         if (!game) return false;
         if (game.isGameOver) return game.isGameOver();
@@ -8816,23 +8817,6 @@ let Chessboard$1 = class Chessboard {
         }
     }
 
-    /**
-     * Gets or sets the animation style
-     * @param {string} [style] - New animation style ('sequential' or 'simultaneous')
-     * @returns {string} Current animation style
-     */
-    animationStyle(style) {
-        if (style === undefined) {
-            return this.config.animationStyle;
-        }
-
-        if (this.validationService.isValidAnimationStyle(style)) {
-            this.config.animationStyle = style;
-        }
-
-        return this.config.animationStyle;
-    }
-
     /**
      * Gets or sets the simultaneous animation delay
      * @param {number} [delay] - New delay in milliseconds
@@ -8882,7 +8866,7 @@ let Chessboard$1 = class Chessboard {
     dehighlightSquare(square) {
         return this.boardService.dehighlight(square);
     }
-    forceSync() { this._updateBoardPieces(true, true); }
+    forceSync() { this._updateBoardPieces(true, true); this._updateBoardPieces(true, false); }
 
     // Metodi mancanti che causano fallimenti nei test
     /**
@@ -8895,37 +8879,37 @@ let Chessboard$1 = class Chessboard {
     movePiece(move, opts = {}) {
         const animate = opts.animate !== undefined ? opts.animate : true;
 
-        // Parse move string if needed
-        let fromSquare, toSquare, promotion;
+        // --- API: accetta id/stringhe, ma converte subito in oggetti ---
+        let fromSquareObj, toSquareObj, promotion;
         if (typeof move === 'string') {
             if (move.length === 4) {
-                fromSquare = move.substring(0, 2);
-                toSquare = move.substring(2, 4);
+                fromSquareObj = this.boardService.getSquare(move.substring(0, 2));
+                toSquareObj = this.boardService.getSquare(move.substring(2, 4));
             } else if (move.length === 5) {
-                fromSquare = move.substring(0, 2);
-                toSquare = move.substring(2, 4);
+                fromSquareObj = this.boardService.getSquare(move.substring(0, 2));
+                toSquareObj = this.boardService.getSquare(move.substring(2, 4));
                 promotion = move.substring(4, 5);
             } else {
                 throw new Error(`Invalid move format: ${move}`);
             }
         } else if (typeof move === 'object' && move.from && move.to) {
-            fromSquare = move.from;
-            toSquare = move.to;
+            // Se sono id, converto in oggetti; se sono già oggetti, li uso direttamente
+            fromSquareObj = typeof move.from === 'string' ? this.boardService.getSquare(move.from) : move.from;
+            toSquareObj = typeof move.to === 'string' ? this.boardService.getSquare(move.to) : move.to;
             promotion = move.promotion;
         } else {
             throw new Error(`Invalid move: ${move}`);
         }
 
-        // Get square objects
-        const fromSquareObj = this.boardService.getSquare(fromSquare);
-        const toSquareObj = this.boardService.getSquare(toSquare);
-
         if (!fromSquareObj || !toSquareObj) {
-            throw new Error(`Invalid squares: ${fromSquare} or ${toSquare}`);
+            throw new Error(`Invalid squares: ${move.from || move.substring(0, 2)} or ${move.to || move.substring(2, 4)}`);
         }
 
-        // Execute the move
-        return this._onMove(fromSquareObj, toSquareObj, promotion, animate);
+        // --- Internamente: lavora solo con oggetti ---
+        const result = this._onMove(fromSquareObj, toSquareObj, promotion, animate);
+        // Dopo ogni mossa, forza la sincronizzazione della board
+        this._updateBoardPieces(true, false);
+        return result;
     }
 
     // Aliases for backward compatibility
@@ -9400,7 +9384,6 @@ class ChessboardFactory {
             hints: true,
             clickable: true,
             moveHighlight: true,
-            animationStyle: 'simultaneous'
         });
 
         // Tournament template
@@ -9411,7 +9394,6 @@ class ChessboardFactory {
             clickable: true,
             moveHighlight: true,
             onlyLegalMoves: true,
-            animationStyle: 'sequential'
         });
 
         // Analysis template
@@ -9422,7 +9404,6 @@ class ChessboardFactory {
             clickable: true,
             moveHighlight: true,
             mode: 'analysis',
-            animationStyle: 'simultaneous'
         });
 
         // Puzzle template
@@ -9433,7 +9414,6 @@ class ChessboardFactory {
             clickable: true,
             moveHighlight: true,
             onlyLegalMoves: true,
-            animationStyle: 'sequential'
         });
 
         // Demo template
@@ -9443,7 +9423,6 @@ class ChessboardFactory {
             hints: false,
             clickable: false,
             moveHighlight: true,
-            animationStyle: 'simultaneous'
         });
     }
 
@@ -10251,11 +10230,7 @@ function validateConfig(config) {
     if (config.moveAnimation && !isValidEasing(config.moveAnimation)) {
         errors.push('Invalid moveAnimation. Must be a valid easing function');
     }
-    
-    if (config.animationStyle && !['sequential', 'simultaneous'].includes(config.animationStyle)) {
-        errors.push('Invalid animationStyle. Must be "sequential" or "simultaneous"');
-    }
-    
+        
     return {
         success: errors.length === 0,
         errors