Example #1
0
def eviteObstacles(percepts):

    dist1 = dist2 = 500
    taille_robot = 20
    liste_obstacles = []
    for p in percepts:
        centre = Point()
        centre.setCoord(p.getX(), p.getY())
        liste_obstacles.append(centre)

    # on dessine 2 droite paralleles a la direction
    # qui partent des bords du robot -> d1 : y = 12 et d2 : y = -12
    # Dans nouveau repere : origine = self
    #                       rotation du repere de l'angle de direction courant
    direction = self.getHeading()
    angle = Math.PI * direction / 180
    t = Math.tan(angle)
    s = Math.sin(angle)
    c = Math.cos(angle)

    for p in liste_obstacles:

        # centre_x, centre_y : centre de l'obstacle dans le repere
        centre_x = (p.getX() + t * p.getY()) / (c + s * t)
        centre_y = -p.getY() / c + t * centre_x

        # savoir quelle droite prendre
        if centre_x > 0:
            if centre_y >= 0 and centre_y <= 2 * taille_robot:
                y = centre_y - taille_robot
                dist1 = min(
                    dist1,
                    -Math.sqrt(taille_robot * taille_robot - y * y) + centre_x)
            elif centre_y < 0 and centre_y >= -(2 * taille_robot):
                y = centre_y + taille_robot
                dist2 = min(
                    dist2,
                    -Math.sqrt(taille_robot * taille_robot - y * y) + centre_x)

    if min(dist1, dist2) <= 100 and abs(dist1 - dist2) > 2:
        if dist1 < dist2:
            direction += 100 / dist1
        else:
            direction -= 100 / dist2

        self.setHeading(direction)
Example #2
0
def eviteAmis(percepts):

	dist1 = dist2 = 500
	taille_robot = 20
	liste_obstacles = []
	for p in percepts:
		centre = Point()
		centre.setCoord(p.getX(), p.getY())
		liste_obstacles.append(centre)
		
		        			
	# on dessine 2 droite paralleles a la direction
	# qui partent des bords du robot -> d1 : y = 12 et d2 : y = -12
	# Dans nouveau repere : origine = self
	#                       rotation du repere de l"angle de direction courant
	direction = self.getHeading()
	angle = Math.PI * direction / 180
	t = Math.tan(angle)
	s = Math.sin(angle)
	c = Math.cos(angle)
		
	for p in liste_obstacles:
	
		# centre_x, centre_y : centre de l"obstacle dans le repere
		centre_x = (  p.getX() + t* p.getY()) / (c + s * t)
		centre_y = -p.getY()/c + t * centre_x

		# savoir quelle droite prendre
		if centre_x > 0:
			if centre_y >= 0 and centre_y <= 2*taille_robot:
				y = centre_y - taille_robot
				dist1 = min(dist1,-Math.sqrt(taille_robot*taille_robot - y*y) + centre_x)
			elif centre_y < 0 and centre_y >= -(2*taille_robot):
				y = centre_y + taille_robot
				dist2 = min(dist2,-Math.sqrt(taille_robot*taille_robot - y*y) + centre_x)

	if min(dist1, dist2) <= 100 and abs(dist1 - dist2) > 2:
		if dist1 < dist2:
			direction += 100/dist1
		else:
			direction -= 100/dist2
	
		self.setHeading(direction)	
Example #3
0
def doIt():	
	global offre
	global tour
	tour = tour + 1
	attendre = 0
	coordonnees.setX(coordonnees.getX() + getDeplX())
	coordonnees.setY(coordonnees.getY() + getDeplY())
	
	# Time to live decremente
	aide.decrementer()
	
	if aide.besoin() and coordonnees.distanceTo(aide.getCoord()) <= 90 :
		aide.finAssistance()
	
	#Rechargement des roquettes?
	if not attenteRoquettes.pret():
		attenteRoquettes.decrementer()
	
	lireMessages()
	
	if synchro.pret():
		monEtat()
	synchro.decrementer()
	
	base_cible = Point()
	if base_ennemie != [] :
		for b in base_ennemie:
			if aide.setAssistance(coordonnees, self.getName(), b.getX(), b.getY(), 10000, AIDE_BASE_ENNEMIE,3, tour):
				base_cible = b
	
	# Deplacement normal
	if aide.besoin():
		direct = self.towards(aide.getVisee().getX() - coordonnees.getX(), aide.getVisee().getY() -coordonnees.getY())
		if coordonnees.distanceTo(aide.getCoord()) > 150 or (aide.besoin() > AIDE_LAUNCHER or aide.besoin()  == AIDE_BASE_ENNEMIE): 
			self.setHeading(direct)
		else:
			self.setHeading(180 + direct)

	# BaryCentre des unites ennemies proches
	centre = Point() 
	percepts = self.getPercepts()
	nb_unites = 0
	
	ennemi_perdu = ennemi_courant.existe()
	qg_ennemi_visible = not (base_cible.estConnu() and base_cible.distanceTo(coordonnees) <= 100)
	for p in percepts:
		team = p.getTeam()
		type_percept = p.getPerceptType()
		if ((type_percept =="Home") or (type_percept =="RocketLauncher") or (type_percept == "Explorer")) and team!=self.getTeam():
			if p.getPerceptType() == "Home":
				base_abs = Point(p.getX() +coordonnees.getX(), p.getY() +coordonnees.getY())
				if not baseEnnemieConnue(base_abs):
					base_ennemie.append(base_abs)
					self.broadcast(groupName, "info", "INFO-QG", str(p.getX()), str(p.getY()))
				qg_ennemi_visible = qg_ennemi_visible or base_abs.distanceTo(base_cible) <= 10
			coord = Point(p.getX() + coordonnees.getX(), p.getY() + coordonnees.getY())
			energie = p.getEnergy()
			if not ennemi_courant.existe() :
				ennemi_courant.setCible(type_percept, coord, energie, tour)
				#self.broadcast(groupName, "launcher", "FIN")
				args = [str(p.getX()), str(p.getY()), str(p.getEnergy())]
				if type_percept == "RocketLauncher":
					self.broadcast(groupName, "launcher", "HELP2", args)
			elif ennemi_courant.egal(type_percept, coord) :
				ennemi_courant.setCible(type_percept, coord, energie, tour)
				ennemi_perdu = 0
			elif (ennemi_courant.getEnergy() > p.getEnergy()) and prioriteType(ennemi_courant.getType()) <= prioriteType(p.getPerceptType()):
				ennemi_courant.setCible(type_percept, coord, energie, tour)
				ennemi_perdu = 0
			
	if base_cible.estConnu() and not qg_ennemi_visible:
		baseEnnemieSuppr(base_cible)
		self.broadcast(groupName, "mobile", "FIN-QG", str(base_cible.getX() - coordonnees.getX()), str(base_cible.getY() - coordonnees.getY()))
		
		
