def reProjectResidual(x, *args): Str_4D = args[0] Xp_1 = args[1] Xp_2 = args[2] k = args[3] R = cv2.Rodrigues(x[0:3]) t = np.array(x[3:6]).reshape(3,1) myC1 = Camera.myCamera(k) myC2 = Camera.myCamera(k) myC1.projectiveMatrix(np.mat([0,0,0]).transpose(),[0, 0, 0]) myC2.projectiveMatrix(np.mat(t),R[0]) rXp_1 = np.mat(myC1.project(Str_4D)) rXp_2 = np.mat(myC2.project(Str_4D)) res_1 = Xp_1 - rXp_1 res_2 = Xp_2 - rXp_2 Res = np.hstack((res_1,res_2)).reshape(-1) nRes = 2*np.sqrt(np.sum(np.power(Res,2))/len(Res)) return nRes
def reProjectResidualwithX(nx, *args): shp = args[0] Xp_1 = args[1] Xp_2 = args[2] k = args[3] R = args[4] t = args[5] stackedx = nx[0:shp[0]*shp[1]] #x = nx[shp[0]*shp[1]:shp[0]*shp[1]+6] Str_4D = stackedx.reshape(shp) #R = cv2.Rodrigues(x[0:3]) #t = np.array(x[3:6]).reshape(3,1) myC1 = Camera.myCamera(k) myC2 = Camera.myCamera(k) myC1.projectiveMatrix(np.mat([0,0,0]).transpose(),[0, 0, 0]) myC2.projectiveMatrix(np.mat(t),R[0]) rXp_1 = np.mat(myC1.project(Str_4D)) rXp_2 = np.mat(myC2.project(Str_4D)) res_1 = Xp_1 - rXp_1 res_2 = Xp_2 - rXp_2 Res = np.hstack((res_1,res_2)).reshape(-1) nRes = 2*np.sqrt(np.sum(np.power(Res,2))/len(Res)) return nRes
def takePhoto_btn_clicked(self):
alert = QMessageBox()
alert.setText("Smile!")
Camera.take_picture(camera)
path = '/home/pi/Desktop/ProfMate/pic.jpg'
student_info.append(path)
alert.exec_()
def new(self):
# start a new game
for row, tiles in enumerate(self.map.data):
for col, tile in enumerate(tiles):
if tile in MAP_KEY:
foo = MAP_KEY[tile]
if tile == 'P':
self.player = foo(col, row)
else:
foo(col, row)
self.camera = Camera(self.map.width, self.map.height)
# def Load(self, sheet_name, animation_name, num_pics, start_x, start_y, w, h):
self.player.Animation_Right.Load("links.gif", "Link_Right", 8, 0, 0,
70, 100, 30)
self.player.Animation_Down.Load("links.gif", "Link_Down", 8, 800, 0,
70, 100, 30)
self.player.Animation_Left.Load("links.gif", "Link_Left", 8, 1600, 0,
70, 100, 30)
self.player.Animation_Up.Load("links.gif", "Link_Up", 8, 2400, 0, 70,
100, 30)
self.player.Animation_Standing.Add_Pic("Link_Standing", "links.gif",
(800, 0, 70, 100))
def __init__(self):
"""Initialize game variables"""
self.clock = pygame.time.Clock()
self.current_map_name = "world"
self.maps = {
"world":Map('Maps/map0.txt', 'images/ProjectUtumno_full.png', screen_size),
"shop": Map('Maps/map_shop.txt', 'images/ProjectUtumno_full.png', screen_size),
"dungeon":Map('Maps/map_dungeon.txt', 'images/ProjectUtumno_full.png', screen_size),
}
self.current_map = self.maps[self.current_map_name]
self.running = False
self.window = pygame.display.set_mode(screen_size)
self.player = Player('images/star.png')
self.bg_color = (0,0,0)
self.event_manager = EventManager()
self.event_manager.addGameObject(self.player)
self.camera = Camera(self.current_map)
self.event_manager.addGameObject(self.camera)
# feel free to move this to its own method or wherever, just using for testing
for enemy in self.current_map.enemy_list.sprites():
self.event_manager.addGameObject(enemy)
self.warpCoordinates = {
"world": [(self.player.position.x,self.player.position.y)],
"shop": [(320,590),(1360,334)],
"dungeon": [(2816,1600),(1440,1525)]
}
def __init__(self, w, h, title):
self.KeyInputState = {
"reset": False,
"space": False,
"b": False,
"v": False,
"g": False,
"h": False,
"n": False
}
self.cam = Camera(60., 1.0, 0.1, 1000.0)
#self.cam.setPos([0,10,1], [0,0,0])
#self.cam.setPos([10,10,10], [0,0,0])
#self.cam.setPos([10,5,10], [0,0,0])
#self.cam.setPos([10,2,10], [0,0,0])
self.cam.setPos([20, 10, 10], [0, 0, 0])
self.timer = Timer()
self.gridMode = False
self.gridAngle = 0
self.gridAxis = [1, 0, 0]
self.graphics = Graphics()
self.lighting = Lighting()
self.scene = Scene()
self.background = Background()
glutInit(sys.argv)
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(w, h)
glutInitWindowPosition(100, 100)
glutCreateWindow(title)
glClearColor(0.25, 0.25, 0.25, 1.0)
glEnable(GL_DEPTH_TEST)
self.lighting.LightSet()
def __init__(self, WINDOW_SIZE):
self.WINDOW_SIZE = Vector2(1366, 768)
self.isGameOver = False
self.playWithRFID = True
self.folderDir = os.path.split(os.getcwd())[0]
self.assetDir = self.folderDir + '/Assets/'
self.inputManager = InputManager()
if self.playWithRFID:
self.myRFIDReader = RFIDReader()
self.inputManager.setRFIDInput(self.myRFIDReader)
pygame.init()
self.clock = pygame.time.Clock()
self.display = pygame.display.set_mode(
(self.WINDOW_SIZE.getX(), self.WINDOW_SIZE.getY()),
pygame.FULLSCREEN)
pygame.display.set_caption('What A Block')
self.loadAssets()
self.cam = Camera(offSet=Vector2(
self.WINDOW_SIZE.getX() / 2,
self.WINDOW_SIZE.getY() / 2 - self.player.getHeight() / 2),
camSize=self.WINDOW_SIZE)
self.player_revealver = Revealer(
IsoToScreen(self.player.getIsoPos(),
self.mapCollection.getBlockSize().getX(),
self.mapCollection.getBlockSize().getY()), 60)
pygame.mixer.music.play(-1)
def __init__(self, objects, characterSpawn, size, background, filename):
self.objects = objects
self.filename = filename
self.character = Character(characterSpawn) # TODO: use characterSpawn
self.objects.append(self.character)
self.camera = Camera(size * 24, background)
self.camera.moveToCenter(self.character.hitBox.center)
def main():
args = getArguments()
camera = None
if args.videofile:
camera = Camera.VideoCamera(args.videofile)
else:
camera = Camera.getCamera()
drone = Tracking.Drone()
cv2.namedWindow('frame')
def run():
while True:
frames = camera.getFrames()
if frames is None:
return
frame = cv2.resize(frames['color'], (0,0), fx=0.5, fy=0.5)
cv2.imshow('frame', frame)
key = cv2.waitKey(1)
if key == ord('q'):
break
del frame
gc.collect()
try:
run()
except Exception as e:
print e
finally:
camera.stop()
def process_inputs():
"""Manages the events and keyboard in the game, sending info to entities.
"""
# Managing events
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
for entity in Entity.collection:
entity.process_event(event)
Camera.process_event(event)
Editor.process_event(event)
# Managing keyboard and mouse.
keys_pressed = pygame.key.get_pressed()
for entity in Entity.collection:
entity.process_inputs(keys_pressed)
Camera.process_inputs(keys_pressed)
Editor.process_inputs(keys_pressed)
def __init__(self):
self.entities = []
self.platforms = []
self.players = []
self.particles = []
self.lag = 0
self.MS_PER_UPDATE = 16
os.environ["SDL_VIDEO_CENTERED"] = "1"
pygame.mixer.pre_init(44100, -16, 1, 512)
pygame.mixer.init()
pygame.init()
self.myfont = pygame.font.SysFont("monospace", 34, bold=True)
self.score = 0
pygame.display.set_caption("Simple Game")
self.screen = pygame.display.set_mode((1280, 720))
pygame.joystick.init()
self.joysticks = [pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())]
for stick in self.joysticks:
stick.init()
self.loadAssets()
player = Player(KeyBoardInput(), PhysicsComponent(self), PlayerGraphics(self.screen))
self.addEntity(player)
for player in self.players:
player.rect.center = self.start
self.camera = Camera(760, 800)
def new(self):
try:
self.mapPath = os.path.join("../assets/", "map1.tmx")
self.map = mapLoader(self.mapPath)
except:
self.mapPath = os.path.join("assets/", "map1.tmx")
self.map = mapLoader(self.mapPath)
self.mapImg = self.map.makeMap(self)
self.mapRect = self.mapImg.get_rect()
self.frontSprites = pygame.sprite.Group()
self.backSprites = pygame.sprite.Group()
self.walls = pygame.sprite.Group()
self.goals = pygame.sprite.Group()
self.positions = []
for i in self.map.tmdata.objects:
if i.name == 'wall':
Wall(self, i.x * TILESIZEMULTI, i.y * TILESIZEMULTI,
i.width * TILESIZEMULTI, i.height * TILESIZEMULTI)
elif i.name == 'goal':
self.positions.append((i.x, i.y))
elif i.name == 'player':
self.player = Player(self, i.x * TILESIZEMULTI,
i.y * TILESIZEMULTI, i.width, i.height)
self.camera = Camera(self.mapRect.width, self.mapRect.height)
def __init__(self, w, h, title):
self.cam = Camera(90.0, 800/600,1, 100000.0)
self.eye = [0.0, -2000.0, 3800.0]
self.target = [0.0, 0.0, 2500.0]
self.up = [0.0, 0.0, 1.0]
self.cam.setPos(self.eye, self.target)
self.timer = Timer()
self.gridMode = False
self.gridAngle = 0
self.gridAxis = [1,0,0]
self.graphics = Graphics()
self.lighting = Lighting()
self.scene = Scene()
self.background = Background()
self.obj_basic = OBJ('island_basic_1.obj', swapyz=True)
self.obj_snow = OBJ('island_basic_snow.obj', swapyz=True)
self.obj_rain = OBJ('island_basic_rain.obj', swapyz=True)
self.obj = self.obj_basic
glutInit(sys.argv)
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(w, h)
glutInitWindowPosition(800, 600)
glEnable(GL_DEPTH_TEST)
glShadeModel(GL_SMOOTH)
self.lighting.LightSet()
def __init__(self, width, height):
'''
Constructor
'''
self.__camera = Camera()
self.__width = width
self.__height = height
def update(screen):
"""Updates the game state one step.
"""
for entity in Entity.collection:
entity.update()
Camera.update()
Editor.update(screen.get_size())
def __init__(self, size, player, viewport):
self.size = size
self.center = size * .5
self.player = player
self.terrain\
= [[Terrain.Grass if y%2 is 0 else Pixel.Black for y in range(size.y)] for x in range(size.x)]
self.entities = [player]
self.camera = Camera(self.player.pos, viewport, self.center)
def __init__(self, objects, characterSpawn, size, background):
self.objects = objects
self.characterSpawn = characterSpawn * 24
self.character = Character(self.characterSpawn)
self.objects.append(self.character)
self.size = size * 24
self.camera = Camera(self.size, background)
self.camera.moveToCenter(self.character.hitBox.center)
self.gameOver = False
def __init__(self, color, depth=None, undistort=True):
self.id = id
self.time_stamp = time.time()
self.camera = Camera()
if undistort:
self.color = self.camera.undistort(color)
else:
self.color = color
self.depth = depth
self.keypoints, self.descriptors = detectORB(self.color)
def warm_up_camera():
camera = Camera()
i = 0
while i != 50:
img = camera.get_frame()
i += 1
del camera
return img
def create_camera(self):
r = -1 / 10
matrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, r],
[0, 0, 0, 1]])
camera = Camera((0, 0, 0), None, self.figure_list[self.cur_figure_ind],
matrix)
self.use_eraser()
camera.switch_to_camera_view(self.draw)
self.canvas.image = ImageTk.PhotoImage(self.image)
self.canvas.create_image(0, 0, image=self.canvas.image, anchor='nw')
class Engine:
def __init__(self, vertices, camera_position):
self.vertices = vertices
self.camera = Camera(camera_position)
self.version = "0.1"
def render(self):
self.camera.render(self.vertices)
def __str__(self):
return f"3D Rendering Engine by Nathcat, Version: {self.version}, Vertices: {self.vertices}, Camera: {self.camera}"
def Update_Key_Holds(self, KeyPressList):
if pygame.joystick.get_count() == 0:
Camera.Keyhold(KeyPressList)
else:
Camera.Keyhold(KeyPressList, self.JoysticksInput[0])
#Game.MainCamera.Keyhold(KeyPressList)
for i in self.Drones:
#print(f'{i} is being updated for Keyholds')
if i.__class__ != Drone.Drone:
return
elif (i.Control_Type == 2 or i.Control_Type == 1) and pygame.joystick.get_count() > 0:
i.Keyhold(KeyPressList, self.JoysticksInput[0])
else:
i.Keyhold(KeyPressList)
def __init__(self):
self.loading = LoadingScreen(self)
self.camera = Camera(self)
self.lighting = Lighting(self)
self.balltable = BallTable(self)
self.menu = Menu(self)
self.decision = Decision(self)
self.mousekey = MouseKey(self)
self.shotStrength = ShotStrength(self)
self.state = GameState.START
self.mode = GameMode.TUTORIAL
self.balls = [Ball(self)] * 16
self.ballinHole = [None] * 16
self.LastFrameTimePoint = 0
def __init__(self):
self.display_init()
self.running = True
self.clock = pygame.time.Clock()
self.skybox = Skybox('textures/skybox/minecraft','png')
self.camera = Camera()
#print(level.playerX,level.playerY,level.playerZ)
self.camera.setPosition((level.playerX,level.playerY,level.playerZ))
#self.camera.setPosition(cn.level.playerPos)
#self.camera.setPosition((0,70,0))
self.plane = glGenLists(1)
self.ID = 3
glNewList(self.plane,GL_COMPILE)
glPushMatrix()
glColor3ub(66,66,66)
tes = Tessellator.instance
tes.startDrawing(GL_LINES)
for i in range(-50,50):
tes.addVertex(-50, 0, i)
tes.addVertex(50, 0, i)
tes.addVertex(i, 0,-50)
tes.addVertex(i, 0, 50)
tes.draw()
glPopMatrix()
glEndList()
self.groundpos = None
self.cubepos = Vector3()
self.near = Vector3()
self.far = Vector3()
self.lasttime = time.time()
self.cloudTickCounter = 0
self.hit = None
main.CTextureManager.initialize("textures")
self.lastpos = Vector3(0,0,0)
self.gui = GUI()
self.gui.add(RandomRect())
def main():
this_camera = Camera()
this_camera.setZoom(1)
this_camera.setRotation(338)
this_camera.setCenter('N03742.179', 'E13555.237')
test_point = Point2D('N03742.183', 'E13555.235')
pixel_point = geodeticToPixel(test_point, this_camera)
print pixel_point
def start(self):
self.clock = pygame.time.Clock()
self.keep_going = 1
self.camera = Camera(screen, self.world_rect, self.player)
self.blank_scr("OMFG A WALL\nOF LAVA!\nRUN AWAY!")
while self.keep_going:
self.clock.tick(FRAME_RATE)
for event in pygame.event.get():
if event.type == QUIT:
exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.keep_going = 0
"""if event.key == K_z: # jump # handled in player class now
if not self.player.states.jumping in self.player.state_lst and not self.player.states.falling in self.player.state_lst:
self.player.state_lst.append(self.player.states.jumping)"""
if event.key == K_x: # attack
if not self.player.states.attacking in self.player.state_lst:
self.player.state_lst.append(self.player.states.attacking)
sounds['fire'].play()
if event.key == K_f:
print "FPS:", self.clock.get_fps()
if event.key == K_p:
self.blank_scr('PAUSED')
self.screen.fill(self.bg_col, (0, CEIL_Y, SCR_SIZE[0], SCR_SIZE[1] - 2*CEIL_Y))
self.camera.update()
self.camera.update_grps(*self.all)
self.check_some_collisions()
self.camera.draw_grps(*self.all)
if self.keep_going:
pygame.display.flip()
sounds['lava'].stop()
def __init__(self):
application = self
#global initialization
pyxel.init(255, 255, caption="Nearym Quest", scale=3)
self.debugOverlay = False
self.camera = Camera()
self.streamingArea = Box()
self.streamingArea.size = Vector2f(512, 512)
self.streamingArea.center = Vector2f(0, 0)
self.renderer = Renderer()
self.physics = Physics()
random.seed(0)
# Event Manager
self.inputManager = InputManager()
self.inputManager.addInput(
Input(InputType.BUTTON, InputNotify.PRESSED, [pyxel.KEY_F1],
'debug'))
# world and player
self.LoadMap()
self.draw_count = 0
# has to be completely at the end of init
pyxel.run(self.update, self.draw)
def handle_IMAGE(self, _args):
"""
:param _args:
:return: :raise TwistedPiException:
"""
log.msg('handle_image', logLevel=logging.DEBUG)
def imageSuccess(_image):
assert _image is not None, "Image is None"
log.msg('Image Size: {0} bytes'.format(_image.tell())
,logLevel = logging.DEBUG)
_image.seek(0)
return threads.deferToThread(EncodeData, _image.read())
def imageError(_err):
log.err(_err)
raise TwistedPiException("Error capturing Image",
ErrorCodes.SERVER_ERROR)
_args = Camera.validate_image_args(_args)
d = threads.deferToThread(Camera.take_image, _args)
d.addCallbacks(imageSuccess, imageError)
return d
def __init__(self, WINDOW_SIZE):
self.WINDOW_SIZE = Vector2(1366, 768)
self.isGameOver = False
self.playWithRFID = True
self.folderDir = os.path.split(os.getcwd())[0]
self.assetDir = self.folderDir + '/Assets/'
self.inputManager = InputManager()
if self.playWithRFID:
self.myRFIDReader = RFIDReader()
self.inputManager.setRFIDInput(self.myRFIDReader)
pygame.init()
self.clock = pygame.time.Clock()
self.display = pygame.display.set_mode((self.WINDOW_SIZE.getX(), self.WINDOW_SIZE.getY()), pygame.FULLSCREEN)
pygame.display.set_caption('What A Block')
self.loadAssets()
self.cam = Camera(offSet = Vector2(self.WINDOW_SIZE.getX()/2 , self.WINDOW_SIZE.getY()/2 - self.player.getHeight()/2), camSize = self.WINDOW_SIZE)
self.player_revealver = Revealer(IsoToScreen(self.player.getIsoPos(), self.mapCollection.getBlockSize().getX(), self.mapCollection.getBlockSize().getY()), 60)
pygame.mixer.music.play(-1)
def __init__(self, color, depth=None):
self.id = id
self.time_stamp = time.time()
self.color = color
self.depth = depth
self.camera = Camera()
self.keypoints, self.descriptors = detectORB(color)
def __init__( self, world_name="" ):
self._world = World()
segment = self._world.levels[ "2" ].segments[ "2.1" ]
segment_dims = segment.get_pixel_dims()
self._tilemap = segment.get_tiles()
self._entities = []
# TODO: Update this logic to more elegantly designate the entity that
# will be followed by the camera.
player_entity = None
for ( (idx_x, idx_y), entity_class ) in segment.get_entities():
entity_pos = ( TILE_DIMS[0] * idx_x, TILE_DIMS[1] * idx_y )
entity_delta = PhysicalState( CompositeHitbox(entity_pos[0], entity_pos[1]) )
entity = Entity( entity_class, entity_delta )
if entity_class == "player":
player_entity = entity
self._entities.append( entity )
self._camera = Camera( target=player_entity.get_hitbox().get_hitbox(),
new_border=PG.Rect(0, 0, segment_dims[0], segment_dims[1]) )
self._collision_detector = SpatialDictionary( segment_dims[0] / 16,
segment_dims[0], segment_dims[1] )
self._setup_collision_detector()
def main(sampleDirectory, scale, ite):
print ("Estimate Motion Between Sample And Original Image")
samples = loadSamples(sampleDirectory)
print("samples loaded")
#print ("Restore SR Image")
camera = Camera.Camera(cfg['psf'])
scale = scale
origSizeX = samples[0][1].size[1] * scale
origSizeY = samples[0][1].size[0] * scale
origImage = numpy.zeros([origSizeX, origSizeY, 3]).astype(numpy.float32)
print("Size Of Estimated Original: %dx%d" % (origSizeX, origSizeY))
for ((dx, dy), sample) in samples:
sampleOrigSize = sample.resize((origSizeX, origSizeY), Image.ANTIALIAS)
sampleAsArr = numpy.asarray(sampleOrigSize)
origImage = origImage / len(samples) # take average value
origImage = Image.fromarray(numpy.uint8(origImage))
# TODO move this to a separate class
for i in range(ite):
origImage, estimDiff = SRRestore(camera, origImage, samples, scale, i)
#estimDiff = 5
estimDiff /= float(origSizeX * origSizeY)
print ('%2d: estimation error: %3f' % (i, estimDiff))
origImage.save(os.path.join(sampleDirectory,'super_resolution.tif'))
def __init__(self):
# gpio.BOARD: using #pin / gpio.BCM: using #GPIO
gpio.setmode(gpio.BOARD)
# gpio.OUT: use this pin for OUTPUT / gpio.IN: use this pin for INPUT
# DC MOTOR(MDD10A)
gpio.setup(Car.__DIR1, gpio.OUT)
gpio.setup(Car.__PWM1, gpio.OUT)
# SERVO MOTOR(PWM)
gpio.setup(Car.__SERVO, gpio.OUT)
# for unwanted movement
gpio.output(Car.__DIR1, False)
# DC MOTOR
self.motor_power = 0
self.speed = 0
self.motor = gpio.PWM(Car.__PWM1, Car.__DC_FREQUENCY)
self.motor.start(0)
self.motor.ChangeDutyCycle(0)
# Servo MOTOR
self.servo_motor = gpio.PWM(Car.__SERVO, Car.__SERVO_FREQUENCY)
self.servo_motor.start(
2.5) # starting duty cycle (it set the servo to 0 degree)
self.servo_motor.ChangeDutyCycle(Car.__MIDDLE)
self.steer = 0
# Controller
self.controller = self.bind()
# Recorder
self.camera = cam.Camera()
self.recording = False
def __init__(self):
global k, pd, pid, comb_pid, max_pwm, max_theta, max_x, frequency, pwm_offset, arduino_port, display_camera_output, initialize_theta_set
#Cart variables
self.max_pwm = max_pwm
self.max_theta = max_theta
self.max_x = max_x
self.frequency = frequency
self.pwm_offset = pwm_offset
self.arduino_port = arduino_port
#Booleans
self.display_camera_output = display_camera_output
self.initialize_theta_set = initialize_theta_set
#Motor, Controller, and Camera Instance Definition
self.motors = Motors.Motors(max_pwm = self.max_pwm, frequency=self.frequency, arduino_port=self.arduino_port)
self.controller = Controller.Controller(max_theta = self.max_theta, max_x = self.max_x)
self.camera = Camera.Camera(self.display_camera_output)
#Controller Vectors
self.k = [-10.0000/1.5, -29.9836/1.5, 822.2578, 85.5362]
self.pd = pd
self.pid = pid
self.comb_pid = comb_pid
self.status = 1
def __init__(self, host, port):
threading.Thread.__init__(self)
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect((self.host, self.port))
self.camera = Camera.Camera()
def load_settings():
screen_size = (700, 550)
screen = pygame.display.set_mode(screen_size)
game_object = {
'player': [],
'tile': [],
'collider': [],
'bg': [],
'objective': []
}
var = {
'folder':
os.path.dirname(os.path.realpath(__file__)),
'total_maps':
len(
os.listdir(
os.path.dirname(os.path.realpath(__file__)) +
'/assets/img/map')),
'camera': [Camera(screen_size)]
}
game_object['bg'].append(
Sprite((0, 0), var['folder'] + '/assets/img/tile/bg.png'))
game_object['bg'][0].img = pygame.transform.scale(game_object['bg'][0].img,
screen_size)
return {
'screen_size': screen_size,
'screen': screen,
'game_object': game_object,
'var': var,
'layers': ['bg', 'tile', 'player', 'objective']
}
def run(self):
self.map.run()
self.enemy_list = []
# Make the enemy objects and add every enemy to the enemy_list.
# Every enemy takes a x and y coordinate as argument.
# (Spawn point)
# And the range it can walk on the x axis.
# The fish takes a third argument.
# You got two choices: 'Water' or 'Lava'.
# According to the fish you want.
self.enemy_list.append(Fish(580, 600, 110, 'Lava'))
self.enemy_list.append(Fish(2570, 600, 400, 'Lava'))
self.enemy_list.append(Slime(1736, 10))
# Add a collider for the enemies and the player.
# It takes the player, map group(tiles),
# an array with all the enemy objects, Reference to
# LevelStateManager
# as arguments.
self.collider = Collider(self.player, self.map.get_group(),
self.enemy_list, self.LevelStateManager)
# Create a camera for this level.
self.camera = Camera(self.shift_start, self.shift_end,
self.map, self.player, self.enemy_list)
# Create a timer for this level.
self.timer = Timer()
# Load the best time of level 2.
self.timer.load_best_time(2)
def __init__(self) -> None:
print('Initializing perception')
self.camera = Camera.Camera()
self.camera.camera_open()
# initialize frame variables
self.latest_raw_img = np.zeros((5, 5)) # blank 5x5 img
self.latest_display_img = np.zeros((5, 5))
# constants used for preception
self.color_range = {
'red': [(0, 151, 100), (255, 255, 255)],
'green': [(0, 0, 0), (255, 115, 255)],
'blue': [(0, 0, 0), (255, 255, 110)],
'black': [(0, 0, 0), (56, 255, 255)],
'white': [(193, 0, 0), (255, 250, 255)],
}
self.range_rgb = {
'red': (0, 0, 255),
'blue': (255, 0, 0),
'green': (0, 255, 0),
'black': (0, 0, 0),
'white': (255, 255, 255),
}
self.size = (640, 480)
self.window_name = "Arm View"
print('Finished initializing perception')
def __init__(self, cam_id=1):
self.gun = Gun.Gun()
self.camera = Camera.Camera(_id=cam_id,
crop_bounds=(200, 1080, 210, 1760),
scale_to_height=500)
self.camera.calibrate(
img_path='C:/Nadav/Repos/paper_dome/camera_calib/')
def __init__(self, music, host):
super(GameScene, self).__init__()
self.background = Surface((WINDOW_WIGTH, WINDOW_HEIGHT))
self.background.fill(Color(BACKGROUND_COLOR))
timer = pygame.time.Clock()
self.music = music
self.enemy = []
self.net=Net()
self.net.subscribe(self.sync)
self.host = host
mouse.set_pos([200, 300])
self.heroes = []
self.up = self.down = self.left = self.right = False
self.entitles_walls = pygame.sprite.Group()
self.entitles = pygame.sprite.Group()
self.addHero(Player(300, 55, 1))
self.walls = []
#map:
self.map = open("maps/testmap.txt", "r")
self.x = 0
self.y = 0
self.lenx = 0
self.leny = 0
for self.row in self.map:
for self.col in self.row:
if self.col == "-":
self.wall = wall(self.x, self.y)
self.entitles_walls.add(self.wall)
self.walls.append(self.wall)
if self.col == " ":
self.floor = floor1(self.x, self.y)
self.entitles_walls.add(self.floor)
self.x = self.x + BLOCK_X
self.y = self.y + BLOCK_Y
self.lenx = self.x / BLOCK_X
self.leny += 1
self.x = 0
for i in self.heroes:
self.entitles.add(i)
total_level_width = self.lenx*WINDOW_WIGTH
total_level_height = self.leny*WINDOW_HEIGHT
self.camera = Camera(camera_configure, total_level_width, total_level_height)
self.enemy = []
if self.host:
self.enemy = [Enemy(100, 100, 1), Enemy(200, 200, 2), Enemy(100, 500, 3)]
for i in self.enemy:
self.entitles.add(i)
self.bul = []
self.bul.append(Bullet(0,0))
if self.music == True:
pygame.mixer.music.load("music/Game.mp3")
pygame.mixer.music.play(-1)
def __init__(self, size, player, viewport):
self.size = size
self.center = size*.5
self.player = player
self.terrain\
= [[Terrain.Grass if y%2 is 0 else Pixel.Black for y in range(size.y)] for x in range(size.x)]
self.entities = [player]
self.camera = Camera(self.player.pos, viewport, self.center)
class Controller:
def __init__(self,model):
#instance of DataModel
self.__model = model
print "initController"
self.bootSystem()
#使用インスタンスを作成
#Viewを先に構築するため__init__と分離
#各インスタンスの作成
#cameraControl
def bootSystem(self):
#opencv,カメラの設定
self.__camera = Camera()
def getCameraPict(self):
print "next"
cameraPil = self.__camera.getPicturePILImage()
return cameraPil
def getCameraCVPict(self):
self.__cameraPict = self.__camera.getPicture()
#水平取得
#単位はdegree
def getHorizon(self):
try:
self.getCameraCVPict()
self.convertGray()
horizon = Horizon(self.__grayCameraPict)
horizon.detectHorizon()
degree = horizon.getHorizon()
print "degree:"+str(degree)
return degree
except:
sys.exit(sys.exc_info()[:2])
#画像変換
def convertGray(self):
cv.Smooth(self.__cameraPict,self.__cameraPict,cv.CV_GAUSSIAN,13,0,0,0)
grayCameraImage = cv.CreateImage((self.__cameraPict.width,self.__cameraPict.height),cv.IPL_DEPTH_8U,1)
cv.CvtColor(self.__cameraPict,grayCameraImage,cv.CV_BGR2GRAY)
cv.EqualizeHist(grayCameraImage,grayCameraImage)
self.__grayCameraPict = grayCameraImage
def draw(self, screen):
if self.graph:
screen_x, screen_y, screen_size = (
Camera.screen_coords_and_size(screen, self.pos)
)
transformed = pygame.transform.rotozoom(
self.graph,
-rad2deg(self.angle),
screen_size)
screen.blit(transformed, (screen_x, screen_y))
def __init__(self, screen):
self.deaths = 0
self.screen = screen
self.level = Level('reallevel')
self.spawn()
self.game_area = screen.subsurface((0, 40, screen.get_width(), screen.get_height() - 40))
self.cam = Camera(self.player, self.level.bounds, self.game_area.get_size())
self.hud = screen.subsurface((0, 0, screen.get_width(), 40))
self.deathtext = pygame.font.Font(None, 20)
def __init__(self): self.loading = LoadingScreen(self) self.camera = Camera(self) self.lighting = Lighting(self) self.balltable = BallTable(self) self.menu = Menu(self) self.decision = Decision(self) self.mousekey = MouseKey(self) self.shotStrength = ShotStrength(self) self.state = GameState.START self.mode = GameMode.TUTORIAL self.balls = [ Ball(self) ]*16 self.ballinHole = [ None ] * 16 self.LastFrameTimePoint = 0
def __init__(self,parent):
tk.Tk.__init__(self,parent)
self.parent = parent
#self.key = os.urandom(32)
self.key = b"G\x82=\xd7\xdf\xc1\\\xd3\xd8\x85\x86\x19\x9a5\x90\x98u%w\xfa\xbe\x1dI\xddL\x01G\x9c\xbd\x8e\x8d\xd4"
self.key2 = b"\x0et\xf1\xfc\xf8'\xd5$M\xb2u\xb0\xc2\x87\xc1\xa4"
self.key128 = b"\xf8\xcd<@\xd0+w-\xde\x9bq/-_P\x12\x01\xcf\xe4\xd3\x8e\x01\xcc\x07\x1bD\xa6\x85\xa0\x97q\x13\x96\x8e\xc1}\xeb\x1f\x87\x14\x05\xc0M\x95t\xc6&\x12Q\x0c\x91\x98\x8cn\x0bV&\x1a\x7f#\xf5e\x18^\x96$z\xa0\x8f\xfc\xeb\xfes\xcf\xb7s\x8d\xf0\xb5\xc9r\xdc`\xcfjPg_\xc5\xa9\xd1It\x0f\nR\xa1\xf6!K+\xaf\xac\xdc\xae\xf1\x1cs\xa61f\x01\xf7\xeew\x93\xe69\x96\x8b\xd6\xb8Y\x1c\xf0h\x9e?"
#print(os.urandom(128))
self.initializeVariables()
self.initializeTkElements()
self.Camera = Camera.init()
with open(self.fileLogs, "w") as fl:
fl.write("Cryptographic Embedded System - Log\n")
def __init__(self):
siren.State.__init__(self)
self.ignoreMouseMove = True
self.fps = 0.0
self.numFrames = 0
self.frameTime = 0.0
# Initialize the input controls
self.initInput()
self.camera = Camera()
# Create the player
self.player = Player('Ben', 'John')
self.player.pos = gmtl.Point3f(0, 0, -5)
rot = gmtl.Quatf()
# gmtl.set(rot, gmtl.AxisAnglef(gmtl.deg2Rad(180), 0,1,0))
self.player.rot = rot
# Big hack to get player rotation control to work
self.vel_change = gmtl.Vec3f()
self.npcs = []
for i in range(4):
av = siren.Avatar.create('John')
av.setWCS(gmtl.EulerAngleXYZf(gmtl.deg2Rad(-90.0), 0, 0))
av.setPos(gmtl.Vec3f(4.0*i, 0, -10))
av.triggerAnimationCycle('DANCE')
self.npcs.append(av)
self.curAnim = 0
self.anims = ['WALK',
'RUN',
'DANCE',
'IDLE',
'TYPE',
'SIT',
'WORK1',
'WORK2']
# Create the texture to hold the motion blur
self.blurTexture = siren.Texture(512, 512, 3, GL_RGB)
# Inite the GL state
glEnable(GL_DEPTH_TEST)
glEnable(GL_TEXTURE_2D)
glClearColor(0,0,0,1)
class Game(object):
def __init__(self, screen):
self.deaths = 0
self.screen = screen
self.level = Level('reallevel')
self.spawn()
self.game_area = screen.subsurface((0, 40, screen.get_width(), screen.get_height() - 40))
self.cam = Camera(self.player, self.level.bounds, self.game_area.get_size())
self.hud = screen.subsurface((0, 0, screen.get_width(), 40))
self.deathtext = pygame.font.Font(None, 20)
def spawn(self):
self.player = Player((self.level.spawnPoint), self.level, self)
def quit(self):
self.done = True
def loop(self):
self.done = False
self.clock = pygame.time.Clock()
while not self.done:
dt = self.clock.tick(30)
#input
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
self.quit()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
self.player.jump()
#update
self.player.update(dt)
self.cam.update(self.player.rect)
#draw
self.hud.fill((80, 80, 80))
text = self.deathtext.render("deaths: " + str(self.deaths), True, (0, 255, 0))
self.hud.blit(text, (0, 0))
self.game_area.fill((0,0,0))
self.cam.draw_background(self.game_area, self.level.background)
self.cam.draw_sprite(self.game_area, self.player)
#refresh
pygame.display.flip()
def run(self):
self.map.run()
# Make the enemy objects and add every enemy to the enemy_list.
# Every enemy takes a x and y coordinate as argument.
# (Spawn point)
# And the range it can walk on the x axis.
# The fish takes a third argument.
# You got two choices: 'Water' or 'Lava'.
# According to the fish you want.
self.enemy_list.append(Fly(500, 600, 100))
self.enemy_list.append(Fly(1500, 100, 100))
self.enemy_list.append(Tank(2600, 50, 380))
self.enemy_list.append(Fish(1000, 700, 200, 'Water'))
# Add a collider for the enemies and the player.
# It takes the player, map group(tiles),
# an array with all the enemy objects, Reference to
# LevelStateManager
# as arguments.
self.collider = Collider(self.player, self.map.get_group(),
self.enemy_list, self.LevelStateManager)
# Load the background music.
# The pygame.mixer.music.load
# method takes the file location as an argument.
# It has to be .wav or .mp3.
self.level_background_music = \
pygame.mixer.music.load('../Data/Music/Level4_2.mp3')
# Play the background music.
# This is only necessary in level1,
# because we don't stop the music when creating level2.
pygame.mixer.music.play()
# Create a camera for this level.
self.camera = Camera(self.shift_start, self.shift_end,
self.map, self.player, self.enemy_list)
# Create a timer for this level.
self.timer = Timer()
# Load the best time of level 1.
self.timer.load_best_time(1)
class World(object):
"""The world class which stores entities and value data."""
def __init__(self, size, player, viewport):
self.size = size
self.center = size*.5
self.player = player
self.terrain\
= [[Terrain.Grass if y%2 is 0 else Pixel.Black for y in range(size.y)] for x in range(size.x)]
self.entities = [player]
self.camera = Camera(self.player.pos, viewport, self.center)
def input(self, input):
#this takes in the input from self.request.get('input')
self.player.handleInput(self, input)
pass
def update(self):
for ent in self.entities:
ent.update(self)
pass
def render(self):
buffer = copy.deepcopy(self.terrain) #COMPOSED OF PIXELS
#PLACE ENTITIES
for ent in world.entities:
pos = self.buffercoord(ent.pos)
if(not ((pos.x < 0 or pos.x > self.size.x)
or (pos.y < 0 or pos.y > self.size.y))):
buffer[pos.x][pos.y] = ent
return self.camera.render(buffer, self)
def buffercoord(self, vect):
floatVect = vect + self.size*.5
return Vector(int(floatVect.x), int(floatVect.y))
def worldcoord(self, vect):
return vect - self.size*.5
def __init__(self):
self.display_init()
self.running = True
self.clock = pygame.time.Clock()
self.skybox = Skybox('textures/skybox/minecraft','png')
self.camera = Camera()
self.camera.setPosition((level.playerX,level.playerY,level.playerZ))
#self.camera.setPosition(cn.level.playerPos)
#self.camera.setPosition((0,20,0))
self.plane = glGenLists(1)
self.ID = 3
glNewList(self.plane,GL_COMPILE)
glPushMatrix()
glColor3ub(66,66,66)
tes = Tessellator.instance
tes.startDrawing(GL_LINES)
for i in range(-50,50):
tes.addVertex(-50, 0, i)
tes.addVertex(50, 0, i)
tes.addVertex(i, 0,-50)
tes.addVertex(i, 0, 50)
tes.draw()
glPopMatrix()
glEndList()
self.groundpos = None
self.cubepos = Vector3()
self.near = Vector3()
self.far = Vector3()
self.lasttime = time.time()
self.cloudTickCounter = 0
self.hit = None
def __init__(self):
"""constructor"""
# mission relevant attributes
# TODO: move these to target class
# self._latitude = "uncalculated"
# self._longitude = "uncalculated"
# self._shape = "unknown"
# self._alpha = "unknown"
# self._alphacolor = "unknown"
# self._color = "unknown"
# self._orientation = "unknown"
# "intermediate" attributes
self._gps_x = 0.0
self._gps_y = 0.0
self._pan = 0.0
self._tilt = 0.0
self._yaw = 0.0
self._pitch = 0.0
self._roll = 0.0
self._plane_orientation = 0.0
self._altitude = 0.0
self._pan = 0.0
# representation of camera used to take picture
self.bloggie = Camera()
self.bloggie.set_params(fc1=3224.35414, fc2=3202.87322, cc1=1396.72711, cc2=975.48995, alpha_c=0.0)
# various crops of pictures
# we want to start with index 1, so we put an dud in crop_list[0]
self.crop_list = [0]
# resolution fields
self.x_thumbnail_resolution = 800
self.y_thumbnail_resolution = 600
self.x_resolution = 2400
self.y_resolution = 1800
ri.TransformBegin()
ri.AttributeBegin()
ri.Color([1,1,1])
ri.Translate( 0,-1.0,0)
ri.Rotate(-90,1,0,0)
ri.Rotate(36,0,0,1)
ri.Scale(0.4,0.4,0.4)
ri.Surface("plastic")
ri.Geometry("teapot")
ri.AttributeEnd()
ri.TransformEnd()
ri = prman.Ri() # create an instance of the RenderMan interface
cam=Camera(Vector(4,0.2,4,1),Vector(0,0,0,1),Vector(0,1,0,0))
cam.fov=40
filename = "Camera.rib"
ri.Begin(filename)
ri.Declare("Light1" ,"string")
ri.Declare("Light2" ,"string")
ri.Declare("Light3" ,"string")
# now we add the display element using the usual elements
# FILENAME DISPLAY Type Output format
ri.Display("Camera.exr", "framebuffer", "rgba")
cam.Format(ri)
def __init__(self):
self.player = PlayerClass.Player()
self.mainCamera = Camera.camera()
self.mainCamera.setCamera(self.player)
self.MapRenderer = MapRender.mapRender(40,800,600)
self.MapRenderer.changeLevel(Level1)
timeOfLastSound = time.time()
#Show the banner, if we're supposed to
if showBanner:
cv2.rectangle(frame, (0,0), (320, 30), (0,0,255), -1)
cv2.putText(frame, "Movement Detected", (0,25), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)
#Activate/Deactivate the banner every 0.5 seconds
if time.time() - timeOfLastFlash > 0.5: #"""map(differenceScore, warningThreshold, warningThreshold * 2, 2, 1)"""
showBanner = not showBanner
timeOfLastFlash = time.time()
return frame
getResetBG() #Setup the background subtractor
#Some test code, only to be run when this isn't being used as a library
if __name__ == "__main__":
while True:
#ret, frame = cap.read()
frame = Camera.getIMG()
fgmask = fgbg.apply(frame)
#res = cv2.bitwise_and(frame, frame, mask = fgmask)
res = processDifference(frame)
cv2.imshow('img', res)
if cv2.waitKey(20) == 27:
break
cv2.destroyAllWindows()
class Game(object):
def __init__(self):
self.display_init()
self.running = True
self.clock = pygame.time.Clock()
self.skybox = Skybox('textures/skybox/minecraft','png')
self.camera = Camera()
self.camera.setPosition((level.playerX,level.playerY,level.playerZ))
#self.camera.setPosition(cn.level.playerPos)
#self.camera.setPosition((0,20,0))
self.plane = glGenLists(1)
self.ID = 3
glNewList(self.plane,GL_COMPILE)
glPushMatrix()
glColor3ub(66,66,66)
tes = Tessellator.instance
tes.startDrawing(GL_LINES)
for i in range(-50,50):
tes.addVertex(-50, 0, i)
tes.addVertex(50, 0, i)
tes.addVertex(i, 0,-50)
tes.addVertex(i, 0, 50)
tes.draw()
glPopMatrix()
glEndList()
self.groundpos = None
self.cubepos = Vector3()
self.near = Vector3()
self.far = Vector3()
self.lasttime = time.time()
self.cloudTickCounter = 0
self.hit = None
def run(self):
while self.running:
delta = time.time()-self.lasttime
self.lasttime += delta
world.timeChange(delta*10)
self.event_handler(pygame.event.get())
self.key_handler(pygame.key.get_pressed())
self.mouse_handler(pygame.mouse.get_pressed())
self.renderScene(delta)
self.timer()
pygame.display.flip()
pygame.quit()
def display_init(self):
#self.screen = pygame.display.set_mode(SCREEN_SIZE,SCREEN_FLAG)
glClearColor(*BLACK)
glClearDepth(1)
w = SCREEN_SIZE[0]
h = SCREEN_SIZE[1]
aspectRatio= w/h
glViewport(0,0,w,h)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(35.0, w/h, 0.5 , 10000.0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
pygame.mouse.set_visible(True)
pygame.mouse.set_pos((w//2,h//2))
glEnable(GL_LIGHTING)
glLightfv(GL_LIGHT1, GL_AMBIENT,(0,0,0,1,0 ))
glLightfv(GL_LIGHT1, GL_DIFFUSE, (0.95,0.95,0.95,1.0))
glLightfv(GL_LIGHT1, GL_SPECULAR, (0.95,0.95,0.95,1.0))
glLightfv(GL_LIGHT1, GL_POSITION, (128, 128.0 , 2.0, 1.0 ))
glEnable(GL_LIGHT1)
#glEnable(GL_FOG)
glFogfv(GL_FOG_COLOR, (GLfloat * 4)(0.5, 0.69, 1.0, 1))
glHint(GL_FOG_HINT, GL_DONT_CARE)
glFogi(GL_FOG_MODE, GL_LINEAR)
glFogf(GL_FOG_DENSITY, 0.35)
glFogf(GL_FOG_START, 20.0)
glFogf(GL_FOG_END, 60.0)
print(glGetString(GL_VERSION))
glFrontFace(GL_CW)
glEnable(GL_ALPHA_TEST)
glEnable (GL_DEPTH_TEST)
glMaterialfv(GL_FRONT, GL_SPECULAR, (0.1,0.1,0.1, 1.0));
glMaterialfv(GL_FRONT, GL_SHININESS, (10.0));
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
def renderScene(self,delta):
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
self.camera.setPerspective()
playerPos = self.camera.position.copy()
playerPos.z = -playerPos.z
near,far = self.camera.getMouseRay(*pygame.mouse.get_pos())
direction = far-near
direction.normalise()
position = Vector3(self.camera.position)
position.z = -position.z
self.groundpos = None
self.hit = world.getRayHit(position,direction)
if self.hit:
self.groundpos = Vector3(self.hit[:3])
self.delPos = Vector3(self.hit[3:6])
# Instance of Tessellator
tes = Tessellator.instance
glPushMatrix()
# Render Sky
self.skybox.render()
glDisable(GL_FOG)
# Render Sun
glPushMatrix()
glTranslatef(playerPos.x,playerPos.y,playerPos.z)
glRotatef(-90.0, 1.0, 0.0, 0.0)
glRotatef(7.5*world.worldHour,1.0,0.0,0.0)
sunp = 30.0
glColor4f(1.0, 1.0, 1.0, 1.0)
glEnable(GL_TEXTURE_2D)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE)
glBindTexture(GL_TEXTURE_2D,TextureManager.get("sun").texture)
tes.startDrawingQuads()
tes.addVertexWithUV(-sunp, 300.0, -sunp, 0.0, 0.0)
tes.addVertexWithUV(sunp, 300.0, -sunp, 1.0, 0.0)
tes.addVertexWithUV(sunp, 300.0, sunp, 1.0, 1.0)
tes.addVertexWithUV(-sunp, 300.0, sunp, 0.0, 1.0)
tes.draw()
glDisable(GL_BLEND)
glPopMatrix()
# Render Clouds
glPushMatrix()
glDisable(GL_CULL_FACE)
glTranslatef(playerPos.x,playerPos.y,playerPos.z)
predictY = self.camera.position.y
spacing = 32
amount = int(256 / spacing)
glBindTexture(GL_TEXTURE_2D,TextureManager.get("clouds").texture)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
red = 1.0
green = 1.0
blue = 1.0
small = 4.8828125e-4
cloudTick = (self.cloudTickCounter + delta)*500
self.cloudTickCounter+= delta
predictX = self.camera.position.x + cloudTick * 0.029999999329447746
predictZ = -self.camera.position.z
tx = floor(predictX/2048)
tz = floor(predictZ/2048)
predictX -= (tx * 2048)
predictZ -= (tz * 2048)
#y = 128 - predictY + 0.33
y = 128
cloudX = (predictX * small)
cloudZ = (predictZ * small)
tes.startDrawingQuads()
#spacing*=2
#amount=int(amount*1)
for ix in range(-spacing*amount,spacing*amount,spacing):
for iz in range(-spacing*amount,spacing*amount,spacing):
tes.addColor(red, green, blue, 0.8)
tes.addVertexWithUV((ix + 0), y, (iz + spacing), ((ix + 0) * small + cloudX), ((iz + spacing) * small + cloudZ))
tes.addColor(red, green, blue, 0.8)
tes.addVertexWithUV((ix + spacing), y, (iz + spacing), ((ix + spacing) * small + cloudX), ((iz + spacing) * small + cloudZ))
tes.addColor(red, green, blue, 0.8)
tes.addVertexWithUV((ix + spacing), y, (iz + 0), ((ix + spacing) * small + cloudX), ((iz + 0) * small + cloudZ))
tes.addColor(red, green, blue, 0.8)
tes.addVertexWithUV((ix + 0), y, (iz + 0), ((ix + 0) * small + cloudX), ((iz + 0) * small + cloudZ))
tes.draw()
glColor4f(1.0, 1.0, 1.0, 1.0)
glDisable(GL_BLEND)
#glEnable(GL_CULL_FACE)
glPopMatrix()
#glEnable(GL_FOG)
# Render Plane
#glCallList(self.plane)
#test.CUBE()
# Render World
#render.render(*floatToInt(*playerPos.toList()))
world.render(playerPos)
glPushMatrix()
if self.groundpos:
glTranslatef(*floatToInt(*self.groundpos.toList()))
glCallList(selectBlock)
glPopMatrix()
self.drawText()
glPopMatrix()
def timer(self):
self.clock.tick()
def key_handler(self,keys):
self.camera.strafe = self.camera.forward = self.camera.up= 0
vel = 0.3
if pygame.key.get_pressed()[pygame.K_z]:
vel = 10
if keys[ord('a')]:
self.camera.MoveX(-vel)
if keys[ord('d')]:
self.camera.MoveX(vel)
if keys[ord('w')]:
self.camera.MoveZ(vel)
if keys[ord('s')]:
self.camera.MoveZ(-vel)
if keys[ord('q')]:
self.camera.Roll(-vel)
if keys[ord('e')]:
self.camera.Roll(vel)
if keys[K_UP]:
self.camera.Pitch(-vel)
if keys[K_DOWN]:
self.camera.Pitch(vel)
if keys[K_LEFT]:
self.camera.Yaw(-vel)
if keys[K_RIGHT]:
self.camera.Yaw(vel)
if keys[ord('r')]:
self.camera.reset()
if keys[K_SPACE]:
self.camera.MoveY(vel)
if keys[K_LSHIFT]:
self.camera.MoveY(-vel)
def mouse_handler(self,mouse):
pass
def event_handler(self,events):
for event in events:
if event.type == QUIT:
self.running = False
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.running = False
elif event.key == K_RETURN:
try:
print("return:",eval(input("Enter Command:\n")))
except:
print("Command failed")
else:
print("Command excuted")
elif event.key == K_1:
self.ID = 1
elif event.key == K_2:
self.ID = 2
elif event.key == K_3:
self.ID = 3
elif event.key == K_4:
self.ID = 4
elif event.key == K_5:
self.ID = 5
elif event.key == K_6:
self.ID = 6
elif event.key == K_7:
self.ID = 7
elif event.key == K_8:
self.ID = 8
elif event.type == MOUSEBUTTONDOWN:
if not self.hit: continue
#face = self.hit[3]
#newPos = self.groundpos+ Vector3(DELTA[face])
#self.groundpos = position + direction*t
newPos = self.groundpos
if self.hit and newPos:
if event.button == 3:
world.setBlock(newPos.x,newPos.y,newPos.z,self.ID)
elif event.button == 1:
world.setBlock(self.delPos.x,self.delPos.y,self.delPos.z,0)
elif event.type == MOUSEMOTION:
x,y =pygame.mouse.get_pos()
self.camera.Yaw(0.15*(x-SCREEN_SIZE[0]//2))
self.camera.Pitch(0.15*(y-SCREEN_SIZE[1]//2))
pygame.mouse.set_pos((SCREEN_SIZE[0]//2,SCREEN_SIZE[1]//2))
def drawText(self):
fpssf = font.render("FPS: %d"%self.clock.get_fps(),True,(255,255,0))
fpstex = createTexture(fpssf)
renderTexture(fpstex[0],(0,0),(fpstex[1],fpstex[2]))
#deleteTexture(fpstex)
xyz = font.render("X: %f Y: %f Z: %f"%(self.camera.position.x,
self.camera.position.y,-self.camera.position.z),True,(255,255,0))
xyztex = createTexture(xyz)
renderTexture(xyztex[0],(0,SCREEN_SIZE[1]-xyztex[2]),(xyztex[1],xyztex[2]))
def GetPlayerCamera():
return Camera._ExistingCamera(_client.Camera)
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(pointer)
glDrawElementsui(GL_QUADS, [0,1,2,3])
#a = PygameWindow()
#a.start_main_loop()
n = Node(10)
n.set_mesh(TestCubeMesh())
n.set_scale(vector([5,5,5,1]))
n.set_rotation(vector([0,0,90,1]))
d = OpenGLDriver()
d.start_video()
eye_pos = vector([10.0,0.0,-10.0,1.0])
c = Camera()
c.set_eye(eye_pos)
c.set_reference(vector([0,0,0,1]))
alpha = 0.1
from PIL import Image
img = Image.open('./ball_8.jpg') # .jpg, .bmp, etc. also work
img_data = array(list(img.getdata()), int8)
texture = glGenTextures(1)
glPixelStorei(GL_UNPACK_ALIGNMENT,1)
glBindTexture(GL_TEXTURE_2D, texture)
glEnable(GL_TEXTURE_2D)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
class Game:
def __init__(self, screen):
self.screen = screen
self.map_rows = len(map)
self.map_cols = len(map[0])
self.world_rect = pygame.Rect(0, 0, TILE_SIZE*(self.map_cols+1), SCR_SIZE[1])
self.bg_col = (0x69, 0x50, 0x36)
self.lives = 4 # should be in player class but whatever
self.big_font = pygame.font.Font(join('data', 'cour.ttf'), 72)
self.font = pygame.font.Font(join('data', 'cour.ttf'), 30)
self.load_grps()
self.load_data()
def load_grps(self):
self.static_sprites = SPRITE_GRP()
self.wall_sprites = SPRITE_GRP()
self.player_sprites = SPRITE_GRP()
self.block_sprites = SPRITE_GRP()
self.all = self.block_sprites, self.player_sprites, self.wall_sprites,\
self.static_sprites
def load_data(self):
# Static stuff first
self.ceil = Ceil()
self.ceil.player_lives = self.lives
self.ground = Ground()
self.static_sprites.add(self.ceil, self.ground)
# Wall stuff
self.wall = Wall()
self.wall_sprites.add(self.wall)
# Player stuff
self.player = Player()
self.player_sprites.add(self.player, self.player.bullet)
self.player.add_collision_grps(*self.all)
# Block stuff
self.map_var = 1
self.render_blocks(0, self.map_cols/4)
def render_blocks(self, start, end):
for y in xrange(self.map_rows):
for x in xrange(start, end):
xx, yy = TILE_SIZE * x, TILE_SIZE * y + CEIL_Y
cell = map[y][x]
pos = xx, yy
if cell == '.': continue
elif cell == '#':
self.block_sprites.add(Block(pos=pos, unbreakable=1))
elif cell == '0':
self.block_sprites.add(Block(pos=pos, reflect=1))
elif cell == '*':
self.block_sprites.add(Block(pos=pos))
elif cell == '^':
self.block_sprites.add(Spike(pos=pos))
elif cell == '@':
r = Rock(pos=pos)
r.player = self.player
r.ground = self.ground
self.block_sprites.add(r)
def start(self):
self.clock = pygame.time.Clock()
self.keep_going = 1
self.camera = Camera(screen, self.world_rect, self.player)
self.blank_scr("OMFG A WALL\nOF LAVA!\nRUN AWAY!")
while self.keep_going:
self.clock.tick(FRAME_RATE)
for event in pygame.event.get():
if event.type == QUIT:
exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.keep_going = 0
"""if event.key == K_z: # jump # handled in player class now
if not self.player.states.jumping in self.player.state_lst and not self.player.states.falling in self.player.state_lst:
self.player.state_lst.append(self.player.states.jumping)"""
if event.key == K_x: # attack
if not self.player.states.attacking in self.player.state_lst:
self.player.state_lst.append(self.player.states.attacking)
sounds['fire'].play()
if event.key == K_f:
print "FPS:", self.clock.get_fps()
if event.key == K_p:
self.blank_scr('PAUSED')
self.screen.fill(self.bg_col, (0, CEIL_Y, SCR_SIZE[0], SCR_SIZE[1] - 2*CEIL_Y))
self.camera.update()
self.camera.update_grps(*self.all)
self.check_some_collisions()
self.camera.draw_grps(*self.all)
if self.keep_going:
pygame.display.flip()
sounds['lava'].stop()
def check_some_collisions(self):
# like player with edges of world
if self.player.rect.left < 0: self.player.rect.left = 0
if self.player.rect.right > self.world_rect.right: self.player.rect.right = self.world_rect.right
# and bullets against blocks
for sprite in self.player_sprites.sprites():
if 'Bullet' in str(sprite):
for block in self.block_sprites.sprites():
if abs(sprite.rect.centerx - block.rect.centerx) >= sprite.max_distance:
continue
if block.rect.collidepoint(sprite.rect.center):
if 'Block' in str(block):
if block.reflect: sprite.dir *= -1
elif block.unbreakable: sprite.done = 1; break
else: sprite.done = 1; self.block_sprites.remove(block); break
else:
sprite.done = 1; break
# and if player is dead
# and to revive the player if the death animation is done
if self.player.dead:
if self.player in self.player_sprites:
self.lives -= 1
self.ceil.player_lives = self.lives
self.wall.old_speed = self.wall.speed
self.wall.speed = 0
self.death_animation()
else:
for ball in self.player_sprites.sprites():
if ball.done and 'DeathBall' in str(ball):
self.player_sprites.empty()
self.player_sprites.add(self.player, self.player.bullet)
self.player.dead = 0
self.player.rect.top = CEIL_Y
self.player.rect.left += TILE_SIZE/2
self.wall.speed = self.wall.old_speed
self.player.state_lst = [self.player.states.standing]
if self.lives <= 0:
self.blank_scr('GAME OVER')
break
# and to remove any blocks the wall hits (speeds up game over time!)
for block in self.block_sprites.sprites():
if block.rect.right - self.wall.rect.right < 0:
self.block_sprites.remove(block)
# and to render more blocks
f = 1.0 * self.player.rect.right / self.world_rect.right
if abs(f - 1./4) <= .1 and self.map_var == 1:
self.map_var += 1
self.kill_some_blocks()
self.render_blocks(self.map_cols/4, 2*self.map_cols/4)
elif abs(f - 2/4.) <= .1 and self.map_var == 2:
self.map_var += 1
self.kill_some_blocks()
self.render_blocks(2*self.map_cols/4, 3*self.map_cols/4)
elif abs(f - 3/4.) <= .1 and self.map_var == 3:
self.map_var += 1
self.kill_some_blocks()
self.render_blocks(3*self.map_cols/4, 4*self.map_cols/4)
# and to check victory
if self.world_rect.right - self.player.rect.right < TILE_SIZE: # win!
if self.lives == 4: txt = 'WOW!\nCongratumalations!\nYou beat it\nwith all lives!'
elif self.lives == 3: txt = 'Congratumalations!\nYou only died\nonce!'
elif self.lives == 2: txt = 'No shame in\nthis win!'
elif self.lives == 1: txt = 'Phew...\nBarely won.'
self.keep_going = 0
self.blank_scr(txt)
def kill_some_blocks(self):
for block in self.block_sprites.sprites():
if self.player.rect.right - block.rect.right > SCR_SIZE[0]/2 + TILE_SIZE:
self.block_sprites.remove(block)
def death_animation(self):
sounds['death'].play()
self.player_sprites.remove(self.player)
for i in xrange(8):
ball = DeathBall(i)
ball.rect.center = self.player.rect.center
self.player_sprites.add(ball)
def blank_scr(self, txt):
sounds['lava'].stop()
if txt == 'GAME OVER': self.keep_going = 0
self.screen.fill((0,0,0))
texts = txt.split('\n')
lines = len(texts)
for i in xrange(lines):
draw_text(self.screen, texts[i], self.big_font, (SCR_SIZE[0]/2, 3*SCR_SIZE[1]/5 - 72*(lines - i)), (255,255,255), 1)
draw_text(self.screen, 'Press any key to continue', self.font, (SCR_SIZE[0]/2, 4*SCR_SIZE[1]/5), (255,255,255), 1)
while 1:
self.clock.tick(10)
for event in pygame.event.get():
if event.type == QUIT:
exit()
if event.type == KEYDOWN:
if self.keep_going: sounds['lava'].play(-1)
return
pygame.display.flip()
