Esempio n. 1
0
int main () {
	PP_Open(); /* open the Prog&Play API */
	PP_Unit u = PP_GetUnitAt(MY_COALITION, 0);
	PP_Pos p = PP_Unit_GetPosition(u);
	p.x += 927;
	p.y -= 513;
	PP_Unit_ActionOnPosition(u, MOVE, p);
	/* close the Prog&Play API */
	PP_Close();
	return 0;
}
Esempio n. 2
0
// faire progresser un groupe en ligne droite d'une certaine distance
void progresser (Groupe g, float distance){
	int i;
	PP_Pos pos;
	
	for (i = 0 ; i < g.nbMembres ; i++){
		pos = PP_Unit_GetPosition(g.membres[i]);
		pos.x = pos.x + distance;
		if (pos.x < 0)
			pos.x = 10;
		if (pos.x > PP_GetMapSize().x)
			pos.x = PP_GetMapSize().x - 10;
		PP_Unit_ActionOnPosition(g.membres[i], MOVE, pos);
	}
}
Esempio n. 3
0
// détermine si une unité est supérieure ou inférieure à une autre en fonction
// d'un critère (X ou Y)
int sup(PP_Unit u1, PP_Unit u2, CRITERE c){
	if (c == X)
		return PP_Unit_GetPosition(u1).x > PP_Unit_GetPosition(u2).x;
	else
		return PP_Unit_GetPosition(u1).y > PP_Unit_GetPosition(u2).y;
}
Esempio n. 4
0
// détermine une cible à attaquer pour le groupe g
PP_Unit determinerCible (Groupe g){
	PP_Unit ennemis [MAX_UNITS];
	int occurrence [MAX_UNITS];
	PP_Unit e, tmp;
	PP_Pos bar;
	int i, j, k, cpt;
	int indice, max;
	float distance, dx, dy;
	PP_PendingCommands cmd;
	
	// initialisation
	cpt = 0;
	// enregistrer les cibles actuelles et comptabiliser les occurences
	for (i = 0 ; i < g.nbMembres ; i++){
		PP_Unit_GetPendingCommands(g.membres[i], &cmd);
		for (j = 0 ; j < cmd.nbCmds ; j++)
			if (cmd.cmd[j].code == ATTACK)
				if (cmd.cmd[j].nbParams == 1){
					// chercher si cet ennemi est déjà pris en compte
					indice = -1;
					e = cmd.cmd[j].param[0];
					for (k = 0 ; k < cpt && indice == -1 ; k++)
						if (ennemis[k] == e)
							indice = k;
					if (indice != -1)
						occurrence[indice]++;
					else{
						ennemis[cpt] = e;
						occurrence[cpt] = 1;
						cpt++;
					}
				}
	}
	if (cpt > 0){
		// identifier l'ennemi le plus référencé et le plus endommagé
		max = 0;
		indice = 0;
		for (i = 0 ; i < cpt ; i++){
			if (occurrence[i] > max){
				indice = i;
				max = occurrence[i];
			}
			else
				if (occurrence[i] == max)
					if (PP_Unit_GetHealth(ennemis[i]) < PP_Unit_GetHealth(ennemis[indice])){
						indice = i;
					}
		}
		return ennemis[indice];
	}
	else{
		// calcul du barycentre du groupe
		bar.x = 0;
		bar.y = 0;
		for (i = 0 ; i < g.nbMembres ; i++){
			bar.x = bar.x + PP_Unit_GetPosition(g.membres[i]).x;
			bar.y = bar.y + PP_Unit_GetPosition(g.membres[i]).y;
		}
		if (g.nbMembres != 0){
			bar.x = bar.x / g.nbMembres;
			bar.y = bar.y / g.nbMembres;
		}
		// rechercher l'ennemi le plus proche du groupe
		distance = PP_GetMapSize().x*PP_GetMapSize().x+PP_GetMapSize().y*PP_GetMapSize().y;
		for (i = 0 ; i < PP_GetNumUnits(ENEMY_COALITION) ; i++){
			tmp = PP_GetUnitAt(ENEMY_COALITION, i);
			dx = bar.x - PP_Unit_GetPosition(tmp).x;
			dy = bar.y - PP_Unit_GetPosition(tmp).y;
			if (dx*dx+dy*dy < distance){
				distance = dx*dx+dy*dy;
				e = tmp;
			}
		}
		return e;
	}
}
Esempio n. 5
0
int main (){
	int i, j, sens;
	PP_Pos pos;
	PP_Unit u, select, tmp;
	bool attaque;
	float distance, dx, dy;
	PP_PendingCommands cmd;
	
	// ouverture du jeu
	PP_Open();
	
	// determination de la direction de l'attaque
	if (PP_GetStartPosition().x < PP_GetMapSize().x/2)
		sens = 1;
	else
		sens = -1;
	
	// lancer la marche
	for (i = 0 ; i < PP_GetNumUnits(MY_COALITION) ; i++){
		pos = PP_Unit_GetPosition(PP_GetUnitAt(MY_COALITION, i));
		if (sens == -1)
			pos.x = 10;
		else
			pos.x = PP_GetMapSize().x - 10;
		PP_Unit_ActionOnPosition(PP_GetUnitAt(MY_COALITION, i), MOVE, pos);
	}
	// attendre le départ de l'armée
	while (!mobile())
		printf("Attente depart armee\n");
	
	// ordonner d'attaquer les bytes ennemis
	while (!PP_IsGameOver()){
		if (PP_GetNumUnits(ENEMY_COALITION) == 0){
			// faire une recherche aléatoire
			for (i = 0 ; i < PP_GetNumUnits(MY_COALITION) ; i++){
				u = PP_GetUnitAt(MY_COALITION, i);
				if (PP_Unit_GetPendingCommands(u, &cmd) != -1){
					if (cmd.nbCmds == 0){
						pos.x = rand() % (int)PP_GetMapSize().x + 1;
						pos.y = rand() % (int)PP_GetMapSize().y + 1;
						PP_Unit_ActionOnPosition(PP_GetUnitAt(MY_COALITION, i), MOVE, pos);
					}
				}
			}
		}
		else{
			// ordonner aux unités qui n'attaquent pas de cibler l'unité ennemie la plus proche d'elle
			for (i = 0 ; i < PP_GetNumUnits(MY_COALITION) ; i++){
				printf(" %d", i);
				u = PP_GetUnitAt(MY_COALITION, i);
				if (PP_Unit_GetPendingCommands(u, &cmd) != -1){
					attaque = false;
					if (cmd.nbCmds == 0)
						attaque = true;
					else if (cmd.nbCmds > 0)
						if (cmd.cmd[0].code != ATTACK)
							attaque = true;
					if (attaque){
						pos = PP_Unit_GetPosition(u);
						// calcul de la distance max pour cette carte
						distance = PP_GetMapSize().x*PP_GetMapSize().x+PP_GetMapSize().y*PP_GetMapSize().y;
						select = -1;
						for (j = 0 ; j < PP_GetNumUnits(ENEMY_COALITION) ; j++){
							tmp = PP_GetUnitAt(ENEMY_COALITION, j);
							dx = pos.x - PP_Unit_GetPosition(tmp).x;
							dy = pos.y - PP_Unit_GetPosition(tmp).y;
							if (dx*dx+dy*dy < distance){
								distance = dx*dx+dy*dy;
								select = tmp;
							}
						}
						if (select != -1)
							PP_Unit_ActionOnUnit(u, ATTACK, select);
					}
				}
				else{
					printf("%s", PP_GetError());
				}
			}
			printf("\n");
		}
	}
	// fermer le jeu
	PP_Close();
	return 0;
}