#	if ennemi_courant.existe():
#		self.setUserMessage("TIR")
#	else:
#		self.setUserMessage(None)

	if ennemi_perdu:
		self.broadcast(groupName, "launcher", "FIN")
		self.broadcast(groupName, "launcher", "ETAT")
		self.broadcast(groupName, "explorer", "ETAT")
		self.setHeading(self.towards(ennemi_courant.getX() - coordonnees.getX(), ennemi_courant.getY() - coordonnees.getY()))
		ennemi_courant.delCible()
		
	elif (ennemi_courant.existe()):
		coord = ennemi_courant.viser(coordonnees)
		if tirer(coord):
			return

	
		
	# Manoeuvres d"evitement
	gentils = Point()
	mechants = Point()
	nb_mechants = 0
	nb_gentils = 0	
	evite = Point()
	amis = Vector()
	tenaille = Point()
	
	#	self.getName()
	liste_amis = []
	liste_rockets = []
	if aide.besoin():
		dist_aide = aide.getVisee().distanceTo(coordonnees)
	else:
		dist_aide = 1000
	for p in percepts:
		dist = self.distanceTo(p)
		if p.getPerceptType() == "RocketLauncher" and p.getTeam() == self.getTeam():
			liste_amis.append(p)
			r = Mobile(coordonnees.getX() + p.getX(), coordonnees.getY() + p.getY())
			amis.add(r)
			if aide.besoin() == AIDE_LAUNCHER :
				p_ami = Point(p.getX() + coordonnees.getX(), p.getY() + coordonnees.getY())
				dist_ami = p_ami.distanceTo(aide.getVisee())
				if dist_aide > 200 and dist_ami > dist_aide+20:
					attendre = 1
		if p.getPerceptType() == "Rocket":
			liste_rockets.append(p)
		if p.getPerceptType() == "Home" and p.getTeam() == self.getTeam():
			liste_amis.append(p)
		ecart_min = ecartMin(p)
		if dist > 0 and dist < ecart_min:
			mult = (ecart_min - dist)/ecart_min
			if p.getPerceptType() == "Obstacle" or (p.getTeam() == self.getTeam()):
				gentils.setCoord(gentils.getX() - p.getX()/dist *mult, gentils.getY() - p.getY()/dist*mult)
				nb_gentils +=1
			else:
				nb_mechants += 1
				mechants.setCoord(mechants.getX() - p.getX()/dist*mult, mechants.getY() - p.getY()/dist*mult)
				
	mon_groupe.amisVus(amis)

	if attendre:
		self.setHeading(self.getHeading() + 180)


	rocket_dangereuse = eviteRockets(liste_rockets)
	
	tirer_loin = aide.besoin() and aide.getVisee().distanceTo(coordonnees) < 200
	# Si on voit une rocket sans voir d"ennemi
	if rocket_dangereuse != None and not tirer_loin:
		d = coordonnees.distanceTo(rocket_dangereuse)
		# Estimation de la pos de l"ennemi : a 150 de distance
		x = (rocket_dangereuse.getX() - coordonnees.getX()) / d * 150
		y = (rocket_dangereuse.getY() - coordonnees.getY())/ d * 150
		args = [str(x), str(y), str(10000)]
		self.broadcast(groupName, "launcher", "ROCKET", args)
		#Demande a un explorateur de venir voir s"il y a quelqu"un
		if offre == None:
			self.broadcast(groupName, "explorer", "ROCKET-REQ",str(x),str(y))
		else:
			self.send(offre, "ROCKET-OK", str(x), str(y))
	
	if rocket_dangereuse != None and attenteRoquettes.pret():
		if tirer(rocket_dangereuse):
			return
	
	if tirer_loin:
		pos = Point()
		pos.setCoord(aide.getVisee().getX(), aide.getVisee().getY())
		if tirer(pos):
			return
	
	
	# Besoin de construire des rockets?
	seuil_rocket = 50
	if tirer_loin:
		seuil_rocket = 10
	
	if (self.getRocketNumber() < seuil_rocket):
	#	self.setUserMessage("Reconstruction Rockets")
		self.buildRocket()
		return
	#else:
	self.setUserMessage(self.getTeam())
	
	if mon_groupe.nbVus() != 0 :
		centre = mon_groupe.barycentre()
		if not aide.besoin():
			if coordonnees.distanceTo(centre) >60:
				direct = self.getHeading()*Math.PI/ 180
				but_virtuel = Point()
				but_virtuel.setCoord(35*Math.cos(direct),35*Math.sin(direct))
				self.setHeading(self.towards(but_virtuel.getX() + centre.getX()-coordonnees.getX(),but_virtuel.getY() + centre.getY() - coordonnees.getY() ))
			formation = mon_groupe.vecteurMoyen()
			direct = self.getHeading()*Math.PI/ 180
			but_virtuel = Point()
			but_virtuel.setCoord(1*Math.cos(direct),1*Math.sin(direct))
			self.setHeading(self.towards(but_virtuel.getX() + formation.getX() ,but_virtuel.getY() + formation.getY()))
		

	eviteAmis(liste_amis)

	if nb_gentils > 0:
		direct = self.getHeading()*Math.PI/ 180
		but_virtuel = Point()
		if aide.besoin() and aide.getVisee().distanceTo(coordonnees) < 200:
			but_virtuel.setCoord(Math.cos(direct),Math.sin(direct))
		else:
			but_virtuel.setCoord(5*Math.cos(direct),5*Math.sin(direct))
		self.setHeading(self.towards(but_virtuel.getX() + gentils.getX(),but_virtuel.getY() + gentils.getY() ))

	if nb_mechants > 0:
		direct = self.getHeading()*Math.PI /180
		but_virtuel = Point()
		but_virtuel.setCoord(2*Math.cos(direct),2*Math.sin(direct))
		self.setHeading(self.towards(but_virtuel.getX() + mechants.getX(),but_virtuel.getY() + mechants.getY() ))
	
	
	self.move()
