include("Move");
include("Leek");

/*
global ennemies_position=[];
for (var e in getAliveEnemies())
	ennemies_position[getCell(e)]=1;


debug(ennemies_position);
var aaaa=getInstructionsCount();
debug("tt="+ennemies_at_range(getCell(getNearestEnemy())+18,2));
debug("ttinstr="+(getInstructionsCount()-aaaa));

aaaa=getInstructionsCount();
debug(getCellDistance(getCell(getNearestEnemy())+18
,  getNearestEnemyToCell(getCell(getNearestEnemy())+18))<3);
debug("gginstr="+(getInstructionsCount()-aaaa));

function ennemies_at_range(cell,range) {
	var res=false;
	if (range==0)
		return (getLeekOnCell(cell) !=-1);
	else {
		var x= getCellX(cell);
		var y=getCellY(cell);
		mark(cell,COLOR_GREEN);
		for (var i=x-range;i<=x+range;i++) {
			for (var j=y-range;j<=y+range;j++) {
				var new_cell = getCellFromXY(i,j);
				if (new_cell==null || abs(i-x)+abs(j-y)>range)continue;
				if (ennemies_position[new_cell]!=null) return true;

			}
		}

	}
	return false;
}
*/

// marche pour aoe de taille 0 ou 2 (chip ou weapon)
function get_best_cell_area_weapon_or_chip(me, weapon, mp) {
	if (getMP() + get_weapon_aoe(weapon)
	+ (isWeapon(weapon) ? getWeaponMaxScope(weapon)
	: getChipMaxScope(weapon)) <
	getCellDistance(getCell(me), getCell(getNearestEnemyTo(me)))) return;

	return (get_cells_weapon_or_chip(weapon,mp));
}

function get_cells_focus2(weapon,mp) {
	if (mp==null) mp=getMP();
	var instr = getInstructionsCount();
	if (instr > 250000) {
		debug("calculs stoppés");
		return;
	}
	var boolWeapon = isWeapon(weapon);
	//	var boolLine =boolWeapon?isInlineWeapon(weapon):isInlineChip(weapon);
	var res = [];
	var minscope = boolWeapon ? getWeaponMinScope(weapon) : getChipMinScope(weapon);
	var maxscope = boolWeapon ? getWeaponMaxScope(weapon) : getChipMaxScope(weapon);
	var mypos = getCell();
	var myX = getCellX(mypos);
	var myY = getCellY(mypos);
	var weapon_aoe = get_weapon_aoe(weapon);
	var minX = myX - maxscope - mp;
	var maxX = myX + maxscope + mp;
	var minY = myY - maxscope - mp;
	var maxY = myY + maxscope + mp;

	for (var i = minX; i <= maxX; i++) {
		var absX = abs(i - myX);
		for (var j = minY; j <= maxY; j++) {
			var absY = abs(j - myY);
			var new_cell = getCellFromXY(i, j);
			if (new_cell != null) {
				if (
				absX + absY > maxscope+mp
				|| (getCellDistance(new_cell, getCell(getNearestEnemyToCell(new_cell)))
				> weapon_aoe)  || isObstacle(new_cell)
				|| absX + absY < minscope-mp

				)


				continue;

				var toMove = boolWeapon ? getCellToUseWeaponOnCell(weapon, new_cell)
				: getCellToUseChipOnCell(weapon, new_cell);
				if (toMove == null || toMove == -1) continue;
				var pathLength = getPathLength(getCell(), toMove);
				if (pathLength <= mp && lineOfSight(toMove, new_cell)) push(res, new_cell);


			}
		}
	}

	return (res);
}


function formForce(x) {
	return (x * (1 + (getForce() / 100)));
}




function getWeaponDmg(weapon) {
	var dmg = [];
	var effects = getWeaponEffects(weapon);
	for (var effect in effects) {
		if (effect[0] == EFFECT_DAMAGE) {
			push(dmg, effect[1]); //min dmg
			push(dmg, effect[2]); //max dmg
			return (dmg);
		}
	}
	return;
}

