src/chess/Board.js - Code Metrics - Inspection of "improved game logic and updated README" - Barelydead/oop-chess - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 12291e...74547d )

by Christofer

created 2017-12-12 16:16 UTC

src/chess/Board.js A

↳ Parent: Project

Size

Lines of Code

172

Duplication

Duplicated Lines	0
Ratio	0 %

Test Coverage

Coverage

93.88%

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
nc	1
dl	0
loc	172
rs	10
ccs	46
cts	49
cp	0.9388
noi	3

1 Function

Rating	Name	Duplication	Size	Complexity
A	Board.js ➔ ???	0	16	1

/**
 * A Chess board module
 * @module
 */
"use strict";

/**
 * Board class contains methods for setting up a chess board
 */
class Board {
    /**
     * Prepare board properties and init empty board
     */
    constructor() {
        this.board = {
            "A": [],
            "B": [],
            "C": [],
            "D": [],
            "E": [],
            "F": [],
            "G": [],
            "H": [],
        };

        this.rows = [null, "A", "B", "C", "D", "E", "F", "G", "H"];

        this.setUpEmptyTable();
    }


    /**
     * Set up empty board
     */
    setUpEmptyTable() {
        for (var key in this.board) {
var someObject;
for (var key in someObject) {
    if ( ! someObject.hasOwnProperty(key)) {
        continue; // Skip keys from the prototype.
    }

    doSomethingWith(key);
}
            this.board[key] =
            [key, key + 1, key + 2, key + 3, key + 4, key + 5, key + 6, key + 7, key + 8];
        }
    }


    /**
     * get the full board
     *
     * @returns {object} - current board state
     */
    getBoard() {
        return this.board;
    }

    /**
     * Check if the is anything blocking the path between 2 squares
     *
     * @returns {mixed} - true if free or square Coo if false
     */
    checkRow(x, y, nx, ny) {
        const direction = x == nx ? "horisontal" : "vertical";
        let row, list, xNumber, nxNumber, i;

        if (direction === "horisontal") {
            row = this.board[x];
            // Slice array to get squares to check
            list = y < ny ? row.slice(y + 1, ny) : row.slice(ny + 1, y);
        } else {
            row = [];
            for (i = 1; i < this.rows.length; i++) {
                row.push(this.board[this.rows[i]][y]);
            }
            // get numeric value of x nx
            xNumber = this.rows.indexOf(x);
            nxNumber = this.rows.indexOf(nx);

            // Slice array to get squares to check
            list = xNumber < nxNumber ? row.slice(xNumber + 1, nxNumber) : row.slice(nxNumber + 1, xNumber);
        }

        // loop squares and check type
        for (i = 0; i < list.length; i++) {
            if (typeof list[i] !== "string") {
                return false;
            }
        }

        return true;
    }

    /**
     * Check if the is anything blocking the path between 2 squares
     *
     * @returns {bool} - true if free else false
     */
    checkDiagonal(x, y, nx, ny) {
        let xNumber, nxNumber, steps;
        steps = Math.abs(y - ny);
        xNumber = this.rows.indexOf(x)
        nxNumber = this.rows.indexOf(nx)

        if (xNumber < nxNumber && y < ny || xNumber > nxNumber && y > ny) {
            y = y > ny ? ny : y;
            xNumber = xNumber > nxNumber ? nxNumber : xNumber;
            for (let i = 1; i < steps; i++) {
                if (typeof this.board[this.rows[xNumber + i]][y + i] == "object") {
                    return false
                }
            }
        } else {
            y = y < ny ? ny : y;
            xNumber = xNumber > nxNumber ? nxNumber : xNumber;
            for (let i = 1; i < steps; i++) {
                if (typeof this.board[this.rows[xNumber + i]][y - i] == "object") {
                    return false
                }
            }
        }
        return true
    }

    /**
     * get a value for a specific square
     *
     * @returns {string}
     */
    getSquare(row, col) {
        return this.board[row][col];
    }


    /**
     * change the value of a square
     *
     * @returns {null}
     */
    updateSquare(row, col, value) {
        this.board[row][col] = value;
    }


    /**
     * Move a piece to another square
     * @param {int} - x, y, nx, ny

     * old xy coordinates and new xy coordinates
     *
     */
    move(x, y, nx, ny) {
        const piece = this.getSquare(x, y);

        this.updateSquare(x, y, x + y);
        this.updateSquare(nx, ny, piece);
    }


    /**
     * Asciify board
     *
     * @returns {String}
     */
    getAsciiBoard() {
        let ascii = "";

        for (var key in this.board) {
var someObject;
for (var key in someObject) {
    if ( ! someObject.hasOwnProperty(key)) {
        continue; // Skip keys from the prototype.
    }

    doSomethingWith(key);
}
            for (let i = 0; i < this.board[key].length; i++) {
                if (typeof this.board[key][i] === "object") {
                    ascii += this.board[key][i].symbol + this.board[key][i].color[0] +  " | "
                } else {
                    ascii += this.board[key][i] +  " | ";
                }
            }
            ascii += "\n";
        }
        return ascii;
    }
}


module.exports = Board;