Example #4
0
def eviteRockets(percepts):
	global coordonnees
	global liste_rockets
	
	evite_rockets = Point()
	nb_rockets = 0
	
	nouvelles_rockets = []
	for p in percepts:
		pos = Point()
		pos.setCoord(p.getX() + coordonnees.getX(), p.getY() + coordonnees.getY())
		c = Rocket(pos)
		nouvelles_rockets.append(c)

	# Evitement des rockets en prenant en compte leur deplacement
	rockets = []
	for r in liste_rockets:
		lg = len(nouvelles_rockets)
		i = 0
		trouve = 0
		if r.getDejaVu():
			nouv_pos = r.getNextCoord()
			while not trouve and i < lg:
				r2 = nouvelles_rockets[i]
				if r2.getCoord().distanceTo(nouv_pos) < 0.0001:
					r.setCoord(r2.getX(), r2.getY())
					rockets.append(r)
					trouve = 1
					nouvelles_rockets.remove(r2)
				else:
					i += 1
		else:
			while not trouve and i < lg:
				r2 = nouvelles_rockets[i]
				dst = r2.getCoord().distanceTo(r.getCoord())
				if abs(dst - 10) < 0.0001:
					#print "Distance : ", str(abs(dst - 10))
					r.setCoord(r2.getX(), r2.getY())
					rockets.append(r)
					trouve = 1
					nouvelles_rockets.remove(r2)
				else:
					i += 1
	
	
	plus_proche = 100
	roc = None
	cy = 0
	for r in rockets:
		s = (r.getNextCoord().getY() - r.getY())/10
		c = (r.getNextCoord().getX() - r.getX())/10
		if c != 0:
			c = 0.0000001
		t = s/c
		x = r.getX() - coordonnees.getX()
		y = r.getY() - coordonnees.getY()
		
		centre_x = -( x + t* y) / (c + s * t)
		centre_y = -y/c - t * centre_x
		centre = Point()
		centre.setCoord(x, y)
		distance = centre.distanceTo(Point())
		#Si je suis sur la trajectoire
		if (centre_x > 0) and abs(centre_y) < 14:
			nb_rockets += 1
			mult = (100 - distance)/100
			if centre_y >= 0:
				evite_rockets.setCoord(evite_rockets.getX() + mult*y, evite_rockets.getY() - mult*x)
			else:
				evite_rockets.setCoord(evite_rockets.getX() - mult*y, evite_rockets.getY() + mult*x)
			if (not r.getShootee()) and (plus_proche > centre_x):
				roc = r
				plus_proche = centre_x
		
			
	
	liste_rockets = rockets
	for r in nouvelles_rockets:
		liste_rockets.append(r)
	
	if nb_rockets > 0:
		direct = self.getHeading()*Math.PI/ 180
		but_virtuel = Point()
		but_virtuel.setCoord(2*Math.cos(direct),2*Math.sin(direct))
		
		self.setHeading(self.towards(but_virtuel.getX() + evite_rockets.getX(),but_virtuel.getY() + evite_rockets.getY()))
	
	if attenteRoquettes.pret() and roc !=None:
#		dist = 14
#		impact = 0
		dx = (roc.getNextCoord().getX() - roc.getX())/10
		dy = (roc.getNextCoord().getY() - roc.getY())/10
		vise = Point()
		#print "TIR:"
		a = 0
		b = 100
		while b - a > 1:
			m = int ((a + b) / 2)
			vise.setCoord(roc.getX() + m*dx,roc.getY() + m*dy)
			if coordonnees.distanceTo(vise) > m + 14:
				a = m
			else:
				b = m
		roc.setShootee(1)
		vise.setCoord(roc.getX() + m*dx,roc.getY() + m*dy)
		return vise
	else:
		return None
