Python Forum
Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
What's the angle?
#1
I'm looking for a way to solve my problem.

I'm working on a game Rocks In Space. Its similar to the old Asteriods game. The craft can turn on a single axis 0 through 360. There is only one screen, If you fly off the screen the autopilot is activated to return the craft to the center of the screen. My problem is that I have a routine that fails to know when the craft has turned through a set of angles and reached its target angle (where I want it to stop).


An import part of it task is to check if an craft has rotated through a set of angles and reached the target angel, but it has to be able to work under the following conditions:
1. it doesn't neccessarily have to be called in a continuos loop.
2. when the check routine is not running the craft could have turned through a few angles.
3. The routine that checks if the craft has reached its target position only knows about the crafts current position, the angle it facing in, the target position, and some other attributes listed below.
4. The craft can turn clockwise or anticlockwise.


The following attributes are exposed and can be accessed at any time:
1. clockwise_anticlockwise # indicating which way the craft is rotating.
2. angle # the crafts position in angles (from 0 - 360)
3. target_angle # the angle the craft should stop on.
4. turning_speed # negative numbers result in an anticlockwise rotation.
5. maximum_speed_step # largest amount the turning_speed can be altered by.

Example #1.A.

A craft is turning clockwise and starts at 0 degrees and rotates clockwise, and may turn in increments of 6 degrees. If the target angle is 90 degrees, a logic expression like the one below would work

target_angle =90
  current_angle >= target_angle:
	# turn has completed.


But if the craft's current position is 30 degrees and the target angle is 300 degrees, what would be the best way to see if the craft has reached the target angle?

Ive provided a listing of the main module used to manage the autopilot and my strategy used to go about it.

from clsTaskManager import *
from clsGameInfo import *
from constants import *


