import os
import rabbyt
from rabbyt import lerp, wrap
from math import cos,sin,pi,sqrt,atan2
from random import *
import pygame
from pygame.locals import *

#setup window
pygame.init() 
pygame.display.set_mode((640, 480), pygame.OPENGL | pygame.DOUBLEBUF) 
rabbyt.set_viewport((640, 480))
rabbyt.set_default_attribs()

def collidelist_add(list):
	for instance in list:
			sprites.append(instance)
def collidelist_remove(list):
	for instance in list:
		if instance in sprites:
			sprites.remove(instance)

#create pSprite class
class pSprite(rabbyt.Sprite):
	def __init__(self,x=0,y=0,sprite=None,shape=None,gravity=0):
		rabbyt.Sprite.__init__(self,x=x,y=y,texture=sprite,shape=shape)
		self.speed=0
		self.direction=0
		self.gravity=gravity
	def motion_add(self,adddir,addspeed):
		cx1=addspeed*cos(adddir*(pi/180))
		cy1=addspeed*sin(adddir*(pi/180))
		cx2=self.speed*cos(self.direction*(pi/180))
		cy2=self.speed*sin(self.direction*(pi/180))
		nx,ny=(cx1+cx2,cy1+cy2)
		self.speed=sqrt(nx*nx+ny*ny)
		atta=atan2(ny,nx)
		self.direction=atta*(180/pi)
	def xspeed(self,newxspeed):
		theta=sin(self.direction*(pi/180))
		if abs(theta) < 0.0001: theta=0
		yspeed=self.speed*theta
		self.direction=atan2(yspeed,newxspeed)*(180/pi)
		self.speed=sqrt(newxspeed*newxspeed+yspeed*yspeed)
	def yspeed(self,newyspeed):
		theta = cos(self.direction*(pi/180))
		if abs(theta) < 0.0001: theta=0
		xspeed=self.speed*theta
		self.direction=atan2(newyspeed,xspeed)*(180/pi)
		self.speed=sqrt(xspeed*xspeed+newyspeed*newyspeed)
	def getxspeed(self):
		theta=round(cos(self.direction*(pi/180))*10000)/10000
		return self.speed*theta
	def getyspeed(self):
		theta=round(sin(self.direction*(pi/180))*10000)/10000
		return self.speed*theta
	def place_free(self,newx,newy):
		hit = 1
		tempx=self.x
		tempy=self.y
		self.x=newx
		self.y=newy
		collisions = rabbyt.collisions.aabb_collide(sprites)
		for pSpr1,pSpr2 in collisions:
    			if (isinstance(pSpr1,player) and isinstance(pSpr2,block)) or (isinstance(pSpr2,player) and isinstance(pSpr1,block)):
				hit = 0
				break
		self.x=tempx
		self.y=tempy
		return hit
	def move_contact(self,dir,iter):
		for n in range(0,iter*2):
			if self.place_free(self.x+cos(dir*(pi/180))*0.5,self.y+sin(dir*(pi/180))*0.5):
				self.x+=cos(dir*(pi/180))*0.5
				self.y+=sin(dir*(pi/180))*0.5
			else:
				break
	def update(self):
		if self.rot>360: self.rot-=360
		if self.rot<0: self.rot+=360
		if self.direction>360: self.direction-=360
		if self.direction<0: self.direction+=360
		self.x=self.x+self.getxspeed()
		self.y=self.y+self.getyspeed()
		if self.gravity > 0: self.motion_add(270,self.gravity)
	def handle_collision(self,other):pass

class player(pSprite):
	def __init__(self,x=0,y=0,sprite=None,shape=None,gravity=0):
		pSprite.__init__(self,x,y,sprite,shape,gravity)
		self.maxxspeed=3
		self.grav=0.25
		self.xaccel = 0.5
		self.rgb=(.7,.3,.6)
	def update(self):
		pSprite.update(self)
		if pygame.key.get_focused:
			keys = pygame.key.get_pressed()
			if self.place_free(self.x+self.getxspeed(),self.y):
				if keys[K_LEFT]: self.xspeed(self.getxspeed()-self.xaccel)
				if keys[K_RIGHT]: self.xspeed(self.getxspeed()+self.xaccel)
			if keys[K_UP]:
				if not self.place_free(self.x,self.y-1):
					self.yspeed(7)
			if not keys[K_RIGHT] and not keys[K_LEFT]:
				self.xspeed(self.getxspeed()*(0.6+0.3*self.place_free(self.x,self.y-1)))

		if abs(self.getyspeed()) < 0.0001: self.yspeed(0)										#limit speeds _before_ calculations?
		if abs(self.getxspeed()) < 0.0001: self.xspeed(0)
		if abs(self.getxspeed()) > self.maxxspeed: self.xspeed(self.maxxspeed*self.getxspeed()/abs(self.getxspeed()))
		self.xspeed(round(self.getxspeed()*1000)/1000)
		self.yspeed(round(self.getyspeed()*1000)/1000)

		if self.place_free(self.x,self.y+self.getyspeed()) and self.place_free(self.x+self.getxspeed(),self.y):	#handles weird collision,
			if not self.place_free(self.x+self.getxspeed(),self.y+self.getyspeed()):					#running into the wall/floor diagonally
				self.xspeed(0)
		if self.place_free(self.x,self.y-1):												#handles gravity
			self.gravity=self.grav
		if not self.place_free(self.x,self.y+self.getyspeed()):									#handles vertical collision
			self.move_contact(atan2(self.getyspeed(),0)*(180/pi),40)
			self.yspeed(0)
			self.gravity=0
			if not self.place_free(self.x,self.y-1):
				self.y=round(self.y)
		if not self.place_free(self.x+self.getxspeed(),self.y):									#handles horizontal collision
			self.move_contact(atan2(0,self.getxspeed())*(180/pi),self.maxxspeed)

class block(pSprite):
	def __init__(self,x=0,y=0,sprite=None,shape=None,gravity=0):
		pSprite.__init__(self,x,y,sprite,shape,gravity)
		self.rgb=(.2,.3,.4)
	def update(self):
		pSprite.update(self)

sprites=[]
player1=player(y=-97,x=-100,shape=(-8,8,8,-8))
sprites.append(player1)
b=block(y=-180,shape=(-160,8,8,-8))
sprites.append(b)
b2=block(y=-100,x=-50,shape=(-8,8,8,-8))
sprites.append(b2)

#the gameloop
keepRunning = True
spawnTime = 40

c = pygame.time.Clock()
last_fps = 0

while keepRunning:
	#messagepump
	for event in pygame.event.get():
		if event.type == QUIT:
			keepRunning = False
		elif event.type == KEYDOWN:
			if event.key == K_ESCAPE:
				keepRunning = False

	#FPS
	c.tick()
	if pygame.time.get_ticks() - last_fps > 1000:
		#print "FPS: ", c.get_fps()
		last_fps = pygame.time.get_ticks()

	#collision
	collisions = rabbyt.collisions.brute_force(sprites)
	for pSpr1,pSpr2 in collisions:
    		pSpr1.handle_collision(pSpr2)
		pSpr2.handle_collision(pSpr1)

	#the actual rendering code
	rabbyt.clear() #clear the screen

	for sprite in sprites[:]:
		sprite.update()
		sprite.render()

	pygame.display.flip() #flip the buffers