Example #5
0
def doIt():
    global moi
    global cibles_observees
    global launcher_vu
    global liste_rockets
    global adr_objectif

    miseAJourMouvement()

    # Phase de detection
    percepts = self.getPercepts()

    liste_obs = []

    # Detection des ennemis
    zero_cible = (cibles_observees == [])
    nouvelles_cibles = []
    cible_launcher = 0
    for p in percepts:
        # On trouve le QG ennemi
        if p.getPerceptType() == 'Home':
            liste_obs.append(p)
            if p.getTeam() != self.getTeam():
                b = Point(p.getX() + coordonnees.getX(),
                          p.getY() + coordonnees.getY())
                if not baseEnnemieConnue(b):
                    base_ennemie.append(b)
                    self.broadcast(groupName, 'info', 'INFO-QG', str(p.getX()),
                                   str(p.getY()))
        # On entre dans la zone de detection d'un rocket-launcher
        elif p.getPerceptType(
        ) == 'RocketLauncher' and p.getTeam() != self.getTeam():
            if not launcher_vu:
                self.broadcast(groupName, 'explorer', 'LAUNCHER_VU')
            launcher_vu = 1
            cible_launcher = 1
            c = CibleObs(p)
            nouvelles_cibles.append(c)
        elif p.getPerceptType(
        ) == 'Explorer' and p.getTeam() != self.getTeam():
            c = CibleObs(p)
            nouvelles_cibles.append(c)
            liste_obs.append(p)
        elif p.getPerceptType() == 'RocketLauncher' and p.getTeam(
        ) == self.getTeam():
            liste_obs.append(p)

    if adr_objectif != None:
        if coordonnees.distanceTo(objectif) < 110:  # or cible_launcher:
            objectif.setConnu(0)
            self.send(adr_objectif, 'ROCKET-FIN')
            adr_objectif = None
        else:
            self.setHeading(
                self.towards(objectif.getX() - coordonnees.getX(),
                             objectif.getY() - coordonnees.getY()))

    # Mise a jour des cibles vues par plusieurs explorateurs
    nb_vus_par_autre = 0
    longueur = len(cibles_observees)
    for c in nouvelles_cibles:
        pos = Point()
        pos.setCoord(c.getX(), c.getY())
        trouve = 0
        i = 0
        while not trouve and i < longueur:
            c_anc = cibles_observees[i]
            if c_anc.getVuParAutre() and pos.distanceTo(c_anc.getCoord()) < 10:
                trouve = 1
                c.setVuParAutre(c_anc.getVuParAutre() - 1)
                nb_vus_par_autre += 1
            i = i + 1

    cibles_observees = nouvelles_cibles

    nb_ennemis = 0
    centre = Point()
    for c in cibles_observees:
        #print str(c.distanceTo(Point()))
        if nb_ennemis < 5 and c.getType(
        ) == 'RocketLauncher' and not c.getVuParAutre():
            mult = 130 - c.distanceTo(Point())
            centre.setCoord(centre.getX() + c.getX() * mult,
                            centre.getY() + c.getY() * mult)
            nb_ennemis += 1
        elif c.getType() == 'RocketLauncher':
            mult = 200 - c.distanceTo(Point())
            centre.setCoord(centre.getX() + c.getX() * mult,
                            centre.getY() + c.getY() * mult)
            nb_ennemis += 1

    if synchro.pret():
        monEtat()
    elif zero_cible and cibles_observees != []:
        monEtat()
    synchro.decrementer()

    #self.setUserMessage(str(len(cibles_observees)))

    if nb_ennemis > 0:
        centre.setCoord(centre.getX() / nb_ennemis, centre.getY() / nb_ennemis)
        repuls = 180
        self.setHeading(repuls + self.towards(centre.getX(), centre.getY()))

    # Evitement des obstacles divers
    evite = Point()
    evite_rockets = Point()
    nb_rockets = 0
    nb_obs = 0
    nb_murs = 0
    nouvelles_rockets = []
    #print ''
    for p in percepts:
        if p.getPerceptType() == 'Rocket':
            pos = Point()
            pos.setCoord(p.getX() + coordonnees.getX(),
                         p.getY() + coordonnees.getY())
            c = Rocket(pos)
            nouvelles_rockets.append(c)
        ecart_min = ecartMin(p)
        d = self.distanceTo(p)
        if d < ecart_min:
            if d > 0:
                mult = (ecart_min - d) / ecart_min
                evite.setCoord(evite.getX() - mult * p.getX() / d,
                               evite.getY() - mult * p.getY() / d)
                nb_obs = nb_obs + 1
                if p.getPerceptType() == 'Obstacle':
                    nb_murs = nb_murs + 1

    # Evitement des rockets en prenant en compte leur deplacement
    rockets = []
    for r in liste_rockets:
        lg = len(nouvelles_rockets)
        i = 0
        trouve = 0
        if r.getDejaVu():
            nouv_pos = r.getNextCoord()
            while not trouve and i < lg:
                r2 = nouvelles_rockets[i]
                if r2.getCoord().distanceTo(nouv_pos) < 0.5:
                    r.setCoord(r2.getX(), r2.getY())
                    rockets.append(r)
                    trouve = 1
                    nouvelles_rockets.remove(r2)
                else:
                    i += 1
        else:
            while not trouve and i < lg:
                r2 = nouvelles_rockets[i]
                dst = r2.getCoord().distanceTo(r.getCoord())
                if abs(dst - 4) < 0.5:
                    r.setCoord(r2.getX(), r2.getY())
                    rockets.append(r)
                    trouve = 1
                    nouvelles_rockets.remove(r2)
                else:
                    i += 1

    for r in rockets:
        s = (r.getNextCoord().getY() - r.getY()) / 4
        c = (r.getNextCoord().getX() - r.getX()) / 4
        t = s / c
        x = r.getX() - coordonnees.getX()
        y = r.getY() - coordonnees.getY()

        centre_x = (x + t * y) / (c + s * t)
        centre_y = -y / c + t * centre_x
        centre = Point()
        centre.setCoord(x, y)
        distance = centre.distanceTo(Point())
        #Si je suis sur la trajectoire
        if distance < 80 and centre_x < 0 and abs(centre_y < 16):
            nb_rockets += 1
            mult = (80 - distance) / 80
            if centre_y >= 0:
                evite_rockets.setCoord(evite_rockets.getX() + mult * y,
                                       evite_rockets.getY() - mult * x)
            else:
                evite_rockets.setCoord(evite_rockets.getX() - mult * y,
                                       evite_rockets.getY() + mult * x)
        #print str(int(centre_x*1000) / 1000), str(int(centre_y * 1000) / 1000)

    liste_rockets = rockets
    for r in nouvelles_rockets:
        liste_rockets.append(r)

    #print ''
    #for r in liste_rockets:
    #	print r.getX(), r.getY()

    eviteObstacles(liste_obs)

    if nb_rockets > 0:
        direct = self.getHeading() * Math.PI / 180
        but_virtuel = Point()
        but_virtuel.setCoord(2 * Math.cos(direct), 2 * Math.sin(direct))

        self.setHeading(
            self.towards(but_virtuel.getX() + evite_rockets.getX(),
                         but_virtuel.getY() + evite_rockets.getY()))

    if nb_obs > 0:
        direct = self.getHeading() * Math.PI / 180
        but_virtuel = Point()
        but_virtuel.setCoord(1 * Math.cos(direct), 1 * Math.sin(direct))

        self.setHeading(
            self.towards(but_virtuel.getX() + evite.getX(),
                         but_virtuel.getY() + evite.getY()))

    # Reception des messages
    while not self.isMessageBoxEmpty():
        message = self.readMessage()
        # Message de position de la base
        if message.getAct() == 'POS':
            coordonnees.setCoord(-message.getFromX(), -message.getFromY())
        elif message.getAct() == 'INFO-QG':
            x_absolu = message.getFromX() + float(
                message.getArgN(1)) + coordonnees.getX()
            y_absolu = message.getFromY() + float(
                message.getArgN(2)) + coordonnees.getY()
            b = Point(x_absolu, y_absolu)
            if (not baseEnnemieConnue(b)):
                base_ennemie.append(b)
        elif message.getAct() == 'FIN-NUM':
            if int(message.getArg1()) < moi:
                moi = moi - 1
        elif message.getAct() == 'NUM':
            liste_autres.append(message.getSender())
        elif message.getAct() == 'FIN-QG':
            x = message.getFromX() + float(
                message.getArg1()) + coordonnees.getX()
            y = message.getFromY() + float(
                message.getArg2()) + coordonnees.getY()
            b = Point(x, y)
            baseEnnemieSuppr(b)
        elif message.getAct() == 'LAUNCHER_VU':
            launcher_vu = 1
        elif message.getAct() == 'ROCKET-REQ':
            if adr_objectif == None and not cible_launcher:
                self.send(message.getSender(), 'ROCKET-OFFRE')
                adr_objectif = message.getSender()
                dest = Point()
                dest.setCoord(
                    message.getFromX() + coordonnees.getX() +
                    float(message.getArg1()),
                    message.getFromY() + coordonnees.getY() +
                    float(message.getArg2()))
                objectif.setCoord(dest.getX(), dest.getY())
        elif message.getAct(
        ) == 'ROCKET-OK' and adr_objectif == message.getSender():
            dest = Point()
            dest.setCoord(
                message.getFromX() + coordonnees.getX() +
                float(message.getArg1()),
                message.getFromY() + coordonnees.getY() +
                float(message.getArg2()))
            objectif.setCoord(dest.getX(), dest.getY())
        elif message.getAct() == 'ROCKET-NON':
            if adr_objectif == message.getSender():
                adr_objectif = None
        elif estMonSuperieur(
                message.getSender()) and (message.getAct() == 'HELP0'
                                          or message.getAct() == 'HELP1'):
            x = message.getFromX() + float(message.getArg1())
            y = message.getFromY() + float(message.getArg2())
            pos = Point()
            pos.setCoord(x, y)
            for c in cibles_observees:
                if pos.distanceTo(c.getCoord()) <= 10:
                    c.setVuParAutre(6)  # 6 tours avant fin ttl

    self.move()
