Piece.jack

class Piece {
    field int type, color;
    // singletons
    static Piece blackPawn, whitePawn;
    static Piece blackBishop, whiteBishop;
    static Piece blackKnight, whiteKnight;
    static Piece blackRook, whiteRook;
    static Piece blackQueen, whiteQueen;
    static Piece blackKing, whiteKing;

    // Call initInstances and the getInstance directly, don't
    // need to interact with the constructors directly yourself!
    function void initInstances() {
        let blackPawn = Piece.newPawn(Utils.BLACK());
        let blackBishop = Piece.newBishop(Utils.BLACK());
        let blackKnight = Piece.newKnight(Utils.BLACK());
        let blackRook = Piece.newRook(Utils.BLACK());
        let blackQueen = Piece.newQueen(Utils.BLACK());
        let blackKing = Piece.newKing(Utils.BLACK());
        let whitePawn = Piece.newPawn(Utils.WHITE());
        let whiteBishop = Piece.newBishop(Utils.WHITE());
        let whiteKnight = Piece.newKnight(Utils.WHITE());
        let whiteRook = Piece.newRook(Utils.WHITE());
        let whiteQueen = Piece.newQueen(Utils.WHITE());
        let whiteKing = Piece.newKing(Utils.WHITE());
        return;
    }

    function void disposeAll() {
        do blackPawn.dispose(); do whitePawn.dispose();
        do blackRook.dispose(); do whiteRook.dispose();
        do blackBishop.dispose(); do whiteBishop.dispose();
        do blackKnight.dispose(); do whiteKnight.dispose();
        do blackQueen.dispose(); do whiteQueen.dispose();
        do blackKing.dispose(); do whiteKing.dispose();
        return;
    }

    // Can use this after you've called initInstances only.
    function Piece getInstance(int type, int color) {
        if (type = Utils.PAWN()) {
            if (color = Utils.WHITE()) {
                return whitePawn;
            }
            return blackPawn;
        }
        if (type = Utils.BISHOP()) {
            if (color = Utils.WHITE()) {
                return whiteBishop;
            }
            return blackBishop;
        }
        if (type = Utils.KNIGHT()) {
            if (color = Utils.WHITE()) {
                return whiteKnight;
            }
            return blackKnight;
        }
        if (type = Utils.ROOK()) {
            if (color = Utils.WHITE()) {
                return whiteRook;
            }
            return blackRook;
        }
        if (type = Utils.QUEEN()) {
            if (color = Utils.WHITE()) {
                return whiteQueen;
            }
            return blackQueen;
        }
        if (type = Utils.KING()) {
            if (color = Utils.WHITE()) {
                return whiteKing;
            }
            return blackKing;
        }
        do Utils.error("Unknown piece type given.");
        return null;
    }

    constructor Piece newPawn(int c) {
        let type = Utils.PAWN();
        let color = c;
        return this;
    }
    constructor Piece newBishop(int c) {
        let type = Utils.BISHOP();
        let color = c;
        return this;
    }
    constructor Piece newKnight(int c) {
        let type = Utils.KNIGHT();
        let color = c;
        return this;
    }
    constructor Piece newRook(int c) {
        let type = Utils.ROOK();
        let color = c;
        return this;
    }
    constructor Piece newQueen(int c) {
        let type = Utils.QUEEN();
        let color = c;
        return this;
    }
    constructor Piece newKing(int c) {
        let type = Utils.KING();
        let color = c;
        return this;
    }
    method void dispose() {
        do Memory.deAlloc(this);
        return;
    }

    method boolean isBlack() {
        return color = Utils.BLACK();
    }

    method boolean isWhite() {
        return color = Utils.WHITE();
    }

    /* Calls corresponding drawing color based on its own location. */
    method void drawPiece(int location, int squareColor) {
        if (type = Utils.PAWN()) {
            if (isWhite()) {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawPawnWW(location);
                } else {
                    do DrawSprites.drawPawnWB(location);
                }
            } else {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawPawnBW(location);
                } else {
                    do DrawSprites.drawPawnBB(location);
                }
            }
            return;
        }

        if (type = Utils.KNIGHT()) {
            if (isWhite()) {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawKnightWW(location);
                } else {
                    do DrawSprites.drawKnightWB(location);
                }
            } else {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawKnightBW(location);
                } else {
                    do DrawSprites.drawKnightBB(location);
                }
            }
            return;
        }

        if (type = Utils.BISHOP()) {
            if (isWhite()) {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawBishopWW(location);
                } else {
                    do DrawSprites.drawBishopWB(location);
                }
            } else {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawBishopBW(location);
                } else {
                    do DrawSprites.drawBishopBB(location);
                }
            }
            return;
        }

        if (type = Utils.ROOK()) {
            if (isWhite()) {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawRookWW(location);
                } else {
                    do DrawSprites.drawRookWB(location);
                }
            } else {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawRookBW(location);
                } else {
                    do DrawSprites.drawRookBB(location);
                }
            }
            return;
        }

        if (type = Utils.QUEEN()) {
            if (isWhite()) {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawQueenWW(location);
                } else {
                    do DrawSprites.drawQueenWB(location);
                }
            } else {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawQueenBW(location);
                } else {
                    do DrawSprites.drawQueenBB(location);
                }
            }
            return;
        }

        if (type = Utils.KING()) {
            if (isWhite()) {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawKingWW(location);
                } else {
                    do DrawSprites.drawKingWB(location);
                }
            } else {
                if (squareColor = Utils.WHITE()) {
                    do DrawSprites.drawKingBW(location);
                } else {
                    do DrawSprites.drawKingBB(location);
                }
            }
            return;
        }

        do Output.printString("Don't know how to draw piece");
        do print();
        do Sys.error(-1);
        return;
    }

    method void print() {
        var String color;

        if (isBlack()) {
            let color = "black";
        } else {
            if (isWhite()) {
                let color = "white";
            } else {
                let color = "unknown color?";
            }
        }

        do Output.printString(color);
        do Output.printString(" ");
        do Output.printString(getTypeStr());
        do Output.println();
        return;
    }

    method String getTypeStr() {
        if (type = Utils.PAWN()) {
            return "Pawn";
        }
        if (type = Utils.KNIGHT()) {
            return "Knight";
        }
        if (type = Utils.BISHOP()) {
            return "Bishop";
        }
        if (type = Utils.ROOK()) {
            return "Rook";
        }
        if (type = Utils.QUEEN()) {
            return "Queen";
        }
        if (type = Utils.KING()) {
            return "King";
        }
        return "Unknown?";
    }
}