1		/**
2		* A Chess board module
3		* @module
4		*/
5		"use strict";
6
7		/**
8		* Board class contains methods for setting up a chess board
9		*/
10		class Board {
11		/**
12		* Prepare board properties and init empty board
13		*/
14		constructor() {
15	6	this.board = {
16		"A": [],
17		"B": [],
18		"C": [],
19		"D": [],
20		"E": [],
21		"F": [],
22		"G": [],
23		"H": [],
24		};
25
26	6	this.rows = [null, "A", "B", "C", "D", "E", "F", "G", "H"];
27
28	6	this.setUpEmptyTable();
29		}
30
31
32		/**
33		* Set up empty board
34		*/
35		setUpEmptyTable() {
36	6	for (var key in this.board) {
		0 ignored issues – show Complexity introduced 2017-12-06 12:46 UTC by Report Bug Copy Issue Report A for in loop automatically includes the property of any prototype object, consider checking the key using `hasOwnProperty`. When iterating over the keys of an object, this includes not only the keys of the object, but also keys contained in the prototype of that object. It is generally a best practice to check for these keys specifically: var someObject; for (var key in someObject) { if ( ! someObject.hasOwnProperty(key)) { continue; // Skip keys from the prototype. } doSomethingWith(key); } Loading history...
37	48	this.board[key] =
38		[key, key + 1, key + 2, key + 3, key + 4, key + 5, key + 6, key + 7, key + 8];
39		}
40		}
41
42
43		/**
44		* get the full board
45		*
46		* @returns {object} - current board state
47		*/
48		getBoard() {
49	1	return this.board;
50		}
51
52		/**
53		* Check if the is anything blocking the path between 2 squares
54		*
55		* @returns {mixed} - true if free or square Coo if false
56		*/
57		checkRow(x, y, nx, ny) {
58	2	const direction = x == nx ? "horisontal" : "vertical";
59		let row, list, xNumber, nxNumber, i;
60
61	2	if (direction === "horisontal") {
62	1	row = this.board[x];
63		// Slice array to get squares to check
64	2	list = y < ny ? row.slice(y + 1, ny) : row.slice(ny + 1, y);
65		} else {
66	1	row = [];
67	1	for (i = 1; i < this.rows.length; i++) {
68	8	row.push(this.board[this.rows[i]][y]);
69		}
70		// get numeric value of x nx
71	1	xNumber = this.rows.indexOf(x);
72	1	nxNumber = this.rows.indexOf(nx);
73
74		// Slice array to get squares to check
75	2	list = xNumber < nxNumber ? row.slice(xNumber + 1, nxNumber) : row.slice(nxNumber + 1, xNumber);
76		}
77
78		// loop squares and check type
79	2	for (i = 0; i < list.length; i++) {
80	4	if (typeof list[i] !== "string") {
81	1	return false;
82		}
83		}
84
85	1	return true;
86		}
87
88		/**
89		* Check if the is anything blocking the path between 2 squares
90		*
91		* @returns {bool} - true if free else false
92		*/
93		checkDiagonal(x, y, nx, ny) {
94		let xNumber, nxNumber, steps;
95	2	steps = Math.abs(y - ny);
96	2	xNumber = this.rows.indexOf(x)
97	2	nxNumber = this.rows.indexOf(nx)
98
99	6	if (xNumber < nxNumber && y < ny \|\| xNumber > nxNumber && y > ny) {
100	2	y = y > ny ? ny : y;
101	2	xNumber = xNumber > nxNumber ? nxNumber : xNumber;
102	2	for (let i = 1; i < steps; i++) {
103	2	if (typeof this.board[this.rows[xNumber + i]][y + i] == "object") {
104	1	return false
105		}
106		}
107		} else {
108	2	y = y < ny ? ny : y;
109	2	xNumber = xNumber > nxNumber ? nxNumber : xNumber;
110		for (let i = 1; i < steps; i++) {
111	2	if (typeof this.board[this.rows[xNumber + i]][y - i] == "object") {
112		return false
113		}
114		}
115		}
116	1	return true
117		}
118
119		/**
120		* get a value for a specific square
121		*
122		* @returns {string}
123		*/
124		getSquare(row, col) {
125	7	return this.board[row][col];
126		}
127
128
129		/**
130		* change the value of a square
131		*
132		* @returns {null}
133		*/
134		updateSquare(row, col, value) {
135	4	this.board[row][col] = value;
136		}
137
138
139		/**
140		* Move a piece to another square
141		* @param {int} - x, y, nx, ny
		0 ignored issues – show Documentation introduced 2017-12-06 12:46 UTC by Report Bug Copy Issue Report The parameter `-` does not exist. Did you maybe forget to remove this comment? Loading history...
142		* old xy coordinates and new xy coordinates
143		*
144		*/
145		move(x, y, nx, ny) {
146	1	const piece = this.getSquare(x, y);
147
148	1	this.updateSquare(x, y, x + y);
149	1	this.updateSquare(nx, ny, piece);
150		}
151
152
153		/**
154		* Asciify board
155		*
156		* @returns {String}
157		*/
158		getAsciiBoard() {
159	1	let ascii = "";
160
161	1	for (var key in this.board) {
		0 ignored issues – show Complexity introduced 2017-12-06 12:46 UTC by Report Bug Copy Issue Report A for in loop automatically includes the property of any prototype object, consider checking the key using `hasOwnProperty`. When iterating over the keys of an object, this includes not only the keys of the object, but also keys contained in the prototype of that object. It is generally a best practice to check for these keys specifically: var someObject; for (var key in someObject) { if ( ! someObject.hasOwnProperty(key)) { continue; // Skip keys from the prototype. } doSomethingWith(key); } Loading history...
162	8	for (let i = 0; i < this.board[key].length; i++) {
163	72	if (typeof this.board[key][i] === "object") {
164		ascii += this.board[key][i].symbol + this.board[key][i].color[0] + " \| "
165		} else {
166	72	ascii += this.board[key][i] + " \| ";
167		}
168		}
169	8	ascii += "\n";
170		}
171	1	return ascii;
172		}
173		}
174
175
176		module.exports = Board;
177

Barelydead / oop-chess

Push — master ( 12291e...74547d )

src/chess/Board.js A

Size

Duplication

Test Coverage

Importance

1 Function

Duplication Side-by-Side

Filter issues like