function initWeapon() {
	if (getWeapon() == null) setWeapon(WEAPON_GRENADE_LAUNCHER);
}

function get_weapon_or_chip_cost(weapon) {
	if (weapon==null) return;
	return (isWeapon(weapon) ? getWeaponCost(weapon) : getChipCost(weapon));
}



function get_cells_weapon_or_chip(weapon,mp) {
	if (getInstructionsCount() > 240000) return;
/*	var bb = getInstructionsCount();
	var res = get_cells_focus(cells, weapon);
	debug("instr_old="+(getInstructionsCount()-bb));
	bb = getInstructionsCount();

	var res2=get_cells_focus2(weapon);
		debug("instr_new="+(getInstructionsCount()-bb));

	debug("res==res2?"+(res==res2));
	debug("count?"+(count(res)==count(res2)));
	mark(res2,COLOR_BLUE);
	debug("res="+res);
	debug(" et res2="+res2);

	debug("cette pute coute" + (getInstructionsCount() - bb)); */

	var res = get_cells_focus2(weapon,mp);
	var bestCell = null;
	var dmg = [];
	dmg['min'] = 0;
	dmg['max'] = 0;
	var affectedEnnemies = 0;
	//              var maxscope = isWeapon(weapon) ? getWeaponMaxScope(weapon) : getChipMaxScope(weapon);
	for (var cell in res) {
		//              if (getMP()<getPathLength(cell, getCell())+maxscope)
		//                      continue;
		var from = isWeapon(weapon) ? getCellToUseWeaponOnCell(cell) : getCellToUseChipOnCell(weapon, cell);
		//      if (weapon==WEAPON_LASER)
		//from=isWeapon(weapon) ? getCellToUseWeaponOnCell(weapon, cell) : getCellToUseChipOnCell(weapon, cell);
		var damageDealt = getAreaDamageOnCell(cell, weapon, from);
		if (damageDealt == null) continue;
		else if ((damageDealt['min'] + damageDealt['max']) /2 > (dmg['min']+dmg['max'])/2) {
			dmg['min'] = damageDealt['min'];
			dmg['max'] = damageDealt['max'];
			dmg['killed'] = damageDealt['killed'];
			dmg['togo'] = from;
			dmg['mpSpend'] = damageDealt['mpSpend'];

			bestCell = cell;
		}

	}
	if (bestCell == null || dmg['min'] <= 0) {
		return;
	} else {
		var weap = [];
		weap['tohit'] = bestCell;

		//weap['togo'] = isWeapon(weapon) ? getCellToUseWeaponOnCell(bestCell) : getCellToUseChipOnCell(weapon, bestCell);
		weap['togo'] = dmg['togo'];
		weap['min'] = dmg['min'];
		weap['max'] = dmg['max'];
		weap['killed'] = dmg['killed'];
		weap['mpSpend'] = dmg['mpSpend'];
		debug(weap+(isWeapon(weapon)?getWeaponName(weapon):getChipName(weapon)));
		return weap;

	}


}