def doIt():
    global offre
    global tour
    tour = tour + 1
    attendre = 0
    coordonnees.setX(coordonnees.getX() + getDeplX())
    coordonnees.setY(coordonnees.getY() + getDeplY())

    # Time to live decremente
    aide.decrementer()

    if aide.besoin() and coordonnees.distanceTo(aide.getCoord()) <= 90:
        aide.finAssistance()

    #Rechargement des roquettes?
    if not attenteRoquettes.pret():
        attenteRoquettes.decrementer()

    lireMessages()

    if synchro.pret():
        monEtat()
    synchro.decrementer()

    base_cible = Point()
    if base_ennemie != []:
        for b in base_ennemie:
            if aide.setAssistance(coordonnees, self.getName(), b.getX(),
                                  b.getY(), 10000, AIDE_BASE_ENNEMIE, 3, tour):
                base_cible = b

    # Deplacement normal
    if aide.besoin():
        direct = self.towards(aide.getVisee().getX() - coordonnees.getX(),
                              aide.getVisee().getY() - coordonnees.getY())
        if coordonnees.distanceTo(aide.getCoord()) > 150 or (
                aide.besoin() > AIDE_LAUNCHER
                or aide.besoin() == AIDE_BASE_ENNEMIE):
            self.setHeading(direct)
        else:
            self.setHeading(180 + direct)

    # BaryCentre des unites ennemies proches
    centre = Point()
    percepts = self.getPercepts()
    nb_unites = 0

    ennemi_perdu = ennemi_courant.existe()
    qg_ennemi_visible = not (base_cible.estConnu()
                             and base_cible.distanceTo(coordonnees) <= 100)
    for p in percepts:
        team = p.getTeam()
        type_percept = p.getPerceptType()
        if ((type_percept == "Home") or (type_percept == "RocketLauncher") or
            (type_percept == "Explorer")) and team != self.getTeam():
            if p.getPerceptType() == "Home":
                base_abs = Point(p.getX() + coordonnees.getX(),
                                 p.getY() + coordonnees.getY())
                if not baseEnnemieConnue(base_abs):
                    base_ennemie.append(base_abs)
                    self.broadcast(groupName, "info", "INFO-QG", str(p.getX()),
                                   str(p.getY()))
                qg_ennemi_visible = qg_ennemi_visible or base_abs.distanceTo(
                    base_cible) <= 10
            coord = Point(p.getX() + coordonnees.getX(),
                          p.getY() + coordonnees.getY())
            energie = p.getEnergy()
            if not ennemi_courant.existe():
                ennemi_courant.setCible(type_percept, coord, energie, tour)
                #self.broadcast(groupName, "launcher", "FIN")
                args = [str(p.getX()), str(p.getY()), str(p.getEnergy())]
                if type_percept == "RocketLauncher":
                    self.broadcast(groupName, "launcher", "HELP2", args)
            elif ennemi_courant.egal(type_percept, coord):
                ennemi_courant.setCible(type_percept, coord, energie, tour)
                ennemi_perdu = 0
            elif (ennemi_courant.getEnergy() > p.getEnergy()) and prioriteType(
                    ennemi_courant.getType()) <= prioriteType(
                        p.getPerceptType()):
                ennemi_courant.setCible(type_percept, coord, energie, tour)
                ennemi_perdu = 0

    if base_cible.estConnu() and not qg_ennemi_visible:
        baseEnnemieSuppr(base_cible)
        self.broadcast(groupName, "mobile", "FIN-QG",
                       str(base_cible.getX() - coordonnees.getX()),
                       str(base_cible.getY() - coordonnees.getY()))

