Esempio n. 1
0
    def update(self, ball_pos, ball_force):
        if type(ball_pos) != sP.Point:
            ball_pos = sP.Point(None, ball_pos)
        if type(ball_force) != sP.Point:
            ball_force = sP.Point(None, ball_force)

        atTarget = self.starpath.getNearTarget(ball_pos)
        if self.target is None:
            self.target = next(iter(atTarget.journeys))
            self.journey = atTarget.journeys[self.target]
            self.origin = atTarget
            self.nxt_mv = self.journey.smooth.getFirstPoint()

        # 35 -> Target size!
        # reached nxt_mv? Fetch the new nxt_mv and slowDown becauhse
        # in smoothPath/simplepath, every point is a corner
        # if there is no next mv, reverse direction!
        if ball_pos.inRange(self.radius + 10, self.nxt_mv):
            self.nxt_mv = self.nxt_mv.next()

            # there is no next move but we hit the last one(our destination)
            if self.nxt_mv is None:
                self.target = self.giveNewTarget(atTarget, self.origin)
                self.journey = atTarget.journeys[self.target]
                self.origin = atTarget
                self.nxt_mv = self.journey.smooth.getFirstPoint()
            else:
                return self.slowDown(ball_pos, ball_force)

        return (self.nxt_mv - ball_pos).norm()
Esempio n. 2
0
    def go_for_target(self, ball_pos, ball_force, radius):
        ball_pos = sP.Point(None, ball_pos)
        ball_force = sP.Point(None, ball_force)

        return self.behavoir.update(ball_pos, ball_force)
Esempio n. 3
0
    def update(self, ball_pos, ball_force):
        if not isinstance(ball_pos, sP.Point):
            ball_pos = sP.Point(None, ball_pos)
        if not isinstance(ball_force, sP.Point):
            ball_force = sP.Point(None, ball_force)
        atTarget = self.starpath.getNearTarget(ball_pos)

        # init
        if self.target is None:
            self.target = self.starpath.getNearTarget(
                self.bestJourney.path.getFirstPoint())
            if self.target in atTarget.journeys.keys():
                self.journey = atTarget.journeys[self.target]
            else:
                self.journey = self.bestJourney
            self.origin = atTarget
            self.nxt_mv = self.journey.smooth.getFirstPoint()

        # did we reached our target, where the best journey starts??
        if atTarget == self.target:
            self.target = 0
            self.journey = self.bestJourney
            self.origin = atTarget
            self.nxt_mv = self.journey.smooth.getFirstPoint()

        # bug, kein next() mehr
        if isinstance(self.nxt_mv.next(), sP.Point) and ball_pos.dist(
                self.nxt_mv) > ball_pos.dist(self.nxt_mv.next()):
            self.nxt_mv = self.nxt_mv.next()

        # 35 -> Target size!
        # reached nxt_mv? Fetch the new nxt_mv and slowDown becauhse
        # in smoothPath/simplepath, every point is a corner
        # if there is no next mv, reverse direction!
        if ball_pos.inRange(self.radius + 10, self.nxt_mv):
            self.nxt_mv = self.nxt_mv.next()

            # there is no next move but we hit the last one(our destination)
            if self.nxt_mv is None:
                if self.journey.collide:
                    self.counter += 1
                # make sure we have learned from our mistakes
                if self.counter == 2:
                    self.counter = 0
                    self.journey = atTarget.journeys[self.giveNewTarget(
                        atTarget, self.origin)]
                    self.origin = atTarget
                    self.nxt_mv = self.journey.smooth.getFirstPoint()
                else:
                    self.journey = atTarget.journeys[self.origin]
                    self.origin = atTarget
                    self.nxt_mv = self.journey.smooth.getFirstPoint()
            else:
                return self.slowDown(ball_pos, ball_force)

        return (self.nxt_mv - ball_pos).norm()


# nimmt immer wieder den am vielversprechendsten Pfad. Dieses kann ein besonders
# kurzer Pfad sein oder ein besonders leicht abzufahrender Pfad, da jedes obstacle
# collision minuspunkte bedeutet und der Ball schwer zu navigieren ist. Er bemerkt
# wenn auf seinem Idealen Pfad unsichtbare Hindernisse liegen und aendert ihn gebenen
# falls. Wenn ihn der gegenspieler gaenzlich von seinem Erfolgspfad abbringt, folgt
# er ihm bis er wieder in die Naehe von seinem Erfolgspfad kommt.
# best perfomance-follower
# class bestFollow(Behavior):

# nimmt immer wieder den am vielversprechendsten Pfad. Dieses kann ein besonders kurzer Pfad sein
# oder ein besonders leicht abzufahrender Pfad, da jedes obstacle collision minuspunkte bedeutet
# und der Ball schwer zu navigieren ist.
# -> nimmt den kürzesten Pfad und bleibt auf diesem
# class bestPerformance(Behavior):

# nimmt keine Ruecksicht auf den Gegenspieler, macht nur sein eigenes
# Ding(evtl einfach default behavior?)
# class ignorant(Behavior):

# ist gaenzlich passiv. sollte jedoch input liefern falls der Gegenspieler nichts mehr
# macht, damit der Spieler nicht denk dass niemand mit spielt.
# class follower(Behavior):