megamanmalte/visual-queens - Change 5Q3SORE3SJYL2W7UQLQPK2XQAHQJ4CHN7FYJTYXDR2M7MPXEPABQC

Highlited attacked squares

Created by Maurizio_Bruetsch on December 17, 2020

5Q3SORE3SJYL2W7UQLQPK2XQAHQJ4CHN7FYJTYXDR2M7MPXEPABQC

Dependencies

In channels

main

Change contents

Deletion in frontend/static/queens.js at line 5365 [4.34]

∅:D[3.303] → [4.107179:107382]

B:BD[4.107179] → [4.107179:107382]

B:BD[4.107382] → [5.0:124]

∅:D[6.82] → [4.107388:107649]

∅:D[3.344] → [4.107388:107649]

∅:D[7.3883] → [4.107388:107649]

∅:D[5.124] → [4.107388:107649]

∅:D[8.11] → [4.107388:107649]

B:BD[4.107388] → [4.107388:107649]

B:BD[4.107649] → [7.3884:3887]

var $elm$core$Platform$Cmd$batch = _Platform_batch;
var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);
var $author$project$Queens$init = function (flags) {
	return _Utils_Tuple2(
		{fixedQueens: $elm$core$Set$empty, id: 1, size: 8, solutionQueens: $elm$core$Set$empty, status: $elm$core$Maybe$Nothing},
		$elm$core$Platform$Cmd$none);
};
var $elm$core$Platform$Sub$batch = _Platform_batch;
var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
var $author$project$Queens$subscriptions = function (model) {
	return $elm$core$Platform$Sub$none;
};

Deletion in frontend/static/queens.js at line 5368 [4.34]

B:BD[7.3990] → [6.83:193]

var $author$project$Queens$Solved = {$: 'Solved'};
var $author$project$Queens$Unsolvable = {$: 'Unsolvable'};

Deletion in frontend/static/queens.js at line 5979 [4.34]

B:BD[7.7752] → [5.125:350]

∅:D[5.350] → [7.7752:8259]

B:BD[7.7752] → [7.7752:8259]

	});
var $elm$core$List$filter = F2(
	function (isGood, list) {
		return A3(
			$elm$core$List$foldr,
			F2(
				function (x, xs) {
					return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
				}),
			_List_Nil,
			list);
	});