class Autopilot:
    def __init__(self, screen_obj):
        self._tasks =TaskManager()         # Create a new task manager.
        self._time_slice =1 /GameInfo.FPS
        self.parameters ={}
        self.scrn_obj =screen_obj
        self.variables ={}
    # __init__()  -----------------------------------------------------------


    def _autopilot_aim_at_center_of_screen(self, obj):
        'Function - designed to be called from a taks queue.'
        print("[_autopilot_aim_at_center_of_screen] - Triggered successfully.")
        #   Get a dictionary of all the parameters
        # for this routine.
        par =Autopilot.parameters["_autopilot_aim_at_center_of_screen"]
    # _autopilot_aim_at_center_of_screen() ----------------------------------
    

    def _autopilot_point_craft_in_oaf(self, obj):
        'Function - designed to be called from a taks queue.'
        class TaskStatus:
            pass
        
        #   Get a dictionary of all the parameters and variables
        # for this routine.
        par =self.parameters["_autopilot_point_craft_in_oaf"]
        var =self.variables["_autopilot_point_craft_in_oaf"]
        #   _.

        so =self.scrn_obj
        if obj.status ==TaskManager.STATUS_TYPES.INIT:
            var["failed attempts"] =0
            var["completed_turn"] =False
            par_obj =TaskStatus()
            par_obj.status =TaskManager.STATUS_TYPES.INIT
            var["par_obj"] =par_obj
            self._r_t_diff =0
            self._r_a_diff =0
            if self.autopilot_rotation ==rotation_types.CLOCKWISE:
                if self._breaking_angle <so.angle:
                    #   Presume its correct and update the relative
                    # angle differential so that more than 360
                    # degrees are represented.
                    self._r_t_diff =360
            elif if self.autopilot_rotation ==rotation_types.ANTICLOCKWISE:
                if self._breaking_angle >so.angle:
                    #   Presume its correct and update the relative
                    # angle differential so that more than 360
                    # degrees are represented.
                    self._r_a_diff =360
            print("[_autopilot_point_craft_in_oaf] - INFO #1: Initial angles set at C angle:{0} Breaking angle:{1}.".format(so.angle, self._breaking_angle))
        elif obj.status ==TaskManager.STATUS_TYPES.RUNNING: 
            #   Need to work on turning the craft in the
            # opposite angle of flight.

            if self.autopilot_rotation ==rotation_types.CLOCKWISE:
                if so.angle >self._breaking_angle:
                    print("[_autopilot_point_craft_in_oaf] - INFO #2: Craft is facing in the direction of the breaking angel.")
                    var["completed_turn"] =True
            elif self.autopilot_rotation ==rotation_types.ANTICLOCKWISE:
                if so.angle <self._breaking_angle:
                    print("[_autopilot_point_craft_in_oaf] - INFO #3: Craft is facing in the direction of the breaking angel.")
                    var["completed_turn"] =True
                

            #   Different states:
            #       - turn completed
            #       - turn incomplete
            if var["completed_turn"] ==True:
                #   Examine the turn speed values to determine
                # if the craft is still turning.
                if so._turn_speed ==0:
                    #   The craft is NOT rotating, and there
                    # is nothing left to do for this task.
                    print("[_autopilot_point_craft_in_oaf] - INFO #4: Craft is facing in the direction of the breaking angel >>>AND<<< has stopped rotating.")
                    obj.status =TaskManager.STATUS_TYPES.COMPLETED
                else:
                    #   The craft is still turning.
                    print("[_autopilot_point_craft_in_oaf] - INFO #5: Rotation has completed but turn speed =", so._turn_speed)
                    update_task_status =False # Lock this task's status.
                    self._autopilot_stop_rotating(obj, update_task_status)
                    if not so._turn_speed ==0:
                        #   Something has seriously wrong, we
                        # shouldn't even be roatating.

                        var["failed attempts"] +=1
                        if var["failed attempts"] >10:
                            #   Give up and let's move onto the next task.
                            print("[_autopilot_point_craft_in_oaf] - WARNING #6: Failed to turn the craft to the breaking angle, and giving up.")
                            obj.status =TaskManager.STATUS_TYPES.COMPLETED
                            
                            #   Lets start this whole thing again.
                            self.autopilot_init()
                            var["failed attempts"] =0 # Reset var.
                        
                            
                    else:
                        #   The craft has sotpped rotating and it has
                        # turned to and pointing in the direction where
                        # we can apply thrusters to nuetralise xy movement.
                        obj.status =TaskManager.STATUS_TYPES.COMPLETED
            else:
                #   Point the craft in the direction of the
                # breaking angle so we can start slowing down by
                # apply thrusters.
                
                #   Hack into the tasked linked routine to set up variables
                # (and parameters) so the routine can run.
                try:
                    tmp_par =self.parameters["_autopilot_turn_to_angle"]
                except KeyError:
                    tmp_par ={}
                finally:
                    tmp_par["angle"] =self._breaking_angle
                    self.parameters["_autopilot_turn_to_angle"] =tmp_par

                try:
                    tmp_var =self.variables["_autopilot_turn_to_angle"]
                except KeyError:
                    tmp_var ={}
                    self.variables["_autopilot_turn_to_angle"] =tmp_var
                #   _.

                update_task_status =False # Lock task's status
                self._autopilot_turn_to_angle(var["par_obj"], update_task_status)
                if var["par_obj"].status ==TaskManager.STATUS_TYPES.INIT:
                    #   Now that the routine has been initialised lets progress
                    # onto running the core part of the routine.
                    var["par_obj"].status =TaskManager.STATUS_TYPES.RUNNING

        #   Save all the parameters and variables usesd by this routine.
        self.variables["_autopilot_point_craft_in_oaf"] =var
        self.parameters["_autopilot_point_craft_in_oaf"] =par
        #   _.

        if obj.status ==TaskManager.STATUS_TYPES.COMPLETED:
            print("[_autopilot_point_craft_in_oaf] - Completed successfully.")
            print("   - current angle:{0}  AOF:{1}".format(self.scrn_obj.angle, self._breaking_angle))
    # _autopilot_point_craft_in_oaf() ---------------------------------------


    def _autopilot_stop_moving(self, obj, update_task_status =True):
        # DESCRIPTION:
        #   This routine is used to bring the craft to a complete stop.
        #
        #
        # NOTES:
        #   # self._angle_x can be (+) or (-)
        
        'Function - designed to be called from a taks queue.'
        
        print("[_autopilot_stop_moving] - Triggered successfully.")
        #   Get a dictionary of all the parameters
        # for this routine.
        par =self.parameters["_autopilot_stop_moving"]
        var =self.variables["_autopilot_stop_moving"]

        #   This phase involves reducing our speed across the x and y
        # planes to zero.
        so =self.scrn_obj
        if so._speed_x >0:
            if so._speed_x +so._angle_x >0:
                #   We can't set the speed to
                # zero just yet.
                so._speed_x +=so._angle_x
            else:
                so._speed_x=0
        elif so._speed_x <0:
            if so._speed_x +so._angle_x <0:
                #   We can't set the speed to
                # zero just yet.
                so._speed_x +=so._angle_x
            else:
                so._speed_x=0
                
        if so._speed_y >0:
            if so._speed_y +so._angle_y >0:
                #   We can't set the speed to
                # zero just yet.
                so._speed_y +=so._angle_y
            else:
                so._speed_y=0
        elif so._speed_y <0:
            if so._speed_y +so._angle_y <0:
                #   We can't set the speed to
                # zero just yet.
                so._speed_y +=so._angle_y
            else:
                so._speed_y=0

        if so._speed_x ==0 and so._speed_y ==0:
            craft_not_moving =True
        else:
            craft_not_moving =False
            
        if update_task_status ==True:
            if craft_not_moving: # Go to the next mode.
                obj.status =TaskManager.STATUS_TYPES.COMPLETED
                print("[_autopilot_stop_moving] - Completed successfully.")
    # _autopilot_stop_moving() ----------------------------------------------
    

    def _autopilot_stop_rotating(self, obj, update_task_status =True):
        'Function - designed to be called from a taks queue.'
        print("[_autopilot_stop_rotating] - Triggered successfully.")
        
        #   Get a dictionary of all the parameters
        # for this routine.
        par =self.parameters["_autopilot_stop_rotating"]
        #   _.

        so =self.scrn_obj
        if so._turn_speed >0: # Craft is still turning.
            if so._turn_speed >self.largest_turn_factor:
                so._turn_speed -=self.largest_turn_factor
            else:
                #   Speed is at a low enough level to
                # reduce it to zero.
                so._turn_speed =0
        elif so._turn_speed <0: # Craft is still turning.
            if so._turn_speed <(0 -self.largest_turn_factor):
                so._turn_speed +=self.largest_turn_factor
            else:
                #   Speed is at a low enough level to
                # reduce it to zero.
                so._turn_speed =0

        if update_task_status ==True:
            #   Check if the task has completed.
            if so._turn_speed ==0:
                #   The craft has stopped rotating, so we can mark
                # this task as being completed.
                obj.status =TaskManager.STATUS_TYPES.COMPLETED
                print("[_autopilot_stop_rotating] - Completed successfully.")
    # _autopilot_stop_rotating() --------------------------------------------


    @staticmethod
    def _autopilot_zero_turn_speed(turn_speed, largest_turn_factor):
        #   Slow the crafts rotation as much as possible.
        if turn_speed >0: # Craft is still turning.
            if turn_speed >largest_turn_factor:
                turn_speed -=largest_turn_factor
            else:
                #   Speed is at a low enough level to
                # reduce it to zero.
                turn_speed =0
        elif turn_speed <0: # Craft is still turning.
            if turn_speed <(0 -largest_turn_factor):
                turn_speed +=largest_turn_factor
            else:
                #   Speed is at a low enough level to
                # reduce it to zero.
                turn_speed =0
        return (turn_speed ==0), turn_speed
    # -----------------------------------------------------------------------


    def _autopilot_turn_to_angle(self, obj, update_task_status =True):
        PHASE_NONBRAKING =1
        PHASE_BRAKING =2
        
        so =self.scrn_obj
        par =self.parameters["_autopilot_turn_to_angle"]
        var =self.variables["_autopilot_turn_to_angle"]
        
        print("[_autopilot_turn_to_angle] - Triggerred successfully (Status:{0} Angle:{1}).".format(obj.status, so.angle))
        if obj.status ==TaskManager.STATUS_TYPES.INIT:
            var["routine_phase"] =PHASE_NONBRAKING
        elif obj.status ==TaskManager.STATUS_TYPES.RUNNING:
            #   Check if the craft has completed its turn.
            if self.autopilot_rotation ==rotation_types.CLOCKWISE:
                
            elif if self.autopilot_rotation ==rotation_types.ANTICLOCKWISE:

                
            if var["routine_phase"] ==PHASE_NONBRAKING:
                #            --- Rotate Quickly ---
                #   Rotate the craft to the desired angle and
                # do it as fast as possible, but make sure
                # that the craft can come to a stop before
                # overshooting the target angle.

                #   Need to make two versions of this while
                # loop, one for rotating clockwise and
                # another for rotating the other way.
                if self.autopilot_rotation ==rotation_types.CLOCKWISE:
                    fnd =False
                    #next_turning_factor_speed =self.scrn_obj._craft.max_turn_factor
                    next_turning_factor_speed =self.largest_turn_factor
                    rs =0
                    print("[_autopilot_turn_to_angle] - INFO #1: The autopilot turned clockwise (next turning factor:{0}).".format(next_turning_factor_speed))
                    while rs <=self.largest_turn_factor:
                        while next_turning_factor_speed >= 0: 
                            #   Find the value for the next best turning
                            # step increase.
                            new_turning_speed =so._turn_speed -rs +next_turning_factor_speed
                            new_angle =self.scrn_obj.angle +(new_turning_speed /GameInfo.FPS) # Advance the angle to the next time frame.
                            evaluation_result =self.evaluate_stop_turn(new_turning_speed, new_angle, par["angle"])
                            if evaluation_result ==True:
                                #   We have found a a new turning speed
                                # that we can use without missing our
                                # target.
                                print("[_autopilot_turn_to_angle] - INFO #2: Found a new turning speed:{0}).".format(new_turning_speed))
                                fnd =True
                                break
                            next_turning_factor_speed -=1
                        if fnd:
                            break
                        else:
                            rs +=1
                elif self.autopilot_rotation ==rotation_types.ANTICLOCKWISE:
                    fnd =False
                    next_turning_factor_speed =(0 -self.largest_turn_factor)
                    print("[_autopilot_turn_to_angle] - INFO #3: The autopilot turned anticlockwise (next turning factor:{0}).".format(next_turning_factor_speed))
                    while next_turning_factor_speed >= 0:
                        #   Find the value for the next best turning
                        # step increase.
                        new_turning_speed =so._turn_speed -rs +next_turning_factor_speed
                        new_angle =self.scrn_obj.angle -(new_turning_speed /GameInfo.FPS) # Advance the angle to the next time frame.
                        #evaluation_result =self.evaluate_stop_turn(new_turning_speed, self.scrn_obj.angle, par["angle"])
                        evaluation_result =self.evaluate_stop_turn(new_turning_speed, new_angle, par["angle"])
                        if evaluation_result ==True:
                            #   We have found a a new turning speed
                            # that we can use without missing our
                            # target.
                            print("[_autopilot_turn_to_angle] - INFO #4: Found a new turning speed:{0}).".format(new_turning_speed))
                            fnd =True
                            break
                        next_turning_factor_speed +=1
                else:
                    print("[_autopilot_turn_to_angle] - WARNING: The autopilot did NOT turn clockwise or anticlockwise.")
                    
                if fnd:
                    print("[_autopilot_turn_to_angle] - INFO #5: Turning speed:{0} (old:{1}).".format(new_turning_speed, so._turn_speed))
                    so._turn_speed =new_turning_speed -rs
                else:
                    #   Move to the next phase.
                    var["routine_phase"] =PHASE_BRAKING
                    print("\n[_autopilot_turn_to_angle] - INFO #6: Entered new phase 'PHASE_BRAKING'.")
            elif var["routine_phase"] ==PHASE_BRAKING:
                print("[_autopilot_turn_to_angle] - INFO: Turning phase #slower turn speed, turning speed:{0} (current speed:{1}) angle:{2}.".format(None, so._turn_speed, so.angle))
                #   Search for a turn speed that results in the craft turning as
                # fast as possible yet able to stop at the desired angle without
                # over-shooting.
                r =0
                while r <self.largest_turn_factor: # < Turn factor increase ?
                    #   Make a prediction on the craft stopping at the desired
                    # angle with the current speed settings.
                    source_angle =so.angle
                    turn_speed =so._turn_speed
                    current_angle =source_angle +((turn_speed -r) *self._time_slice)
                    largest_turn_factor =self.largest_turn_factor
                    stop_trying =False
                    while stop_trying ==False:
                        result, turn_speed =self._autopilot_zero_turn_speed(turn_speed, largest_turn_factor)
                        if result ==False:
                            #   The craft needs more time to stop the rotation.
                            target_angle =par["angle"]
                            if self.autopilot_rotation ==rotation_types.CLOCKWISE:
                                if source_angle >target_angle:
                                    target_angle +=360
                                if current_angle <target_angle:
                                    #   There's still a chance of stopping before
                                    # the desired target angle.
                                    stop_trying =False
                                else:
                                    stop_trying =True
                            elif self.autopilot_rotation ==rotation_types.ANTICLOCKWISE:
                                if source_angle <target_angle:
                                    target_angle +=360
                                if current_angle >target_angle:
                                    #   There's still a chance of stopping before
                                    # the desired target angle.
                                    stop_trying =False
                                else:
                                    stop_trying =True
                        else:
                            #   Even if we did nothing at this point the craft
                            # can still come to a stop before over shooting
                            # the target.
                            break

                                    

                    if not turn_speed ==0:
                        #   We need to apply the brakes on the crafts
                        # rotation because its turning to fast.
                        r +=1
                    else:
                        #   The craft can stop the ratation in time to
                        # hit the target angel without over-shooting.
                        if r >0:
                            #   The craft can only stop at the desired
                            # target if we reduce the speed now.
                            
                            so._turn_speed -=r #   Update the speed of rotation.
                        break

                if update_task_status ==True:
                    if so._turn_speed ==0:
                        obj.status =TaskManager.STATUS_TYPES.COMPLETED 
            
        self.parameters["_autopilot_turn_to_angle"] =par
        self.variables["_autopilot_turn_to_angle"] =var
        print("[_autopilot_turn_to_angle] - Status:", obj.status)
        #   _.
        
    # autopilot_turn_to_angle() ---------------------------------------------
            

    def activate_autopilot(self):
        if self._autopilot ==cls.AUTOPILOT_OFF:
            self._autopilot =cls.AUTOPILOT_ON
            self._autopilot_init()
    # activate_autopilot() --------------------------------------------------

    
    def autopilot_init(self):
        'Creates a set of tasks to bring the craft back to the screen center.'
        #   Do the stuff neccessary to start the autopilot.
        print("[autopilot_init] - Started ...")
        
        #   Determine angle of flight.
        self._aof =self.scrn_obj.evaluate_flight_path()  # Angle of Flight.
        self._breaking_angle =None              # Oppoosit to Angle of Flight.
        self._craft_is_moving =False
        self.autopilot_rotation =None           # Type of rotation.
        self.largest_turn_factor =None          # Largest turn increment value.
        self._RT =None                          # Rotation types.
        

        

        #  >>> Find the Oppoosite Angle of Flight <<<
        # ----------------------------------------------
        #   In order to neutralise the speed to come to
        # a stand still the craft needs to face in the
        # opposite direction of the angle of flight,
        # calculate the breaking angle.
        self._breaking_angle =self._aof +180
        while self._breaking_angle >360: # Attempt to rectify angle.
            self._breaking_angle -=360
        #   _.

        #   >>> Turn Clockwise or Anti-Clockwise <<
        # ----------------------------------------------
        #   In order for the craft to turn and face in
        # the opposite direction to the angle of flight
        # the craft needs to turn clockwise or ant-
        # clockwise. Unfortunately the craft could be
        # facing in any direction prior to the
        # autopilot kicking in.
        #
        #   Call the routine to determine the shortest
        # turning circle.
        c_val, a_val=self.scrn_obj.clockwise_anticlockwise(self._aof, self._breaking_angle )
        if c_val <=a_val:   #  Its quicker to turn clockwise.
            #my_rotation =RT.CLOCKWISE
            self.autopilot_rotation =self.scrn_obj._craft.RT.CLOCKWISE
        else:               # Its quicker to turn anti-clockwise.
            #my_rotation =RT.ANTICLOCKWISE
            self.autopilot_rotation =self.scrn_obj._craft.RT.ANTICLOCKWISE
        #   _.
        
        
        self.largest_turn_factor =self.scrn_obj._craft.max_turn_factor /GameInfo.FPS

        #   --- Build the Task List ---
        #
        #   Build a task list for the autopilot to follow
        # to return the craft to the center of the screen.
        self._tasks.clear_tasks()
        self._tasks.add(self.autopilot_stop_rotating())
        self._tasks.add(self.autopilot_point_craft_in_oaf())
        self._tasks.add(self.autopilot_stop_moving())
        self._tasks.add(self.autopilot_aim_at_center_of_screen())
        #   _.

