Esempio n. 1
0
def boardToLevelCoord(width, length, coordinate):
  coord = vector.tVector3(0.0, 0.0, 0.0) # create a new vector
  xzero = -0.5*width + 0.5*SQUARE_SIZE # 3D x-coordinate for 2D coordinate x = 0
  zzero = (0.5*length - 0.5*SQUARE_SIZE) # 3D z-coordinate for 2D coordinate y = 0
  toAdd = vector.tVector3(xzero + (coordinate['x'] ), 0.0, zzero - (coordinate['y'] ))
  coord = coord + toAdd
  return coord
Esempio n. 2
0
def initGraphics():
  pygame.init()

  # constants
  global SCREEN_SIZE
  SCREEN_SIZE = (1024,600) # screen size when not fullscreen
  global DISPLAY_FLAGS
  DISPLAY_FLAGS = OPENGL|DOUBLEBUF #|FULLSCREEN # display settings
  global INIT_DIRECTION
  INIT_DIRECTION = vector.tVector3(1.0, 0.0, 0.0) # inital bomberman direction

  # global variables
  global pos
  pos = vector.tVector3(0, 0, 0) # Position Vector Camera
  global view
  view = vector.tVector3(0, 0, 0) # View Vector Camera
  global up
  up = vector.tVector3(0, 0, 0) # Up Vector Camera
  global bdirection
  bdirection = vector.tVector3(0.0, 0.0, 0.0) # direction of bomberman
  global angle
  angle = 0.0 # angle for rotating the bomberman

  # dispplay settings
  os.environ["SDL_VIDEO_CENTERED"] = "1" # Center the graphics window.
  global screen
  screen = pygame.display.set_mode(SCREEN_SIZE,DISPLAY_FLAGS)
  pygame.display.set_caption("Bomb3D v"+__version__)
Esempio n. 3
0
def boardToLevelCoord(width, length, coordinate):
    coord = vector.tVector3(0.0, 0.0, 0.0)  # create a new vector
    xzero = -0.5 * width + 0.5 * SQUARE_SIZE  # 3D x-coordinate for 2D coordinate x = 0
    zzero = (0.5 * length - 0.5 * SQUARE_SIZE
             )  # 3D z-coordinate for 2D coordinate y = 0
    toAdd = vector.tVector3(xzero + (coordinate['x']), 0.0,
                            zzero - (coordinate['y']))
    coord = coord + toAdd
    return coord
Esempio n. 4
0
def setCamera(graph, coordinate, direction):
  pos = vector.tVector3(0.0, 0.0, 0.0)
  view = vector.tVector3(0.0, 0.0, 0.0)
  up = vector.tVector3(0.0, 1.0, 0.0)
  
  pos.x = coordinate.x - 25*direction['x']
  pos.y = 4.0
  pos.z = coordinate.z - 25*direction['y']
  
  view.x = coordinate.x + direction['x']
  view.y = 4.0
  view.z = coordinate.z + direction['y']
  
  graph.camera.Position_Camera(pos.x, pos.y, pos.z, view.x, view.y, view.z, up.x, up.y, up.z)
Esempio n. 5
0
def setCamera(graph, coordinate, direction):
    pos = vector.tVector3(0.0, 0.0, 0.0)
    view = vector.tVector3(0.0, 0.0, 0.0)
    up = vector.tVector3(0.0, 1.0, 0.0)

    pos.x = coordinate.x - 25 * direction['x']
    pos.y = 4.0
    pos.z = coordinate.z - 25 * direction['y']

    view.x = coordinate.x + direction['x']
    view.y = 4.0
    view.z = coordinate.z + direction['y']

    graph.camera.Position_Camera(pos.x, pos.y, pos.z, view.x, view.y, view.z,
                                 up.x, up.y, up.z)
