mirror of
https://github.com/bendtherules/pytry.git
synced 2026-08-18 13:53:01 +00:00
815 lines
37 KiB
Python
815 lines
37 KiB
Python
# only for python 2.x
|
|
from uniquelist import * # imports uniquelist
|
|
import pygame
|
|
import pygame.gfxdraw
|
|
from pygame.locals import * # imports the constants
|
|
from math import *
|
|
#Mouse constants
|
|
B_LEFT_CLICK =1
|
|
B_RIGHT_CLICK =3
|
|
B_MIDDLE_CLICK =2
|
|
B_SCROLLUP =4
|
|
B_SCROLLDOWN =5
|
|
|
|
# Direction constants
|
|
TOP =1
|
|
LEFT =2
|
|
BOTTOM =3
|
|
RIGHT =4
|
|
|
|
class fun_Game(object):
|
|
list_class=uniquelist()
|
|
list_event=[] # event_list of this step
|
|
list_event_old=[] # event_list of the previous step
|
|
list_state_all_buttons=[] # A sequence of boolean representing the state of every key
|
|
list_state_all_buttons_old=[] # A sequence of boolean representing the state of every key of previous step
|
|
def __init__(self,width,height,fps=30):
|
|
pygame.init()
|
|
self.fps=fps
|
|
self.clock=pygame.time.Clock()
|
|
self.width=width
|
|
self.height=height
|
|
|
|
def update_all_class(self):
|
|
for temp_cls in fun_Game.list_class:
|
|
for temp_count in temp_cls.list_instance:
|
|
temp_count.update()
|
|
|
|
def _cache_event_list(self):
|
|
''' Cache event_list in every step.
|
|
All events in fun_Game.list_event have a "type" property which are the usual constants. '''
|
|
fun_Game.list_event_old=fun_Game.list_event # move current list to old list
|
|
fun_Game.list_state_all_buttons_old=fun_Game.list_state_all_buttons
|
|
|
|
fun_Game.list_event=pygame.event.get()
|
|
fun_Game.list_state_all_buttons=pygame.key.get_pressed() #Returns a sequence of boolean representing the state of every key. Use key constant values for indexing.
|
|
#print fun_Game.list_event # debug message
|
|
# control access to list_event
|
|
# with getter, do something crazy for filtering
|
|
# or a filtering function
|
|
|
|
def run(self):
|
|
self.screen=pygame.display.set_mode([self.width,self.height])
|
|
while True:
|
|
self._cache_event_list() # Todo: Add other update-related functions
|
|
self.update_all_class()
|
|
# VERY IMPORTANT: Do a spare first step so that every variable / list gets initialised well. Start instant creation and execution from second step.
|
|
# IMPORTANT: First do all fun_Game related stuff before dealing with game objects.
|
|
self.clock.tick(self.fps)
|
|
self.screen.fill([50,100,150]) # Todo: Remove this debug statement
|
|
pygame.display.flip() # debug statement
|
|
#print(event)
|
|
#print(fun_Game.list_event_old)
|
|
# Todo - Add crazy functions to allow other objects and instances finding like GM
|
|
|
|
#class fun_Game ends here
|
|
|
|
class meta_fun_Class(type):
|
|
def __new__(cls,name,base,clsdict):
|
|
temp_class=type.__new__(cls,name,base,clsdict)
|
|
fun_Game.list_class.append(temp_class)
|
|
cls.priority_order=cls.depth=len(fun_Game.list_class) #by default, priority_order and depth depends on "when class was defined"
|
|
return temp_class
|
|
|
|
class fun_Class(object):
|
|
__metaclass__=meta_fun_Class
|
|
list_instance=uniquelist()
|
|
#list_update_functions stores the list of functions to call in the given order.
|
|
#It can be used for injecting custom user functions (remember order).
|
|
list_update_functions=uniquelist() #action_draw not added as it depends on depth
|
|
list_check_functions=uniquelist() # all the check functions added here. what they do: if event_<event_name>: action_<event_name>
|
|
|
|
def __init__(self,x,y,img=None):
|
|
self.x=0
|
|
self.y=0
|
|
self.img=img #img should be a fun_Image, but lets do that later
|
|
fun_Class.list_instance.append(self)
|
|
self.action_create()
|
|
|
|
def update(self):
|
|
'''calls all functions in list_update_functions in the given order'''
|
|
temp=None
|
|
for temp in fun_Class.list_update_functions:
|
|
temp(self)
|
|
|
|
def draw(self):
|
|
# do some blitting depending on self.img
|
|
pass
|
|
|
|
def register(list_to_register=None):
|
|
''' Used as decorator: Adds the function to list_to_register '''
|
|
def temp_func(what_to_register):
|
|
list_to_register.append(what_to_register)
|
|
return what_to_register
|
|
return temp_func
|
|
|
|
@register(list_update_functions)
|
|
def action_begin_step(self):
|
|
pass
|
|
@register(list_update_functions)
|
|
def action_step(self):
|
|
tmp=self.event_mouse_click()
|
|
if tmp:
|
|
print tmp
|
|
print(self.mouse_get_focused())
|
|
@register(list_update_functions)
|
|
def action_end_step(self):
|
|
pass
|
|
# creation and destroy event
|
|
def action_create(self):
|
|
''' Better to use this function than overloading __init__() '''
|
|
pass
|
|
def action_destroy(self):
|
|
''' Executed when the instance is destroyed '''
|
|
pass
|
|
def destroy(self):
|
|
action_destroy(self)
|
|
|
|
# checks for all standard events -- functions named like check_<event>
|
|
# what they do: if event_<event_name>: action_<event_name>
|
|
# so lets define event_<event_name>,action_<event_name>,check_<event_name> for each <event_name>
|
|
|
|
# keyboard handling (later move to keyboard module)
|
|
|
|
# occurs if the key was held down continously since the last step
|
|
def event_key_pressed(self,key_value):#check if it works
|
|
if get_event_list(list_to_get=fun_Game.list_state_all_buttons)[key_value] \
|
|
and get_event_list(list_to_get=fun_Game.list_state_all_buttons_old)[key_value]\
|
|
and (not get_event_list(event_types=KEYUP,further_check_variable_name="key",further_check_value=key_value))\
|
|
and (not get_event_list(event_types=KEYUP,further_check_variable_name="key",further_check_value=key_value,list_to_get=fun_Game.list_event_old)):
|
|
return True
|
|
|
|
def action_key_pressed(self,key_value):
|
|
pass
|
|
def check_key_pressed(self):
|
|
pass # Todo: think about how to do it
|
|
|
|
# occurs if the key is held at the moment (live)
|
|
def event_key_pressed_live(self,key_value):#check if it works
|
|
''' Returns True if the key (represented by key_code) is currently pressed.
|
|
Problem is that this function is live. Returns True if the key is pressed at that moment.
|
|
So, for example, two calls in two consecutive steps may return True although the key has been left in the meantime. '''
|
|
temp_all_buttons=get_event_list(list_to_get=fun_Game.list_state_all_buttons) #Returns a sequence of boolean representing the state of every key. Use key constant values for indexing.
|
|
if temp_all_buttons[key_value]: # indexing by key_value
|
|
return True
|
|
def action_key_pressed_live(self,key_value):
|
|
pass
|
|
def check_key_pressed_live(self):
|
|
temp_all_buttons=get_event_list(list_to_get=fun_Game.list_state_all_buttons) #Returns a sequence of boolean representing the state of every key. Use key constant values for indexing.
|
|
for temp in range(len(temp_all_buttons)): # temp represents the key code in numbers as it is the index of list_state_all_buttons indirectly
|
|
if temp_all_buttons[temp]:
|
|
self.action_key_pressed_live(temp) #temp is the keycode
|
|
|
|
# occurs if a key press occurs (i.e. pushed down)
|
|
# key repetations may occur as the list is cached per step and there might be multiple (same key)press per step.
|
|
def event_key_down(self,key=None):
|
|
if key == None:
|
|
return get_event_list(KEYDOWN)
|
|
else:
|
|
return get_event_list(KEYDOWN,"key",key)
|
|
def action_key_down(self,key):
|
|
pass
|
|
def check_key_down(self):
|
|
for temp in get_event_list(KEYDOWN):
|
|
action_key_down(self,temp.key)
|
|
|
|
|
|
#probably wierd thing to do - define all <>_key_down as equivalent to <>_key_press
|
|
event_key_press = event_key_down
|
|
action_key_press = action_key_down
|
|
check_key_press = check_key_down
|
|
|
|
# occurs if key is released
|
|
def event_key_up(self,key=None):
|
|
if key==None:
|
|
return get_event_list(KEYUP)
|
|
else:
|
|
return get_event_list(KEYUP,"key",key)
|
|
def action_key_up(self,key):
|
|
pass
|
|
def check_key_up(self):
|
|
for temp in get_event_list(KEYUP):
|
|
action_key_up(self,temp.key)
|
|
# Todo: Do other key and keyboard related functions (look at GM for related functions)
|
|
# Mouse handling (later move it to mouse module)
|
|
#Mouse constants (defined at top - move them to a constants module, which will be imported in the global namespace)
|
|
#mouse click
|
|
def event_mouse_click(self,button=None):
|
|
if button==None:
|
|
return get_event_list(event_types=MOUSEBUTTONDOWN)
|
|
else:
|
|
return get_event_list(event_types=MOUSEBUTTONDOWN,further_check_variable_name="button",further_check_value=button)
|
|
def action_mouse_click(self,button):
|
|
pass
|
|
def check_mouse_click(self):
|
|
list_temp=get_event_list(event_types=MOUSEBUTTONDOWN)
|
|
for temp in list_temp:
|
|
action_mouse_click(temp.button)
|
|
#mouse get pressed
|
|
def event_mouse_get_pressed(self,button=None):
|
|
''' event_mouse_get_pressed() -> tuple looking like (1,0,0) i.e. ( left_click_state, middle_click_state, right_click_state ).
|
|
Use an index which is (corresponding_constant - 1). For eg event_mouse_get_pressed()[0] returns left click state.
|
|
event_mouse_get_pressed(button) -> Returns 0 or 1 depending on pressed or not. '''
|
|
if button==None:
|
|
return pygame.mouse.get_pressed()
|
|
else:
|
|
return pygame.mouse.get_pressed()[button-1] # because the tuple returned has o-based indexing
|
|
# end of mouse handling
|
|
# other mouse-based functions
|
|
def mouse_get_focused(self):
|
|
return pygame.mouse.get_focused()
|
|
def mouse_set_visible(self,bool_value):
|
|
return pygame.mouse.set_visible(bool_value)
|
|
def mouse_get_rel(self):
|
|
''' Returns relative movement of the mouse since the last call to this function.
|
|
mouse_get_rel() -> (x,y) '''
|
|
return pygame.mouse.get_rel()
|
|
def mouse_set_cursor_image(self,image=None):
|
|
pass # todo: complete after the image part is done
|
|
# implement mouse_pos as variable
|
|
@property
|
|
def mouse_pos(self):
|
|
''' mouse_pos -> (x,y)
|
|
mouse_pos = [x,y] -> Sets cursor position '''
|
|
return pygame.mouse.get_pos()
|
|
@mouse_pos.setter
|
|
def mouse_pos(self,val):
|
|
''' val should be a list [x,y] '''
|
|
if not isinstance(val,list):
|
|
raise TypeError("val should be a list [x,y]")
|
|
pygame.mouse.set_pos(val)
|
|
|
|
# implement mouse_x as variable
|
|
@property
|
|
def mouse_x(self):
|
|
''' mouse_x -> x
|
|
mouse_x = some_x -> Sets cursor x position '''
|
|
return pygame.mouse.get_pos()[0] # get_pos -> (x,y)
|
|
@mouse_x.setter
|
|
def mouse_x(self,x):
|
|
pygame.mouse.set_pos([x,mouse_y])
|
|
|
|
# implement mouse_y as variable
|
|
@property
|
|
def mouse_y(self):
|
|
''' mouse_y -> y
|
|
mouse_y = some_y -> Sets cursor y position '''
|
|
return pygame.mouse.get_pos()[1] # get_pos -> (x,y)
|
|
@mouse_y.setter
|
|
def mouse_y(self,y):
|
|
pygame.mouse.set_pos([mouse_x,y])
|
|
# end of mouse-related function
|
|
#other various events
|
|
|
|
def event_intersect_room_boundary(self): # todo: test after image part is done
|
|
''' Checks if the object (its image bounding box) is intersecting the room boundary, but not totally outside the room.
|
|
Returns direction constants like TOP, LEFT, BOTTOM, RIGHT. '''
|
|
if (self.x+self.image.bbox.width/2)>fun_Game.room_width and not (self.x-self.image.bbox.width/2)>fun_Game.room_width:
|
|
return RIGHT # all constants defined at global level
|
|
elif (self.y+self.image.bbox.height/2)>fun_Game.room_height and not (self.y-self.image.bbox.height/2)>fun_Game.room_height:
|
|
return BOTTOM
|
|
elif (self.x-self.image.bbox.width/2)<0 and not (self.x+self.image.bbox.width/2)<0:
|
|
return LEFT
|
|
elif (self.y-self.image.bbox.height/2)<0 and not (self.y+self.image.bbox.height/2)<0:
|
|
return TOP
|
|
def action_intersect_room_boundary(self):
|
|
pass
|
|
def check_intersect_room_boundary(self):
|
|
if event_intersect_room_boundary(self):
|
|
action_intersect_room_boundary(self)
|
|
|
|
def event_outside_room_boundary(self):
|
|
''' Checks if the object (its image bounding box) is totally outside room.
|
|
Returns direction constants like TOP, LEFT, BOTTOM, RIGHT. '''
|
|
if (self.x-self.image.bbox.width/2)>fun_Game.room_width:
|
|
return RIGHT # all constants defined at global level
|
|
elif (self.y-self.image.bbox.height/2)>fun_Game.room_height:
|
|
return BOTTOM
|
|
elif (self.x+self.image.bbox.width/2)<0:
|
|
return LEFT
|
|
elif (self.y+self.image.bbox.height/2)<0:
|
|
return TOP
|
|
|
|
# end of fun_Class
|
|
# Other classes
|
|
class Circle(object):
|
|
def __init__(self,(x,y),radius,color=None):
|
|
self.center=[x,y]
|
|
self.radius=radius
|
|
self.color=color
|
|
|
|
@property
|
|
def center_x(self):
|
|
return self.center[0]
|
|
@property
|
|
def center_y(self):
|
|
return self.center[1]
|
|
@center_x.setter
|
|
def center_x(self,new_x):
|
|
self.center[0]=new_x
|
|
@center_y.setter
|
|
def center_y(self,new_y):
|
|
self.center[1]=new_y
|
|
@property
|
|
def bbox(self):
|
|
left=self.center_x-self.radius
|
|
top=self.center_y-self.radius
|
|
width=self.radius*2
|
|
height=self.radius*2
|
|
return pygame.Rect(left, top, width, height)
|
|
# todo: remember about the colour. document - center is list unlike tuple in case of rect.
|
|
def __repr__(self):
|
|
return "{0.__class__}( center={0.center}, radius={0.radius}, color={0.color})".format(self)
|
|
|
|
def copy(self):
|
|
return Circle((self.center_x,self.center_y),self.radius,self.color)
|
|
|
|
def move(self,move_x,move_y):
|
|
return Circle((self.center_x+move_x,self.center_y+move_y),self.radius,self.color)
|
|
|
|
def move_ip(self,move_x,move_y):
|
|
self.center_x+=move_x
|
|
self.center_y+=move_y
|
|
|
|
def inflate(self,inflate_radius):
|
|
return Circle((self.center_x,self.center_y),self.radius+inflate_radius,self.color)
|
|
|
|
def inflate_ip(self,inflate_radius):
|
|
self.radius+=inflate_radius
|
|
|
|
def is_inside(self,another_circle):
|
|
''' Checks if this circle is fully inside another_circle '''
|
|
return distance( self.center, another_circle.center )<self.radius
|
|
|
|
def is_inside_mutual(self,another_circle):
|
|
''' Checks if this circle is fully inside another_circle and also the opposite.
|
|
2x Faster than using is_inside for both of them. '''
|
|
return (distance( self.center, another_circle.center ) < max( self.radius, another_circle.radius) )
|
|
|
|
def collide_circle(self,another_circle):
|
|
''' Checks if this circle intersects with another_circle. '''
|
|
return (distance( self.center, another_circle.center ) <= (self.radius + another_circle.radius) )
|
|
|
|
def collide_point(self, (point_x, point_y)):
|
|
''' Checks if (point_x, point_y) is inside this circle. '''
|
|
return (distance(self.center, (point_x,point_y) ) <= self.radius )
|
|
|
|
def collide_list_circle(self, list_circle):
|
|
''' Checks if this circle intersects with any of the circles in circle_list. '''
|
|
for circle in list_circle:
|
|
if collide_circle(self,circle):
|
|
return True
|
|
else: #else of the for loop
|
|
return False
|
|
|
|
def collide_list_all_circle(self,list_circle):
|
|
''' Checks if this circle intersects with all of the circles in circle_list. '''
|
|
for circle in list_circle:
|
|
if not collide_circle(self,circle):
|
|
return False
|
|
else: #else of the for loop
|
|
return True
|
|
|
|
def collide_rect(self,another_rect):
|
|
''' Checks if this circle collides with another_rect. '''
|
|
return not ( (self.center_x+self.radius)<another_rect.left or (self.center_x-self.radius)>another_rect.right or (self.center_y+self.radius)<another_rect.top or (self.center_y-self.radius)>another_rect.bottom )
|
|
|
|
def collide_list_rect(self,list_rect):
|
|
''' Returns True if collides with any of the rect in the list. '''
|
|
for temp_rect in list_rect:
|
|
if collide_rect(self,temp_rect):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def collide_list_all_rect(self,list_rect):
|
|
''' Returns True if collides with all the rect in the list. '''
|
|
for temp_rect in list_rect:
|
|
if not collide_rect(self,temp_rect):
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
@classmethod
|
|
def get_circumcircle_from_rect(cls,another_rect):# create a circle with same center and radius=sqrt(w^2+h^2)
|
|
import math
|
|
return cls(another_rect.center, math.sqrt(another_rect.width**2+another_rect.height**2)/2)
|
|
|
|
@classmethod
|
|
def get_incircle_from_rect(cls,another_rect): # radius of incircle is same as the min of width and height (as it's not a square)
|
|
import math
|
|
return cls(another_rect.center,min(another_rect.width,another_rect.height))
|
|
|
|
# union -needs to be a circle *within* which the union of the bounding box of all the circles can be fit.
|
|
# warning about all the union functions: The circles returned are not necessarily the most optimum union circle, but it will surely contain the others.
|
|
def _union(self,circle_1,circle_2):
|
|
''' self.__union((new_center_x,new_center_y),new_radius) -> ([x,y],radius) which are the resultant values. '''
|
|
return self.circumcircle_from_rect(circle_1.bbox.union(circle_2.bbox))
|
|
|
|
def union(self,new_circle):
|
|
''' Returns a new circle which is the union of these two circles '''
|
|
return self._union(self,new_circle)
|
|
|
|
def union_ip(self,new_circle):
|
|
''' Turns this circle into a circle which is a union of these two circles. '''
|
|
temp_circle=self._union(self,new_circle)
|
|
self.center, self.radius = temp_circle.center, temp_circle.radius
|
|
|
|
def _unionall(self,circle_1,seq_circle): # list_circle_params : [((x1,y1),radius_1), ((x2,y2),radius_2), ...]
|
|
''' returns ([x,y],radius) for the resultant union of all circles.
|
|
sequence_circle must be a sequence of circles. '''
|
|
return self.circumcircle_from_rect(circle_1.bbox.unionall([temp_circle.bbox for temp_circle in seq_circle]))
|
|
|
|
def unionall(self,seq_circle): #seq_circle: sequence of circles
|
|
return self._unionall(self,seq_circle)
|
|
|
|
def unionall_ip(self,seq_circle):
|
|
''' Turns this circle into a circle which is a union of this circles with all circles in seq_circle'''
|
|
temp_circle=self._unionall(self,seq_circle)
|
|
self.center, self.radius = temp_circle.center, temp_circle.radius
|
|
|
|
# draw functions
|
|
def draw(self,surface,(x,y)=(None,None),color=None,width=1,use_antialiasing=False):
|
|
''' Draws this Circle on surface. It must be of width and height greater than or equal to its bbox.
|
|
(x,y)->co-ordinates whether the center of the Circle should be drawn on the surface.
|
|
width argument doesnt work with antialiasing. width=0 makes it filled.
|
|
antialiasing may break in later versions as the backend pygame.gfxdraw is experimental.
|
|
color falls back first to Circle.color (if present) and then to blue color.'''
|
|
if (x,y)==(None,None):
|
|
(x,y)=self.center
|
|
if not color:
|
|
if self.color:
|
|
color=self.color
|
|
else:
|
|
color=pygame.Color("blue")
|
|
|
|
if not use_antialiasing:
|
|
pygame.draw.circle(surface, color,(x,y), self.radius, width)
|
|
else:
|
|
pygame.gfxdraw.aacircle(surface, x, y, self.radius, color)
|
|
|
|
def get_surface(self,surface=None,flags=0):
|
|
''' Returns a new surface with dimensions of (Circle.bbox.width,Circle.bbox.width) and other properties as surface.
|
|
This Circle can be safely drawn on it.'''
|
|
if surface:
|
|
return pygame.Surface((self.bbox.width,self.bbox.height),flags,surface)
|
|
else:
|
|
return pygame.Surface((self.bbox.width,self.bbox.height),flags)
|
|
|
|
def get_surface_drawn(self,(x,y)=(None,None),color=None,width=1,use_antialiasing=False,surface=None,flags=0):
|
|
''' Returns a surface which has the tiltedRect drwan on it. '''
|
|
temp_surf=self.get_surface(surface,flags)
|
|
self.draw(temp_surf,(x,y),color,width,use_antialiasing)
|
|
return temp_surf
|
|
|
|
# end of Circle class
|
|
#start of tiltedRect class
|
|
class tiltedRect(pygame.Rect):
|
|
# make a metaclass which wraps a lot of functions just like move is defined below.
|
|
# functions to be wrapped - move,inflate
|
|
# Think about them - clamp,clip,union,fit,contains,collide
|
|
# the metaclass can probably also change the __str__ of the class.
|
|
# About drawing - use pygame.transform.rotate to get a rotated surface to be drawed.
|
|
def __init__(self,(left,top),(width,height),angle,centered_coords=False,color=None):
|
|
''' Angle in degrees.
|
|
centered_coords -> whether the (left,top) is actually intended to be (center_x,center_y) or not.
|
|
I.e. if centered_coords==True the (left,top) co-ordinates are used as (center_x,center_y) co-ordinates of the tiltedRect'''
|
|
self.angle=angle
|
|
self.color=color
|
|
if centered_coords==True:
|
|
left=left-width/2
|
|
top=top-height/2
|
|
super(tiltedRect,self).__init__((left,top),(width,height))
|
|
def __copy__(self):
|
|
return tiltedRect((self.left,self.top),(self.width,self.height),self.angle)
|
|
def __repr__(self):
|
|
return "{0.__class__.__name__}((top={0.top}, left={0.left}), (width={0.width}, height={0.height}), angle={0.angle}, color={0.color})".format(self)
|
|
@classmethod
|
|
def create_from_rect(cls,another_rect,angle):
|
|
return cls((another_rect.left,another_rect.top),(another_rect.width,another_rect.height),angle)
|
|
def get_rect(self):
|
|
return pygame.Rect((left,top),(width,height))
|
|
def move(self,x,y):
|
|
return self.create_from_rect(super(tiltedRect,self).move(x,y),self.angle)
|
|
def inflate(self,x,y):
|
|
return self.create_from_rect(super(tiltedRect,self).inflate(x,y),self.angle)
|
|
def normalize(self): # not sure what this one does - ask others
|
|
return self.create_from_rect(super(tiltedRect,self).normalize(),self.angle)
|
|
def rotate(self,some_angle):
|
|
temp_return=self.__copy__()
|
|
temp_return.angle+=some_angle
|
|
return temp_return
|
|
def rotate_ip(self,some_angle):
|
|
self.angle+=some_angle
|
|
|
|
def rotate_point_relative(self,x,y,theta=None):#generalise the parameters to accept x1,y1,x2,y2,rot_angle
|
|
''' x,y -> Absolute co-ords of the point to be rotated wrt to the rectangles center. self.centerx,self.centery are internally substracted from them.
|
|
theta -> angle (in degrees) by which the point is to be rotated. Default value is self.angle.
|
|
Returns absolute positions of the points after rotation. '''
|
|
if theta==None:
|
|
theta=self.angle
|
|
return self.rotate_point(x,y,self.centerx,self.centery,theta)
|
|
|
|
@classmethod
|
|
def rotate_point(cls,x,y,origin_x,origin_y,theta): # to be allowed as rotate_point(class)
|
|
''' x,y -> Absolute co-ords of the point to be rotated. origin_x,origin_y are internally substracted from them.
|
|
(origin_x,origin_y) -> Absolute co-ords of the origin wrt to which the point will be rotated
|
|
theta -> angle (in degrees) by which the point is to be rotated.
|
|
Returns absolute positions of the points after rotation. '''
|
|
import math
|
|
x_diff=x-origin_x
|
|
y_diff=y-origin_y
|
|
y_diff=-y_diff # -y_diff because of the inverted nature of y co-ordinate system in pygame
|
|
r=math.sqrt(x_diff**2+y_diff**2)
|
|
initial_angle=math.atan2(y_diff,x_diff)
|
|
final_angle=initial_angle+math.radians(theta)
|
|
rotated_x_diff=r*math.cos(final_angle)
|
|
rotated_y_diff=r*math.sin(final_angle)
|
|
rotated_y_diff = -rotated_y_diff # - used for same reason as above
|
|
rotated_x = rotated_x_diff + origin_x
|
|
rotated_y = rotated_y_diff + origin_y
|
|
return (rotated_x,rotated_y)
|
|
|
|
def rotate_point_polar(self,r,initial_angle,theta=None):
|
|
''' theta and initial_angle in radians.
|
|
initial_angle ->angle r makes with horizontal.
|
|
theta -> angle to be rotated by. '''
|
|
if theta==None:
|
|
theta=self.angle
|
|
final_angle=initial_angle+theta
|
|
rotated_x=r*math.cos(final_angle)
|
|
rotated_y=r*math.sin(final_angle)
|
|
return (rotated_x,rotated_y)
|
|
|
|
@property
|
|
def bottomleft_rotated(self):
|
|
temp=self.bottomleft
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
@property
|
|
def topleft_rotated(self):
|
|
temp=self.topleft
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
@property
|
|
def bottomright_rotated(self):
|
|
temp=self.bottomright
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
@property
|
|
def topright_rotated(self):
|
|
temp=self.topright
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
@property
|
|
def midleft_rotated(self):
|
|
temp=self.midleft
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
@property
|
|
def midright_rotated(self):
|
|
temp=self.midright
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
@property
|
|
def midtop_rotated(self):
|
|
temp=self.midtop
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
@property
|
|
def midbottom_rotated(self):
|
|
temp=self.midbottom
|
|
return self.rotate_point_relative(temp[0],temp[1])
|
|
|
|
# related to bounding box
|
|
@property
|
|
def bbox(self):
|
|
list_x=[self.topleft_rotated[0],self.topright_rotated[0],self.bottomleft_rotated[0],self.bottomright_rotated[0]]
|
|
list_y=[self.topleft_rotated[1],self.topright_rotated[1],self.bottomleft_rotated[1],self.bottomright_rotated[1]]
|
|
min_x=floor(min(list_x))
|
|
max_x=ceil(max(list_x))
|
|
min_y=floor(min(list_y))
|
|
max_y=ceil(max(list_y))
|
|
return pygame.Rect((min_x,min_y),(max_x-min_x,max_y-min_y))
|
|
@property
|
|
def bbox_fixed(self):
|
|
diagonal=sqrt(self.width**2+self.height**2)
|
|
diagonal=ceil(diagonal)
|
|
return pygame.Rect((floor(self.centerx-diagonal/2),floor(self.centery-diagonal/2)),(diagonal+1,diagonal+1)) #diagonal+1 is used to redue corner issues, which still might be here.
|
|
# corners
|
|
@property
|
|
def corners(self):
|
|
''' List of actual (rotated) corners. '''
|
|
return [self.topleft_rotated,self.topright_rotated,self.bottomright_rotated,self.bottomleft_rotated]
|
|
@property
|
|
def corners_relative(self):
|
|
return [(temp[0]-self.centerx,temp[1]-self.centery) for temp in self.corners]
|
|
|
|
# circles related to the rect
|
|
def get_circumcircle(self):
|
|
Circle.get_circumcircle_from_rect(self.bbox)
|
|
def get_incircle(self):
|
|
Circle.get_incircle_from_rect(self.bbox)
|
|
|
|
# collision events
|
|
def collide_point(self,*args):
|
|
''' collidepoint(x,y) ->
|
|
collidepoint((x,y)) -> '''
|
|
temp_len=len(args)
|
|
temp_x=None
|
|
temp_y=None
|
|
if temp_len==2:
|
|
temp_x=args[0]
|
|
temp_y=args[1]
|
|
elif temp_len==1:
|
|
if len(args[0])==2:
|
|
temp_x,temp_y=args[0]
|
|
else:
|
|
raise TypeError("Arguments are of incorrect type")
|
|
else:
|
|
raise TypeError("Arguments are of incorrect type")
|
|
if temp_x==None or temp_y==None:
|
|
raise TypeError("argument must contain two numbers")
|
|
return pygame.Rect((self.left,self.top),(self.width,self.height)).collidepoint(self.rotate_point_relative(temp_x,temp_y))
|
|
|
|
def collide_rect(self,rect):
|
|
''' Tests if it collides with rect, which should be instance of rect class. '''
|
|
# First test:whether bbox collides with rect. If not, no collision.
|
|
if not self.bbox.colliderect(rect):
|
|
return False
|
|
else:
|
|
# Todo: Else sure test: Need to do line class first. Test if any line of titedRect collides with any line of (instead, the whole) rect.
|
|
pass
|
|
|
|
# draw functions
|
|
def draw(self,surface,(x,y)=(None,None),color=None,width=1,centered=False,use_antialiasing=False,blend=True):
|
|
''' Draws this tiltedRect on surf_to_draw_on. It must be of width and height greater or equal to its bbox.
|
|
(x,y)->co-ordinates whether the lefttop point of its bbox should be drawn on the surface. Use centered=True to provide co-ords of the center instead.
|
|
If centered=True, by default, it draws at the center of the surface provided.
|
|
width argument doesnt work with antialiasing. width=0 makes it filled.
|
|
blend argument works only with antialiasing. The boolean blend argument set to true will blend the shades with existing shades instead of overwriting them.
|
|
color falls back first to tiltedRect.color (if present) and then to blue color.'''
|
|
if not centered:
|
|
if (x,y)==(None,None):
|
|
(x,y)=(0,0)
|
|
iter_corners=[(temp[0]+x-self.bbox.left,temp[1]+y-self.bbox.top) for temp in self.corners]
|
|
else:
|
|
if (x,y)==(None,None):
|
|
x,y=surface.get_width()/2,surface.get_height()/2
|
|
iter_corners=[(temp[0]+x,temp[1]+y) for temp in self.corners_relative]
|
|
if not color:
|
|
if self.color:
|
|
color=self.color
|
|
else:
|
|
color=pygame.Color("blue")
|
|
if not use_antialiasing:
|
|
pygame.draw.polygon(surface, color, iter_corners, width)
|
|
#pygame.gfxdraw.polygon(surface, iter_corners, color)#gfxdraw module doesnt work
|
|
else:
|
|
pygame.draw.aalines(surface, color, True, iter_corners, blend)
|
|
def get_surface(self,surface=None,flags=0,fixed=False):
|
|
''' Returns a new surface with dimensions of (tiltedRect.bbox.width,tiltedRect.bbox.width) and other properties as surface.
|
|
This tiltedRect can be safely drawn on it.'''
|
|
if not fixed:
|
|
width,height=self.bbox.width,self.bbox.height
|
|
else:
|
|
width,height=self.bbox_fixed.width,self.bbox_fixed.height
|
|
|
|
return pygame.Surface((width,height),flags,surface)
|
|
def get_surface_drawn(self,(x,y)=(None,None),color=None,width=1,fixed=False,use_antialiasing=False,blend=True,surface=None,flags=0):
|
|
''' Returns a surface which has the tiltedRect drwan on it. '''
|
|
temp_surf=self.get_surface(surface,flags,fixed)
|
|
if not fixed:
|
|
self.draw(temp_surf,(x,y),color,width,False,use_antialiasing,blend)
|
|
else:
|
|
self.draw(temp_surf,(x,y),color,width,True,use_antialiasing,blend)
|
|
return temp_surf
|
|
|
|
def collide_tiltedRect(self,another_tiltedRect):
|
|
'''Checks whether this tiltedRect collides with another_titltedrect, which must be a instance of titledRect. '''
|
|
# Rotates both tiltedRect by -another_tiltedRect.angle. So, another_tiltedRect becomes a Rect called temp_Rect.
|
|
# Then check if the rotated version of this tiltedRect (temp_tiltedRect) collides with the obtained Rect.
|
|
temp_tiltedRect=self.rotate(-another_tiltedRect.angle)
|
|
temp_Rect=another_tiltedRect.get_rect()
|
|
return temp_tiltedRect.colliderect(temp_Rect)
|
|
|
|
# functions outside all classes
|
|
def get_event_list(event_types=None,further_check_variable_name=None,further_check_value=None,list_to_get=None):#list_to_get is attached to a constant list here
|
|
''' Get the required events from the event_list.
|
|
get_event_list([event_types],[further_check_variable_name],further_check_value=None,list_to_get=fun_Game.list_event):
|
|
event_types (optional): event_name|list[event_name]
|
|
get_event_list() -> returns whole event_list(to be precise, list_to_get)
|
|
get_event_list(events) -> returns event_list(to be precise, list_to_get) filtered to contain only "events"
|
|
get_event_list([events],further_check_variable_name="var_name",further_check_value=value) ->
|
|
returns sub-list containing those elements of get_event_list([events]) for which var_name=value
|
|
Potential candidates for list_to_get -> fun_Game.list_event, fun_Game.list_event_old, fun_Game.list_state_all_buttons, fun_Game.list_state_all_buttons_old'''
|
|
if list_to_get==None:
|
|
list_to_get=fun_Game.list_event_old
|
|
if further_check_variable_name:
|
|
further_check_enabled=True
|
|
else:
|
|
further_check_enabled=False
|
|
if event_types:
|
|
if not hasattr(event_types,"__iter__"):
|
|
event_types=[event_types] # if not iterable, make a list out of it
|
|
def func_filter():
|
|
list_return=[]
|
|
if not event_types:
|
|
return list_to_get
|
|
for temp_1 in list_to_get: # all events in fun_Game.list_event have a "type" property
|
|
for temp_2 in event_types:
|
|
if temp_1.type==temp_2:
|
|
list_return.append(temp_1)
|
|
return list_return
|
|
def further_check_filter(temp_list): # returns part of temp_list which passes further_check
|
|
list_return=[]
|
|
if further_check_enabled:
|
|
for temp in temp_list:
|
|
if getattr(temp,further_check_variable_name)==further_check_value:# may raise error if further_check_variable_name is not present for all members of the list
|
|
list_return.append(temp)
|
|
else:
|
|
list_return=temp_list
|
|
return list_return
|
|
return further_check_filter(func_filter()) # returns elements common in fun_Game.list_events and events which are accepted after further_check
|
|
# end of get_event_list()
|
|
|
|
def distance((x1,y1),(x2,y2)): # Maybe make a non-square rooted function for comparison (faster)
|
|
import math
|
|
return(math.sqrt((x2-x1)**2+(y2-y1)**2))
|
|
|
|
#following constants are required for the next function
|
|
UNION=1
|
|
INTERSECTION=2
|
|
DIFFERENCE=3
|
|
ADD=4
|
|
MAKE_IT_VARIABLE_LIST=5 # for each member (usually objects) in the list, it is replaced by one of its variables
|
|
def operation_on_lists(operation,list1,list2=None,variable_name=None):
|
|
''' operation_on_lists(operation, list1, list2) -> list
|
|
Does operation involving list1 and list2.
|
|
variable_name is required only for MAKE_IT_VARIABLE_LIST operation. It is a string representing the variable name
|
|
Valid operations are UNION, INTERSECTION, DIFFERENCE, ADD, MAKE_IT_VARIABLE_list '''
|
|
def intersection():
|
|
if list2==None:
|
|
raise TypeError("second argument i.e. list2 should be a list")
|
|
list_return=[]
|
|
for temp1 in list1:
|
|
for temp2 in list2:
|
|
if temp1==temp2:
|
|
list_return.append(temp1)
|
|
return list_return
|
|
def union():
|
|
if list2==None:
|
|
raise TypeError("second argument i.e. list2 should be a list")
|
|
list_return = uniquelist()
|
|
list_return.extend(list1)
|
|
list_return.extend(list2)
|
|
return list_return
|
|
def add():
|
|
if list2==None:
|
|
raise TypeError("second argument i.e. list2 should be a list")
|
|
list_return=[]
|
|
list_return.append(list1)
|
|
list_return.append(list2)
|
|
return list_return
|
|
def difference():
|
|
if list2==None:
|
|
raise TypeError("second argument i.e. list2 should be a list")
|
|
list_return=[]
|
|
list_intersection=intersection()
|
|
for temp1 in list1:
|
|
if temp1 not in list_intersection:
|
|
list_return.append(temp1)
|
|
return list_return
|
|
def make_it_variable_list(): # for each member (usually objects) in the list, it is replaced by one of its variables
|
|
if variable_name==None:
|
|
raise TypeError("variable_name should be a string")
|
|
if not list2==None:
|
|
raise TypeError("list2 should be None")
|
|
return_list=[getattr(temp,variable_name) for temp in list1]
|
|
|
|
if operation==UNION:
|
|
return union()
|
|
elif operation==INTERSECTION:
|
|
return intersection()
|
|
elif operation==DIFFERENCE:
|
|
return difference()
|
|
elif operation==ADD:
|
|
return add()
|
|
elif operation==MAKE_IT_VARIABLE_LIST:
|
|
return make_it_variable_list()
|
|
else:
|
|
raise ValueError("Invalid operation name. Valid operations are UNION, INTERSECTION, DIFFERENCE.")
|
|
# end of operation_on_lists()
|
|
#Todo: see below
|
|
# 1. Allow rect-like and circle-like constructs wherever rect and circle are expected.
|
|
# 2. Do all sort of type-checking.
|
|
# Design tips I will use later
|
|
# IMP: always derive classes from object. Else, in python 2.x, they become old-style class which sucks.
|
|
# use tuples instead of lists wherver possible because they are usually faster to create
|
|
# learn about generators
|
|
# named tuples, arrays are better. use more of them. named tuples can be accessed.
|
|
# refactor code into proper modules as-well-as use better named functions and variables
|
|
# use enumerate() for getting the index and value of elements while looping through lists. This mistake done atleast 1 time.
|
|
# use xrange instead of range. It produces one at a time. range is replaced by xrange in python 3.x
|
|
# use reversed() for backward loops, sorted() for sorted order.
|
|
# instead of zip(), use izip().
|
|
# use key instead of comparator
|
|
# use iter(iter_type,sentinel_value) instead of for loops
|
|
# partial() makes a function with more number of argument to less number of argument
|
|
# use for/else instead of exit based on flags
|
|
# look at dict.iteritems() and dict.setdefaults
|
|
# learn defaultdicts and collections module
|