#	if ennemi_courant.existe():
#		self.setUserMessage("TIR")
#	else:
#		self.setUserMessage(None)

    if ennemi_perdu:
        self.broadcast(groupName, "launcher", "FIN")
        self.broadcast(groupName, "launcher", "ETAT")
        self.broadcast(groupName, "explorer", "ETAT")
        self.setHeading(
            self.towards(ennemi_courant.getX() - coordonnees.getX(),
                         ennemi_courant.getY() - coordonnees.getY()))
        ennemi_courant.delCible()

    elif (ennemi_courant.existe()):
        coord = ennemi_courant.viser(coordonnees)
        if tirer(coord):
            return

    # Manoeuvres d"evitement
    gentils = Point()
    mechants = Point()
    nb_mechants = 0
    nb_gentils = 0
    evite = Point()
    amis = Vector()
    tenaille = Point()

    #	self.getName()
    liste_amis = []
    liste_rockets = []
    if aide.besoin():
        dist_aide = aide.getVisee().distanceTo(coordonnees)
    else:
        dist_aide = 1000
    for p in percepts:
        dist = self.distanceTo(p)
        if p.getPerceptType() == "RocketLauncher" and p.getTeam(
        ) == self.getTeam():
            liste_amis.append(p)
            r = Mobile(coordonnees.getX() + p.getX(),
                       coordonnees.getY() + p.getY())
            amis.add(r)
            if aide.besoin() == AIDE_LAUNCHER:
                p_ami = Point(p.getX() + coordonnees.getX(),
                              p.getY() + coordonnees.getY())
                dist_ami = p_ami.distanceTo(aide.getVisee())
                if dist_aide > 200 and dist_ami > dist_aide + 20:
                    attendre = 1
        if p.getPerceptType() == "Rocket":
            liste_rockets.append(p)
        if p.getPerceptType() == "Home" and p.getTeam() == self.getTeam():
            liste_amis.append(p)
        ecart_min = ecartMin(p)
        if dist > 0 and dist < ecart_min:
            mult = (ecart_min - dist) / ecart_min
            if p.getPerceptType() == "Obstacle" or (p.getTeam()
                                                    == self.getTeam()):
                gentils.setCoord(gentils.getX() - p.getX() / dist * mult,
                                 gentils.getY() - p.getY() / dist * mult)
                nb_gentils += 1
            else:
                nb_mechants += 1
                mechants.setCoord(mechants.getX() - p.getX() / dist * mult,
                                  mechants.getY() - p.getY() / dist * mult)

    mon_groupe.amisVus(amis)

    if attendre:
        self.setHeading(self.getHeading() + 180)

    rocket_dangereuse = eviteRockets(liste_rockets)

    tirer_loin = aide.besoin(
    ) and aide.getVisee().distanceTo(coordonnees) < 200
    # Si on voit une rocket sans voir d"ennemi
    if rocket_dangereuse != None and not tirer_loin:
        d = coordonnees.distanceTo(rocket_dangereuse)
        # Estimation de la pos de l"ennemi : a 150 de distance
        x = (rocket_dangereuse.getX() - coordonnees.getX()) / d * 150
        y = (rocket_dangereuse.getY() - coordonnees.getY()) / d * 150
        args = [str(x), str(y), str(10000)]
        self.broadcast(groupName, "launcher", "ROCKET", args)
        #Demande a un explorateur de venir voir s"il y a quelqu"un
        if offre == None:
            self.broadcast(groupName, "explorer", "ROCKET-REQ", str(x), str(y))
        else:
            self.send(offre, "ROCKET-OK", str(x), str(y))

    if rocket_dangereuse != None and attenteRoquettes.pret():
        if tirer(rocket_dangereuse):
            return

    if tirer_loin:
        pos = Point()
        pos.setCoord(aide.getVisee().getX(), aide.getVisee().getY())
        if tirer(pos):
            return

    # Besoin de construire des rockets?
    seuil_rocket = 50
    if tirer_loin:
        seuil_rocket = 10

    if (self.getRocketNumber() < seuil_rocket):
        #	self.setUserMessage("Reconstruction Rockets")
        self.buildRocket()
        return
    #else:
    self.setUserMessage(self.getTeam())

    if mon_groupe.nbVus() != 0:
        centre = mon_groupe.barycentre()
        if not aide.besoin():
            if coordonnees.distanceTo(centre) > 60:
                direct = self.getHeading() * Math.PI / 180
                but_virtuel = Point()
                but_virtuel.setCoord(35 * Math.cos(direct),
                                     35 * Math.sin(direct))
                self.setHeading(
                    self.towards(
                        but_virtuel.getX() + centre.getX() -
                        coordonnees.getX(),
                        but_virtuel.getY() + centre.getY() -
                        coordonnees.getY()))
            formation = mon_groupe.vecteurMoyen()
            direct = self.getHeading() * Math.PI / 180
            but_virtuel = Point()
            but_virtuel.setCoord(1 * Math.cos(direct), 1 * Math.sin(direct))
            self.setHeading(
                self.towards(but_virtuel.getX() + formation.getX(),
                             but_virtuel.getY() + formation.getY()))

    eviteAmis(liste_amis)

    if nb_gentils > 0:
        direct = self.getHeading() * Math.PI / 180
        but_virtuel = Point()
        if aide.besoin() and aide.getVisee().distanceTo(coordonnees) < 200:
            but_virtuel.setCoord(Math.cos(direct), Math.sin(direct))
        else:
            but_virtuel.setCoord(5 * Math.cos(direct), 5 * Math.sin(direct))
        self.setHeading(
            self.towards(but_virtuel.getX() + gentils.getX(),
                         but_virtuel.getY() + gentils.getY()))

    if nb_mechants > 0:
        direct = self.getHeading() * Math.PI / 180
        but_virtuel = Point()
        but_virtuel.setCoord(2 * Math.cos(direct), 2 * Math.sin(direct))
        self.setHeading(
            self.towards(but_virtuel.getX() + mechants.getX(),
                         but_virtuel.getY() + mechants.getY()))

    self.move()
