Aug-13-2018, 08:38 PM
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
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.
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() --------------------------------------------------