##        active_task.completed =True
    # _autopilot_init() ------------------------------------------------------


    def autopilot_aim_at_center_of_screen(self):
        'Function - generates a task (definition) and registers it in the queue.'
        obj =TaskManager.definition()
        obj.name ="autopilot_aim_at_center_of_screen"
        obj.linked_routine = self._autopilot_stop_rotating

        #   Store parameter information in this
        # class.
        par ={}
        var ={}
        #par["x"] =121
        self.parameters["_autopilot_aim_at_center_of_screen"] =par
        self.variables["_autopilot_point_craft_in_oaf"] =var
        #   _.

        return obj
    # autopilot_aim_at_center_of_screen() -----------------------------------


    def autopilot_point_craft_in_oaf(self):
        'Function - generates a task (definition) and registers it in the queue.'
        obj =TaskManager.definition()
        obj.name ="autopilot_point_craft_in_oaf"
        obj.linked_routine = self._autopilot_point_craft_in_oaf
        
        #   Store parameter information in this
        # class.
        par ={}
        var ={}
        #par["x"] =121
        self.parameters["_autopilot_point_craft_in_oaf"] =par
        self.variables["_autopilot_point_craft_in_oaf"] =var
        #   _.

        return obj
    # autopilot_point_craft_in_oaf() ----------------------------------------


    def autopilot_stop_moving(self):
        'Function - generates a task (definition) and registers it in the queue.'
        obj =TaskManager()
        obj.name ="autopilot_stop_moving"
        obj.linked_routine =self._autopilot_stop_moving

         #   Store parameter information in this
        # class.
        par ={}
        var ={}
        #par["x"] =121
        self.parameters["_autopilot_stop_moving"] =par
        self.variables["_autopilot_stop_moving"] =var
        #   _.

        return obj
    # autopilot_stop_moving() -----------------------------------------------


    def autopilot_stop_rotating(self):
        'Function - generates a task (definition) and registers it in the queue.'
        obj =TaskManager.definition()
        obj.name ="autopilot_stop_rotating"
        obj.linked_routine = self._autopilot_stop_rotating
        
        #   Store parameter information in this
        # class.
        par ={}
        var ={}
        #par["x"] =121
        self.parameters["_autopilot_stop_rotating"] =par
        self.variables["_autopilot_stop_rotating"] =var
        #   _.

        return obj
    # autopilot_stop_rotating() ------------------------------------------------------


    def autopilot_turn_to_angle(self, angle):
        'Function - generates a task (definition) and registers it in the queue.'
        obj =TaskManager.definition()
        obj.name ="autopilot_turn_to_angle"
        obj.linked_routine = self._autopilot_turn_to_angle
        
        #   Store parameter information in this
        # class.
        par ={}
        var ={}
        par["angle"] =angle
        self.parameters["_autopilot_turn_to_angle"] =par
        self.variables["_autopilot_turn_to_angle"] =var
        print("[autopilot_turn_to_angle] - Parameters and variables stored successfully.")
        #   _.


        return obj
    # autopilot_turn_to_angle() ---------------------------------------------


    def evaluate_stop_turn(self, turning_speed, current_angle, target_angel, recurrence =False):
        eval_result =False
        run_it_again =False
        calculated_angle =None

        #   Only do this section once.
        if recurrence ==False:
            #   Preceed to calibrate the angle if neccessary.
            if self.autopilot_rotation ==rotation_types.CLOCKWISE:
                if target_angel <current_angle:
                    #   Adjudst the [target_angle] so its relative to the
                    # current angle.
                    target_angel +=360
            elif self.autopilot_rotation ==rotation_types.ANTICLOCKWISE:
                if target_angel >current_angle:
                    #   Adjust the [current_angle] so its relative to the
                    # target angle so we can perform a simple
                    # comparison.
                    current_angle +=360
        #   _.
        
                
        #   -- Reduce the turning speed ---
        #
        #   Reduce the turing speed simulating maximum breaking.
        #if turning_speed >0:
        if self.autopilot_rotation ==rotation_types.CLOCKWISE:
            #rotation_type =rotation_types.CLOCKWISE 
            if turning_speed >self.scrn_obj._craft.max_turn_factor:
                #   Craft is rotating to fast to come to a
                # complete stop at the moment.
                turning_speed -=self.scrn_obj._craft.max_turn_factor
            else:
                #   We can stop the rotation completly.
                #print("[evaluate_stop_turn] - INFO: Turning clockwise we can stop the rotation completly.")
                turning_speed =0
        #elif turning_speed <0:
        elif self.autopilot_rotation ==rotation_types.ANTICLOCKWISE: 
            #rotation_type =rotation_types.ANTICLOCKWISE 
            if turning_speed <(0 -self.scrn_obj._craft.max_turn_factor):
                #   Craft is rotating to fast to come to a
                # complete stop at the moment.
                turning_speed +=self.scrn_obj._craft.max_turn_factor
            else:
                #   We can stop the rotation completly.
                #print("[evaluate_stop_turn] - INFO: Turning anticlockwise we can stop the rotation completly.")
                turning_speed =0
        else:
            #   Looks like the craft isn't rotating.
            print("[evaluate_stop_turn] - WARNING: Turning speed is zero.")
            self._autopilot_rotation =rotation_types.NIETHER 

        #   Calculate the angle travelled by the craft over
        # the set time frame.
        if turning_speed ==0:
            additional_angles =0
        else:
            additional_angles =(turning_speed /GameInfo.FPS)
        #   _.
        
            
        if self.autopilot_rotation ==rotation_types.CLOCKWISE:
            calculated_angle =current_angle +additional_angles
            if calculated_angle <=target_angel:
                #   --- Within Range ---
                #   At the present rate of turning the craft
                # will rotate through a number of angles over the
                # set period within the specifed target range.
                if turning_speed ==0:
                    #   Our evaluation of the stopping range has
                    # been completed.
                    eval_result =True
                else:
                    run_it_again =True
        elif self.autopilot_rotation ==rotation_types.ANTICLOCKWISE:
            calculated_angle =current_angle -additional_angles
            if calculated_angle >=target_angel:
                #   --- Within Range ---
                #   At the present rate of turning the craft
                # will rotate through a number of angles over the
                # set period within the specifed target range.
                if turning_speed ==0:
                    #   Our evaluation of the stopping range has
                    # been completed.
                    eval_result =True
                else:
                    run_it_again =True

        #   DEBUG information
        if calculated_angle ==None:
            print("   [evaluate_stop_turn] - INFO #1: Angle:{0} Turning speed:{1} Target angle:{2} (Rotation type:{3} Result:{4}).".format(current_angle, turning_speed, target_angel, self.autopilot_rotation, eval_result))
        else:
            if run_it_again:
                print("   [evaluate_stop_turn] - INFO #2: Angle:{0} Turning speed:{1} Target angle:{2} (Rotation type:{3} Result:{4}).".format(calculated_angle, turning_speed, target_angel, self.autopilot_rotation, "n/a"))
            else:
                print("   [evaluate_stop_turn] - INFO #2: Angle:{0} Turning speed:{1} Target angle:{2} (Rotation type:{3} Result:{4}).".format(calculated_angle, turning_speed, target_angel, self.autopilot_rotation, eval_result))
            
       if run_it_again ==True:
            #   Since the rotation speed hasn't been
            # neutralised to zero we need to see how
            # far the craft will rotate before coming to a
            # complete stop.
            
            #   perform an evaluation on the next time frame.
            #
            #   * Note(s)
            #       Setting [recurrence] =True ensures that the target
            #       angle can only be calibrated once.
            #
            #eval_result =self.evaluate_stop_turn(turning_speed, calculated_angle, target_angel)
            eval_result =self.evaluate_stop_turn(turning_speed, calculated_angle, target_angel, recurrence =True)
            #   _.
            
            
        #   Return the result of the time
        # frame analysis to the calling
        # routine.
        if eval_result ==False:
            #   DEBUG information
            if calculated_angle ==None:
                print("   [evaluate_stop_turn] - INFO #3: Routine calculated that the craft is turning to fast."
                  "\n      * Angle:{0} Turning speed:{1} Target angle:{2}.".format(current_angle, turning_speed, target_angel))
            else:
                print("   [evaluate_stop_turn] - INFO #4: Routine calculated that the craft is turning to fast."
                      "\n      * Angle:{0} Turning speed:{1} Target angle:{2}.".format(calculated_angle, turning_speed, target_angel))
        
        return eval_result
            
    # evaluate_stop_turn() --------------------------------------------------
    
Reply


Possibly Related Threads…
Thread Author Replies Views Last Post
  angle of rotation berckut72 4 2,957 Apr-27-2020, 04:55 PM
Last Post: berckut72
  [PyGame] Converting PyGame 2 axis joystick float to 360 angle archieab 1 3,315 Sep-26-2018, 05:40 PM
Last Post: archieab

Forum Jump:

User Panel Messages

Announcements
Announcement #1 8/1/2020
Announcement #2 8/2/2020
Announcement #3 8/6/2020