var $elm$core$Dict$foldl = F3(
	function (func, acc, dict) {
		foldl:
		while (true) {
			if (dict.$ === 'RBEmpty_elm_builtin') {
				return acc;
			} else {
				var key = dict.b;
				var value = dict.c;
				var left = dict.d;
				var right = dict.e;
				var $temp$func = func,
					$temp$acc = A3(
					func,
					key,
					value,
					A3($elm$core$Dict$foldl, func, acc, left)),
					$temp$dict = right;
				func = $temp$func;
				acc = $temp$acc;
				dict = $temp$dict;
				continue foldl;
			}
		}

Deletion in frontend/static/queens.js at line 5980 [4.34]

B:BD[7.8264] → [7.8264:9059]

var $elm$core$Dict$filter = F2(
	function (isGood, dict) {
		return A3(
			$elm$core$Dict$foldl,
			F3(
				function (k, v, d) {
					return A2(isGood, k, v) ? A3($elm$core$Dict$insert, k, v, d) : d;
				}),
			$elm$core$Dict$empty,
			dict);
	});
var $elm$core$Set$filter = F2(
	function (isGood, _v0) {
		var dict = _v0.a;
		return $elm$core$Set$Set_elm_builtin(
			A2(
				$elm$core$Dict$filter,
				F2(
					function (key, _v1) {
						return isGood(key);
					}),
				dict));
	});
var $elm$core$Set$insert = F2(
	function (key, _v0) {
		var dict = _v0.a;
		return $elm$core$Set$Set_elm_builtin(
			A3($elm$core$Dict$insert, key, _Utils_Tuple0, dict));
	});
var $elm$core$Set$fromList = function (list) {
	return A3($elm$core$List$foldl, $elm$core$Set$insert, $elm$core$Set$empty, list);
};

Insertion in frontend/static/queens.js at line 6152 [4.34]

[7.13945]

[7.14227]

};
var $elm$json$Json$Decode$field = _Json_decodeField;
var $elm$json$Json$Decode$int = _Json_decodeInt;
var $elm$json$Json$Decode$list = _Json_decodeList;
var $elm$core$Basics$negate = function (n) {
	return -n;
};
var $author$project$Queens$solutionDecoder = function () {
	var listToTuple = function (l) {
		if (l.b && l.b.b) {
			var x = l.a;
			var _v1 = l.b;
			var y = _v1.a;
			var xs = _v1.b;
			return _Utils_Tuple2(x, y);
		} else {
			return _Utils_Tuple2(-1, -1);
		}
	};
	return A2(
		$elm$json$Json$Decode$field,
		'queens',
		$elm$json$Json$Decode$list(
			A2(
				$elm$json$Json$Decode$map,
				listToTuple,
				$elm$json$Json$Decode$list($elm$json$Json$Decode$int))));
}();
var $author$project$Queens$formatQueen = function (_v0) {
	var i = _v0.a;
	var j = _v0.b;
	return '&queen=' + ($elm$core$String$fromInt(i) + (':' + $elm$core$String$fromInt(j)));
};
var $author$project$Queens$solveUrl = function (m) {
	return 'solve?id=1&size=' + ($elm$core$String$fromInt(m.size) + A3(
		$elm$core$List$foldl,
		$elm$core$Basics$append,
		'',
		A2(
			$elm$core$List$map,
			$author$project$Queens$formatQueen,
			$elm$core$Set$toList(m.fixedQueens))));
};
var $author$project$Queens$requestSolution = function (m) {
	return $elm$http$Http$get(
		{
			expect: A2($elm$http$Http$expectJson, $author$project$Queens$ReceivedSolution, $author$project$Queens$solutionDecoder),
			url: $author$project$Queens$solveUrl(m)
		});
};
var $author$project$Queens$init = function (flags) {
	var model = {fixedQueens: $elm$core$Set$empty, id: 1, size: 8, solutionQueens: $elm$core$Set$empty, status: $elm$core$Maybe$Nothing};
	return _Utils_Tuple2(
		model,
		$author$project$Queens$requestSolution(model));
};
var $elm$core$Platform$Sub$batch = _Platform_batch;
var $elm$core$Platform$Sub$none = $elm$core$Platform$Sub$batch(_List_Nil);
var $author$project$Queens$subscriptions = function (model) {
	return $elm$core$Platform$Sub$none;
};
var $author$project$Queens$Solved = {$: 'Solved'};
var $author$project$Queens$Unsolvable = {$: 'Unsolvable'};
var $elm$core$List$filter = F2(
	function (isGood, list) {
		return A3(
			$elm$core$List$foldr,
			F2(
				function (x, xs) {
					return isGood(x) ? A2($elm$core$List$cons, x, xs) : xs;
				}),
			_List_Nil,
			list);
	});
var $elm$core$Dict$foldl = F3(
	function (func, acc, dict) {
		foldl:
		while (true) {
			if (dict.$ === 'RBEmpty_elm_builtin') {
				return acc;
			} else {
				var key = dict.b;
				var value = dict.c;
				var left = dict.d;
				var right = dict.e;
				var $temp$func = func,
					$temp$acc = A3(
					func,
					key,
					value,
					A3($elm$core$Dict$foldl, func, acc, left)),
					$temp$dict = right;
				func = $temp$func;
				acc = $temp$acc;
				dict = $temp$dict;
				continue foldl;
			}
		}
	});
var $elm$core$Dict$filter = F2(
	function (isGood, dict) {
		return A3(
			$elm$core$Dict$foldl,
			F3(
				function (k, v, d) {
					return A2(isGood, k, v) ? A3($elm$core$Dict$insert, k, v, d) : d;
				}),
			$elm$core$Dict$empty,
			dict);
	});
var $elm$core$Set$filter = F2(
	function (isGood, _v0) {
		var dict = _v0.a;
		return $elm$core$Set$Set_elm_builtin(
			A2(
				$elm$core$Dict$filter,
				F2(
					function (key, _v1) {
						return isGood(key);
					}),
				dict));
	});
var $elm$core$Set$insert = F2(
	function (key, _v0) {
		var dict = _v0.a;
		return $elm$core$Set$Set_elm_builtin(
			A3($elm$core$Dict$insert, key, _Utils_Tuple0, dict));
	});
var $elm$core$Set$fromList = function (list) {
	return A3($elm$core$List$foldl, $elm$core$Set$insert, $elm$core$Set$empty, list);

Insertion in frontend/static/queens.js at line 6297 [4.34]

[5.659]

var $elm$core$Platform$Cmd$batch = _Platform_batch;
var $elm$core$Platform$Cmd$none = $elm$core$Platform$Cmd$batch(_List_Nil);

Deletion in frontend/static/queens.js at line 6330 [4.34]

∅:D[5.1255] → [7.14231:14384]

B:BD[3.13221] → [7.14231:14384]

B:BD[7.14384] → [2.0:536]

var $elm$json$Json$Decode$field = _Json_decodeField;
var $elm$json$Json$Decode$int = _Json_decodeInt;
var $elm$json$Json$Decode$list = _Json_decodeList;
var $elm$core$Basics$negate = function (n) {
	return -n;
};
var $author$project$Queens$solutionDecoder = function () {
	var listToTuple = function (l) {
		if (l.b && l.b.b) {
			var x = l.a;
			var _v1 = l.b;
			var y = _v1.a;
			var xs = _v1.b;
			return _Utils_Tuple2(x, y);
		} else {
			return _Utils_Tuple2(-1, -1);
		}
	};
	return A2(
		$elm$json$Json$Decode$field,
		'queens',
		$elm$json$Json$Decode$list(
			A2(
				$elm$json$Json$Decode$map,
				listToTuple,
				$elm$json$Json$Decode$list($elm$json$Json$Decode$int))));
}();

Deletion in frontend/static/queens.js at line 6332 [4.34]

B:BD[4.107717] → [6.194:363]

B:BD[6.363] → [5.1256:1758]

		var formatQueen = function (_v3) {
			var i = _v3.a;
			var j = _v3.b;
			return '&queen=' + ($elm$core$String$fromInt(i) + (':' + $elm$core$String$fromInt(j)));
		};
		var solveUrl = function (m) {
			return 'solve?id=1&size=' + ($elm$core$String$fromInt(m.size) + A3(
				$elm$core$List$foldl,
				$elm$core$Basics$append,
				'',
				A2(
					$elm$core$List$map,
					formatQueen,
					$elm$core$Set$toList(m.fixedQueens))));
		};
		var requestSolution = function (m) {
			return $elm$http$Http$get(
				{
					expect: A2($elm$http$Http$expectJson, $author$project$Queens$ReceivedSolution, $author$project$Queens$solutionDecoder),
					url: solveUrl(m)
				});
		};

Replacement in frontend/static/queens.js at line 6346 [4.34]
B:BD[5.1943] → [5.1943:1976]
```
					requestSolution(newModel));
```
[5.1943]
[3.13511]
```
					$author$project$Queens$requestSolution(newModel));
```
Replacement in frontend/static/queens.js at line 6371 [4.34]
B:BD[5.2494] → [5.2494:2527]
```
					requestSolution(newModel));
```
[5.2494]
[9.503]
```
					$author$project$Queens$requestSolution(newModel));
```

Replacement in frontend/static/queens.js at line 6396 [4.34]

B:BD[5.3006] → [5.3006:3118]

					($elm$core$Set$size(newModel.fixedQueens) > 0) ? requestSolution(newModel) : $elm$core$Platform$Cmd$none);

[5.3006]

[7.14970]

					($elm$core$Set$size(newModel.fixedQueens) > 0) ? $author$project$Queens$requestSolution(newModel) : $elm$core$Platform$Cmd$none);