Esempio n. 6
0
    def Rotate_View(self, angle, x, y, z):
        vNewView = vector.tVector3(0, 0, 0)
        # Get the view vector (The direction we are facing)
        vView = self.mView - self.mPos

        # Calculate the sine and cosine of the angle once
        cosTheta = math.cos(angle)
        sinTheta = math.sin(angle)

        # Find the new x position for the new rotated point
        vNewView.x = (cosTheta + (1 - cosTheta) * x * x) * vView.x
        vNewView.x = vNewView.x + (
            (1 - cosTheta) * x * y - z * sinTheta) * vView.y
        vNewView.x = vNewView.x + (
            (1 - cosTheta) * x * z + y * sinTheta) * vView.z

        # Find the new y position for the new rotated point
        vNewView.y = ((1 - cosTheta) * x * y + z * sinTheta) * vView.x
        vNewView.y = vNewView.y + (cosTheta + (1 - cosTheta) * y * y) * vView.y
        vNewView.y = vNewView.y + (
            (1 - cosTheta) * y * z - x * sinTheta) * vView.z

        # Find the new z position for the new rotated point
        vNewView.z = ((1 - cosTheta) * x * z - y * sinTheta) * vView.x
        vNewView.z = vNewView.z + (
            (1 - cosTheta) * y * z + x * sinTheta) * vView.y
        vNewView.z = vNewView.z + (cosTheta + (1 - cosTheta) * z * z) * vView.z

        # Now we just add the newly rotated vector to our position to set
        # our new rotated view of our camera.
        self.mView = self.mPos + vNewView
Esempio n. 7
0
	def Rotate_View(self, angle, x, y, z):
		vNewView = vector.tVector3(0,0,0)
		# Get the view vector (The direction we are facing)
		vView = self.mView - self.mPos		

		# Calculate the sine and cosine of the angle once
		cosTheta = math.cos(angle)
		sinTheta = math.sin(angle)

		# Find the new x position for the new rotated point
		vNewView.x = (cosTheta + (1 - cosTheta) * x * x) * vView.x
		vNewView.x = vNewView.x + ((1 - cosTheta) * x * y - z * sinTheta) * vView.y
		vNewView.x = vNewView.x + ((1 - cosTheta) * x * z + y * sinTheta) * vView.z

		# Find the new y position for the new rotated point
		vNewView.y = ((1 - cosTheta) * x * y + z * sinTheta) * vView.x
		vNewView.y = vNewView.y + (cosTheta + (1 - cosTheta) * y * y) * vView.y
		vNewView.y = vNewView.y + ((1 - cosTheta) * y * z - x * sinTheta) * vView.z

		# Find the new z position for the new rotated point
		vNewView.z = ((1 - cosTheta) * x * z - y * sinTheta) * vView.x
		vNewView.z = vNewView.z + ((1 - cosTheta) * y * z + x * sinTheta) * vView.y
		vNewView.z = vNewView.z + (cosTheta + (1 - cosTheta) * z * z) * vView.z

		# Now we just add the newly rotated vector to our position to set
		# our new rotated view of our camera.
		self.mView = self.mPos + vNewView
Esempio n. 8
0
	def Strafe_Camera(self, speed):
		vVector = self.mView - self.mPos # Get the view vector
        
		vOrthoVector = vector.tVector3(0.0, 0.0, 0.0) # Orthogonal vector for the view vector
		vOrthoVector.x = -vVector.z
		vOrthoVector.z =  vVector.x
		# left positive cameraspeed and right negative -cameraspeed.
		self.mPos.x = self.mPos.x + vOrthoVector.x * speed
		self.mPos.z = self.mPos.z + vOrthoVector.z * speed
		self.mView.x = self.mView.x + vOrthoVector.x * speed
		self.mView.z = self.mView.z + vOrthoVector.z * speed