def eviteRockets(percepts):
    global coordonnees
    global liste_rockets

    evite_rockets = Point()
    nb_rockets = 0

    nouvelles_rockets = []
    for p in percepts:
        pos = Point()
        pos.setCoord(p.getX() + coordonnees.getX(),
                     p.getY() + coordonnees.getY())
        c = Rocket(pos)
        nouvelles_rockets.append(c)

    # Evitement des rockets en prenant en compte leur deplacement
    rockets = []
    for r in liste_rockets:
        lg = len(nouvelles_rockets)
        i = 0
        trouve = 0
        if r.getDejaVu():
            nouv_pos = r.getNextCoord()
            while not trouve and i < lg:
                r2 = nouvelles_rockets[i]
                if r2.getCoord().distanceTo(nouv_pos) < 0.0001:
                    r.setCoord(r2.getX(), r2.getY())
                    rockets.append(r)
                    trouve = 1
                    nouvelles_rockets.remove(r2)
                else:
                    i += 1
        else:
            while not trouve and i < lg:
                r2 = nouvelles_rockets[i]
                dst = r2.getCoord().distanceTo(r.getCoord())
                if abs(dst - 10) < 0.0001:
                    #print "Distance : ", str(abs(dst - 10))
                    r.setCoord(r2.getX(), r2.getY())
                    rockets.append(r)
                    trouve = 1
                    nouvelles_rockets.remove(r2)
                else:
                    i += 1

    plus_proche = 100
    roc = None
    cy = 0
    for r in rockets:
        s = (r.getNextCoord().getY() - r.getY()) / 10
        c = (r.getNextCoord().getX() - r.getX()) / 10
        if c != 0:
            c = 0.0000001
        t = s / c
        x = r.getX() - coordonnees.getX()
        y = r.getY() - coordonnees.getY()

        centre_x = -(x + t * y) / (c + s * t)
        centre_y = -y / c - t * centre_x
        centre = Point()
        centre.setCoord(x, y)
        distance = centre.distanceTo(Point())
        #Si je suis sur la trajectoire
        if (centre_x > 0) and abs(centre_y) < 14:
            nb_rockets += 1
            mult = (100 - distance) / 100
            if centre_y >= 0:
                evite_rockets.setCoord(evite_rockets.getX() + mult * y,
                                       evite_rockets.getY() - mult * x)
            else:
                evite_rockets.setCoord(evite_rockets.getX() - mult * y,
                                       evite_rockets.getY() + mult * x)
            if (not r.getShootee()) and (plus_proche > centre_x):
                roc = r
                plus_proche = centre_x

    liste_rockets = rockets
    for r in nouvelles_rockets:
        liste_rockets.append(r)

    if nb_rockets > 0:
        direct = self.getHeading() * Math.PI / 180
        but_virtuel = Point()
        but_virtuel.setCoord(2 * Math.cos(direct), 2 * Math.sin(direct))

        self.setHeading(
            self.towards(but_virtuel.getX() + evite_rockets.getX(),
                         but_virtuel.getY() + evite_rockets.getY()))

    if attenteRoquettes.pret() and roc != None:
        #		dist = 14
        #		impact = 0
        dx = (roc.getNextCoord().getX() - roc.getX()) / 10
        dy = (roc.getNextCoord().getY() - roc.getY()) / 10
        vise = Point()
        #print "TIR:"
        a = 0
        b = 100
        while b - a > 1:
            m = int((a + b) / 2)
            vise.setCoord(roc.getX() + m * dx, roc.getY() + m * dy)
            if coordonnees.distanceTo(vise) > m + 14:
                a = m
            else:
                b = m
        roc.setShootee(1)
        vise.setCoord(roc.getX() + m * dx, roc.getY() + m * dy)
        return vise
    else:
        return None
