def __init__(self):
self.deck = Deck()
self.pyramid = Pyramid()
for i in range(28):
self.pyramid.deck_pyramid.append(self.deck.__next__())
for card in self.pyramid.deck_pyramid:
print(card)
print("-----------")
class World:
tiles = defaultdict(lambda: None)
orders = set()
resources = set()
base = Pyramid(9, 9)
workers = []
def load(self, filename, world):
for y, line in enumerate(open(filename, 'r')):
for x, column in enumerate(line):
if column not in TileType.__dict__:
continue
t = Tile(getattr(TileType, column), world, x=x, y=y)
self.tiles[(x, y)] = t
def neighbors_los(self, p):
potential_points = [
(p[0] + 1, p[1]),
(p[0], p[1] + 1),
(p[0] - 1, p[1]),
(p[0], p[1] - 1),
(p[0] + 1, p[1] + 1),
(p[0] - 1, p[1] + 1),
(p[0] - 1, p[1] - 1),
(p[0] + 1, p[1] - 1),
]
points = []
for p in potential_points:
tile = self.tiles[p]
if not tile:
continue
points.append(p)
return points
def neighbors(self, p):
potential_points = [
(p[0] + 1, p[1]),
(p[0], p[1] + 1),
(p[0] - 1, p[1]),
(p[0], p[1] - 1),
]
points = []
for p2 in potential_points:
old_tile = self.tiles[p]
if old_tile.type in DIGGABLE_TYPES:
continue
tile = self.tiles[p2]
if not tile:
continue
if tile.type in WALKABLE_TYPES + DIGGABLE_TYPES:
points.append(p2)
return points
def cost(self, p1, p2):
t1, t2 = self.tiles[p1], self.tiles[p2]
return (TILE_COSTS[t1.type] + TILE_COSTS[t2.type]) / 2
def initialize(self):
rect = Rectangle()
rect.bottomLeft = self.intersection(self.ray(0, 0))
rect.topLeft = self.intersection(self.ray(0, self.image['height']))
rect.topRight = self.intersection(
self.ray(self.image['width'], self.image['height']))
rect.bottomRight = self.intersection(self.ray(self.image['width'],
0.0))
self.pyramid = Pyramid(self.position, rect)
self.plane = Plane(rect, self.image)
def __init__(self, parent=None):
super().__init__(parent=parent)
self.card = False
self._well = Deck(DeckStrategy.invisible, self)
self._vwell = Deck(DeckStrategy.visible, self)
self._pyramid = Pyramid(self._well, self)
p = self.palette()
p.setColor(self.backgroundRole(), QtGui.QColor(3, 89, 2))
self.setPalette(p)
self.__score = 0
self.score_view = QtWidgets.QLabel("Score: 0", parent=self)
self.score_view.setGeometry(20, Card.height + 20, 200, 40)
ps = self.score_view.palette()
ps.setColor(self.score_view.foregroundRole(),
QtGui.QColor(255, 255, 255))
self.score_view.setPalette(ps)
self.show()
def __init__(
self,
detector,
descriptor=None,
num_features=2000,
num_levels=4,
scale_factor=1.2,
sigma0=1.0, # N.B.: SIFT use 1.6 for this value
first_level=0,
pyramid_type=PyramidType.RESIZE,
use_block_adaptor=False,
do_parallel=kPyramidAdaptorUseParallelComputations,
do_sat_features_per_level=False):
self.detector = detector
self.descriptor = descriptor
self.num_features = num_features
self.is_detector_equal_to_descriptor = (
self.detector == self.descriptor)
self.num_levels = num_levels
self.scale_factor = scale_factor
self.inv_scale_factor = 1. / scale_factor
self.sigma0 = sigma0
self.first_level = first_level
self.pyramid_type = pyramid_type
self.use_block_adaptor = use_block_adaptor
self.do_parallel = do_parallel # do parallel computations
self.do_sat_features_per_level = do_sat_features_per_level # saturate number of features for each level
self.pyramid = Pyramid(num_levels=num_levels,
scale_factor=scale_factor,
sigma0=sigma0,
first_level=first_level,
pyramid_type=pyramid_type)
self.initSigmaLevels()
self.block_adaptor = None
if self.use_block_adaptor:
self.block_adaptor = BlockAdaptor(self.detector,
self.descriptor,
row_divs=kAdaptorNumRowDivs,
col_divs=kAdaptorNumColDivs,
do_parallel=False)
"""Test file check all Pyramid module funcation """
from pyramid import Pyramid
if __name__ == "__main__":
import os #remove if dont have linux
myPyramid = Pyramid()
while 1:
print("""---Pyramid DataStructure---
\n |1| Insert Pyramid Layer
\n |2| View Pyramid Graph
\n |3| Vertical List
\n |4| Reverse Vertical List
\n |5| Horizontal List
\n |6| Reverse Horizontal List
\n |7| POP Pyramid Layer
\n |8| DeQueue Pyramid Layer
\n |9| Root to Right List
\n |10| Root to Left List
\n |11| Root to Up List
\n |12| Root to Down List
""")
ch = input("Enter : ")
if ch == "1":
myPyramid.insert_pyramid_layer(input("Enter Down Data :"),
input("Enter Right Data :"),
input("Enter Top Data :"),
input("Enter Left Data :"))
elif ch == "2":
myPyramid.graph_view()
def keyPressed(*args):
global camera
global lineVision
global objVision
key=glutGetModifiers()
#print(args[0])
# If escape is pressed, kill everything.
if args[0]==ESCAPE:
sys.exit()
elif args[0] == b'z':
scene.objects[0].rotate_point_z(10,scene.objects[0].center)
elif args[0] == b"x":
scene.objects[0].rotate_point_x(10,scene.objects[0].center)
elif args[0] == b"c":
scene.objects[0].rotate_point_y(10,scene.objects[0].center)
elif args[0] == b"b":
scene.objects[0].increase_subdivisions()
elif args[0] == b"n":
scene.objects[0].decrease_subdivisions()
elif args[0] == b"w":
camera.move_forward(.1)
elif args[0] == b"s":
camera.move_backward(.1)
elif args[0] == b"1":
scene.cleanScene()
scene.addObject(Sphere(18,12,1))
scene.addObject(grid)
elif args[0] == b"2":
scene.cleanScene()
scene.addObject(Torus(11,11,.3,1))
scene.addObject(grid)
elif args[0] == b"3":
scene.cleanScene()
scene.addObject(Cylinder(2,11,0.08))
scene.addObject(grid)
elif args[0] == b"4":
scene.cleanScene()
scene.addObject(Box(1,1,1))
scene.addObject(grid)
elif args[0] == b"5":
scene.cleanScene()
scene.addObject(Pyramid(.4))
scene.addObject(grid)
elif args[0] == b"6":
scene.cleanScene()
scene.addObject(Icosahedron())
scene.addObject(grid)
elif args[0] == b"7":
scene.cleanScene()
scene.addObject(Octahedron(1,3))
scene.addObject(grid)
elif args[0] == b"l":
lineVision=True
objVision=False
elif args[0] == b"o":
lineVision=False
objVision=True
elif args[0] == b"p":
lineVision=True
objVision=True
elif args[0] == b"f":
camera=Camera(Vec3d(0,0,5),Vec3d(0,0,-1))
def __init__(self, levels):
self.__queue = []
# self.__levels = levels
# self.__marbles = 0
self.__pyramid = Pyramid(levels)
import numpy as np
from pyramid import Pyramid, PyramidType
from utils_img import combine_images_horizontally
img = cv2.imread('../data/kitti06-12.png', cv2.IMREAD_COLOR)
pyramid_params = dict(
num_levels=8,
scale_factor=1.2,
sigma0=1.,
first_level=-1, # 0: start from image; -1: start from image*scale_factor
pyramid_type=PyramidType.RESIZE)
pyramid = Pyramid(**pyramid_params)
print('pyramid_type: ', pyramid.pyramid_type.name)
print('first_level: ', pyramid.first_level)
time_start = time.time()
pyramid.compute(img)
duration = time.time() - time_start
print('duration: ', duration)
for i in range(0, pyramid.num_levels):
name = 'level ' + str(i) + ': img - img_filtered'
img_pyr = combine_images_horizontally(pyramid.imgs[i],
pyramid.imgs_filtered[i])
cv2.imshow(name, img_pyr)
print(name, ' size: ', pyramid.imgs[i].shape)
def application(e, start_response):
db = DB()
headers = [('Content-Type', 'text/html; charset=utf-8')]
app_root = urllib.parse.urlunsplit(
(e['wsgi.url_scheme'], e['HTTP_HOST'], e['SCRIPT_NAME'], '', ''))
params = urllib.parse.parse_qs(e['QUERY_STRING'])
path_info = e['PATH_INFO']
# ----- If user has valid session cookie set session = True --------------------
session = False
session_user = None
cookies = http.cookies.SimpleCookie()
if 'HTTP_COOKIE' in e:
cookies.load(e['HTTP_COOKIE'])
if 'session' in cookies:
session_user, session_pass = cookies['session'].value.split(':')
session = db.user_pass_valid(session_user, session_pass)
# ----- The common start of every page ---------------------------
page = '''<!DOCTYPE html>
<html><head><title>Game</title>
<style>
table { border-collapse: collapse; }
table, th, td { border: 1px solid silver; padding: 2px; }
</style>
</head>
<body>
<h1>Rock-Paper-Scissors</h1>'''
# ----- For logging in and registering ---------------------------
if path_info == '/login_register':
param_do = params['do'][0] if 'do' in params else None
param_user = params['username'][0] if 'username' in params else None
param_pass = params['password'][0] if 'password' in params else None
login_register_form = '''
<form>
<input type="text" name="username"> Username<br>
<input type="password" name="password"> Password<br>
<input type="submit" name="do" value="Login"> or
<input type="submit" name="do" value="Register">
</form>'''
if param_do == 'Login' and param_user and param_pass:
if db.user_pass_valid(param_user, param_pass):
headers.append(('Set-Cookie',
'session={}:{}'.format(param_user,
param_pass)))
headers.append(('Location', app_root))
start_response('303 See Other', headers)
return []
else:
start_response('200 OK', headers)
page += login_register_form
return [(page +
'Wrong username or password</body></html>').encode()]
elif param_do == 'Register' and param_user and param_pass:
if db.add_username(param_user, param_pass):
headers.append(('Set-Cookie',
'session={}:{}'.format(param_user,
param_pass)))
headers.append(('Location', app_root))
start_response('303 See Other', headers)
return []
else:
start_response('200 OK', headers)
page += login_register_form
return [
(page +
'Username {} is taken.</body></html>'.format(param_user)
).encode()
]
else:
start_response('200 OK', headers)
return [(page + login_register_form + '</body></html>').encode()]
# ----- Logout --------------------------------------------
elif path_info == '/logout':
headers.append(
('Set-Cookie', 'session=0; expires=Thu, 01 Jan 1970 00:00:00 GMT'))
headers.append(('Location', app_root))
start_response('303 See Other', headers)
return []
# ----- Root page -----------------------------------------
elif path_info == '/' or not path_info:
if not session:
start_response('200 OK', headers)
page += '<a href="{}/login_register">Log in or register</a> to play</body></html>'.format(
app_root)
return [page.encode()]
page += '{} | <a href="{}/logout">Logout</a>'.format(
session_user, app_root)
# page += ' | <a href="{}">Refresh</a>'.format(app_root)
page += '<h2>My games</h2>\n'
page += '<table><tr><th>Game</th><th>Goal</th><th>Quit</th><th>State</th><th>Players</th></tr>\n'
games = [
Pyramid(i, p, g, st, ts, t, db.connection)
for i, p, g, st, ts, t in db.get_games_by_user(session_user)
]
for game in games:
page += '<tr><td>{}</td><td>{}</td><td><a href="{}/quit?id={}">quit</a></td>'.format(
game.id, game.goal, app_root, game.id)
players_scores = ', '.join([
'{}{}|{}{}'.format(
'' if p['playing'] else
'<s>', # Add open strikethrough tag if player left game
p['name'],
p['score'],
''
if p['playing'] else '</s>' # Add close strikethrough tag
) for p in game.players
])
if game.state == 0: # Accepting players
page += '<td>Awaiting {}</td>'.format(game.num_players -
len(game.players))
page += '<td>' + ', '.join([p['name']
for p in game.players]) + '</td>'
elif game.state == 2:
page += '<td><a href="{}/game?id={}">Game over</a></td>'.format(
app_root, game.id)
page += '<td>' + players_scores + '</td>'
elif game.is_players_turn(session_user): # Playing, player's turn
page += '<td><a href="{}/game?id={}">My turn</a></td>'.format(
app_root, game.id)
page += '<td>' + players_scores + '</td>'
else: # Playing, not player's turn
page += '<td><a href="{}/game?id={}">Awaiting Turn</a></td>'.format(
app_root, game.id)
page += '<td>' + players_scores + '</td>'
page += '</tr>\n'
page += '</table>'
page += '<p><a href="{}/newgame">Start a New Game</a></p>'.format(
app_root)
ts1 = max(game.ts for game in games) if games else None
page += '<h2>Games accepting players</h2>\n'
page += '<table><tr><th>Game</th><th>Goal</th><th>Join</th><th>State</th><th>Players</th></tr>\n'
games = [
Pyramid(i, p, g, 0, ts, t, db.connection) for i, p, g, ts, t in
db.get_registering_games_by_user(session_user)
]
for game in games:
page += '<tr><td>{}</td><td>{}</td><td><a href="{}/join?id={}">join</a></td>'.format(
game.id, game.goal, app_root, game.id)
page += '<td>{} of {} players</td>'.format(len(game.players),
game.num_players,
game.id)
page += '<td>' + ', '.join([p['name']
for p in game.players]) + '</td>'
page += '</tr>\n'
page += '</table>'
ts2 = max(game.ts for game in games) if games else None
page += '''
<script>
function callback(event) {{
if (event.target.readyState == 4 && event.target.responseText != '{} {}') {{
window.location = '{}'
}}
}}
function timeFunc(event) {{
var xmlhttp = new XMLHttpRequest();
xmlhttp.addEventListener("readystatechange", callback)
xmlhttp.open("GET", "{}/updated_games", true)
xmlhttp.setRequestHeader("Content-Type", "text/plain")
xmlhttp.send()
}}
setInterval(timeFunc, 1000)
</script>'''.format(ts1, ts2, app_root, app_root)
start_response('200 OK', headers)
return [(page + '</body></html>').encode()]
# ----- Check if game list changed -------------------------------------------
elif path_info == '/updated_games':
if not session:
start_response('200 OK', headers)
return ['No session'.encode()]
ts1, ts2 = db.updated_games(session_user)
start_response('200 OK', headers)
return ['{} {}'.format(ts1, ts2).encode()]
# ----- Register new game ---------------------------------------------------------------
# ***** MODIFY THIS PART TO ASK FOR NUMBER OF PLAYERS AND RECEIVE NUMBER OF PLAYERS *****
elif path_info == '/newgame':
if not session:
start_response('200 OK', headers)
return ['No session'.encode()]
if 'goal' in params:
db.new_game(2, params['goal'][0], session_user)
headers.append(('Location', app_root))
start_response('303 See Other', headers)
return []
page += '''
<h2>Create New Game</h2>
<form>
<h3>Play until score:</h3>
<input type="radio" name="goal" value="1">1<br>
<input type="radio" name="goal" value="3">3<br>
<input type="radio" name="goal" value="5">5<br>
<input type="radio" name="goal" value="10" checked>10<br>
<input type="radio" name="goal" value="20">20<br>
<input type="radio" name="goal" value="100">100<br>
<input type="submit" value="Create">
</form>
</body></html>'''
start_response('200 OK', headers)
return [page.encode()]
# ----- Join game -----------------------------------------
elif path_info == '/join':
if not session:
start_response('200 OK', headers)
return ['No session'.encode()]
game_id = params['id'][0]
db.join_game(game_id, session_user)
headers.append(('Location', app_root))
start_response('303 See Other', headers)
return []
# ----- Quit game -----------------------------------------
elif path_info == '/quit':
if not session:
start_response('200 OK', headers)
return ['No session'.encode()]
game_id = params['id'][0]
db.quit_game(game_id, session_user)
headers.append(('Location', app_root))
start_response('303 See Other', headers)
return []
# ----- Game ------------------------------------------------------------
elif path_info == '/game':
if not session:
start_response('200 OK', headers)
return ['No session'.encode()]
game_id = params['id'][0]
(players, goal, state, ts, turns) = db.get_game_by_id(game_id)
game = Pyramid(game_id, players, goal, state, ts, turns, db.connection)
if game.state == 0: # Error: cannot view game, it is still registering players
start_response('200 OK', headers)
return [
(page + 'Still registering players</body></html>').encode()
]
if 'move' in params: # Player came here by making a move
game.add_player_move(session_user, params['move'][0])
page += '<a href="{}">Home</a>'.format(app_root)
# page += ' | <a href="{}/game?id={}">Refresh</a>'.format(app_root, game_id)
page += '<h3>Game {} -- Play to {}</h3>'.format(game.id, game.goal)
if game.state == 2:
page += '<p>Game over</p>'
elif game.is_players_turn(session_user):
page += '<p>Your move: '
move_template = '<a href="{}/game?id={}&move={}">{}</a>'
move_links = [
move_template.format(app_root, game.id, mval, mname)
for mval, mname in game.valid_moves(session_user)
]
page += ' | '.join(move_links)
else:
page += '<p>Wait for your turn</p>'
page += '<table>\n<tr><th> </th>'
for p in game.players:
page += '<th>{}</th>'.format(
p['name']) if p['playing'] else '<th><s>{}</s></th>'.format(
p['name'])
page += '</tr>\n<tr style="background-color: silver"><td>Round</td>'
for p in game.players:
page += '<td>{} p</td>'.format(p['score'])
page += '</tr>\n'
for index, turn in enumerate(
reversed(game.decorated_moves(session_user))):
page += '<tr><td>{}</td>'.format(len(game.turns) - index)
for move, winner in turn:
if winner:
page += '<td style="background-color:lightgreen">{}</td>'.format(
move)
else:
page += '<td>{}</td>'.format(move)
page += '</tr>\n'
page += '</table>'
if game.state == 1:
page += '''
<script>
function callback(event) {{
if (event.target.readyState == 4 && event.target.responseText != '{}') {{
window.location = '{}/game?id={}'
}}
}}
function timeFunc(event) {{
var xmlhttp = new XMLHttpRequest();
xmlhttp.addEventListener("readystatechange", callback)
xmlhttp.open("GET", "{}/updated_game?id={}", true)
xmlhttp.setRequestHeader("Content-Type", "text/plain")
xmlhttp.send()
}}
setInterval(timeFunc, 1000)
</script>'''.format(game.ts, app_root, game.id, app_root, game.id)
start_response('200 OK', headers)
return [(page + '</body></html>').encode()]
# ----- Check if game changed --------------------------------------
elif path_info == '/updated_game':
if not session:
start_response('200 OK', headers)
return ['No session'.encode()]
start_response('200 OK', headers)
p, g, s, ts, t = db.get_game_by_id(params['id'][0])
return ['{}'.format(ts).encode()]
# ----- Dump tables ------------------------------------------------
elif path_info == '/dump':
users, games, players = db.dump()
page += '<a href="{}">Home</a>'.format(app_root)
page += ' | <a href="{}/clear_games">Clear games and players</a>'.format(
app_root)
page += ' | <a href="{}/clear_all">Clear all</a>'.format(app_root)
page += '<h2>Table "user"</h2>\n'
page += '<p>Contains all registered users and their passwords.</p>\n'
page += '<table><tr><th>name</th><th>password</th></tr>\n'
for name, password in users:
page += '<tr><td>{}</td><td>{}</td></tr>\n'.format(name, password)
page += '</table>\n'
page += '<h2>Table "game"</h2>\n'
page += '<p>One row for every game.</p>\n'
page += '<table><tr><th>rowid</th><th>players</th><th>goal</th><th>state</th><th>ts</th><th>turns</th></tr>\n'
for rowid, numplayers, goal, state, ts, turns in games:
page += '<tr><td>{}</td><td>{}</td><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr>\n'.format(
rowid, numplayers, goal, state, ts, turns)
page += '</table>\n'
page += '<h2>Table "player"</h2>\n'
page += '<p>Connects players with games. One row for every player in a game.</p>\n'
page += '<table><tr><th>rowid</th><th>game_id</th><th>user_name</th><th>score</th><th>playing</th></tr>\n'
for rowid, game_id, user_name, score, playing in players:
page += '<tr><td>{}</td><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr>\n'.format(
rowid, game_id, user_name, score, playing)
page += '</table>\n'
page += '</body></html>'
start_response('200 OK', headers)
return [page.encode()]
# ----- Clear tables --------------------------------------
elif path_info == '/clear_games':
db.clear_tables(False)
headers.append(('Location', '{}/dump'.format(app_root)))
start_response('303 See Other', headers)
return []
elif path_info == '/clear_all':
db.clear_tables(True)
headers.append(('Location', '{}/dump'.format(app_root)))
start_response('303 See Other', headers)
return []
# ----- Unknown web app ----------------------------------------------------------
else:
start_response('200 OK', headers)
return [
(page +
'Unknown Web app {}</body></html>'.format(path_info)).encode()
]
from deck import Deck
from pyramid import Pyramid
class Game(object):
def __init__(self):
self.deck = Deck()
self.pyramid = Pyramid()
for i in range(28):
self.pyramid.deck_pyramid.append(self.deck.__next__())
for card in self.pyramid.deck_pyramid:
print(card)
print("-----------")
g = Game()
p = Pyramid()
p.call(8)
from parse_scene import SceneParser
from pyramid import Pyramid
csv_row = [
273.805471207, 634.350474966, 5.47014316383, 396.71899049, 769.570813668,
5.46746117302, 716.12735601, 637.839968735, 4.17549101131, 1602.9590356,
1386.1706033, 4.93679909159, 132.91424965, 39.6180430965, 4.06897520457,
1017.61180338, 1280.84238753, 5.30929246675, 519.734389661, 157.465496871,
4.86189480527, 1052.81750419, 1114.7492892, 5.17453822111, 399.624083354,
152.848283046, 5.5284601383, 1476.00762606, 168.542917377, 4.41782320434,
620.176397096, 1378.2212009, 5.20734816895, 1722.59757491, 733.156401685,
5.18754977088, 1367.73392843, 746.551383153, 4.52141636174
]
scene = SceneParser.parse_csv_row(csv_row).cut_high_magnitudes(5.3)
scene.cartesian_to_spherical()
hip_data = '../data/hip_main.dat'
full_scene = SceneParser.parse_hip_data(hip_data).cut_high_magnitudes(5.3)
p = Pyramid(scene, full_scene)
p.find_match()
def main():
pygame.init()
size = 600
display = (size, size)
pygame.display.set_mode(display, DOUBLEBUF | OPENGL)
player = Player()
clock = pygame.time.Clock()
exit = True
wall = True
sens = 0.25
vel = 18
thetax = 0
thetay = 0
jump = False
bcheck = True
randpyramid = random.choice([i for i in range(2, 7)])
pyramid_list = []
for i in range(randpyramid):
x = Pyramid()
pyramid_list.append(x)
c = 0
bullet_list = []
while exit:
clock.tick(90)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
# Define mouse position and camera orientation
m = glGetDoublev(GL_MODELVIEW_MATRIX).flatten()
pos = player.getposition()
mouse_dx, mouse_dy = pygame.mouse.get_rel()
mousepos = pygame.mouse.get_pos()
# Define keys and getting direction of movement
keys = pygame.key.get_pressed()
fwd = -vel * (keys[K_w] - keys[K_s])
strafe = vel * (keys[K_a] - keys[K_d])
if abs(fwd) or abs(strafe):
try:
wallcollide(player, fwd, strafe)
except IndexError:
pass
if keys[pygame.K_ESCAPE]:
exit = False
if pygame.mouse.get_pressed() == (0, 0, 0):
bcheck = True
if bcheck:
if pygame.mouse.get_pressed() == (1, 0, 0):
b = Bullet()
b.brotate(thetax, thetay)
b.bmove(pos[0], pos[1], pos[2])
bullet_list.append(b)
bcheck = False
if not jump:
if keys[pygame.K_SPACE]:
jump = True
if jump:
array = np.linspace(-1, 1)
player.gravity(array[c])
c += 1
if c == len(array):
c = 0
jump = False
if wall:
player.rotateworld(mouse_dx * sens, mouse_dy * sens)
thetax = deg(atan2(m[8], m[0]))
thetay = deg(
atan2(-m[6],
-m[8] * sin(rad(thetax)) + m[10] * cos(rad(thetax))))
if keys[pygame.K_UP]:
player.rotateworld(0, -0.4)
player.updatecross(0, -0.4)
if keys[pygame.K_RIGHT]:
player.rotateworld(0.4, 0)
player.updatecross(0.4, 0)
if keys[pygame.K_DOWN]:
player.rotateworld(0, 0.4)
player.updatecross(0, 0.4)
if keys[pygame.K_LEFT]:
player.rotateworld(-0.4, 0)
player.updatecross(-0.4, 0)
wall = True
if mousepos[0] <= 1:
pygame.mouse.set_pos(size, mousepos[1])
wall = False
if mousepos[0] >= size - 1:
pygame.mouse.set_pos(0, mousepos[1])
wall = False
if mousepos[1] <= 1:
pygame.mouse.set_pos(mousepos[0], size)
wall = False
if mousepos[1] >= size - 1:
pygame.mouse.set_pos(mousepos[0], 0)
wall = False
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
player.drawroom()
player.draw()
for i in pyramid_list:
i.drawpyramid()
i.checkpyramid(player)
for i in bullet_list:
i.bmove(i.bvel * sin(rad(i.thetax)), -i.bvel * sin(rad(i.thetay)),
-i.bvel * cos(rad(i.thetax)))
i.drawbullet()
try:
if abs(i.pos[0]) > i.mulx:
bullet_list.remove(i)
if abs(i.pos[2]) > i.mulz:
bullet_list.remove(i)
if abs(i.pos[1]) > i.muly or i.pos[1] < 0:
bullet_list.remove(i)
except ValueError:
pass
player.updatecross(thetax, -thetay)
player.crosshair()
if keys[K_KP_ENTER]:
pygame.event.set_grab(True)
pygame.mouse.set_cursor((8, 8), (0, 0), (0, 0, 0, 0, 0, 0, 0, 0),
(0, 0, 0, 0, 0, 0, 0, 0))
pygame.mouse.set_pos(size / 2, size / 2)
player.rotateworld(-thetax, -thetay)
thetax, thetay = 0, 0
player.crosshair()
pygame.display.flip()
print(player.getposition())
def __init__(self, debug=True):
self.pyramid = Pyramid()
self.debug = debug
for col, x in enumerate([int(s) for s in line.split(" ")]):
vals[row_idx][col] = x
row_idx += 1
return vals
def make_output(file_path, occur_dict):
with open(file_path, "w") as fdw:
for k, v in sorted(occur_dict.items()):
output_line = "{} | {}\n".format(k, v["n"])
if v["trails"] is not None:
output_line += " TRAILS: {}\n".format(v["trails"])
fdw.write(output_line)
# for trails mode
# --trails -output res/output_trails.txt
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("-input", nargs='?', default="res/input.txt")
parser.add_argument("-output", nargs='?', default="res/output.txt")
parser.add_argument("--trails", action='store_true')
args = parser.parse_args()
vals = vals_from_file(args.input)
pyramid = Pyramid(vals)
pyramid.calc_path_sums(include_trails=args.trails)
make_output(args.output, pyramid._path_sums)
r = int((x / self.width) * 255) if x / self.width < 1 else 1
g = int((y / self.height) * 255) if y / self.height < 1 else 1
b = 0
self.pixels[y][x] = Color(r, g, b)
r = Raytracer(400, 400)
#r.envMap = Envmap('fondo.bmp')
r.light = Light(
position = V3(0, 20, 20),
intensity = 1.5
)
r.ambientLight = AmbientLight(strength = 0.1)
r.scene = [
Pyramid([V3(-1, 0, -10), V3(-3, 2, -10), V3(-5, 0, -10), V3(-1, 0, -10)], blue3),
Pyramid([V3(1, 0, -10), V3(3, 2, -10), V3(5, 0, -10), V3(1, 0, -10)], blue3),
Pyramid([V3(-2, 0, -10), V3(-4, 2, -10), V3(-6, 0, -10), V3(-2, 0, -10)], blue2),
Pyramid([V3(2, 0, -10), V3(4, 2, -10), V3(6, 0, -10), V3(2, 0, -10)], blue2),
Pyramid([V3(0, 0, -10), V3(-2, 2, -10), V3(-4, 0, -10), V3(0, 0, -10)], blue4),
Pyramid([V3(0, 0, -10), V3(2, 2, -10), V3(4, 0, -10), V3(0, 0, -10)], blue4),
Pyramid([V3(2, 0, -10), V3(0, 3, -10), V3(-2, 0, -10), V3(2, 0, -10)], blue1),
Cube(V3(0, -2, -2), 2, beige),
Pyramid([V3(-1, 0, -10), V3(3, 0, -10), V3(-1, 0, -5), V3(-1, -1, -10)], brown),
Cube(V3(0.75, -0.75, -2.5), 0.5, blue5),
Sphere(V3(0.75, -0.40, -2.5), 0.20, white),
Sphere(V3(0.75, -0.16, -2.5), 0.05, white),
Plane(V3(2, -10, -15), V3(0,1,0), mirror),
Sphere(V3(5, 0.1, -10), 0.10, green),
