package com.domain;

import java.util.List;

public abstract class BishopMoveCalculator {

    public List<Coordinate> calculate(int aRow, int aColumn, List<Coordinate> aCandidates) {
        while (isValidCoordinate(aRow, aColumn)) {
            aCandidates.add(new Coordinate(aRow, aColumn));

            aRow = nextRow(aRow);
            aColumn = nextColumn(aColumn);
        }

        return aCandidates;
    }

    public abstract boolean isValidCoordinate(int aRow, int aColumn);
    public abstract int nextRow(int aCurrentRow);
    public abstract int nextColumn(int aCurrentColumn);

}


...


package com.domain;

import java.util.ArrayList;
import java.util.List;

public class WhiteBishop extends GamePiece {

    public WhiteBishop(GameBoard aBoard, Coordinate aTile) {
        super(PieceType.WHITE_BISHOP, aTile, aBoard);
    }

    @Override
    public List<Coordinate> candidateMoves() {
        List<Coordinate> candidates = new ArrayList<Coordinate>();

        candidates = calculateForwardLeftMoves(candidates);
        candidates = calculateForwardRightMoves(candidates);
        candidates = calculateBackwardLeftMoves(candidates);
        candidates = calculateBackwardRightMoves(candidates);

        return candidates;
    }

    private List<Coordinate> calculateForwardLeftMoves(List<Coordinate> aCandidates) {
        int currentRow = super.row() - 1;
        int currentColumn = super.column() - 1;

        BishopMoveCalculator calculator = new ForwardLeftMoveCalculator();
        return calculator.calculate(currentRow, currentColumn, aCandidates);
    }

    private List<Coordinate> calculateForwardRightMoves(List<Coordinate> aCandidates) {
        int currentRow = super.row() - 1;
        int currentColumn = super.column() + 1;

        BishopMoveCalculator calculator = new ForwardRightMoveCalculator(super.board);
        return calculator.calculate(currentRow, currentColumn, aCandidates);
    }

    private List<Coordinate> calculateBackwardLeftMoves(List<Coordinate> aCandidates) {
        int currentRow = super.row() + 1;
        int currentColumn = super.column() - 1;

        BishopMoveCalculator calculator = new BackwardLeftMoveCalculator(super.board);
        return calculator.calculate(currentRow, currentColumn, aCandidates);
    }

    private List<Coordinate> calculateBackwardRightMoves(List<Coordinate> aCandidates) {
        int currentRow = super.row() + 1;
        int currentColumn = super.column() + 1;

        BishopMoveCalculator calculator = new BackwardRightMoveCalculator(super.board);
        return calculator.calculate(currentRow, currentColumn, aCandidates);
    }

    @Override
    protected GamePiece constructNewPieceToMove(Coordinate aNewLocation) {
        return new WhiteBishop(board, aNewLocation);
    }

    private class ForwardLeftMoveCalculator extends BishopMoveCalculator {
        @Override
        public boolean isValidCoordinate(int aRow, int aColumn) {
            return (aRow >= 0) && (aColumn >= 0);
        }

        @Override
        public int nextRow(int aCurrentRow) {
            return --aCurrentRow;
        }

        @Override
        public int nextColumn(int aCurrentColumn) {
            return --aCurrentColumn;
        }
    }

    private class ForwardRightMoveCalculator extends BishopMoveCalculator {
        private final GameBoard board;

        public ForwardRightMoveCalculator(GameBoard aBoard) {
            board = aBoard;
        }

        @Override
        public boolean isValidCoordinate(int aRow, int aColumn) {
            return (aRow >= 0) && (aColumn < board.columns());
        }

        @Override
        public int nextRow(int aCurrentRow) {
            return --aCurrentRow;
        }

        @Override
        public int nextColumn(int aCurrentColumn) {
            return ++aCurrentColumn;
        }
    }

    private class BackwardLeftMoveCalculator extends BishopMoveCalculator {
        private final GameBoard board;

        public BackwardLeftMoveCalculator(GameBoard aBoard) {
            board = aBoard;
        }

        @Override
        public boolean isValidCoordinate(int aRow, int aColumn) {
            return (aRow < board.rows()) && (aColumn >= 0);
        }

        @Override
        public int nextRow(int aCurrentRow) {
            return ++aCurrentRow;
        }

        @Override
        public int nextColumn(int aCurrentColumn) {
            return --aCurrentColumn;
        }
    }

    private class BackwardRightMoveCalculator extends BishopMoveCalculator {
        private final GameBoard board;

        public BackwardRightMoveCalculator(GameBoard aBoard) {
            board = aBoard;
        }

        @Override
        public boolean isValidCoordinate(int aRow, int aColumn) {
            return (aRow < board.rows()) && (aColumn < board.columns());
        }

        @Override
        public int nextRow(int aCurrentRow) {
            return ++aCurrentRow;
        }

        @Override
        public int nextColumn(int aCurrentColumn) {
            return ++aCurrentColumn;
        }
    }

}