// work for both chip and weapon
function getAreaDamageOnCell(cell, weapon, from) {
	var boolWeapon = isWeapon(weapon);
	var tabBaseDamage = boolWeapon ? getWeaponDmg(weapon) : getChipDamage(weapon);
	var targets = null;
	var distanceToTravel = 0;
	var aoe=get_weapon_aoe(weapon);
	if (from != getCell()) distanceToTravel = getPathLength(getCell(), from);
	if (from != null && aoe>0) targets = getTargetsFrom(weapon, cell, from);
	else {
		if (aoe==0)
			targets=[getLeekOnCell(cell)];
		else
			targets = boolWeapon ? getWeaponTargets(weapon, cell)
			: getChipTargets(weapon, cell);
	}
	var res = [];
	res['killed'] = 0;
	res['min'] = 0;
	res['max'] = 0;
	if (targets == null || isEmpty(targets)) return;
	for (var target in targets) {
		if (isAlly(target)) {
			if (target == getLeek() && weapon == CHIP_LIGHTNING) continue;
			else return;
		}
		var tabDmg = [];
		tabDmg[0] = tabBaseDamage[0];
		tabDmg[1] = tabBaseDamage[1];
		var distanceToMiddleArea = getCellDistance(cell, getCell(target));
		var multiplier;
		var weapon_aoe = get_weapon_aoe(weapon);
		if (weapon_aoe > 0)
		multiplier = (100 - (50 * distanceToMiddleArea / weapon_aoe));
		else multiplier = 100;
		applyForceAndMultiplier(tabDmg, multiplier);
		var dmgAfterReduc = reducedDmg(tabDmg, target);



	/*
		if (average(dmgAfterReduc) >= life) {
			if (dmgAfterReduc[0]>life)
			res['killed']++;
			dmgAfterReduc[0] = 5 * life;
			dmgAfterReduc[1] = 5 * life;

		} */
		if (getLevel(target)>80  && (isWeapon(weapon)|| getChipCooldown(weapon)==0)) {
			var dmgTurn =
		average(dmgAfterReduc)*ceil(getTP()/get_weapon_or_chip_cost(weapon));
		var life = getLife(target);
			if (dmgTurn>life) {
			res['killed']++;
			dmgAfterReduc[0] += 500;
			dmgAfterReduc[1] += 500;
		}}
		if (getLevel(target) < 85) {
			dmgAfterReduc[0] *= 0.7;
			dmgAfterReduc[1] *= 0.7;
		}
		if (dmgAfterReduc[1] > 0) {
			res['min'] += dmgAfterReduc[0];
			res['max'] += dmgAfterReduc[1];
		}

	}

	res['min'] *= 1 - 0.09 * distanceToTravel;
	res['max'] *= 1 - 0.09 * distanceToTravel;
	res['mpSpend'] = distanceToTravel;
	return res;

}

function get_weapon_aoe(weapon) {
	if (weapon == WEAPON_LASER) return 5;
	else if (weapon == WEAPON_GRENADE_LAUNCHER || weapon == CHIP_METEORITE
	|| weapon == CHIP_ICEBERG || weapon == CHIP_LIGHTNING) return 2;
	else if (weapon=WEAPON_GAZOR) return 3;
	else return 0;
}









global global_force;
global_force = getForce();

function formForceGlobal(x) {
	return (x * (1 + global_force / 100));
}
// renvoit les dmg reduits par le bouclier de enemy
function reducedDmg(dmg, enemy) {;
	var absoluteShield = getAbsoluteShield(enemy);
	var relativeShield = getRelativeShield(enemy);
	var res = [];
	var minDmg = ((1 - (relativeShield / 100)) * dmg[0]) - absoluteShield;
	var maxDmg = ((1 - (relativeShield / 100)) * dmg[1]) - absoluteShield;
	minDmg <= 0 ? push(res, 0) : push(res, minDmg);
	maxDmg <= 0 ? push(res, 0) : push(res, maxDmg);
	return (res);
}

function applyForceAndMultiplier(@tabDmg, multiplier) {
	tabDmg[0] = floor(formForceGlobal(tabDmg[0]) * multiplier / 100);
	tabDmg[1] = floor(formForceGlobal(tabDmg[1]) * multiplier / 100);
}

function getTargetsFrom(weapon, cell, from) {
	var cells = isWeapon(weapon) ? getWeaponEffectiveArea(weapon, cell, from) : getChipEffectiveArea(weapon, cell, from);
	var victims = [];
	for (var cellTest in cells) {
		var leek = getLeekOnCell(cellTest);
		if (leek != -1) {
			push(victims, leek);
		}
	}
	if (victims == null || isEmpty(victims)) return;
	else return victims;
}