Replacement in frontend/static/queens.js at line 6400 [4.34]
B:BD[7.15025] → [5.3119:3149]
```
					requestSolution(model));
```
[7.15025]
[7.15266]
```
					$author$project$Queens$requestSolution(model));
```

Insertion in frontend/static/queens.js at line 6487 [4.34]

[3.14411]

[8.521]

var $author$project$Queens$isAttacked = F2(
	function (queens, square) {
		var isAttackedBy = F2(
			function (_v1, _v2) {
				var qX = _v1.a;
				var qY = _v1.b;
				var sX = _v2.a;
				var sY = _v2.b;
				return (_Utils_eq(qX, sX) && _Utils_eq(qY, sY)) ? false : (_Utils_eq(qX, sX) ? true : (_Utils_eq(qY, sY) ? true : ((_Utils_eq(qX - qY, sX - sY) || _Utils_eq(qY + qX, sY + sX)) ? true : false)));
			});
		if (!queens.b) {
			return false;
		} else {
			var x = queens.a;
			var xs = queens.b;
			return A2(isAttackedBy, x, square) || A2($author$project$Queens$isAttacked, xs, square);
		}
	});

Replacement in frontend/static/queens.js at line 6573 [4.34]
B:BD[8.1894] → [8.1894:1916]
```
			$elm$svg$Svg$rect,
```
[8.1894]
[8.1916]
```
			$elm$svg$Svg$g,
			_List_Nil,
```