Esempio n. 9
0
def GetCollisionOffset(vNormal, radius, distance):
    vOffset = vector.tVector3(0, 0, 0)

    # Once we find if a collision has taken place, we need to make sure the sphere
    # doesn't move into the wall.  In our app, the position will actually move into
    # the wall, but we check our collision detection before we render the scene, which
    # eliminates the bounce back effect it would cause.  The question is, how do we
    # know which direction to move the sphere back?  In our collision detection, we
    # account for collisions on both sides of the polygon.  Usually, you just need
    # to worry about the side with the normal vector and positive distance.  If
    # you don't want to back face cull and have 2 sided planes, I check for both sides.

    # Let me explain the math that is going on here.  First, we have the normal to
    # the plane, the radius of the sphere, as well as the distance the center of the
    # sphere is from the plane.  In the case of the sphere colliding in the front of
    # the polygon, we can just subtract the distance from the radius, then multiply
    # that new distance by the normal of the plane.  This projects that leftover
    # distance along the normal vector.  For instance, say we have these values:

    #	vNormal = (1, 0, 0)		radius = 5		distance = 3

    # If we subtract the distance from the radius we get: (5 - 3 = 2)
    # The number 2 tells us that our sphere is over the plane by a distance of 2.
    # So basically, we need to move the sphere back 2 units.  How do we know which
    # direction though?  This part is easy, we have a normal vector that tells us the
    # direction of the plane.
    # If we multiply the normal by the left over distance we get:  (2, 0, 0)
    # This new offset vectors tells us which direction and how much to move back.
    # We then subtract this offset from the sphere's position, giving is the new
    # position that is lying right on top of the plane.  Ba da bing!
    # If we are colliding from behind the polygon (not usual), we do the opposite
    # signs as seen below:

    # If our distance is greater than zero, we are in front of the polygon
    if (distance > 0):
        # Find the distance that our sphere is overlapping the plane, then
        # find the direction vector to move our sphere.
        distanceOver = radius - distance
        vOffset = vNormal * distanceOver
    else:  # Else colliding from behind the polygon
        # Find the distance that our sphere is overlapping the plane, then
        # find the direction vector to move our sphere.
        distanceOver = radius + distance
        vOffset = vNormal * -distanceOver

    # There is one problem with check for collisions behind the polygon, and that
    # is if you are moving really fast and your center goes past the front of the
    # polygon, it will then assume you were colliding from behind and not let
    # you back in.  Most likely you will take out the if / else check, but I
    # figured I would show both ways in case someone didn't want to back face cull.

    # Return the offset we need to move back to not be intersecting the polygon.
    return vOffset
Esempio n. 10
0
def GetCollisionOffset(vNormal, radius, distance):
	vOffset = vector.tVector3(0, 0, 0)

	# Once we find if a collision has taken place, we need to make sure the sphere
	# doesn't move into the wall.  In our app, the position will actually move into
	# the wall, but we check our collision detection before we render the scene, which
	# eliminates the bounce back effect it would cause.  The question is, how do we
	# know which direction to move the sphere back?  In our collision detection, we
	# account for collisions on both sides of the polygon.  Usually, you just need
	# to worry about the side with the normal vector and positive distance.  If 
	# you don't want to back face cull and have 2 sided planes, I check for both sides.

	# Let me explain the math that is going on here.  First, we have the normal to
	# the plane, the radius of the sphere, as well as the distance the center of the
	# sphere is from the plane.  In the case of the sphere colliding in the front of
	# the polygon, we can just subtract the distance from the radius, then multiply
	# that new distance by the normal of the plane.  This projects that leftover
	# distance along the normal vector.  For instance, say we have these values:
	
	#	vNormal = (1, 0, 0)		radius = 5		distance = 3

	# If we subtract the distance from the radius we get: (5 - 3 = 2)
	# The number 2 tells us that our sphere is over the plane by a distance of 2.
	# So basically, we need to move the sphere back 2 units.  How do we know which
	# direction though?  This part is easy, we have a normal vector that tells us the
	# direction of the plane.  
	# If we multiply the normal by the left over distance we get:  (2, 0, 0)
	# This new offset vectors tells us which direction and how much to move back.
	# We then subtract this offset from the sphere's position, giving is the new
	# position that is lying right on top of the plane.  Ba da bing!
	# If we are colliding from behind the polygon (not usual), we do the opposite
	# signs as seen below:
	
	# If our distance is greater than zero, we are in front of the polygon
	if (distance > 0):
		# Find the distance that our sphere is overlapping the plane, then
		# find the direction vector to move our sphere.
		distanceOver = radius - distance
		vOffset = vNormal * distanceOver
	else: # Else colliding from behind the polygon
		# Find the distance that our sphere is overlapping the plane, then
		# find the direction vector to move our sphere.
		distanceOver = radius + distance
		vOffset = vNormal * -distanceOver

	# There is one problem with check for collisions behind the polygon, and that
	# is if you are moving really fast and your center goes past the front of the
	# polygon, it will then assume you were colliding from behind and not let
	# you back in.  Most likely you will take out the if / else check, but I
	# figured I would show both ways in case someone didn't want to back face cull.

	# Return the offset we need to move back to not be intersecting the polygon.
	return vOffset