function get_weapon_or_chip_victims_area(weapon, cell, from) {
	var targets = getTargetsFrom(weapon, cell, from);
	var res = 0;
	for (var target in targets) {
		if (isAlly(target)) {
			if (target == getLeek() && (weapon == CHIP_LIGHTNING || weapon == WEAPON_LASER)) continue;
			else return 0;
		} else {
			res++;
		}
	}
	return res;
}


function attack(cell, weapon) {
	isWeapon(weapon) ? useWeaponOnCell(cell['tohit']) : useChipOnCell(weapon, cell['tohit']);
}

function moveCell(cell) {
	moveTowardCell(cell['togo']);
}

//verifie qu'il y a au moins 1 ennemi'
function verifTargets(weapon, cell) {
	var cells = isWeapon(weapon)
	? getWeaponEffectiveArea(weapon, cell, getCell())
	: getChipEffectiveArea(weapon, cell, getCell());
	for (var cellTest in cells) {
		var leek = getLeekOnCell(cellTest);
		if ( leek != -1 && isEnemy(leek))return true;

	}
	return false;
}



function chip_or_weapon_cell(weapon, cell) {
	if (weapon==null) return;
	var tp_cost = isWeapon(weapon) ? getWeaponCost(weapon) : getChipCost(weapon);
	if (cell == null || cell == -1 || cell['max'] == null || getTP() < tp_cost || cell['max'] <= 0) return;


	if ((cell != null && (cell['max'] > 0)
	&& ((getTP() >= tp_cost) && (verifTargets(weapon, cell['tohit']))))) {

		mark(cell['togo'], COLOR_GREEN);
		mark(cell['tohit'], COLOR_RED);
		moveCell(cell);
		var ee = getNearestEnemyToCell(cell['tohit']);
		if (getCooldown(CHIP_LIBERATION) == 0
		&& (canUseChip(CHIP_LIBERATION, ee)) && getTP() >= tp_cost + 5 && (
		(getAbsoluteShield(ee) > 80 && getRelativeShield(ee) > 25) || (getAbsoluteShield(ee) > 150
		|| getRelativeShield(ee) > 44))) {

			useChip(CHIP_LIBERATION, ee);

		}
		var timeout = 6;
		while (getTP()>=tp_cost && (verifTargets(weapon, cell['tohit'])) && timeout>0) {
		attack(cell, weapon);
		timeout--;
		}
	}
}






function setBestWeapon(@res, weapons, @bestWeapon, @bestDmg) {
	var me = getLeek();
	bestWeapon = null;
	res = [];
	bestDmg = 0;
	for (var weapon in weapons) {
		if ((isWeapon(weapon) ? getWeaponCost(weapon)
		: getChipCost(weapon)) <= getTP())
		res[weapon] = get_best_cell_area_weapon_or_chip(me, weapon, getMP());
		if (getInstructionsCount() > 250000) {
			debug("calculs stoppés");
			break;
		}
	}
	for (var weapon in weapons) {
		if (res[weapon] == null) continue;
		var avg = getEfficacite(res[weapon], weapon);
		if (avg > bestDmg) {
			bestDmg = avg;
			bestWeapon = weapon;
		}

	}
}



function getChipDamage(chip) {
	var dmg = [];
	var effects = getChipEffects(chip);
	for (var effect in effects) {
		if (effect[0] == EFFECT_DAMAGE) {
			push(dmg, effect[1]); //min dmg
			push(dmg, effect[2]); //max dmg
		}
	}
	return (dmg);
}



function getEfficacite(cell, weapon) {
	if (weapon == null) return 0;
	var weapon_cost = get_weapon_or_chip_cost(weapon);
	var ec= max(0,isWeapon(weapon)
	? getWeaponFailure(weapon) : getChipFailure(weapon)-(getCores()-1));
	return ((((((100 - ec)) / 100)
	* ((cell['min'] + cell['max']) / 2)) / weapon_cost));

}