Replacement in frontend/static/queens.js at line 6577 [4.34]

B:BD[8.1942] → [8.1942:1974]

B:BD[8.1974] → [7.16906:16945]

∅:D[7.16945] → [8.2014:2046]

B:BD[8.2014] → [8.2014:2046]

B:BD[8.2046] → [7.16946:17128]

∅:D[7.17128] → [8.2171:2206]

B:BD[8.2171] → [8.2171:2206]

B:BD[8.2206] → [3.15459:15569]

B:BD[3.15569] → [3.15569:15617]

∅:D[3.15617] → [8.2281:2304]

B:BD[8.2281] → [8.2281:2304]

					$elm$svg$Svg$Attributes$x(
					$elm$core$String$fromInt(i * w)),
					$elm$svg$Svg$Attributes$y(
					$elm$core$String$fromInt(j * w)),
					$elm$svg$Svg$Attributes$width(
					$elm$core$String$fromInt(w)),
					$elm$svg$Svg$Attributes$height(
					$elm$core$String$fromInt(w)),
					$elm$svg$Svg$Attributes$fill(
					(A2($elm$core$Basics$modBy, 2, i + j) === 1) ? 'lightblue' : 'white'),
					$elm$svg$Svg$Events$onClick(
					A2($author$project$Queens$AddQueen, i, j))
				]),
			_List_Nil);

[8.1942]

[3.16345]

					A2(
					$elm$svg$Svg$rect,
					_List_fromArray(
						[
							$elm$svg$Svg$Attributes$x(
							$elm$core$String$fromInt(i * w)),
							$elm$svg$Svg$Attributes$y(
							$elm$core$String$fromInt(j * w)),
							$elm$svg$Svg$Attributes$width(
							$elm$core$String$fromInt(w)),
							$elm$svg$Svg$Attributes$height(
							$elm$core$String$fromInt(w)),
							$elm$svg$Svg$Attributes$fill(
							(A2($elm$core$Basics$modBy, 2, i + j) === 1) ? 'lightblue' : 'white'),
							$elm$svg$Svg$Events$onClick(
							A2($author$project$Queens$AddQueen, i, j))
						]),
					_List_Nil),
					A2(
					$author$project$Queens$isAttacked,
					$elm$core$Set$toList(model.fixedQueens),
					_Utils_Tuple2(i, j)) ? A2(
					$elm$svg$Svg$foreignObject,
					_List_fromArray(
						[
							$elm$svg$Svg$Attributes$width(
							$elm$core$String$fromInt(w)),
							$elm$svg$Svg$Attributes$height(
							$elm$core$String$fromInt(w)),
							$elm$svg$Svg$Attributes$x(
							$elm$core$String$fromInt(i * w)),
							$elm$svg$Svg$Attributes$y(
							$elm$core$String$fromInt(j * w))
						]),
					_List_fromArray(
						[
							A2(
							$elm$html$Html$img,
							_List_fromArray(
								[
									$elm$html$Html$Attributes$width(w),
									$elm$html$Html$Attributes$height(w),
									$elm$html$Html$Attributes$src('static/attacked.svg')
								]),
							_List_Nil)
						])) : A2($elm$svg$Svg$svg, _List_Nil, _List_Nil)
				]));

Replacement in frontend/static/queens.js at line 13495 [4.34]

B:BD[7.42797] → [7.42797:42855]

				$mdgriffith$elm_ui$Element$text('Size')),
			max: 20,

[7.42797]

[7.42855]

				$mdgriffith$elm_ui$Element$text(
					'Size = ' + $elm$core$String$fromInt(model.size))),
			max: 50,

Replacement in frontend/src/Queens.elm at line 57 [4.108667]

B:BD[3.17968] → [3.17968:17983]

B:BD[3.17983] → [5.5507:5574]

∅:D[5.5574] → [7.43366:43383]

B:BD[3.18010] → [7.43366:43383]

B:BD[7.43383] → [6.1927:1952]

∅:D[6.1952] → [3.18010:18040]

∅:D[7.43383] → [3.18010:18040]

B:BD[3.18010] → [3.18010:18040]

    ( { id = 1
      , fixedQueens = Set.empty
      , solutionQueens = Set.empty
      , size = 8
      , status = Nothing
      }
    , Cmd.none
    )

[3.17968]

[4.109051]

    let
        model = 
            { id = 1
            , fixedQueens = Set.empty
            , solutionQueens = Set.empty
            , size = 8
            , status = Nothing
            }
    in
        ( model, requestSolution model ) 