Esempio n. 11
0
    def Strafe_Camera(self, speed):
        vVector = self.mView - self.mPos  # Get the view vector

        vOrthoVector = vector.tVector3(
            0.0, 0.0, 0.0)  # Orthogonal vector for the view vector
        vOrthoVector.x = -vVector.z
        vOrthoVector.z = vVector.x
        # left positive cameraspeed and right negative -cameraspeed.
        self.mPos.x = self.mPos.x + vOrthoVector.x * speed
        self.mPos.z = self.mPos.z + vOrthoVector.z * speed
        self.mView.x = self.mView.x + vOrthoVector.x * speed
        self.mView.z = self.mView.z + vOrthoVector.z * speed
Esempio n. 12
0
def Cross(vVector1,vVector2):
	vNormal = vector.tVector3(0,0,0) # The vector to hold the cross product

	# The X value for the vector is:  (V1.y * V2.z) - (V1.z * V2.y)
	vNormal.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y))
														
	# The Y value for the vector is:  (V1.z * V2.x) - (V1.x * V2.z)
	vNormal.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z))
														
	# The Z value for the vector is:  (V1.x * V2.y) - (V1.y * V2.x)
	vNormal.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x))

	return vNormal # Return the cross product (Direction the polygon is facing - Normal)
Esempio n. 13
0
def Cross(vVector1, vVector2):
    vNormal = vector.tVector3(0, 0, 0)  # The vector to hold the cross product

    # The X value for the vector is:  (V1.y * V2.z) - (V1.z * V2.y)
    vNormal.x = ((vVector1.y * vVector2.z) - (vVector1.z * vVector2.y))

    # The Y value for the vector is:  (V1.z * V2.x) - (V1.x * V2.z)
    vNormal.y = ((vVector1.z * vVector2.x) - (vVector1.x * vVector2.z))

    # The Z value for the vector is:  (V1.x * V2.y) - (V1.y * V2.x)
    vNormal.z = ((vVector1.x * vVector2.y) - (vVector1.y * vVector2.x))

    return vNormal  # Return the cross product (Direction the polygon is facing - Normal)
Esempio n. 14
0
def LoadVertices():
  global g_NumberOfVerts
  # This function reads in the vertices from an ASCII text file (World.raw).
  # First, we read in the vertices with a temp CVector3 to get the number of them.
  # Next, we rewind the file pointer and then actually read in the vertices into
  # our allocated CVector3 array g_vWorld[].

  # Create a file and load the model from a file of vertices
  fp = open(FILE_NAME, "r")

  # Read in the vertices that are stored in the file
  arr = []
  for line in fp.readlines(): # Read line after line
    arr.append(map(float, line.split())) # Map the vertices into a 2-dim array
    new = vector.tVector3(arr[g_NumberOfVerts][0], arr[g_NumberOfVerts][1], arr[g_NumberOfVerts][2])
    g_vWorld.append(new)
    g_NumberOfVerts = g_NumberOfVerts + 1									 
  # Close our file because we are done
  fp.close()
Esempio n. 15
0
	def __init__(self): 
		self.mPos = vector.tVector3(0.0, 0.0, 0.0)							
		self.mView = vector.tVector3(0.0, 0.0, 0.0)							
		self.mUp = vector.tVector3(0.0, 0.0, 0.0)	
		self.mStrafe = vector.tVector3(0.0, 0.0, 0.0)
		self.mRadius = 1