Example #8
0
def doIt():
	global moi
	global cibles_observees
	global launcher_vu
	global liste_rockets
	global adr_objectif
	
	miseAJourMouvement()
	
	
	# Phase de detection
	percepts = self.getPercepts()
	
	liste_obs = []
	
	# Detection des ennemis
	zero_cible = (cibles_observees == [])
	nouvelles_cibles = []
	cible_launcher = 0
	for p in percepts:
		# On trouve le QG ennemi
		if p.getPerceptType() == 'Home':
			liste_obs.append(p)
			if p.getTeam() != self.getTeam():
				b = Point(p.getX() + coordonnees.getX(), p.getY() + coordonnees.getY())
				if not baseEnnemieConnue(b):
					base_ennemie.append(b)
					self.broadcast(groupName, 'info', 'INFO-QG', str(p.getX()), str(p.getY()))
		# On entre dans la zone de detection d'un rocket-launcher
		elif p.getPerceptType() == 'RocketLauncher' and p.getTeam() != self.getTeam():
			if not launcher_vu:
				self.broadcast(groupName, 'explorer', 'LAUNCHER_VU')
			launcher_vu = 1
			cible_launcher = 1
			c = CibleObs( p)
			nouvelles_cibles.append(c)
		elif p.getPerceptType() == 'Explorer' and p.getTeam() != self.getTeam() :
			c = CibleObs( p)
			nouvelles_cibles.append(c)
			liste_obs.append(p)
		elif p.getPerceptType() == 'RocketLauncher' and p.getTeam() == self.getTeam():
			liste_obs.append(p)
	
	if adr_objectif != None:
		if coordonnees.distanceTo(objectif) < 110:# or cible_launcher:
			objectif.setConnu(0)
			self.send(adr_objectif, 'ROCKET-FIN')
			adr_objectif = None
		else:
			self.setHeading( self.towards(objectif.getX() - coordonnees.getX(), objectif.getY() - coordonnees.getY()))
	
		
	# Mise a jour des cibles vues par plusieurs explorateurs
	nb_vus_par_autre = 0
	longueur = len(cibles_observees)
	for c in nouvelles_cibles:
		pos = Point()
		pos.setCoord(c.getX(), c.getY())
		trouve = 0
		i = 0
		while not trouve and i < longueur:
			c_anc = cibles_observees[i]
			if c_anc.getVuParAutre() and pos.distanceTo(c_anc.getCoord()) < 10:
				trouve = 1
				c.setVuParAutre(c_anc.getVuParAutre() - 1)
				nb_vus_par_autre += 1
			i = i+1
	
	cibles_observees = nouvelles_cibles
	
	nb_ennemis = 0
	centre = Point()
	for c in cibles_observees :
		#print str(c.distanceTo(Point()))
		if nb_ennemis < 5 and c.getType() == 'RocketLauncher' and not c.getVuParAutre():
			mult = 130 - c.distanceTo(Point())
			centre.setCoord(centre.getX() + c.getX()*mult, centre.getY() +  c.getY()*mult)
			nb_ennemis += 1
		elif c.getType() == 'RocketLauncher':
			mult =  200- c.distanceTo(Point())
			centre.setCoord(centre.getX() + c.getX()*mult, centre.getY() +  c.getY()*mult)
			nb_ennemis += 1
	
	if synchro.pret():
		monEtat()
	elif zero_cible and cibles_observees != []:
		monEtat()
	synchro.decrementer()
	
	#self.setUserMessage(str(len(cibles_observees)))
		
	if nb_ennemis > 0:
		centre.setCoord(centre.getX()/nb_ennemis, centre.getY()/ nb_ennemis)
		repuls = 180
		self.setHeading(repuls + self.towards(centre.getX(),centre.getY()))
		
		
	# Evitement des obstacles divers
	evite = Point()
	evite_rockets = Point()
	nb_rockets = 0
	nb_obs = 0
	nb_murs = 0
	nouvelles_rockets = []
	#print ''
	for p in percepts:
		if p.getPerceptType() == 'Rocket':
			pos = Point()
			pos.setCoord(p.getX() + coordonnees.getX(), p.getY() + coordonnees.getY())
			c = Rocket(pos)
			nouvelles_rockets.append(c)
		ecart_min = ecartMin(p)
		d = self.distanceTo(p)
		if  d < ecart_min:
			if d > 0:
				mult = (ecart_min - d)/ecart_min
				evite.setCoord(evite.getX() - mult*p.getX()/d, evite.getY() - mult*p.getY()/d )
				nb_obs = nb_obs + 1
				if p.getPerceptType() == 'Obstacle':
					nb_murs = nb_murs + 1
	
	
	# Evitement des rockets en prenant en compte leur deplacement
	rockets = []
	for r in liste_rockets:
		lg = len(nouvelles_rockets)
		i = 0
		trouve = 0
		if r.getDejaVu():
			nouv_pos = r.getNextCoord()
			while not trouve and i < lg:
				r2 = nouvelles_rockets[i]
				if r2.getCoord().distanceTo(nouv_pos) < 0.5:
					r.setCoord(r2.getX(), r2.getY())
					rockets.append(r)
					trouve = 1
					nouvelles_rockets.remove(r2)
				else:
					i += 1
		else:
			while not trouve and i < lg:
				r2 = nouvelles_rockets[i]
				dst = r2.getCoord().distanceTo(r.getCoord())
				if abs(dst - 4) < 0.5:
					r.setCoord(r2.getX(), r2.getY())
					rockets.append(r)
					trouve = 1
					nouvelles_rockets.remove(r2)
				else:
					i += 1
	
	
	for r in rockets:
		s = (r.getNextCoord().getY() - r.getY())/4
		c = (r.getNextCoord().getX() - r.getX())/4
		t = s/c
		x = r.getX() - coordonnees.getX()
		y = r.getY() - coordonnees.getY()
		
		centre_x = ( x + t* y) / (c + s * t)
		centre_y = -y/c + t * centre_x
		centre = Point()
		centre.setCoord(x, y)
		distance = centre.distanceTo(Point())
		#Si je suis sur la trajectoire
		if distance < 80 and centre_x < 0 and abs(centre_y < 16):
			nb_rockets += 1
			mult = (80 - distance)/80
			if centre_y >= 0:
				evite_rockets.setCoord(evite_rockets.getX() + mult*y, evite_rockets.getY() - mult*x)
			else:
				evite_rockets.setCoord(evite_rockets.getX() - mult*y, evite_rockets.getY() + mult*x)
		#print str(int(centre_x*1000) / 1000), str(int(centre_y * 1000) / 1000)
		
	
	liste_rockets = rockets
	for r in nouvelles_rockets:
		liste_rockets.append(r)
	
	#print ''
	#for r in liste_rockets:
	#	print r.getX(), r.getY()
	
	eviteObstacles(liste_obs)
	
	if nb_rockets > 0:
		direct = self.getHeading()*Math.PI/ 180
		but_virtuel = Point()
		but_virtuel.setCoord(2*Math.cos(direct),2*Math.sin(direct))
		
		self.setHeading(self.towards(but_virtuel.getX() + evite_rockets.getX(),but_virtuel.getY() + evite_rockets.getY()))
	
	if nb_obs > 0:
		direct = self.getHeading()*Math.PI/ 180
		but_virtuel = Point()
		but_virtuel.setCoord(1*Math.cos(direct),1*Math.sin(direct))
		
		self.setHeading(self.towards(but_virtuel.getX() + evite.getX(),but_virtuel.getY() + evite.getY() ))
	
		
	
		
	# Reception des messages
	while not self.isMessageBoxEmpty():
		message = self.readMessage()
		# Message de position de la base
		if message.getAct() == 'POS':
			coordonnees.setCoord(-message.getFromX(), -message.getFromY())
		elif message.getAct() == 'INFO-QG':
			x_absolu = message.getFromX() + float(message.getArgN(1)) + coordonnees.getX()
			y_absolu = message.getFromY() + float(message.getArgN(2)) + coordonnees.getY()
			b = Point(x_absolu, y_absolu)
			if (not baseEnnemieConnue(b)):
				base_ennemie.append(b)
		elif message.getAct() == 'FIN-NUM' :
			if int(message.getArg1()) < moi :
				moi = moi - 1
		elif message.getAct() == 'NUM':
			liste_autres.append(message.getSender())
		elif message.getAct() == 'FIN-QG':
			x = message.getFromX() + float(message.getArg1()) + coordonnees.getX()
			y = message.getFromY() + float(message.getArg2()) + coordonnees.getY()
			b = Point(x,y)
			baseEnnemieSuppr(b)
		elif message.getAct() == 'LAUNCHER_VU':
			launcher_vu = 1
		elif message.getAct() == 'ROCKET-REQ':
			if adr_objectif == None and not cible_launcher:
				self.send(message.getSender(), 'ROCKET-OFFRE')
				adr_objectif = message.getSender()
				dest = Point()
				dest.setCoord(message.getFromX() + coordonnees.getX() + float(message.getArg1()), message.getFromY() + coordonnees.getY() + float(message.getArg2()))
				objectif.setCoord (dest.getX(), dest.getY())
		elif message.getAct() == 'ROCKET-OK' and adr_objectif == message.getSender():
			dest = Point()
			dest.setCoord(message.getFromX() + coordonnees.getX() + float(message.getArg1()), message.getFromY() + coordonnees.getY() + float(message.getArg2()))
			objectif.setCoord (dest.getX(), dest.getY())
		elif message.getAct() == 'ROCKET-NON':
			if adr_objectif == message.getSender():
				adr_objectif = None
		elif estMonSuperieur(message.getSender()) and (message.getAct() == 'HELP0' or message.getAct() == 'HELP1'):
			x =  message.getFromX()+ float(message.getArg1())
			y =  message.getFromY()+ float(message.getArg2())
			pos = Point()
			pos.setCoord(x, y)
			for c in cibles_observees:
				if pos.distanceTo(c.getCoord()) <= 10:
					c.setVuParAutre(6) # 6 tours avant fin ttl
			
	self.move()