/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0xAAAAAA
});

/**** 
* Game Code
****/ 
/* 
Game Zones:
- The game is played on a 2048x2732 pixels screen.
0. let playersZoneWidth = 200;
1. let ScoreZone = {x: 0, y: 0, width: app.screen.width, height: 200};
2. let OptionsZone = {x: 0, y: app.screen.height-200, width: app.screen.width, height: 200};
3. let HumanZone = {x: 0, y: 200, width: playersZoneWidth, height: app.screen.height-OptionsZone.height-ScoreZone.height};
4. let ComputerZone = {x: app.screen.width-playersZoneWidth, y: 200, width: playersZoneWidth, height: app.screen.height-OptionsZone.height-ScoreZone.height};
5. let RoadZone = {x: playersZoneWidth, y: 200, width: app.screen.width-HumanZone.width-OrdiZone.width, height: app.screen.height-OptionsZone.height-ScoreZone.height};
Game settings:
- At the start of the game, 10 rocks of three different sizes (small, medium, large) are randomly placed in the RoadZone.
- The rocks have square 100x100 pixels sprites centered (anchor 0.5, 0.5).
- The Rocks have a front and a back zone to simulate a contact area with the Buldos.
- Each rock is on its own horizontal 100 pixels wide line.
- There are two players: the human player and the computer.
- Each player has two Buldos to move the rocks, a kind of bulldozer.
- The human Buldos are called "buldoRocks" and the computer Buldos are called "buldoZers".
- The buldoRocks have a 100x100 pixels sprite centered (anchor 0.5, 0.5).
- The buldoZers have a 100x100 pixels sprite centered (anchor 0.5, 0.5).
- The Buldos have a front and a back zone to simulate the pushing of the rocks.
- At the start of the game, the buldoRocks are placed in the HumanZone and the buldoZers are placed in the ComputerZone (abscissa centered and ordinate equally spaced 1/3, 2/3).
- The buldoRocks are facing right and the buldoZers are facing left.
Game rules:
- The buldoZers are controlled by the computer and will move randomly (or futher with AI) to push the rocks towards the HumanZone.
- The buldoRocks are controlled by the human player and will move when the player clicks or taps to push the rocks towards the ComputerZone.
- The human player selects a buldoRock by clicking or tapping on it, then selects a rock to push by clicking or tapping on it.
- The Buldos may only move in lignes, horizontally or vertically, and may not move diagonally.
- When a Buldo is selected to push a rock, the Buldo must move to the ordonnate of the rock
- To move to the ordonnate of the rock, the Buldo will probably have to make a 90 degres rotation, then move vertically up or down to the ordonnate of the rock, then make a 90 degres rotation to face the rock.
- When a rock is entirely into the HumanZone or the ComputerZone, it is out of the game (loss of visibility of its sprite or destruction of the object Rock).
- When a Buldo has finished pushing a rock, it comes back to its camp (HumanZone or ComputerZone) horizontally and once in its camp, it turns at 180 degres to face the RoadZone.
- A Buldo moving without pushing anything has a base speed V (to futher adjust).
- When a bulldozer pushes a small rock, the combined speed is V/2.
- When a bulldozer pushes a medium rock, the combined speed is V/4.
- When a bulldozer pushes a large rock, the combined speed is V/8.
- When two bulldozers push a rock together, one behind the other, the pushing speeds are doubled compared to the speed of a single bulldozer.
- It is possible to push a rock that is being pushed by the opponent to block or slow down its movement.
- If a second Buldo is added in this situation, the rock will be pushed in the direction where there are fewer Buldos.
- The game ends when all rocks have been moved out of the RoadZone.
- The winner is the one with the highest score, based on the number and size of rocks successfully moved to the opposing zone (small rock is 1 point, medium rock is 2 points, large rock is 3 points).
- The goal for the human player is to move all the rocks to the ComputerZone while preventing the computer from doing the same.
- There is no time limit in this game, and players must use their judgment to determine the best way to move rocks and use their Buldos to win the game.
*/ 
/* 
Game Zones:
- The game is played on a 2048x2732 pixels screen.
0. let playersZoneWidth = 200;
1. let ScoreZone = {x: 0, y: 0, width: app.screen.width, height: 200};
2. let OptionsZone = {x: 0, y: app.screen.height-200, width: app.screen.width, height: 200};
3. let HumanZone = {x: 0, y: 200, width: playersZoneWidth, height: app.screen.height-OptionsZone.height-ScoreZone.height};
4. let ComputerZone = {x: app.screen.width-playersZoneWidth, y: 200, width: playersZoneWidth, height: app.screen.height-OptionsZone.height-ScoreZone.height};
5. let RoadZone = {x: playersZoneWidth, y: 200, width: app.screen.width-HumanZone.width-OrdiZone.width, height: app.screen.height-OptionsZone.height-ScoreZone.height};
- At the start of the game, 10 rocks of three different sizes are randomly placed in the RoadZone.
- Each player has two bulldozers to move the rocks.
- A bulldozer moving without pushing anything has a base speed V.
- When a bulldozer pushes a small rock, the combined speed is V/2.
- When a bulldozer pushes a medium rock, the combined speed is V/4.
- When a bulldozer pushes a large rock, the combined speed is V/8.
- When two bulldozers push a rock together, one behind the other, the pushing speeds are doubled compared to the speed of a single bulldozer.
- The human player clicks on a rock to command the nearest free bulldozer to push it towards the ComputerZone.
- The computer-controlled bulldozers randomly choose a rock and push it towards the HumanZone.
- If a human bulldozer is free, the player can click on a rock already being pushed to have the bulldozer move behind the first one and push the rock faster.
- It is possible to push a rock that is being pushed by the opponent to block or slow down its movement. If a second bulldozer is added in this situation, the rock will be pushed in the direction where there are fewer bulldozers.
- The game ends when all rocks have been moved out of the RoadZone. The winner is the one with the highest score, based on the number and size of rocks successfully moved to the opposing zone.
- The goal for the human player is to move all the rocks to the ComputerZone while preventing the computer from doing the same. Effective strategy and skillful bulldozer management are necessary to maximize the score.
There is no time limit in this game, and players must use their judgment to determine the best way to move rocks and use their bulldozers to win the game.
*/ 
//PARAMETRES DIVERS DU JEU 
function _typeof2(o) {
	"@babel/helpers - typeof";
	return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof2(o);
}
function __defineProperties(target, props) {
	for (var i = 0; i < props.length; i++) {
		var descriptor = props[i];
		descriptor.enumerable = descriptor.enumerable || false;
		descriptor.configurable = true;
		if ("value" in descriptor) {
			descriptor.writable = true;
		}
		Object.defineProperty(target, _toPropertyKey2(descriptor.key), descriptor);
	}
}
function _createClass2(Constructor, protoProps, staticProps) {
	if (protoProps) {
		__defineProperties(Constructor.prototype, protoProps);
	}
	if (staticProps) {
		__defineProperties(Constructor, staticProps);
	}
	Object.defineProperty(Constructor, "prototype", {
		writable: false
	});
	return Constructor;
}
function _toPropertyKey2(t) {
	var i = _toPrimitive2(t, "string");
	return "symbol" == _typeof2(i) ? i : String(i);
}
function _toPrimitive2(t, r) {
	if ("object" != _typeof2(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof2(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
function _classCallCheck2(instance, Constructor) {
	if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function _defineProperties(target, props) {
	for (var i = 0; i < props.length; i++) {
		var descriptor = props[i];
		descriptor.enumerable = descriptor.enumerable || false;
		descriptor.configurable = true;
		if ("value" in descriptor) {
			descriptor.writable = true;
		}
		Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
	}
}
function _createClass(Constructor, protoProps, staticProps) {
	if (protoProps) {
		_defineProperties(Constructor.prototype, protoProps);
	}
	if (staticProps) {
		_defineProperties(Constructor, staticProps);
	}
	Object.defineProperty(Constructor, "prototype", {
		writable: false
	});
	return Constructor;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : String(i);
}
function _toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
function _classCallCheck(instance, Constructor) {
	if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
var nbRochers = 10; //nombre de rochers
var vitesseBuldo = 8.0; //vitesse de déplacement des buldos a vide, vitesse/2 quand ils poussent un petit rocher, vitesse/4 pour un moyen, vitesse/8 pour un gros
var humanCamp = 1; //camp du joueur humain
var ordiCamp = -1; //camp du joueur ordinateur
var ancrageMedian = 0.5; //ancrage median des sprites
var buldoRockHotSpotX = 35; //hotspot X du sprite buldoRock, offset du sprite par rapport à l'ancrage
var buldoRockHotSpotY = 0; //hotspot Y du sprite buldoRock
var buldoRockBkHotSpotX = -40; //hotspot arriere du buldoRock
var buldoRockBkHotSpotY = 0;
var buldoZerHotSpotX = -35; //hotspot X du sprite buldoZer, offset du sprite par rapport à l'ancrage
var buldoZerHotSpotY = 0; //hotspot Y du sprite buldoZer
var buldoZerBkHotSpotX = 35; //hotspot arriere du buldoZer
var buldoZerBkHotSpotY = 0;
var petitRocher = 2; //taille du rocher (2=petit, 4=moyen, 8=gros)
var petitRocherDxHotLeft = -16; //hotspot X du sprite petitRocher, offset du sprite par rapport à l'ancrage
var petitRocherDyHotLeft = 0; //hotspot Y du sprite petitRocher
var petitRocherDxHotRight = 20; //hotspot X du sprite petitRocher, offset du sprite par rapport à l'ancrage
var petitRocherDyHotRight = 0; //hotspot Y du sprite petitRocher
var moyenRocher = 4; //taille du rocher (2=petit, 4=moyen, 8=gros)
var moyenRocherDxHotLeft = -35; //hotspot X du sprite moyenRocher, offset du sprite par rapport à l'ancrage
var moyenRocherDyHotLeft = 0; //hotspot Y du sprite moyenRocher
var moyenRocherDxHotRight = 15; //hotspot X du sprite moyenRocher, offset du sprite par rapport à l'ancrage
var moyenRocherDyHotRight = 0; //hotspot Y du sprite moyenRocher
var grosRocher = 8; //taille du rocher (2=petit, 4=moyen, 8=gros)
var grosRocherDxHotLeft = -40; //hotspot X du sprite grosRocher, offset du sprite par rapport à l'ancrage
var grosRocherDyHotLeft = 0; //hotspot Y du sprite grosRocher
var grosRocherDxHotRight = 45; //hotspot X du sprite grosRocher, offset du sprite par rapport à l'ancrage
var grosRocherDyHotRight = 0; //hotspot Y du sprite grosRocher
var typeRotation = 1; //Type 1 = rotation
var typeLigneHtoX = 2; //Type 2 = déplacement horizontal vers une position X
var typeLigneVtoY = 3; //Type 3 = déplacement vertical vers une position Y
var scoreHumain = 0;
var scoreOrdi = 0;
var ScoreZone = {
	x: 0,
	y: 0,
	width: game.width,
	height: 200
};
var OptionsZone = {
	x: 0,
	y: game.height - 200,
	width: game.width,
	height: 200
};
var HumanZone = {
	x: 0,
	y: ScoreZone.height,
	width: game.width / 10,
	height: game.height - ScoreZone.height - OptionsZone.height
};
var ComputerZone = {
	x: game.width - game.width / 10,
	y: ScoreZone.height,
	width: game.width / 10,
	height: HumanZone.height
};
var RoadZone = {
	x: HumanZone.width,
	y: ScoreZone.height,
	width: game.width - HumanZone.width - ComputerZone.width,
	height: game.height - OptionsZone.height - ScoreZone.height
};
var Rocher = /*#__PURE__*/_createClass(function Rocher() {
	var tailleRocher = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : petitRocher;
	var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : RoadZone.width / 2;
	var y = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : RoadZone.height / 2;
	_classCallCheck(this, Rocher);
	var self = this; // Initialize self to refer to the Rocher instance
	self.name = "rocher";
	self.dxHotLeftSpot = petitRocherDxHotLeft; //Offset du point chaud du sprite (point de contact avec le rocher a gauche) décalage par rapport au point d'ancrage
	self.dyHotLeftSpot = petitRocherDyHotLeft;
	self.dxHotRightSpot = petitRocherDxHotRight; //Offset du point chaud du sprite (point de contact avec le rocher a droite) décalage par rapport au point d'ancrage
	self.dyHotRightSpot = petitRocherDyHotRight;
	self.isBeingPushed = false; //Flag qui indique si le rocher est pousse par un buldo
	self.vitesse = 0.0;
	self.pushedByHuman = null; //BuldoRock qui pousse le rocher
	self.pushedByOrdi = null; //BuldoZer qui pousse le rocher
	self.totalPushers = 0; //Nombre de buldos qui poussent le rocher (+1 pour un buldoRock, -1 pour un buldoZer)
	var rocher_petit_sprite = game.addChild(LK.getAsset('small_rock', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	var rocher_moyen_sprite = game.addChild(LK.getAsset('medium_rock', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	var rocher_gros_sprite = game.addChild(LK.getAsset('large_rock', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	self.tailleRocher = tailleRocher;
	if (self.tailleRocher == petitRocher) {
		self.sprite = rocher_petit_sprite;
	}
	if (self.tailleRocher == moyenRocher) {
		self.sprite = rocher_moyen_sprite;
	}
	if (self.tailleRocher == grosRocher) {
		self.sprite = rocher_gros_sprite;
	}
	self.sprite.x = x;
	self.sprite.y = y;
	self.sprite.anchor.set(0.5);
	self.sprite.scale.set(1.0);
	if (self.tailleRocher == petitRocher) {
		self.dxHotLeftSpot = petitRocherDxHotLeft;
		self.dyHotLeftSpot = petitRocherDyHotLeft;
		self.dxHotRightSpot = petitRocherDxHotRight;
		self.dyHotRightSpot = petitRocherDyHotRight;
	}
	if (self.tailleRocher == moyenRocher) {
		self.dxHotLeftSpot = moyenRocherDxHotLeft;
		self.dyHotLeftSpot = moyenRocherDyHotLeft;
		self.dxHotRightSpot = moyenRocherDxHotRight;
		self.dyHotRightSpot = moyenRocherDyHotRight;
	}
	if (self.tailleRocher == grosRocher) {
		self.dxHotLeftSpot = grosRocherDxHotLeft;
		self.dyHotLeftSpot = grosRocherDyHotLeft;
		self.dxHotRightSpot = grosRocherDxHotRight;
		self.dyHotRightSpot = grosRocherDyHotRight;
	}
	if (self.tailleRocher == petitRocher) {
		self.name = "Petit Rocher";
	}
	if (self.tailleRocher == moyenRocher) {
		self.name = "Moyen Rocher";
	}
	if (self.tailleRocher == grosRocher) {
		self.name = "Gros Rocher";
	}
}); //fin class Rocher
var Buldo = /*#__PURE__*/_createClass2(function Buldo(sprite, x, y, dxHotSpot, dyHotSpot, dxBkHotSpot, dyBkHotSpot, camp) {
	_classCallCheck2(this, Buldo);
	this.name = "buldo";
	this.isSelected = false; //Flag qui indique si le Buldo est selectionne
	this.sprite = sprite;
	this.sprite.x = x;
	this.sprite.y = y;
	this.sprite.anchor.set(0.5);
	this.sprite.scale.set(1.0);
	this.dxAvHotSpot = dxHotSpot; //Offset du point chaud du sprite (point de contact avec le rocher) décalage par rapport au point d'ancrage
	this.dyAvHotSpot = dyHotSpot;
	this.dxBkHotSpot = dxBkHotSpot; //Offset du point chaud arriere du sprite (point de contact avec un autre Buldo) décalage par rapport au point d'ancrage
	this.dyBkHotSpot = dyBkHotSpot;
	this.camp = camp; //Camp du buldo (1=Human buldoRock ou 2=Ordi buldoZer)
	this.xBase = x; //Position de base du sprite
	this.yBase = y;
	this.stack = []; //Pile des points x,y destination cliqués par la souris
	this.movesStack = []; //Pile des mouvements a effectuer (types de mouvements : 1 : rotation, 2 : horizontal, 3 : vertical, 4 : xy)
	this.vitessePS = vitesseBuldo; //vitesse de deplacement du sprite en pixels par secondes
	this.vitesseEnCours = 0.0; //vitesse de deplacement en cours en pixels par secondes en cours de deplacement
	this.vitDxms = 0.0; //vitesse de deplacement horizontale en pixels par secondes
	this.vitDyms = 0.0; //vitesse de deplacement verticale en pixels par secondes
	this.isMoving = false; //Flag qui indique si le Buldo est en mouvement
	this.isMovingH = false; //Flag qui indique si le Buldo est en mouvement         
	this.isMovingH = false; //Flag qui indique si le Buldo est en mouvement horizontal
	this.isMovingV = false; //Flag qui indique si le Buldo est en mouvement vertical
	this.isMovingXY = false; //Flag qui indique si le Buldo est en mouvement vers un point x,y
	this.isMovingHtoPush = false; //Flag qui indique si le Buldo est en mouvement horizontal pour pousser un rocher
	this.xDestination = 0.0; //Abscisse x du point x,y destination
	this.yDestination = 0.0; //Ordonnee y du point x,y destination
	this.distTotale = 0.0; //Distance totale a parcourir 
	this.distRestante = 0.0; //Distance restante a parcourir en pixels 
	this.isPushing = false; //Flag qui indique si le Buldo est en train de pousser un rocher
	this.rocherPushed = null; //Rocher pousse par le Buldo
	this.isRotating = false; //Flag qui indique si le Buldo est en rotation
	this.sprite.rotation = 0.0;
	this.angleDegresTotal = 0.0; //Angle total a tourner en degres
	this.angleRadiansLeft = 0.0; //Angle restant a tourner en radians
	this.vitesseAngulaireDS = 2.0; //vitesse de rotation du sprite en degres par secondes
	this.vitesseAngulaireRms = 0.0; //vitesse angulaire en radians par millisecondes    
}); //fin constructor
function generateRandomRock(nombreRochers) {
	//Calcul de positions aléatoire pour les rochers dans la zone de route
	var zoneMiniy = RoadZone.y;
	var zoneMaxiy = RoadZone.y + RoadZone.height;
	//Calcul des ordonnees possibles pour les rochers entre zoneMiniy + 50 et zoneMaxiy - 50
	var ordonneesPossibles = [];
	for (var i = zoneMiniy + 50; i < zoneMaxiy - 50; i += 100) {
		ordonneesPossibles.push(i);
	}
	//Securite : si le nombre de rochers demande est superieur au nombre d'ordonnees possibles, on ajuste le nombre de rochers
	if (nombreRochers > ordonneesPossibles.length) {
		nombreRochers = ordonneesPossibles.length;
	}
	var rochers = [];
	//Creation des rochers
	for (var i = 0; i < nombreRochers; i++) {
		// Choisir une taille de rocher aléatoire
		var sizes = [petitRocher, moyenRocher, grosRocher];
		var size = sizes[Math.floor(Math.random() * sizes.length)];
		// Choisir une abscisse aléatoire pour le rocher
		var zoneMinix = RoadZone.x + 100;
		var zoneMaxix = RoadZone.x + RoadZone.width - 100;
		var x = Math.random() * (zoneMaxix - zoneMinix) + zoneMinix;
		//Choix d'une ordonnee aleatoire en supprimant l'ordonnee choisie precedemment
		var index = Math.floor(Math.random() * ordonneesPossibles.length);
		var y = ordonneesPossibles[index];
		ordonneesPossibles.splice(index, 1);
		// Créer le rocher
		var rock = new Rocher(size, x, y);
		rochers.push(rock);
	}
	return rochers;
} //fin generateRandomRock
var rochers = generateRandomRock(nbRochers); //création des rochers