# HG changeset patch
# User azmaeve <az.maeve@gmail.com>
# Date 1281872390 -7200
#      Sun Aug 15 13:39:50 2010 +0200
# Node ID 60ee3e2607529cd01a2eb195a41de13a46172af2
# Parent  0000000000000000000000000000000000000000
Initial commit

diff --git a/ogm/__init__.py b/ogm/__init__.py
new file mode 100644
--- /dev/null
+++ b/ogm/__init__.py
@@ -0,0 +1,1 @@
+__all__=["tileset","layer","level","character","engine","physics"]
diff --git a/ogm/character.py b/ogm/character.py
new file mode 100644
--- /dev/null
+++ b/ogm/character.py
@@ -0,0 +1,102 @@
+from ogm.tileset import Tileset_GL
+import xml.dom.minidom
+from OpenGL.GL import *
+from OpenGL.GLU import *
+import ogm.engine
+import ogm.physics
+class Character:
+	def __init__(self,xml_file):
+		engine = ogm.engine.get_engine()
+		dom_doc = xml.dom.minidom.parse(xml_file)
+		root = dom_doc.getElementsByTagName("character")[0]
+		self.name = root.getAttribute("name")
+		self.creator = root.getAttribute("creator")
+		self.date = root.getAttribute("date")
+		self.h = int(root.getAttribute("h"))
+		self.w = int(root.getAttribute("w"))
+		self.license = root.getAttribute("license")#need test
+		
+		tiles = dom_doc.getElementsByTagName("tileset")[0]
+		tileh = int(tiles.getAttribute("h"))
+		tilew = int(tiles.getAttribute("w"))
+		tilefile = tiles.getAttribute("file")
+		if tiles.hasAttribute("colorkey"):
+			colorkey = int(tiles.getAttribute("colorkey"))
+		else:
+			colorkey = None
+		self.tileset = tmptileset = engine.get_tileset(tilefile,tilew,tileh,colorkey)#Tileset_GL(tilefile,tilew,tileh)
+		
+		bbox = dom_doc.getElementsByTagName("boundingbox")[0]
+		xoff = int(bbox.getAttribute("xoffset"))
+		yoff = int(bbox.getAttribute("yoffset"))
+		w = int(bbox.getAttribute("width"))
+		h = int(bbox.getAttribute("height"))
+		self.bbox = ogm.physics.BoundingBox(xoff,yoff,w,h)
+		
+		self.x = 0
+		self.y = 0
+		self.actions = {}
+		for action in dom_doc.getElementsByTagName("action"):
+			key = action.getAttribute("key")
+			act = []
+			for step in action.getElementsByTagName("step"):
+				tile = int(step.getAttribute("tile"))
+				time = int(step.getAttribute("time"))
+				act.append((time,tile))
+			self.actions[key] = act 
+			
+		self.current_act = self.actions.keys()[0]
+		self.time = 0
+		self.texture = self.tileset[self.actions[self.current_act][0][1]]
+		print self.w, self.h
+		#self.tnext = self.actions["right"][1][0]
+	def get_action(self):
+		return self.current_act
+	def get_bounding_box(self):
+		return self.bbox		
+		
+	def render(self,xoff,yoff):
+		glBindTexture(GL_TEXTURE_2D, self.texture)
+
+		#print self.tileset[self.level[x][y]],xp,yp
+		#top 
+		glPushMatrix()
+		glLoadIdentity()
+		glTranslatef(xoff, -1*yoff-2,0.0)
+		
+		glTranslatef(0.0,0.0, -244.0)
+		glBegin(GL_QUADS)
+		# Top left corner
+		glTexCoord2f(0, 1)
+		glVertex(self.x, -1*self.y, 0)
+		# Top right corner
+		glTexCoord2f(1, 1)
+		glVertex(self.x+self.w, -1*self.y, 0)
+
+		# Bottom right corner
+		glTexCoord2f(1, 0)
+		glVertex(self.x+self.w, -1*self.y-self.h, 0)
+		# Bottom left corner
+		glTexCoord2f(0, 0)
+		glVertex(self.x, -1*self.y-self.h, 0)
+		glEnd()
+		glPopMatrix()
+		
+	def action(self, action):
+		if action == None:
+			self.time = 0
+			return
+		if not action == self.current_act:
+			self.current_act = action
+			self.time = 0
+	def update (self,time):
+		self.time = self.time + time
+		self.x += int(time * self.bbox.vect[0])
+		self.y += int(time * self.bbox.vect[1]) 
+		for tme,tile in self.actions[self.current_act]:
+			if self.time <= tme:
+				self.texture = self.tileset[tile]
+				return
+		self.time = 0
+		self.texture = self.tileset[self.actions[self.current_act][0][1]]
+		
diff --git a/ogm/controler.py b/ogm/controler.py
new file mode 100644
--- /dev/null
+++ b/ogm/controler.py
@@ -0,0 +1,85 @@
+import pygame
+import ogm.engine
+class Controler:
+	'''
+	Controler abstraction class
+	'''
+	def __init__( self ):
+		self.objects = []
+	def bind_object( self ,obj):
+		self.objects.append(obj)
+	def update( self ,time):
+		raise NotImplementedError( "Should have implemented this" )
+	def release_obj( self, obj):
+		self.objects.remove(obj)
+        
+class PlayerControler( Controler ):
+	'''
+	Controler that allows keyboard bindings (draft, will be configurable in future release)
+	'''
+
+	def update( self ,time):
+		key = pygame.key.get_pressed()
+		for car in self.objects:
+			if key[pygame.K_SPACE] :
+				if  car.bbox.contact['down']:
+					car.bbox.accel(0,-0.6)
+			if key[pygame.K_LEFT]:
+				car.bbox.vect[0] = -0.3
+				car.action("left")
+			elif key[pygame.K_RIGHT]:
+				car.bbox.vect[0] = 0.3
+				car.action("right")
+			elif key[pygame.K_DOWN]:
+				car.action("down")
+			elif key[pygame.K_UP]:
+				car.action("up")
+			else:
+				car.action(None)
+				car.bbox.vect[0] = 0.0
+
+class AIContactSeeker( Controler ):
+	'''
+	Naive "AI", seek contact with the player
+	'''
+	def __init__( self ):
+	#	self.objects = []
+		Controler.__init__(self)
+		self.dist = []
+		self.rate = 300
+		self.counter = 0
+	def update( self ,time):
+		self.counter += time
+		engine = ogm.engine.get_engine()
+		
+		th = engine.level.collide_tile_h
+		tw = engine.level.collide_tile_w
+		if self.counter > self.rate or len(self.dist) == 0:
+			self.counter = 0
+			car = engine.get_player()
+			array = engine.level.collide_array
+			bbox = car.get_bounding_box()
+			px = (car.x + bbox.xoff + bbox.width/2)/tw
+			py = (car.y + bbox.yoff + bbox.height/2)/th
+			self.dist = []
+			for x in range(len(array)):
+				self.dist.append([])
+				for y in range(len(array)):
+					if array[x][y] == 0:
+						self.dist[x].append(abs(px-x)+abs(py-y))
+					else:
+						self.dist[x].append(len(self.dist)+len(self.dist[x])+1)
+			
+			
+		for car in self.objects:
+			bbox = car.get_bounding_box()
+			px = (car.x + bbox.xoff + bbox.width/2)/tw
+			py = (car.y + bbox.yoff + bbox.height/2)/th
+	
+			if (px+1)<len(self.dist) and self.dist[px+1][py] < self.dist[px][py]:
+				car.bbox.vect[0] = 0.1
+				car.action("right")
+			elif (px-1)<len(self.dist) and self.dist[px-1][py] < self.dist[px][py]:
+				car.bbox.vect[0] = -0.1
+				car.action("left")
+
diff --git a/ogm/engine.py b/ogm/engine.py
new file mode 100644
--- /dev/null
+++ b/ogm/engine.py
@@ -0,0 +1,127 @@
+from ogm.physics import Physics
+import ogm.level
+from ogm.tileset import Tileset_GL
+import pygame
+import sys
+engine = None
+import thread
+class Engine:
+	'''
+	Engine Object, handle the whole game, responsible for traking and updating every assets
+	'''
+	def __init__(self):
+		self.physics = Physics()
+		self.level = None
+		self.tilesets = {}
+		self.controlers = {}
+		self.levels = {}
+		self.player = None
+
+		self.actors = {}
+	def set_player (self,name):
+		if self.actors.has_key(name):
+			self.player = name
+		else:
+			pass
+			#raise exception
+	def get_player (self):
+		return self.actors[self.player]
+	def add_actor (self, name, obj):
+
+		if self.actors.has_key(name):
+			self.remove_actor(name)
+		self.actors[name]= obj
+		self.physics.add_object(obj)
+		
+	def remove_actor (self, name):
+		self.physics.remove_object(self.actors[name])
+		del self.actors[name]
+
+	def remove_actor_by_instance (self, obj):
+		for key in self.actors.keys():
+			if self.actors[key] == obj:
+				self.physics.remove_object(self.actors[key])
+				del self.actors[key]
+				return
+	
+	def add_controler (self, name, obj):
+		self.controlers[name] = obj
+	def get_controler(self, name):
+		return self.controler[name]
+	def __del__(self):
+		pass
+	def unload_level(self,name):
+		del self.level
+		self.level = None
+	def load_level(self,name):
+		del self.level
+		self.level = ogm.level.Level(self.levels[name])
+		
+	def get_tileset(self,name,width,height,colorkey):
+		'''
+		Ensure unique instance of tilesets
+		'''
+		if not self.tilesets.has_key((name,width,height,colorkey)):
+			self.tilesets[(name,width,height,colorkey)] = [Tileset_GL(name,width,height,colorkey),1]
+		else:
+			self.tilesets[(name,width,height,colorkey)][1] += 1
+		return self.tilesets[(name,width,height,colorkey)][0]
+		
+	def release_tileset(self,name,width,height,colorkey):
+		'''
+			smart pointer proc, free tileset from memory when no longer required
+			Warning, get_tileset have to match release_tileset
+		'''
+		# nb: should use directly garbage collector in the future
+		if self.tilesets[(name,width,height,colorkey)][1] == 1: 
+			del  self.tilesets[(name,width,height,colorkey)]
+		else:
+			self.tilesets[(name,width,height,colorkey)][1] -= 1
+	def render(self,xoff,yoff):
+		if self.level != None:
+			self.level.render_callList(xoff,yoff)
+		for actor in self.actors.values():
+			actor.render(xoff,yoff)
+	def update(self,time):
+			for controler in self.controlers.values():
+				controler.update(time)
+			for actor in self.actors.values():
+				actor.update(time)
+			self.physics.update(time)
+	def start(self):
+		'''
+		start the main loop
+		'''
+		clock = pygame.time.Clock()
+		fps = 0
+		time_passed = 0.0
+		time_passed_seconds = 0.0
+		total_time = 0
+		
+		while True:
+			for event in pygame.event.get():
+				if event.type == pygame.QUIT:
+					return
+				
+			fps = fps +1
+			time_passed = clock.tick()
+			time_passed_seconds = time_passed / 1000.
+			total_time = total_time + time_passed_seconds
+			if int(total_time)>1:
+				print float(fps)/total_time
+				total_time = 0
+				fps= 0
+				
+			self.update(time_passed)
+			xoff = -1* self.actors[self.player].x
+			yoff = -1*self.actors[self.player].y +50
+			self.render(xoff,yoff)
+			pygame.display.flip()
+			
+def init():
+	global engine
+	engine = Engine()
+
+	
+def get_engine():
+	return engine
diff --git a/ogm/layer.py b/ogm/layer.py
new file mode 100644
--- /dev/null
+++ b/ogm/layer.py
@@ -0,0 +1,149 @@
+from ogm.tileset import Tileset
+import pygame
+from OpenGL.GL import *
+from OpenGL.GLU import *
+class Layer:
+
+	def __init__(self,tileset,array):
+		self.tileset = tileset
+		self.level = array
+		self.drawable = list()
+		for x in range (len (self.level)):
+			for y in range (len( self.level[x])):
+				if self.level[x][y] == -1:
+					continue
+				self.drawable.append((x,y))
+				
+		
+	def draw(self,surface,xoff,yoff):
+		for x in range (len (self.level)):
+			for y in range (len( self.level[x])):
+				rect = pygame.Rect(x*self.tileset.tile_width+xoff,\
+				y*self.tileset.tile_height+yoff,self.tileset.tile_width,\
+				self.tileset.tile_height)
+				surface.blit(self.tileset[self.level[x][y]],rect,None)
+	def __del__(self):
+		del self.tileset
+		
+	def draw_gl(self):
+
+		if len(self.drawable)>0:
+			for x,y in self.drawable:
+
+				xp= x*self.tileset.tile_width 
+				yp= -1*y*self.tileset.tile_height 
+				
+				glBindTexture(GL_TEXTURE_2D, self.tileset[self.level[x][y]])
+
+				glBegin(GL_QUADS)
+				# Top left corner
+				glTexCoord2f(0, 1)
+				glVertex(xp, yp, 0)
+				# Top right corner
+				glTexCoord2f(1, 1)
+				glVertex(xp+self.tileset.tile_width, yp, 0)
+
+				# Bottom right corner
+				glTexCoord2f(1, 0)
+				glVertex(xp+self.tileset.tile_width, yp-self.tileset.tile_height, 0)
+				# Bottom left corner
+				glTexCoord2f(0, 0)
+				glVertex(xp, yp-self.tileset.tile_height, 0)
+				glEnd()
+					
+	def draw_gl_cubes(self, size):
+
+		if len(self.drawable)>0:
+			for x,y in self.drawable:
+				xp= x*self.tileset.tile_width #-(len (self.level))*10
+				yp= -1*(y*self.tileset.tile_height) #-(len (self.level))*10
+
+				glBindTexture(GL_TEXTURE_2D, self.tileset[self.level[x][y]])
+
+				#top 
+				
+				glBegin(GL_QUADS)
+				# Top left corner
+				glTexCoord2f(0, 1)
+				glVertex(xp, yp, 0)
+				# Top right corner
+				glTexCoord2f(1, 1)
+				glVertex(xp+self.tileset.tile_width, yp, 0)
+				# Bottom right corner
+				glTexCoord2f(1, 0)
+				glVertex(xp+self.tileset.tile_width, yp-self.tileset.tile_height, 0)
+				# Bottom left corner
+				glTexCoord2f(0, 0)
+				glVertex(xp, yp-self.tileset.tile_height, 0)
+				glEnd()
+				#sides
+				#left
+				if (x-1 <=0) or (self.level[x - 1][y] == -1) :
+					glBegin(GL_QUADS)
+					# Top left corner
+					glTexCoord2f(0, 1)
+					glVertex(xp, yp, 0)
+					# Top right corner
+					glTexCoord2f(1, 1)
+					glVertex(xp, yp-self.tileset.tile_height, 0)
+					# Bottom right corner
+					glTexCoord2f(1, 0)
+					glVertex(xp, yp-self.tileset.tile_height, -32)
+					# Bottom left corner
+					glTexCoord2f(0, 0)
+					glVertex(xp, yp, -1*size)
+					glEnd()
+				#right
+				if (x + 1 >= len(self.level)) or (self.level[x + 1][y] == -1) :
+					glBegin(GL_QUADS)
+					# Top left corner
+					glTexCoord2f(0, 1)
+					glVertex(xp+self.tileset.tile_width, yp, 0)
+					# Top right corner
+					glTexCoord2f(1, 1)
+					glVertex(xp+self.tileset.tile_width, yp-self.tileset.tile_height, 0)
+					# Bottom right corner
+					glTexCoord2f(1, 0)
+					glVertex(xp+self.tileset.tile_width, yp-self.tileset.tile_height, -1*size)
+					# Bottom left corner
+					glTexCoord2f(0, 0)
+					glVertex(xp+self.tileset.tile_width, yp, -1*size)
+					glEnd()
+					
+				#top
+				if (y - 1 <= 0) or (self.level[x][y-1] == -1) :
+					glBegin(GL_QUADS)
+					# Top left corner
+					glTexCoord2f(0, 1)
+					glVertex(xp, yp, 0)
+					# Top right corner
+					glTexCoord2f(1, 1)
+					glVertex(xp+self.tileset.tile_width, yp, 0)
+					# Bottom right corner
+					glTexCoord2f(1, 0)
+					glVertex(xp+self.tileset.tile_width, yp, -1*size)
+					# Bottom left corner
+					glTexCoord2f(0, 0)
+					glVertex(xp, yp, -1*size)
+					glEnd()	
+				#bottom
+				if (y + 1 >= len(self.level[x])) or (self.level[x][y+1] == -1) :
+					glBegin(GL_QUADS)
+					# Top left corner
+					glTexCoord2f(0, 1)
+					glVertex(xp, yp-self.tileset.tile_height, 0)
+					# Top right corner
+					glTexCoord2f(1, 1)
+					glVertex(xp+self.tileset.tile_width, yp-self.tileset.tile_height, 0)
+					# Bottom right corner
+					glTexCoord2f(1, 0)
+					glVertex(xp+self.tileset.tile_width, yp-self.tileset.tile_height, -32)
+					# Bottom left corner
+					glTexCoord2f(0, 0)
+					glVertex(xp, yp-self.tileset.tile_height, -32)
+					glEnd()
+				
+				
+			
+				
+
diff --git a/ogm/level.py b/ogm/level.py
new file mode 100644
--- /dev/null
+++ b/ogm/level.py
@@ -0,0 +1,227 @@
+from ogm.layer import Layer
+from ogm.tileset import Tileset
+from ogm.tileset import Tileset_GL
+import xml.dom.minidom
+from OpenGL.GL import *
+from OpenGL.GLU import *
+import pygame
+import ogm.engine
+
+class Level:
+	def __init__(self,xml_file=None):
+		if xml_file==None:
+			pass
+		else:
+			
+			engine = ogm.engine.get_engine()
+			self.filename = xml_file
+			dom_doc = xml.dom.minidom.parse(xml_file)
+			root = dom_doc.getElementsByTagName("level")[0]
+			self.name = root.getAttribute("name")
+			self.creator = root.getAttribute("creator")
+			self.date = root.getAttribute("date")
+			self.h = int(root.getAttribute("h"))
+			self.w = int(root.getAttribute("w"))
+			self.background = None
+			self.license = root.getAttribute("license")#need test
+			
+			# building layers
+			layers = dom_doc.getElementsByTagName("layer")
+			self.layers = {}
+			self.layer_name = {}
+			self.elevations = {}
+			self.volumes = {}
+			for layer in layers:
+				tmplayr = []
+				tileset = layer.getAttribute("tileset")
+				tileh = int(layer.getAttribute("tile_h"))
+				tilew = int(layer.getAttribute("tile_w"))
+				if layer.hasAttribute("colorkey"):
+					colorkey = int(layer.getAttribute("colorkey"))
+				else:
+					colorkey = None
+				def_tile = int(layer.getAttribute("default_tile"))
+				lid = int(layer.getAttribute("id"))
+				if layer.hasAttribute("elevation"):
+					self.elevations[lid] = int(layer.getAttribute("elevation"))
+				else:
+					self.elevations[lid] = 0
+				if layer.hasAttribute("volume"):
+					self.volumes[lid] = int(layer.getAttribute("volume"))
+				else:
+					self.volumes[lid] = 0
+				self.layer_name[lid] = (layer.getAttribute("name"))
+				for x in range(self.w):
+					tmplayr.append([])
+					for y in range(self.h):
+						tmplayr[x].append(def_tile)
+				
+				cels = layer.getElementsByTagName("cell")
+				for cell in cels:
+					tmplayr[int(cell.getAttribute("x"))]\
+					[int(cell.getAttribute("y"))] = int(cell.getAttribute("tile"))
+				tmptileset = engine.get_tileset(tileset,tilew,tileh,colorkey)#Tileset_GL(tileset,tilew,tileh,colorkey)
+
+				self.layers[lid] = Layer(tmptileset,tmplayr)
+			self.layers_id = self.layers.keys()
+			self.layers_id.sort()
+			self.callList = {}
+			for id in self.layers_id:
+				self.callList[id] = None
+			self.compute_callList()
+			
+			clayer = dom_doc.getElementsByTagName("collision_layer")[0]
+			self.collide_tile_h = int(clayer.getAttribute("tile_h"))
+			self.collide_tile_w = int(clayer.getAttribute("tile_w"))
+			def_tile = int(clayer.getAttribute("default_tile"))
+			tmplayr = []
+			for x in range(self.w):
+				tmplayr.append([])
+				for y in range(self.h):
+					tmplayr[x].append(def_tile)
+			cels = clayer.getElementsByTagName("cell")
+			for cell in cels:
+				tmplayr[int(cell.getAttribute("x"))]\
+				[int(cell.getAttribute("y"))] = int(cell.getAttribute("tile"))
+			self.collide_array = tmplayr
+			# need clean up ---
+			bg = dom_doc.getElementsByTagName("bg")
+			if len(bg) == 1:
+			
+				surf = pygame.image.load(bg[0].getAttribute("image"))
+				surf.convert_alpha()
+				
+				texture_data = pygame.image.tostring(surf, 'RGBA', True)
+				texture_id = glGenTextures(1)
+				glBindTexture(GL_TEXTURE_2D, texture_id)
+				#for mip mapping
+				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR)
+				# Tell OpenGL that data is aligned to byte boundries
+				glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+				#for mip mapping
+				gluBuild2DMipmaps( GL_TEXTURE_2D,4, surf.get_width(),surf.get_height(),\
+				GL_RGBA,GL_UNSIGNED_BYTE, texture_data)
+				self.background = texture_id
+			else:
+				self.background = None
+			
+	def draw(self,surface,xoff,yoff):
+		for lid in self.layers_id:
+			self.layers[lid].draw(surface,xoff,yoff)
+	
+	def __del__(self):
+		engine = ogm.engine.get_engine()
+		for lid in self.layers_id:
+			ts = self.layers[lid].tileset
+			engine.release_tileset(ts.filename,ts.tile_width,ts.tile_height,ts.colorkey)
+			glDeleteLists(self.callList[lid],1)
+			del self.layers[lid]
+		if self.background != None:
+			glDeleteTextures(self.background)
+	def compute_callList(self):
+		for lid in self.layers_id:
+			self.callList[lid] = glGenLists(1)
+			glNewList(self.callList[lid],GL_COMPILE)
+			if not self.volumes[lid] == 0:
+				glTranslatef(0.0, 0.0, self.volumes[lid])
+				self.layers[lid].draw_gl_cubes(self.volumes[lid])
+			else:
+				self.layers[lid].draw_gl()
+			glEndList()
+	def render_callList(self,xoff,yoff):
+		# Clear the screen (similar to fill)
+		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
+		# Clear the modelview matrix
+
+		glPushMatrix()
+		glLoadIdentity()
+		glDisable(GL_DEPTH_TEST)
+		if self.background != None:
+
+			glBindTexture(GL_TEXTURE_2D, self.background)
+				#print self.tileset[self.level[x][y]],xp,yp
+			#top 
+			glTranslatef(0.0, 0.0, -250.0)
+			
+			glBegin(GL_QUADS)
+			# Top left corner
+			glTexCoord2f(0, 1)
+			glVertex(-200,200, 0)
+			# Top right corner
+			glTexCoord2f(1, 1)
+			glVertex(200, 200, 0)
+			# Bottom right corner
+			glTexCoord2f(1, 0)
+			glVertex(200, -200, 0)
+			# Bottom left corner
+			glTexCoord2f(0, 0)
+			glVertex(-200, -200, 0)
+			glEnd()
+		#glTranslatef(xoff, -1*yoff,0.0)
+		glEnable(GL_DEPTH_TEST)
+		glPopMatrix()
+		for lid in self.layers_id:
+			
+			glPushMatrix()
+			glLoadIdentity()
+			#glRotate(5, 1,0, 0)
+			glTranslatef(xoff, -1*yoff,0.0)
+			
+			
+			glTranslatef(0.0, 0.0, -250.0)
+			glTranslatef(0.0, 0.0, self.elevations[lid])
+			
+			glCallList(self.callList[lid])
+			glPopMatrix()
+		
+	def render(self,xoff,yoff):
+		# Clear the screen (similar to fill)
+		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
+		# Clear the modelview matrix
+
+		glPushMatrix()
+		glLoadIdentity()
+		glDisable(GL_DEPTH_TEST)
+		if self.background != None:
+
+			glBindTexture(GL_TEXTURE_2D, self.background)
+				#print self.tileset[self.level[x][y]],xp,yp
+			#top 
+			glTranslatef(0.0, 0.0, -250.0)
+			
+			glBegin(GL_QUADS)
+			# Top left corner
+			glTexCoord2f(0, 1)
+			glVertex(-200,200, 0)
+			# Top right corner
+			glTexCoord2f(1, 1)
+			glVertex(200, 200, 0)
+			# Bottom right corner
+			glTexCoord2f(1, 0)
+			glVertex(200, -200, 0)
+			# Bottom left corner
+			glTexCoord2f(0, 0)
+			glVertex(-200, -200, 0)
+			glEnd()
+		#glTranslatef(xoff, -1*yoff,0.0)
+		glEnable(GL_DEPTH_TEST)
+		glPopMatrix()
+		for lid in self.layers_id:
+			
+			glPushMatrix()
+			glLoadIdentity()
+			#glRotate(5, 1,0, 0)
+			glTranslatef(xoff, -1*yoff,0.0)
+			
+			
+			glTranslatef(0.0, 0.0, -250.0)
+			glTranslatef(0.0, 0.0, self.elevations[lid])
+			
+			if not self.volumes[lid] == 0:
+				glTranslatef(0.0, 0.0, self.volumes[lid])
+				self.layers[lid].draw_gl_cubes(self.volumes[lid])
+			else:
+				self.layers[lid].draw_gl()
+			glPopMatrix()
+
diff --git a/ogm/physics.py b/ogm/physics.py
new file mode 100644
--- /dev/null
+++ b/ogm/physics.py
@@ -0,0 +1,204 @@
+import ogm.engine
+COLLIDE_WITH_EVERYTHING = 511
+COLLIDE_WITH_NOTHING = 0
+COLLIDE_WITH_LEVEL = 2
+AFFECTED_BY_GRAVITY = 4
+COLLIDE_WITH_ACTORS = 8
+COLLIDE_WITH_PARTICLES = 16
+COLLIDE_WITH_GROUP_3 = 32
+COLLIDE_WITH_GROUP_4 = 64
+COLLIDE_WITH_GROUP_5 = 128
+COLLIDE_WITH_GROUP_6 = 256
+
+class Physics:
+	def __init__(self):
+		self.objects = []
+	def __del__(self):
+		pass
+	def add_object(self,obj):
+		self.objects.append(obj)
+	def remove_object(self,obj):
+		self.objects.remove(obj)
+	def update(self,time):
+		engine = ogm.engine.get_engine()
+		array = engine.level.collide_array
+		th = engine.level.collide_tile_h
+		tw = engine.level.collide_tile_w
+		h = engine.level.h
+		w = engine.level.w
+		for obj1 in self.objects:
+			bbox1 = obj1.get_bounding_box()
+			u = obj1.y+bbox1.yoff
+			b = obj1.y+bbox1.yoff + bbox1.height
+			r = obj1.x+bbox1.xoff + bbox1.width
+			l = obj1.x+bbox1.xoff
+			if l <= 0 or r >= w*tw \
+			or b <= 0 or u >= h*th:
+				print "out of this silent planet"
+
+				engine.remove_actor_by_instance(obj1)
+				continue
+			if bbox1.state & AFFECTED_BY_GRAVITY:
+				bbox1.accel(0,(0.098/32.0)*time)
+			if bbox1.state & COLLIDE_WITH_NOTHING:
+				continue
+			elif bbox1.state & COLLIDE_WITH_LEVEL :
+				#check left
+				xdiff = 0
+				ydiff = 0
+				
+				#check up
+				if bbox1.vect[1]<0 and (array[(l+1)/tw][(u)/th] == 1\
+				or  array[(r-1)/tw][(u)/th] == 1):
+
+					obj1.y += (u)%th 
+					bbox1.vect[1]=0.0
+					bbox1.contact['up'] = True
+					u = obj1.y+bbox1.yoff
+					b = obj1.y+bbox1.yoff + bbox1.height
+				else:
+					bbox1.contact['up'] = False
+				#check down
+				if  bbox1.vect[1]>0 and (array[(l+1)/tw][(b)/th] == 1\
+				or array[(r-1)/tw][(b)/th] == 1):
+
+					obj1.y -= (b)%th 
+					bbox1.vect[1]=0.0
+					bbox1.contact['down'] = True
+					u = obj1.y+bbox1.yoff
+					b = obj1.y+bbox1.yoff + bbox1.height
+				else:
+					bbox1.contact['down'] = False
+				
+				if 	bbox1.vect[0]<0:
+					if (array[(l)/tw][(u+1)/th] == 1\
+					or array[(l)/tw][(b-1)/th] == 1):
+
+						obj1.x += tw-(l)%tw
+						bbox1.contact['left'] = True
+						r = obj1.x+bbox1.xoff + bbox1.width
+						l = obj1.x+bbox1.xoff
+
+					else:
+						bbox1.contact['left'] = False
+					
+					#check right
+					if  (array[(r)/tw][(u+1)/th] == 1\
+					or array[(r)/tw][(b-1)/th] == 1):
+						obj1.x -= (r)%tw
+					else:
+						bbox1.contact['right'] = False
+				else:
+					
+					#check right
+					if  (array[(r)/tw][(u+1)/th] == 1\
+					or array[(r)/tw][(b-1)/th] == 1):
+						obj1.x -= (r)%tw
+
+						bbox1.contact['right'] = True
+						r = obj1.x+bbox1.xoff + bbox1.width
+						l = obj1.x+bbox1.xoff
+
+					else:
+						bbox1.contact['right'] = False
+						
+					if (array[(l)/tw][(u+1)/th] == 1\
+					or array[(l)/tw][(b-1)/th] == 1):
+	
+						obj1.x += tw-(l)%tw
+						bbox1.contact['left'] = True
+					else:
+						bbox1.contact['left'] = False
+					
+				
+		for obj1 in self.objects:
+			bbox1 = obj1.get_bounding_box()	
+			if not bbox1.state & COLLIDE_WITH_ACTORS:
+				continue
+			for obj2 in self.objects:
+				
+				if obj1 == obj2:
+					continue
+				bbox2 = obj2.get_bounding_box()
+				if not bbox2.state & COLLIDE_WITH_ACTORS:
+					continue
+				contact =  bbox1.colide_with(obj1.x,obj1.y,bbox2,obj2.x, obj2.y)
+
+				if not bbox1.contact['left'] and not bbox2.contact['right']:
+					obj1.x -= contact['right']/2
+					obj2.x += contact['right']/2
+				elif not bbox1.contact['left']:
+					obj1.x -= contact['right']
+				elif not bbox2.contact['right']:
+					obj2.x += contact['right']
+				
+				
+					
+				if not bbox1.contact['right'] and not bbox2.contact['left']:
+					obj1.x += contact['left']/2
+					obj2.x -= contact['left']/2
+				elif not bbox1.contact['right']:
+					obj1.x += contact['left']
+				elif not bbox2.contact['left']:
+					obj2.x -= contact['left']
+					
+				if contact['right']!= 0:
+					bbox1.contact['right'] = True
+					bbox2.contact['left'] = True
+					print obj1.name ,obj2.name
+					if obj1.name == "disc":
+						print "kill"
+						engine.remove_actor_by_instance(obj2)
+						continue
+					elif  obj2.name == "disc":
+						print "kill"
+						engine.remove_actor_by_instance(obj1)
+						continue
+					
+					
+				if contact['left']!= 0:
+					bbox1.contact['left'] = True
+					bbox2.contact['right'] = True
+					print obj1.name ,obj2.name
+					if obj1.name == "disc":
+						print "kill"
+						engine.remove_actor_by_instance(obj2)
+						continue
+					elif  obj2.name == "disc":
+						print "kill"
+						engine.remove_actor_by_instance(obj1)
+						continue
+					
+
+class BoundingBox:
+	def __init__(self,xoff,yoff,w,h):
+		self.xoff = xoff
+		self.yoff = yoff
+		self.width = w
+		self.height = h
+		self.state = COLLIDE_WITH_EVERYTHING
+		self.counter = 0
+		self.vect = [0.0,0.0] #momentum
+		self.contact = {'left':False,'right':False,'up':False,'down':False}
+	def accel(self,x,y):
+		self.vect[0] += x
+		self.vect[1] += y
+		
+	def colide_with(self,x,y,bbox,x2,y2):
+		contact = {'left':0,'right':0,'up':0,'down':0}
+		if (((bbox.yoff+y2)-(self.yoff+y+self.height))*((bbox.yoff+y2+bbox.height)-(self.yoff+y)))<0:
+			
+			if ( (bbox.xoff+x2+bbox.width )> (self.xoff+x) and (bbox.xoff+x2 )< (self.xoff+x)):
+				contact['left'] = (bbox.xoff+x2+bbox.width) - (self.xoff+x)
+			if ( (bbox.xoff+x2 )< (self.xoff+x + self.width) and (bbox.xoff+x2 )> (self.xoff+x )):
+				contact['right'] = (self.xoff+x + self.width) - (bbox.xoff+x2 )
+
+		#not tested
+		if ( (bbox.yoff+y2+bbox.height )> (self.yoff+y) and (bbox.yoff+y2 )< (self.yoff+y+self.height)):
+			contact['down'] = (bbox.yoff+y2+bbox.height) - (self.yoff+y)
+		if ( (bbox.yoff+y2 )< (self.yoff+y + self.height) and (bbox.yoff+y2 )> (self.yoff+y )):
+			contact['up'] = (self.yoff+y + self.height) - (bbox.yoff+y2 )
+		return contact
+				
+		
+		
diff --git a/ogm/tileset.py b/ogm/tileset.py
new file mode 100644
--- /dev/null
+++ b/ogm/tileset.py
@@ -0,0 +1,84 @@
+import pygame
+from OpenGL.GL import *
+from OpenGL.GLU import *
+
+class Tileset:
+	'''
+	Tileset, legacy interface for tileset manipulation, non-OpenGL
+	'''
+	def __init__(self,filename,width,height):
+		self.filename = filename
+		self.tile_width = width
+		self.tile_height = height
+		self.surface = pygame.image.load(self.filename)
+		self.surface.convert_alpha()
+		self.len = (self.surface.get_width()/self.tile_width)*(self.surface.get_height()/self.tile_height)
+		
+		self.tiles = []
+		
+		# 
+		for y in range(self.surface.get_height()/self.tile_height):
+			for x in range((self.surface.get_width()/self.tile_width)):
+				rect = pygame.Rect(x*self.tile_width,y*self.tile_height,self.tile_width,self.tile_height)
+				self.tiles.append(self.surface.subsurface(rect))
+
+	def __getitem__(self, key):
+		return self.tiles[key]		
+	def __len__(self):
+		return self.len
+		
+class Tileset_GL:
+	'''
+	TilesetGL, OpenGL tileset class, load and manage tiles
+	'''
+	def __init__(self,filename,width,height,colorkey=None):
+		self.filename = filename
+		self.tile_width = width
+		self.tile_height = height
+		self.surface = pygame.image.load(self.filename)
+		self.colorkey = colorkey
+		if colorkey!= None:
+			self.surface.set_colorkey(colorkey)
+		self.surface.convert_alpha()
+		self.len = (self.surface.get_width()/self.tile_width)*(self.surface.get_height()/self.tile_height)
+		
+		self.tiles = list()
+		for y in range(self.surface.get_height()/self.tile_height):
+			for x in range((self.surface.get_width()/self.tile_width)):
+				rect = pygame.Rect(x*self.tile_width,y*self.tile_height,self.tile_width,self.tile_height)
+				texture_data = pygame.image.tostring(self.surface.subsurface(rect), 'RGBA', True)
+				texture_id = glGenTextures(1)
+				glBindTexture(GL_TEXTURE_2D, texture_id)
+				
+				# Tell OpenGL how to scale images
+				glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST )
+				glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST )
+				
+				#for mip mapping
+				#glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+				#glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR)
+
+				
+				# Tell OpenGL that data is aligned to byte boundries
+				glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+				glTexImage2D( GL_TEXTURE_2D, 0,4, self.tile_width,self.tile_height,0,\
+				GL_RGBA,GL_UNSIGNED_BYTE, texture_data)
+				
+				#for mip mapping
+				#gluBuild2DMipmaps( GL_TEXTURE_2D,4, self.tile_width,self.tile_height,\
+				#GL_RGBA,GL_UNSIGNED_BYTE, texture_data)
+
+				self.tiles.append(texture_id)
+
+
+
+	def __del__(self):
+		for texture_id in self.tiles:
+			glDeleteTextures(texture_id)
+			
+
+	def __getitem__(self, key):
+		return self.tiles[key]
+			
+	def __len__(self):
+		return self.len