Esempio n. 16
0
	def Position_Camera(self, pos_x, pos_y, pos_z, view_x, view_y, view_z, up_x, up_y, up_z):
		self.mPos = vector.tVector3(pos_x, pos_y, pos_z) # set position
		self.mView = vector.tVector3(view_x, view_y, view_z) # set view
		self.mUp = vector.tVector3(up_x, up_y, up_z) # set the up vector
Esempio n. 17
0
DISPLAY_FLAGS = PyGLoc.OPENGL|PyGLoc.DOUBLEBUF
FILE_NAME = "World.raw"

MAP = []
MAP.append((1,1,1,1,1))
MAP.append((1,2,2,0,1))
MAP.append((1,2,1,0,1))
MAP.append((1,0,0,0,0))
MAP.append((1,1,1,1,1))

# player location: x,y,angle,color
PLAYERS = [(1.5,1.5,50,(255,0,0)),(6.5,7.5,280,(0,255,0))]

# global variables
objCamera = camera.CCamera() # Our Camera
pos = vector.tVector3(0, 0, 0) # Vector Camera Position
view = vector.tVector3(0, 0, 0) # View Vector Camera
up = vector.tVector3(0, 0, 0) # Up Vector Camera
g_vWorld = [] # Array containing all the triangles our world consists of
g_NumberOfVerts = 0 # Number of vertices used in our world

# Load the vertices specified in our world file
def LoadVertices():
  global g_NumberOfVerts
  # This function reads in the vertices from an ASCII text file (World.raw).
  # First, we read in the vertices with a temp CVector3 to get the number of them.
  # Next, we rewind the file pointer and then actually read in the vertices into
  # our allocated CVector3 array g_vWorld[].

  # Create a file and load the model from a file of vertices
  fp = open(FILE_NAME, "r")
Esempio n. 18
0
 def __init__(self):
     self.mPos = vector.tVector3(0.0, 0.0, 0.0)
     self.mView = vector.tVector3(0.0, 0.0, 0.0)
     self.mUp = vector.tVector3(0.0, 0.0, 0.0)
     self.mStrafe = vector.tVector3(0.0, 0.0, 0.0)
     self.mRadius = 1
Esempio n. 19
0
 def Position_Camera(self, pos_x, pos_y, pos_z, view_x, view_y, view_z,
                     up_x, up_y, up_z):
     self.mPos = vector.tVector3(pos_x, pos_y, pos_z)  # set position
     self.mView = vector.tVector3(view_x, view_y, view_z)  # set view
     self.mUp = vector.tVector3(up_x, up_y, up_z)  # set the up vector
Esempio n. 20
0
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *

from math import floor, pi

import math3D
import vector
import pygame
pygame.init()

SCREEN_SIZE = (640,480) # screen size when not fullscreen
SQUARE_SIZE = 80
MAP_SCREEN_RATIO = 3;
INIT_DIRECTION = vector.tVector3(0.0, 1.0, 0.0) # inital bomberman direction

# global variables
bdirection = vector.tVector3(0.0, 0.0, 0.0) # direction of bomberman
angle = 0.0

class HUD(): # The HUD
  def __init__(self, textures):
    self.visuals = textures
    
  def Draw_Mini_Map(self, gamestate):
    self.HudMode(True)
    # map size           
    real_map_width = float(gamestate.level.size['x'])
    real_map_height = float(gamestate.level.size['y'])
    relative_map_width = gamestate.level.size['x'] / SQUARE_SIZE
Esempio n. 21
0
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *

from math import floor, pi

import math3D
import vector
import pygame
pygame.init()

SCREEN_SIZE = (640, 480)  # screen size when not fullscreen
SQUARE_SIZE = 80
MAP_SCREEN_RATIO = 3
INIT_DIRECTION = vector.tVector3(0.0, 1.0, 0.0)  # inital bomberman direction

# global variables
bdirection = vector.tVector3(0.0, 0.0, 0.0)  # direction of bomberman
angle = 0.0


class HUD():  # The HUD
    def __init__(self, textures):
        self.visuals = textures

    def Draw_Mini_Map(self, gamestate):
        self.HudMode(True)
        # map size
        real_map_width = float(gamestate.level.size['x'])
        real_map_height = float(gamestate.level.size['y'])