def main(args):
if len(args) < 3:
print "Usage: <me> <staticxml-input> <statictsv-output>"
sys.exit(1)
(staticxml, statictsv) = args[1:3]
sa = StaticAnalysis(staticxml)
if options.flag_debug:
sa.printInfo()
grapher.Grapher(sa).generateDepGraphs()
spreadsheet.SpreadsheetWriter(sa).exportSpreadsheet(statictsv)
def main():
# create render window
window = grapher.Grapher()
# create cube models
render_models = list()
render_models.append(cube.Cube())
render_models.append(cube.Cube())
render_models.append(cube.Cube())
render_models.append(cube.Cube())
render_models[0].set_pos(5, 0, 10)
render_models[1].set_pos(-5, 0, 10)
render_models[2].set_pos(5, -4, 13)
render_models[3].set_pos(-5, -7, 10)
# create walls
render_models.append(wall.Wall())
render_models[4].set_pos(0, -8, 25)
render_models[4].scale = 8
render_models.append(wall.Wall())
render_models[5].set_pos(16, -8, 9)
render_models[5].set_rot(0, 90, 0)
render_models[5].scale = 8
# create camera
cam = camera.Camera()
# temp
r = 0
s = 0.2
# main loop
try:
while True:
# clear grapher
window.clear()
# render models in render_models list
for rm in render_models:
# set global model-space stuff here
rm.set_rot_delta(r, r, r)
# transform model and get transformed coordinate pairs
coords = rm.process(cam, fov)
# render segments from coordinate pair list
for i in coords:
# gather depth coordinates
sz = i[0][2]
ez = i[1][2]
# if segment is completely behind player, skip rendering
if sz < 0 and ez < 0:
continue
# gather transformed coordinates
startx = i[0][0]
starty = i[0][1]
endx = i[1][0]
endy = i[1][1]
# if segment is partially behind player, clip segment to camera's field of view
if sz < 0 or ez < 0:
# ffffuuuuuuu
pass
# draw segment
window.draw_line(startx, starty, endx, endy)
# draw debug text
coords = "Player: (%f, %f, %f)" % (cam.pos_x, cam.pos_y, cam.pos_z)
pang = "Player angle: %f" % cam.angle
options = "Options: ROT: %d, SPD: %d" % (r, s)
window.console_out("3D Engine test - HalfBurntToast")
window.console_out(coords)
window.console_out(pang)
window.console_out(options)
# update grapher
window.update()
# get command input
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_r:
r = int(not r)
if event.key == pygame.K_p:
cam.reset()
print("Reset")
# get movement input
keys = pygame.key.get_pressed()
if keys[pygame.K_w]:
ang = numpy.deg2rad(numpy.abs(360 - cam.angle))
cam.pos_z -= numpy.cos(ang) * s
cam.pos_x -= numpy.sin(ang) * s
if keys[pygame.K_s]:
ang = numpy.deg2rad(numpy.abs(360 - cam.angle))
cam.pos_z += numpy.cos(ang) * s
cam.pos_x += numpy.sin(ang) * s
if keys[pygame.K_a]:
ang = numpy.deg2rad(numpy.abs(360 - (cam.angle - 90)))
cam.pos_z += numpy.cos(ang) * s
cam.pos_x += numpy.sin(ang) * s
if keys[pygame.K_d]:
ang = numpy.deg2rad(numpy.abs(360 - (cam.angle - 90)))
cam.pos_z -= numpy.cos(ang) * s
cam.pos_x -= numpy.sin(ang) * s
if keys[pygame.K_e]:
cam.angle = (cam.angle - 0.6) % 360
if keys[pygame.K_q]:
cam.angle = (cam.angle + 0.6) % 360
# if not using any input handling, uncommon the line below
#pygame.event.pump()
# temp delay. TODO: replace with FPS regulator
pygame.time.delay(10)
except KeyboardInterrupt:
pygame.quit()
import scoreController
import gridController
import tileController
import grapher
import ai
import viewController
timeController = timeController.TimeController(1)
scoreController = scoreController.ScoreController()
gridController = gridController.GridController(scoreController)
tileController = tileController.TileController(gridController)
grapher = grapher.Grapher(scoreController)
ai = ai.AI(gridController, scoreController, grapher)
viewController = viewController.ViewController(gridController, timeController,
scoreController, ai, grapher)
cTile = tileController.getRandomTile()
nTile = tileController.getRandomTile()
viewController.setTile(cTile, nTile)
while not viewController.abort:
if timeController.timeEvent():
if viewController.aiState:
move, rotate, rating = ai.makeMove(cTile)
if not cTile.incY():
def __init__(self):
self.graph = Graph(grapher.Grapher())
a_c = x
b_c = y
# z
a_z = a_c
b_z = b_c
start = 100
inkr = 6
for i in range(100): # Break off point
if rad(a_z, b_z) > 2:
rgb = [inkr * i, inkr * i, inkr * i + start]
for j in range(len(rgb)):
if rgb[j] > 255:
rgb[j] = 255
return rgb
a_z, b_z = Z(a_z, b_z, a_c, b_c)
return [0, 0, 0]
w = 200
h = 200
rgb = image_generator.gen_plane(func, w, h)
pic = grapher.Grapher(rgb, w, h)
pic.gen_frame()
pic.gen_axes()
pic.create()
def RunRobotSim(scale=0.5, dt=0.1, invert=False):
counter = 0
decTime = time.time()
pygame.init()
print "Screen: ", pygame.display.get_driver()
mPerPixel = 0.01 / scale
sizeX = int(1600 * scale)
sizeY = int(800 * scale)
screen = pygame.display.set_mode((sizeX, sizeY))
disp = pygame.Surface((sizeX / 2, sizeY))
disp2 = pygame.Surface((sizeX / 2, sizeY))
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-a",
default="",
dest="ip",
help="addres of robot",
metavar="IP")
parser.add_option("-c",
default="auto",
dest="acontrol",
help="Automatic Control",
metavar="CONTROL")
options, args = parser.parse_args()
ip = options.ip
acontrol = options.acontrol
#acontrol="auto"
engine = None
if ip:
import rpyc
engine = rpyc.connect_by_service("engine", ip)
print "Connectted to service!"
run = True
robotV = RobotVis.RobotVis(RobotSim.RobotSim(mPerPixel), mPerPixel)
#robotShaddow = RobotVis.RobotVis(RobotSim.RobotReal('192.168.0.203', 13500))
activeU = [robotV.robot.maxU, robotV.robot.maxU]
enviroment = Enviroment.Enviroment(sizeX / 2)
enviroment2 = Enviroment.Enviroment(sizeX / 2)
enviroment.LoadFromFile('map.txt')
robotV.enviroment = enviroment
enviroment2.SetClear(80, 60)
graph = grapher.Grapher(sizeX, sizeY / 4)
robotV.robot.dT = dt
joy = None
pygame.joystick.init()
try:
joy = pygame.joystick.Joystick(0)
joy.init()
except:
pass
timeControl = time.time()
#TODO:Fix
while run:
time.sleep(0.02)
for e in pygame.event.get():
if e.type == pygame.QUIT:
run = False
#main cycle
U = robotV.robot.Au(activeU)
X = robotV.robot.Vr(U)
S = robotV.robot.Vs(enviroment, enviroment2)
activeU = [0, 0]
if engine:
activeU = [0, 0]
#commands = engine.root.Get(5)
else:
try:
#print [joy.get_axis(0) * 64, -joy.get_axis(1) * 64]
#print joy.get_axis(0), joy.get_axis(1)
x = joy.get_axis(0) * 60
y = -joy.get_axis(1) * 60
activeU = [y + x / 2, y - x / 2]
if activeU == [0.0, 0.0]:
raise Exception()
timeControl = time.time()
#ret[0] = round(joy.get_axis(0))
#ret[1] = round(joy.get_axis(1))
except:
pass
if timeControl + 2 < time.time():
if acontrol == "auto":
activeU = robotV.robot.As(S)
#print activeU
#paint sensor response
graph.AddData(S)
#paint robot
enviroment.paint(disp)
enviroment2.paint(disp2)
if decTime + 2 < time.time():
decTime = time.time()
print decTime
for i, x in enumerate(enviroment2.map):
for j, y in enumerate(x):
enviroment2.map[i][j] -= 8
if enviroment2.map[i][j] < 0:
enviroment2.map[i][j] = 0
robotV.enviroment.paint(disp)
robotV.paint(disp)
if invert:
screen.fill((255, 255, 255))
screen.blit(disp, (0, 0), None, pygame.BLEND_SUB)
screen.blit(disp2, (sizeX / 2, 0), None, pygame.BLEND_SUB)
else:
screen.blit(disp, (0, 0))
screen.blit(disp2, (sizeX / 2, 0))
for y in range(0, int(sizeY * mPerPixel)):
for x in range(0, int(sizeX * mPerPixel)):
pygame.draw.circle(
screen, (255, 255, 0),
map(int, (x / mPerPixel, y / mPerPixel)), 2)
graph.Paint(screen, sizeY - graph.gr.get_height(), invert)
pygame.display.flip()