[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[pygame] Direction By Sequence 1 to 9 Instead Of Degrees
import math
import pygame
class X4Line:
"""X4LINE CALCULATES THE ANGLE AND LENGTH OF STRAIGHT LINE BETWEEN 2 POINTS!
- USING __INT__ TO INITIALIZE CLASS OBJECTS,
- BY PASSING SELF INIT PARAMETERS IN TO ATTRIBUTES.
- THEN SELF ATTRIBUTES GET PASSED BACK AS CLASS ATTRIBUTES!
- PAST BACK ONLY WHEN A VARIABLE, AN INSTANCE, HAS BEEN CREATED!
- DISTANCE ANGLE CALCULATOR
- CALCULATES LENGTH AND ANGLE OF A STRAIGHT LINE BETWEEN 2 POINTS!"""
def __init__(self, X1, Y1, X2, Y2):
self.Dx = X2 - X1
self.Dy = Y2 - Y1
self.Dist = math.sqrt(self.Dx**2 + self.Dy**2)
self.Tan_Angle = math.atan( self.Dy/ self.Dx)
self.Sin_Angle = math.asin( self.Dy/ math.sqrt( self.Dx**2 + self.Dy**2))
self.Cos_Angle = math.acos( self.Dx/ math.sqrt( self.Dx**2 + self.Dy**2))
#SHIP CALCULATIONS!
def Dir(Course):
"""FUNCTION DIR CONVERTS DIRECTION 1 TO 8.999 BACK TO ANGLE.
- AND NOTE NEGATIVE BECAUSE OF 90 DEGREE ROTATION SHIFT!"""
return ((Course-1) *(math.pi/4))
def Sin4Dy( Dm, Adjust):
"""FUNCTION SIN4DY IS USED FOR THE Y AXIS STARTING AT 1 IN UPPER LEFT CORNER.
- COMVERT DY BECAUSE OF Y AXIS REVERSE COUNT AND ADD ROUNDING ADJUSTMENT!"""
Dm*=SIN # GLOBAL SIN VALUE!
if Dm<0:
Adjust = -Adjust
Dm+=Adjust
return (-Dm)
def Ship_Course (dy, dx): #, dz):
"""FUNCTION SHIP_COURSE PASSES IN 2 VALUES DY AND DX.
- DY AND DX ARE THE CHANGE IN DIRECTION, SLOPE, BETWEEN 2 POINTS OF A STRAIGHT LINE.
- USED FOR DIRECTION AND DISTANCE FOR THE VECTOR X & Y CALCULATION!
- DIRECTION IS COUNTER CLOCKWISE BASED ON NUMBER OF RADIANS IN THE
- ANGLE FORMED AND CONVERTED TO A NUMBER WITH VALUES LIKE
- 1 IN THE 3 O'CLOCK, 3 IN THE 12 O'CLOCK, 5 AT 9 O'CLOCK, OR 7 IN THE 6 O'CLOCKE DIRECTIONS
- ANY OTHER VALUES FROM 1 TO 8.999 WILL BE A FRACTION OF THOSE VALUES!
- A SINGLE VALUE REPRESENTING THE DIRECTION OF THE VECTOR BETWEEN 2 OBJECTS IN SPACE!"""
# VARIABLES:
Factor=1.0
Angle=0.0
Angle2=0.0
if dx>=0: # What Direction Is SHIP Going?
Factor=5.0 # DIRECTION TO LEFT!
if dy==0: # ONLY HORIZONTAL MOVEMENT?
return(Factor) # Yes! Then Return.
if dx==0: #ONLY VERTICAL MOVEMENT?
if dy<0: # DOWN?
return(7) # Yes! OR
else: # THEN,
return(3) # UP!
# PI Radians Of Tangent Angle, Opposite Over Adjacent, DY/DX Slope.
# NOW THE ANGLE WE ARE USING IS FROM THE OTHER SHIP BACK, SO X IS Y AND Y IS X.
Angle= math.atan( dx/dy) # NORMAL MAP X-Y!
Angle2= math.atan( dx/dy) # BASIC GAME WHEN GOING DOWN Y VALUE GOES UP!
# STORE THE ANGLE FOR FUTURE GLOBAL ANGLE CALCULATIONS!
C1ANGLE=Angle2
# BASIC GAME DIR CALCULATION!
# ROTATING THE X AND Y 90 DEGREES!
# THIS WILL GIVE THE NEW TANGENT ANGLE SO X IS Y AND Y IS X!
# OR Y INCREASING GOING DOWN MEANS Y ABOVE IS NEGATIVE TO ENTERPRISE.
# ROTATING 90 DEGREES PLACES ANGLE WHERE TANGENT IS NEGATIVE, GIVING
# NEGATIVE VALUE NEEDED. ALL ANGLES ARE NOW COMPLIMENT, THUS MAINTAINING
# POSITIVE X VALUE AS LONG AS KLINGON MOVES IN FRONT OF ENTERPRISE!
# FOR Y VALUES WILL GO DOWN WHEN ANGLE INCREASES BECAUSE IT IS COMPLIMENT!
# NOW WE MUST FIGURE KLINGON WITH RESPECT TO ENTERPRISE!
# TO ADD AMOUNT TO GIVE THE NUMBERS FROM 1 TO 9 EQUIVALENT!
if dy<0: # QUADS 1 OR 2, KLINGON ABOVE ENTERPRISE?
Angle2+= 3*(math.pi/2) # NO, SO ADD ENOUGH RADIANS TO PUT BELOW!
else: # ONLY ROTATE 90 DEGREES FOR CONVERSION COUNT!
Angle2+= (math.pi/2) # ADD PI/2 RADIANS!
# THEN CONVERT TO OUR DIRECTIONAL POINTER EQUIVALENT!
# NOTE: EACH PI/4 HAS A TANGENT OF 1 SO, 4 TIMES FOR EACH HALF CIRCLE!
# THEN NEGATE THE PI BY DIVIDING IT OUT!
Angle2= Angle2*4 /math.pi +1 # NOW WE HAVE 1 TO 8.999 POINTER!
return (Angle2) # BASIC GAME DIRECTION OF ANGLE, 1 TO 9
# CALCULATIONS BELOW ARE FOR A STANDARD X AND Y AXIS!
# STANDARD WHERE Y GOES UP IN VALUE WHEN GOING VERTICALLY UP!
if Angle<0 and dx<0: # IS ANGLE IN QUAD 4?
Factor=9 # YES, ADJUST FACTOR!
# NOW ADJUST FOR OUR POINTER EQUIVALENT 1 TO 8.99
Angle= Factor +Angle/(math.pi/4) # ADJUST PER EACH 45 DEGREES.
return (Angle) # DIRECTION OF ANGLE, 1 TO 9
# FUNCTION USED IN NORMAL X-Y AXIS, NOT IN PROGRAM!
def ship_angle(course):
"GET SHIP ANGLE FROM DIRECTION 0-9!"
Angle=0.0
Factor=0
Dir=0.0,
# GET THE DIRECTION INTEGER FACTOR.
Factor = Math.floor( course)
Dir = course
course-=1 # ROTATE RIGHT TO CONVERT TO RADIAN ANGLE FACTOR.
# if (course>2 and course<4) or course>6: # QUADS 2 AND 4?
# course*=-1 # YES, MAKE NEGATIVE.
Angle= course*(math.pi/4)
Angle-= math.pi/2
Angle= -Angle
Angle= math.tan(Angle)
return (Angle)
def Dir4Ship2Ship( S1DSS, S2DSS):
"CALCULATE THE ANGLE FROM SHIP S1 TO SHIP S2!"
Dy4DSS= Ships[ S1DSS].Sy -Ships[ S2DSS].Sy # SECTOR Y POS!
Dx4DSS= Ships[ S1DSS].Sx -Ships[ S2DSS].Sx # SECTOR X POS!
return (Ship_Course( Dy4DSS, Dx4DSS)) # THE ANGLE 1 TO 8.999 GOING COUNTERCLOCKWISE!
print "Module Location.Name: %s" % X4Line
print X4Line.__doc__
print "Assign Object X The Values X4Line(1.0, 1.0, 8.0, 8.0)"
x = X4Line( 1.0, 1.0, 8.0, 8.0)
print "DX part: X.Dx= %2.2f" % x.Dx
print "Dy part: X.Dy= %2.2f" % x.Dy
print "Distance is: %2.4f" % x.Dist
print "The Tan Angle is: %2.4f" % x.Tan_Angle
print "The Sin Angle is: %2.4f" % x.Sin_Angle
print "The Cos Angle is: %2.4f" % x.Cos_Angle
print "The Value Of Pi Is: %2.6f" % math.pi
print Ship_Course
print Ship_Course.__doc__
print "Remember that ship in upper left Y is 1 and left side X is 1"
print "So: if ship is up and left of Enterprise the y and x trying to get to it"
print "are both positive! For the line to that ship is S-point - E-point"
print "Ship Direction:"
Dy= 8.
Dx= -1.
print "Dx= %2.2f" % Dx
print "Dy= %2.2f" % Dy
Course = Ship_Course (Dy,Dx)
print "Ship Course %2.2f" % Course
Angle = Dir( Course)
print "The Angle Is %3.3f Degrees" % math.degrees( Angle)
print "Tangent Angle Is %2.5f Of PI" % (Angle / math.pi)
print "Tangent Angle Is %2.5f Radians" % Angle