solveUrl m = 
    "solve?id=1&size=" 
    ++ String.fromInt m.size 
    ++ (List.foldl (++) "" <| List.map formatQueen (Set.toList m.fixedQueens))
formatQueen (i,j) = "&queen=" ++ String.fromInt i ++ ":" ++ String.fromInt j
requestSolution m = 
    Http.get 
        { url = solveUrl m
        , expect = Http.expectJson ReceivedSolution solutionDecoder
        }

Deletion in frontend/src/Queens.elm at line 86 [4.108667]

B:BD[4.109179] → [6.1953:1962]

B:BD[6.1962] → [5.5575:5597]

∅:D[5.5597] → [6.1982:2014]

B:BD[6.1982] → [6.1982:2014]

B:BD[6.2014] → [5.5598:5723]

B:BD[5.5723] → [2.1074:1160]

∅:D[2.1160] → [5.5723:5904]

B:BD[5.5723] → [5.5723:5904]

B:BD[6.2228] → [6.2228:2235]

    let 
        solveUrl m = 
            "solve?id=1&size=" 
            ++ String.fromInt m.size 
            ++ (List.foldl (++) "" <| List.map formatQueen (Set.toList m.fixedQueens))
        formatQueen (i,j) = "&queen=" ++ String.fromInt i ++ ":" ++ String.fromInt j
        requestSolution m = 
            Http.get 
                { url = solveUrl m
                , expect = Http.expectJson ReceivedSolution solutionDecoder
                }
    in

Replacement in frontend/src/Queens.elm at line 203 [4.108667]

B:BD[7.44681] → [7.44681:44732]

            , label = labelAbove [] <| text "Size"

[7.44681]

[7.44732]

            , label = labelAbove [] <| text ("Size = " ++ String.fromInt model.size)

Replacement in frontend/src/Queens.elm at line 205 [4.108667]
B:BD[7.44754] → [7.44754:44777]
```
            , max = 20
```
[7.44754]
[7.44777]
```
            , max = 50
```

Insertion in frontend/src/Queens.elm at line 236 [4.108667]

[8.4360]

isAttacked : List (Int, Int) -> (Int, Int) -> Bool
isAttacked queens square = 
    let 
        isAttackedBy (qX, qY) (sX, sY) = 
            if qX == sX && qY == sY
                then False
            else if qX == sX
                then True
            else if qY == sY
                then True
            else if qX - qY == sX - sY || qY + qX == sY + sX
                then True
            else False
    in
        case queens of
            [] -> False
            (x::xs) -> isAttackedBy x square || isAttacked xs square

Replacement in frontend/src/Queens.elm at line 260 [4.108667]

∅:D[7.45297] → [8.4409:4441]

B:BD[8.4409] → [8.4409:4441]

B:BD[8.4441] → [7.45298:45483]

∅:D[7.45483] → [8.4599:4678]

B:BD[8.4599] → [8.4599:4678]

B:BD[8.4678] → [3.18346:18390]

∅:D[3.18390] → [8.4678:4707]

B:BD[8.4678] → [8.4678:4707]

        square (i,j) = Svg.rect
            [ Attr.x <| String.fromInt (i * w)
            , Attr.y <| String.fromInt (j * w)
            , Attr.width <| String.fromInt w
            , Attr.height <| String.fromInt w
            , Attr.fill <| if modBy 2 (i+j) == 1 then "lightblue" else "white"
            , Events.onClick (AddQueen i j)
            ]
            []

[7.45297]

[8.4707]

        square (i,j) = 
            Svg.g
                []
                [ Svg.rect
                    [ Attr.x <| String.fromInt (i * w)
                    , Attr.y <| String.fromInt (j * w)
                    , Attr.width <| String.fromInt w
                    , Attr.height <| String.fromInt w
                    , Attr.fill <| if modBy 2 (i+j) == 1 then "lightblue" else "white"
                    , Events.onClick (AddQueen i j)
                    ]
                    []
                , if isAttacked (Set.toList model.fixedQueens) (i, j)
                    then
                        Svg.foreignObject
                            [ Attr.width <| String.fromInt w
                            , Attr.height <| String.fromInt w
                            , Attr.x <| String.fromInt (i * w)
                            , Attr.y <| String.fromInt (j * w)
                            ]
                            ( 
                                [ img 
                                    [ HAttr.width w
                                    , HAttr.height w
                                    , src "static/attacked.svg"
                                    ]
                                    []
                                ]
                            )
                    else
                        Svg.svg [] []
                ]