def _CreteAsteroid(self, **kwargs):
go = gameObject.GameObject(kwargs["callable"])
go.Type = "Asteroid"
go.asteroidType = kwargs["asteroidType"]
go.transform = transform.Transform()
go.transform.x = kwargs["transform"].x
go.transform.y = kwargs["transform"].y
go.transform.speed = kwargs["transform"].speed
go.transform.rotation = kwargs["transform"].rotation
go.transform.rotationSpeed = kwargs["transform"].rotationSpeed
if go.asteroidType is AsteroidType.large:
go.sound = self.bigAsteroidExplosionSound
go.radius = 40
image, path = self.itemFactory.getAsteroid(AsteroidType.large)
go.Render = renderer.Renderer(80, 80, path, go.transform, image,
None, go.Type)
elif go.asteroidType is AsteroidType.medium:
go.sound = self.mediumAsteroidExplosionSound
go.radius = 25
go.transform.speed += 0.2
image, path = self.itemFactory.getAsteroid(AsteroidType.medium)
go.Render = renderer.Renderer(50, 50, path, go.transform, image,
None, go.Type)
else:
go.sound = self.smallAsteroidExplosionSound
go.transform.speed += 0.4
go.radius = 15
image, path = self.itemFactory.getAsteroid(AsteroidType.small)
go.Render = renderer.Renderer(30, 30, path, go.transform, image,
None, go.Type)
go.Render.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
self.SceneManager.scene.addItem(go.Render)
return go
def paste_below_item(parent, scene):
''' Paste items under a selected symbol '''
LOG.debug('Pasting below item ' + repr(parent)[slice(0, 20)])
symbols = []
for item_list, _ in COPY_PASTE:
states = [i for i in item_list if isinstance(i, ogAST.State)]
for i in [
c for c in item_list
if not isinstance(c, (ogAST.State, ogAST.TextArea,
ogAST.Start))
]:
LOG.debug('PASTE ' + str(i))
# Create the new item from the AST description
new_item = Renderer.render(i,
scene=CLIPBOARD,
parent=None,
states=states)
# Check that item is compatible with parent
if (type(new_item).__name__ in parent.allowed_followers):
# Move the item from the clipboard to the scene
Renderer.add_to_scene(new_item, scene)
new_item.pos_x = new_item.pos_y = 0.0
symbols.append(new_item)
else:
raise TypeError(
'Cannot paste here ({t1} cannot follow {t2})'.format(
t1=type(new_item), t2=type(parent)))
return symbols
def _CreateProjectile(self, **kwargs):
width = 4
height = -12
go = gameObject.GameObject(kwargs["callable"])
go.Type = "Projectile"
go.name = kwargs["name"]
go.transform.x = kwargs["transform"].x
go.transform.y = kwargs["transform"].y
go.transform.rotation = kwargs["transform"].rotation
go.transform.speed = kwargs["transform"].speed
go.transform.rotationSpeed = kwargs["transform"].rotationSpeed
if kwargs["playerType"] is PlayerType.player1:
go.Render = renderer.Renderer(width, height, None, go.transform,
None, Qt.gray, go.Type)
if kwargs["playerType"] is PlayerType.player2:
go.Render = renderer.Renderer(width, height, None, go.transform,
None, Qt.red, go.Type)
if kwargs["playerType"] is PlayerType.player3:
go.Render = renderer.Renderer(width, height, None, go.transform,
None, Qt.green, go.Type)
if kwargs["playerType"] is PlayerType.player4:
go.Render = renderer.Renderer(width, height, None, go.transform,
None, Qt.yellow, go.Type)
self.SceneManager.scene.addItem(go.Render)
go.Render.moveItem()
go.Render.rotateItem()
return go
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)
class Engine:
def __init__(self):
self.running = True
self.screen = pg.display.set_mode(
(SCREENWIDTH, SCREENHEIGHT),
pg.DOUBLEBUF | pg.RESIZABLE | pg.HWSURFACE)
self.env = Environment3()
self.camera = Camera(SCREENWIDTH, SCREENHEIGHT, THETA_W, THETA_H, NEAR,
FAR, self.env.sectors[0], self.env, False)
self.renderer = Renderer()
def run(self):
pg.init()
pg.display.set_caption('2.5D Engine')
clock = pg.time.Clock()
while self.running:
self.processInputs()
self.camera.processEvents(pg.event.get())
self.camera.update(self.env, False)
self.renderer.renderFrame(self.screen, self.camera, self.env)
pg.display.update()
clock.tick()
def processInputs(self):
events = pg.event.get()
for event in events:
if event.type == pg.QUIT:
self.running = False
self.camera.processEvents(events)
def __init__(self):
self.running = True
self.screen = pg.display.set_mode(
(SCREENWIDTH, SCREENHEIGHT),
pg.DOUBLEBUF | pg.RESIZABLE | pg.HWSURFACE)
self.env = Environment3()
self.camera = Camera(SCREENWIDTH, SCREENHEIGHT, THETA_W, THETA_H, NEAR,
FAR, self.env.sectors[0], self.env, False)
self.renderer = Renderer()
def init(self, stateManager):
self.player = Player(0, 0, -1.0, 0.0, 0.0, 0.66)
self.map = Map("level1.png", self.player)
self.oldMapPos = (int(self.player.posX), int(self.player.posY))
self.renderer = Renderer(stateManager.display, self.player, self.map)
# Mouse for FPS
pygame.event.set_grab(True)
pygame.mouse.set_visible(False)
# Play music
if Settings.MUSIC:
pygame.mixer.music.load("Resources/Sounds/Music/turmoil.ogg")
pygame.mixer.music.play(-1)
class PreviewCanvas(object):
def __init__(self,
parent,
sf,
notations,
sd=SongDecorator(),
embedded=False):
object.__init__(self)
show_link = not embedded and platform.system() != 'Linux'
self.link = None
if show_link:
self.main_panel = wx.Window(parent)
bSizer = wx.BoxSizer(wx.VERTICAL)
self.link = wx.adv.HyperlinkCtrl(
self.main_panel, 0, _("Copy formatted song to clipboard"), '')
tt = wx.ToolTip(
_("Copy formatted song to clipboard, so that it can be pasted in any program and printed"
))
self.link.SetToolTip(tt)
bSizer.Add(self.link, 0, wx.EXPAND)
parent = self.main_panel
self.panel = wx.ScrolledWindow(parent, style=wx.BORDER_DOUBLE)
self.panel.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
self.pixedScrolled = 10
self.panel.SetScrollbars(self.pixedScrolled, self.pixedScrolled, 0, 0)
self.panel.Bind(wx.EVT_PAINT, self.OnPaint, self.panel)
self.panel.SetBackgroundColour(wx.WHITE)
self.text = ""
if show_link:
bSizer.Add(self.panel, 1, wx.EXPAND)
else:
self.main_panel = self.panel
#SongFormat
self.renderer = Renderer(sf, sd, notations)
if show_link:
self.main_panel.SetSizer(bSizer)
self.main_panel.Layout()
def OnPaint(self, e):
#print("OnPaint")
dc = wx.AutoBufferedPaintDC(self.panel)
self.panel.PrepareDC(dc)
dc.SetBackground(wx.WHITE_BRUSH)
dc.Clear()
w, h = self.renderer.Render(self.text, dc)
self.panel.SetVirtualSize(wx.Size(w, h))
def Refresh(self, text):
self.text = text
self.panel.Refresh()
def SetDecorator(self, sd):
self.renderer.SetDecorator(sd)
def DrawOnDC(self, dc):
decorator = self.pref.decorator if self.pref.labelVerses else SongDecorator(
)
r = Renderer(self.pref.format, decorator, self.pref.notations)
start, end = self.text.GetSelection()
if start == end:
w, h = r.Render(self.text.GetText(), dc)
else:
w, h = r.Render(self.text.GetText(), dc,
self.text.LineFromPosition(start),
self.text.LineFromPosition(end))
return w, h
def initUI(self):
self.resize(1280, 720)
self.center()
# Put a real title here when I think of something to name this
self.setWindowTitle('Yoshi\'s new Island Editor')
# Set up initial ui layout
vLayout = QtWidgets.QVBoxLayout(self)
self.setLayout(vLayout)
# Placeholder for where Obj editor widget will go
label = QtWidgets.QLabel("Placeholder")
# Place View and Editor widgets into horizontal layout
hLayout = QtWidgets.QHBoxLayout()
hLayout.addWidget(label)
hLayout.addWidget(self.view)
# Setup Zoom widget
# noinspection PyUnresolvedReferences
self.zoom.valueChanged.connect(self.ZoomAdjust)
zoomLayout = QtWidgets.QHBoxLayout()
zoomLayout.addWidget(self.zoom)
zoomLayout.addWidget(self.zoomLabel)
# Place everything into the vertical layout
vLayout.addLayout(hLayout)
vLayout.addLayout(zoomLayout)
# Load level data
filename = input("input a level name: ")
levelData = Reader.LoadLevelData(filename)
# Render Stuff
# Render Collision
for col in range(0, len(levelData.Data[0])):
Renderer.RenderCollision(levelData.Data[0][col], self.view)
# Render Objects
for obj in range(0, len(levelData.Data[1])):
Objects.InitObject(levelData.Data[1][obj], self.view)
# Render Areas
for area in range(0, len(levelData.Data[2])):
Renderer.RenderAreas(levelData.Data[2][area], self.view)
# Render Paths
for path in range(0, len(levelData.Data[3])):
Renderer.RenderPaths(levelData.Data[3][path], self.view)
self.setWindowTitle('Yoshi\'s new Island Editor | ' + filename)
def OnExportAsHtml(self, evt):
n = self.AskExportFileName(_("HTML file"), "html")
if n is not None:
h = HtmlExporter(self.pref.format)
r = Renderer(self.pref.format, h, self.pref.notations)
start, end = self.text.GetSelection()
if start == end:
r.Render(self.text.GetText(), None)
else:
r.Render(self.text.GetText(), None,
self.text.LineFromPosition(start),
self.text.LineFromPosition(end))
with open(n, "w", encoding='utf-8') as f:
f.write(h.getHtml())
f.close()
def __init__(self):
self.player_class = 0
self.player_id = None
self.player_x = 300
self.player_y = 300
self.player_lead_x_change = 0
self.player_lead_y_change = 0
self.previous_x = 0
self.previous_y = 0
#Server response flag
self.is_registered = False
#self.ammo = ammo
self.time_lasted = 0
self.average_performance = 0
#Feature variables
self.health = 100
self.score = 0 #measures endurance against remaining health
self.class_packs = 0 #measures agility
self.out_of_bounds_OR_game_over = 0
#apply game rules, violation of which will cost something
#resourcefulness
#ammo and shields
self.renderer = Renderer.Renderer()
def main(pattern_file, img_file):
pattern = cv2.imread('pattern.png', 0) # trainImage
matcher = cm.CorrespondenceMatcher(pattern)
estimator = pe.ProjectionEstimator()
renderer = rr.Renderer()
print("loading image " + img_file)
query = cv2.imread(img_file, 0) # queryImage
q_h, q_w = query.shape[:2]
p_h, p_w = pattern.shape[:2]
print("finding homography for " + img_file)
h = matcher.find_homography(query)
print("homography matrix " + str(h))
print("finding extrinsic camera parameter for " + img_file)
rx, ry, rz, px, py, pz, residual = estimator.compute_extrinsic(
h, p_w, q_w, FOCAL_LENGTH, PATTERN_SIZE)
print("rotation: " + str([rx, ry, rz]))
print("position: " + str([px, py, pz]))
print("parameter residual " + str(residual))
print("rendering result generated from pattern " + pattern_file +
" and image " + img_file)
renderer.render(img_file, rx, ry, rz, px, py, pz)
def resetBoard():
nonlocal board1, renderer, controller, count, srcTile, desTile, ID, currentTile \
,displayHover, currentSide, wep_sniper, wep_assault, wep_shotgun, soldiers
f = open("map.txt")
tiles = {}
for line in f.readlines():
cols = line.split()
passable = (cols[2] == "True")
tiles[(int(cols[0]), int(cols[1]))] = board.Tile(
(int(cols[0]), int(cols[1])), passable, int(cols[3]),
int(cols[4]), int(cols[5]), int(cols[6]))
#print(tiles)
board1 = board.Board(15, 20, tiles)
for i in range(0, board1.width):
for j in range(0, board1.height):
exec(
compile(
open("soldier.txt", "rb").read(), "soldier.txt",
'exec'))
# exec(compile(open("map.txt", "rb").read(), "map.txt", 'exec'))
print("HI!")
renderer = Renderer.Renderer(board1, screen)
controller = Controller.Controller()
count = 0
srcTile = None
desTile = None
ID = None
currentTile = None
displayHover = 0
currentSide = 0
def __init__(self):
super(VehicleDetector, self).__init__()
# Sliding windows
self.yStart = 400
self.yStop = 650
self.x_overlap = 0.65
self.y_overlap = 0.75
# Filter
self.filterThreshold = 2
self.filter = F.Filter(self.filterThreshold)
# Print summary to check correct parameters
self.Summary()
# Sub-components
self.renderer = R.Renderer()
self.database = D.Database()
cars, notcars = self.database.GetListOfImages()
self.classifier = C.Classifier(cars,
notcars,
loadFromFile=True,
database=self.database)
# Output video parameters
self.outputToImages = 0
self.outputVideoName = self.database.GetOutputVideoPath()
# Train classifier ?
self.trainClassifier = 1
# TODO: implement the loading
# Bounding boxes
self.bboxes = self.LoadSlidingWindows()
def __init__(self):
super(Test, self).__init__()
self.database = D.Database()
cars, notcars = self.database.GetListOfImages()
self.classifier = C.Classifier(cars, notcars, loadFromFile=True, database=self.database)
self.renderer = R.Renderer()
self.vehicleDetector = V.VehicleDetector()
def __init__(self, direction, speed, socket_data_list): self.socket_data_list = socket_data_list self.color = red self.direction = direction self.speed = speed self.damage_point = gameObject.damage_point self.top_attack_startx = 0 self.bottom_attack_startx = 0 self.left_attack_starty = 0 self.right_attack_starty = 0 self.x = 0 self.y = 0 self.end_x = 0 self.end_y = 0 self.isActive = True self.renderer = Renderer.Renderer() self.aum = AUM.AttackUnitMover() self.aum.initialize(self) self.top_side_attack_config = [] #configuration for top attack self.left_side_attack_config = [] #configuration for left attack self.bottom_side_attack_config = [] #configuration for bottom attack self.right_side_attack_config = [] #configuration for right attack self.create_attack_start_list() #initializes attack data from server self.create_attack_config() #populates attack config lists
def resize(self, event):
size = (event.width, event.height)
self.image = Image.new('RGBA', size)
self._computeBands(size)
self.display()
self.renderer = Renderer.Renderer(self.master, self.image,
self.colorspace.hasAlpha)
self.config(image=self.renderer)
def __init__(self):
# We create a MainWindow object and initialise with the UI from PMainWindowUi
self.app = QtGui.QApplication(sys.argv)
self.MainWindow = QtGui.QMainWindow()
self.ui_m = MainWindowUi.Ui_MainWindow()
self.ui_m.setupUi(self.MainWindow)
# We connect all the buttons to their respective callback functions, called when the 'clicked' event is generated
self.ui_m.pushButton.clicked.connect(self.openLoadStackDialog)
self.ui_m.pushButton_2.clicked.connect(self.cutObj)
self.ui_m.pushButton_3.clicked.connect(self.setSliceResolution)
self.ui_m.pushButton_4.clicked.connect(self.changeColorMap)
self.ui_m.pushButton_5.clicked.connect(self.takeSnapshot)
#self.ui_m.pushButton_6.clicked.connect(self.saveAsVTKObj)
self.ui_m.pushButton_7.clicked.connect(self.record)
self.ui_m.pushButton_8.clicked.connect(self.removePoint)
self.ui_m.pushButton_9.clicked.connect(self.addPoint)
self.ui_m.pushButton_10.clicked.connect(self.renderV)
#self.ui_m.pushButton_11.clicked.connect(self.openVTKObj)
self.ui_m.pushButton_12.clicked.connect(self.changeBGColor)
self.ui_m.pushButton_13.clicked.connect(self.resetCamera)
self.ui_m.pushButton_11.clicked.connect(self.alignPlaneToX)
self.ui_m.pushButton_14.clicked.connect(self.alignPlaneToZ)
self.ui_m.pushButton_15.clicked.connect(self.alignPlaneToY)
# Below are the toggle buttons
self.ui_m.radioButton.toggled.connect(self.toggleOutline)
self.ui_m.radioButton_2.toggled.connect(self.togglePlane)
self.ui_m.radioButton_3.toggled.connect(self.toggleClippingBox)
self.ui_m.radioButton_4.toggled.connect(self.toggleVolume)
self.ui_m.radioButton_5.toggled.connect(self.toggleSlice)
self.ui_m.radioButton_6.toggled.connect(self.toggleAlignedPlane)
self.ui_m.horizontalSlider.valueChanged.connect(self.valueChangeSlider)
# These are the 'Clip' and 'Set' (set slice reolution) buttons which are initially disabled, enabled only when the Plane Widget is active
self.ui_m.pushButton_2.setEnabled(False)
self.ui_m.pushButton_3.setEnabled(False)
self.ui_m.pushButton_10.setEnabled(False)
self.ui_m.pushButton_11.setEnabled(False)
self.ui_m.pushButton_14.setEnabled(False)
self.ui_m.pushButton_15.setEnabled(False)
self.ui_m.horizontalSlider.setEnabled(False)
self.Dialog = QtGui.QDialog()
self.ui_l = Ui_Dialog()
self.ui_l.setupUi(self.Dialog)
self.pRenderer = Renderer.Renderer()
self.pRenderer.renderBlank(self.ui_m.qvtkWidget)
self.MainWindow.show()
self.pCutObj = CutObj.CutObj()
self.histWidg = HistogramWidget.HistogramWidget()
self.loadStack = LoadStack.LoadStack(self)
sys.exit(self.app.exec_())
def checkParams(self, fractal):
for current in filenames:
args = Arguer.Argue([
fractal, current, '--dim', filenames[current], '--zoom', '2',
'--pan', '[-1.0,1.0]', '--iters', '50', '--com', '[-0.75,0.11]'
])
r = Renderer.Render(args).draw()
args = Arguer.Argue([
fractal, current, '--dim', filenames[current], '--zoom', '5',
'--pan', '[2.5,-0.5]', '--iters', '13'
])
r = Renderer.Render(args).draw()
self.assertTrue(os.path.isfile(current))
self.assertTrue(
self.checkDims(
filenames[current][:filenames[current].index('x')],
filenames[current][filenames[current].index('x') + 1:],
current))
def moveallsearchers(searchers, count, window):
reachedend = False
for i in range(count):
if searchers[i].x == Renderer.grid_width - 1 and searchers[
i].y == Renderer.grid_height - 1:
reachedend = True
Renderer.drawpath(searchers[i], window)
break
if searchers[i].randmoves == 1 or (searchers[i].mutate
and searchers[i].count >
(4 * lifespan) / 6):
movesearcher(searchers[i], random.randint(0, 3))
else:
movesearcher(searchers[i], searchers[i].dna[searchers[i].count])
searchers[i].count += 1
return reachedend
def paste_floating_objects(scene):
''' Paste items with no parents (states, text areas) '''
symbols = []
LOG.debug('PASTING FLOATING OBJECTS')
for item_list, terminators in COPY_PASTE:
# states is a list passed as parameter - not a generator:
start = [i for i in item_list if isinstance(i, ogAST.Start)]
states = [i for i in item_list if isinstance(i, ogAST.State)]
text_areas = (i for i in item_list if isinstance(i, ogAST.TextArea))
labels = (i for i in item_list if isinstance(i, ogAST.Floating_label))
procedures = (i for i in item_list if isinstance(i, ogAST.Procedure))
processes = (i for i in item_list if isinstance(i, ogAST.Process))
for state in states:
# First check if state has already been pasted
try:
new_item = Renderer.render(state,
scene=CLIPBOARD,
terminators=terminators,
states=states)
except TypeError as err:
LOG.debug('No paste "' + state.inputString + '" -' + str(err))
# Discard terminators (explanation given in Renderer._state)
pass
else:
LOG.debug('PASTE STATE "' + state.inputString + '"')
symbols.append(new_item)
# Insert the new state at click coordinates
Renderer.add_to_scene(new_item, scene)
for each in chain(text_areas, labels, procedures, processes):
LOG.debug('PASTE TA/LAB/PROC')
new_item = Renderer.render(each, scene, states=states)
symbols.append(new_item)
if start:
start, = start
LOG.debug('PASTE START')
for item in scene.visible_symb:
if isinstance(item, sdlSymbols.Start):
raise TypeError('Only one START symbol is possible')
new_item = Renderer.render(start, scene, states=states)
symbols.append(new_item)
return symbols
def __init__(self, game: GameMain, city: City) -> None:
super().__init__(game)
self.city = city
game.city = self.city
game.city_size = self.city.size
self.eye_pos = (
[int(i / self.game.renderer.tile_size) for i in self.game.center])
game.renderer = Renderer(game, self.city, self.eye_pos)
self.iso_eye_pos = (
[int(i) for i in game.renderer.cart2iso(self.eye_pos)])
def paste_floating_objects(scene):
''' Paste items with no parents (states, text areas) '''
symbols = []
LOG.debug('PASTING FLOATING OBJECTS')
for item_list, terminators in COPY_PASTE:
# states is a list passed as parameter - not a generator:
start = [i for i in item_list if isinstance(i, ogAST.Start)]
states = [i for i in item_list if isinstance(i, ogAST.State)]
text_areas = (i for i in item_list if isinstance(i, ogAST.TextArea))
labels = (i for i in item_list if isinstance(i, ogAST.Floating_label))
procedures = (i for i in item_list if isinstance(i, ogAST.Procedure))
processes = (i for i in item_list if isinstance(i, ogAST.Process))
for state in states:
# First check if state has already been pasted
try:
new_item = Renderer.render(state, scene=CLIPBOARD,
terminators=terminators, states=states)
except TypeError as err:
LOG.debug('No paste "' + state.inputString + '" -' + str(err))
# Discard terminators (explanation given in Renderer._state)
pass
else:
LOG.debug('PASTE STATE "' + state.inputString + '"')
symbols.append(new_item)
# Insert the new state at click coordinates
Renderer.add_to_scene(new_item, scene)
for each in chain(text_areas, labels, procedures, processes):
LOG.debug('PASTE TA/LAB/PROC')
new_item = Renderer.render(each, scene, states=states)
symbols.append(new_item)
if start:
start, = start
LOG.debug('PASTE START')
for item in scene.visible_symb:
if isinstance(item, sdlSymbols.Start):
raise TypeError('Only one START symbol is possible')
new_item = Renderer.render(start, scene, states=states)
symbols.append(new_item)
return symbols
def paste_below_item(parent, scene):
''' Paste items under a selected symbol '''
LOG.debug('Pasting below item ' + repr(parent)[slice(0, 20)])
symbols = []
for item_list, _ in COPY_PASTE:
states = [i for i in item_list if isinstance(i, ogAST.State)]
for i in [c for c in item_list if not isinstance
(c, (ogAST.State, ogAST.TextArea, ogAST.Start))]:
LOG.debug('PASTE ' + str(i))
# Create the new item from the AST description
new_item = Renderer.render(i, scene=CLIPBOARD,
parent=None, states=states)
# Check that item is compatible with parent
if (type(new_item).__name__ in parent.allowed_followers):
# Move the item from the clipboard to the scene
Renderer.add_to_scene(new_item, scene)
new_item.setPos(0, 0)
symbols.append(new_item)
else:
raise TypeError('Cannot paste here ({t1} cannot follow {t2}'
.format(t1=type(new_item), t2=type(parent)))
return symbols
def paste_floating_objects(scene):
''' Paste items with no parents (states, text areas) '''
symbols = []
LOG.debug('PASTING FLOATING OBJECTS')
for item_list, terminators in COPY_PASTE:
# states is a list passed as parameter - not a generator:
start = [i for i in item_list if isinstance(i, ogAST.Start)]
states = [i for i in item_list if isinstance(i, ogAST.State)]
text_areas = (i for i in item_list if isinstance(i, ogAST.TextArea))
labels = (i for i in item_list if isinstance(i, ogAST.Floating_label))
procedures = (i for i in item_list if isinstance(i, ogAST.Procedure))
processes = (i for i in item_list if isinstance(i, ogAST.Process))
for state in states:
# nesting is not copied, because the nested content is a scene
# that is just referenced.. content must be actually copied
# to a new scene only if a state is renamed (this will preserve
# the nesting content of the original state)
# First check if state has already been pasted
try:
new_item = Renderer.render(state,
scene=CLIPBOARD,
terminators=terminators,
states=states)
except TypeError as err:
LOG.debug('No paste "' + state.inputString + '" -' + str(err))
# Discard terminators (explanation given in Renderer._state)
pass
else:
LOG.debug('PASTE STATE "' + state.inputString + '"')
symbols.append(new_item)
# Insert the new state at click coordinates
Renderer.add_to_scene(new_item, scene)
for each in chain(text_areas, labels):
LOG.debug('PASTE Text Area/Label')
new_item = Renderer.render(each, scene, states=states)
symbols.append(new_item)
for each in chain(procedures, processes):
LOG.debug('PASTE Process/Procedure')
new_item = Renderer.render(each, scene, states=states)
symbols.append(new_item)
new_item.nested_scene = scene.create_subscene(
new_item.context_name)
# Render recursively, creating any required scene
try:
new_item.nested_scene.render_everything(each.content)
except TypeError as err:
LOG.debug(str(err))
if start:
start, = start
LOG.debug('PASTE START')
for item in scene.visible_symb:
if isinstance(item, sdlSymbols.Start):
raise TypeError('Only one START symbol is possible')
new_item = Renderer.render(start, scene, states=states)
symbols.append(new_item)
return symbols
def render_scene(self, dimensions, image_name):
to_canvas = TransformationFactory.to_canvas(dimensions)
randy = Renderer(dimensions) # initialize renderer
print("Rendering...")
# TO VIEW SPACE
scene_edges = []
scene_faces = []
for model in self.scene.models:
for face in model.faces:
scene_faces.append(
Face(face.v1, face.v2, face.v3, random_color()))
print("faces in scene: {}".format(len(scene_faces)))
scene_faces = transform_faces(scene_faces, self.to_view_space)
print("basis swap to camera complete")
# RENDER BEFORE CULLING
self.render_face_edges(scene_faces, dimensions,
image_name + "_beforeCulling",
[self.to_screen_space, to_canvas])
# CULLING
before_filter = len(scene_faces)
culled_faces = []
for face in scene_faces:
if not face.should_cull():
culled_faces.append(face)
difference = before_filter - len(culled_faces)
print(str(difference) + " FACES CULLED")
# TO SCREEN SPACE
scene_faces = transform_faces(culled_faces, self.to_screen_space)
# RENDER AFTER CULLING
self.render_face_edges(scene_faces, dimensions,
image_name + "_afterCulling", [to_canvas])
# TODO: Clipping
scene_faces = clip(scene_faces)
self.render_face_edges(scene_faces, dimensions,
image_name + "_afterClipping", [to_canvas])
# TODO: RENDER HERE
scene_faces = transform_faces(scene_faces, to_canvas)
for face in scene_faces:
randy.rasterize(face)
randy.save(image_name + "_afterRasterizing")
# TODO: Rasterize
# TODO: Z-Buffer
print("image saved!")
def paste_floating_objects(scene):
''' Paste items with no parents (states, text areas) '''
symbols = []
LOG.debug('PASTING FLOATING OBJECTS')
for item_list, terminators in COPY_PASTE:
# states is a list passed as parameter - not a generator:
start = [i for i in item_list if isinstance(i, ogAST.Start)]
states = [i for i in item_list if isinstance(i, ogAST.State)]
text_areas = (i for i in item_list if isinstance(i, ogAST.TextArea))
labels = (i for i in item_list if isinstance(i, ogAST.Floating_label))
procedures = (i for i in item_list if isinstance(i, ogAST.Procedure))
processes = (i for i in item_list if isinstance(i, ogAST.Process))
for state in states:
# nesting is not copied, because the nested content is a scene
# that is just referenced.. content must be actually copied
# to a new scene only if a state is renamed (this will preserve
# the nesting content of the original state)
# First check if state has already been pasted
try:
new_item = Renderer.render(state, scene=CLIPBOARD,
terminators=terminators, states=states)
except TypeError as err:
LOG.debug('No paste "' + state.inputString + '" -' + str(err))
# Discard terminators (explanation given in Renderer._state)
pass
else:
LOG.debug('PASTE STATE "' + state.inputString + '"')
symbols.append(new_item)
# Insert the new state at click coordinates
Renderer.add_to_scene(new_item, scene)
for each in chain(text_areas, labels):
LOG.debug('PASTE Text Area/Label')
new_item = Renderer.render(each, scene, states=states)
symbols.append(new_item)
for each in chain(procedures, processes):
LOG.debug('PASTE Process/Procedure')
new_item = Renderer.render(each, scene, states=states)
symbols.append(new_item)
new_item.nested_scene = scene.create_subscene(
new_item.context_name)
# Render recursively, creating any required scene
try:
new_item.nested_scene.render_everything(each.content)
except TypeError as err:
LOG.debug(str(err))
if start:
start, = start
LOG.debug('PASTE START')
for item in scene.visible_symb:
if isinstance(item, sdlSymbols.Start):
raise TypeError('Only one START symbol is possible')
new_item = Renderer.render(start, scene, states=states)
symbols.append(new_item)
return symbols
def start():
win_offset_y = 25
os.environ['SDL_VIDEO_WINDOW_POS'] = str(0) + "," + str(win_offset_y)
pygame.init()
info_obj = pygame.display.Info()
#print(info_obj)
screen_dim = Vec2d(int(info_obj.current_w),
int(info_obj.current_h - win_offset_y))
em = EventManager.EventManager()
game_engine = GameEngine.GameEngine(em, screen_dim)
renderer = Renderer.Renderer(em, game_engine, screen_dim)
controller = Controller.Controller(em, game_engine)
game_engine.run()
def __init__(self,
parent,
sf,
notations,
sd=SongDecorator(),
embedded=False):
object.__init__(self)
show_link = not embedded and platform.system() != 'Linux'
self.link = None
if show_link:
self.main_panel = wx.Window(parent)
bSizer = wx.BoxSizer(wx.VERTICAL)
self.link = wx.adv.HyperlinkCtrl(
self.main_panel, 0, _("Copy formatted song to clipboard"), '')
tt = wx.ToolTip(
_("Copy formatted song to clipboard, so that it can be pasted in any program and printed"
))
self.link.SetToolTip(tt)
bSizer.Add(self.link, 0, wx.EXPAND)
parent = self.main_panel
self.panel = wx.ScrolledWindow(parent, style=wx.BORDER_DOUBLE)
self.panel.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
self.pixedScrolled = 10
self.panel.SetScrollbars(self.pixedScrolled, self.pixedScrolled, 0, 0)
self.panel.Bind(wx.EVT_PAINT, self.OnPaint, self.panel)
self.panel.SetBackgroundColour(wx.WHITE)
self.text = ""
if show_link:
bSizer.Add(self.panel, 1, wx.EXPAND)
else:
self.main_panel = self.panel
#SongFormat
self.renderer = Renderer(sf, sd, notations)
if show_link:
self.main_panel.SetSizer(bSizer)
self.main_panel.Layout()
def game_start(args):
engine = g.GameEngine(int(args.size))
re = None
num_games = int(args.number)
num_humans = int(args.humans)
board_size = int(args.size)
gui = int(args.graphical)
if gui:
re = r.Renderer(engine)
re.window_setup(500, 500)
for i in range(num_games):
winner, num_moves = play_game(engine, num_humans, re, FIRST_AI,
SECOND_AI, board_size)
print('Player', i, 'won in', num_moves, 'moves.')
def __init__(self, direction, speed):
self.color = red
self.direction = direction
self.speed = speed
self.x = 0
self.y = 0
self.end_x = 0
self.end_y = True
self.isActive = True
self.renderer = Renderer.Renderer()
self.aum = AUM.AttackUnitMover()
self.top_side_attack_config = []
self.left_side_attack_config = []
self.bottom_side_attack_config = []
self.right_side_attack_config = []
self.create_attack_config()
def __init__(self):
self.player_id = None
self.player_x = 300
self.player_y = 300
self.player_lead_x_change = 0
self.player_lead_y_change = 0
self.player_class = 0.14026667
#self.ammo = ammo
self.time_lasted = 0
self.average_performance = 0
#Possible Feature variables
self.health = 100
self.score = 0 #measures endurance
self.class_packs = 0 #measures agility
#apply game rules, violation of which will cost something
#resourcefulness
#ammo and shields
self.renderer = Renderer.Renderer()
'''
Created on Nov 8, 2012
@author: Wighton
'''
from Planner import *
from Renderer import *
planner = Planner(500,500)
planner.loadObstacles(open("/Users/Wighton/Documents/Aptana_Workspace/MotionPlanner/obstacles", "r"));
planner.loadRobot(open("/Users/Wighton/Documents/Aptana_Workspace/MotionPlanner/robot", "r"));
planner.getRoadmap()
renderer = Renderer(700, 700)
renderer.addSceneObject(planner)
renderer.start()
del im
del t
t = self.image
self.image = self.tomorrow
self.tomorrow = t
self.ticks += 1
if __name__ == "__main__":
logging.getLogger().setLevel(logging.INFO)
logging.basicConfig()
args = Renderer.cmd_line_args()
LN2015 = Renderer.Player('gameoflife', MADRIX_X, MADRIX_Y, fps=24, args=args)
LN2015.load_sprite("gameoflife", 50, GOL())
alive = True
while alive:
alive = LN2015.run()
if 'windows' in platform.platform().lower():
ffmpeg_exe = 'C:\\Users\\admin\\Desktop\\ffmpeg-20150921-git-74e4948-win64-static\\bin\\ffmpeg.exe'
else:
ffmpeg_exe = 'ffmpeg'
LN2015.export_video(ffmpeg_exe)
def startGame(self):
if self._debugMode:
print("Initializing game...")
self._running = True
self._mainWindow = tk.Tk()
self._mainWindow.protocol("WM_DELETE_WINDOW", self.stopGame)
self._mainWindow.title(self._title)
self._mainWindow.resizable(0, 0)
self._renderer = Renderer(self)
self._gameInput = Input(self)
try:
self._mainCanvas = tk.Canvas(
self._mainWindow, width=self._size[0], height=self._size[1],
borderwidth=0
)
self._mainCanvas.pack()
self._mainCanvas.update()
except:
self._mainWindow = None
if self._debugMode:
print("!!! Unexpected error occurred on startGame.")
raise
if self._debugMode:
print("Game running...")
lastTimer = self.getTimeMicros()
lastTime = lastTimer
renderDelta = 0
updateDelta = 0
frames = 0
updates = 0
microPerRender = 1000000 / self._targetFPS
microPerUpdate = 1000000 / self._targetUPS
while self._running:
timeNow = self.getTimeMicros()
timeDelta = (timeNow-lastTime)
renderDelta += timeDelta
updateDelta += timeDelta
lastTime = timeNow
if updateDelta > microPerUpdate:
updateDelta -= microPerUpdate
updates += 1
if self._currentScene is not None:
self._gameScenes[self._currentScene].onUpdate(
self._gameInput, timeDelta/1000000.0
)
self._gameInput._update()
if not self._vSync or renderDelta > microPerRender:
renderDelta -= microPerRender
frames += 1
if self._currentScene is not None:
self._renderer.clearAll(self._gameBG)
self._gameScenes[self._currentScene].onRender(
self._renderer, renderDelta
)
if self._showFPS:
self._renderer.setColor(Color(255, 255, 255))
self._renderer.drawString(
(10, 5), self._infoText, tk.NW, tk.LEFT
)
self.sleep(self._idleTime)
if self.getTimeMicros() - lastTimer >= 1000000:
self._PSInfo = [frames, updates, timeDelta/1000.0]
self._infoText = "%d FPS, %d UPS [%0.2fms]" % (
frames, updates, timeDelta/1000.0
)
if self._debugMode:
print(self._infoText)
frames = 0
updates = 0
lastTimer = self.getTimeMicros()
if self._currentScene is not None:
self._gameScenes[self._currentScene].onExit()
tk.sys.exit(0)
class Game:
_debugMode = False
_PSInfo = [-1, -1, -1]
_infoText = "-1 FPS -1 UPS [0.00ms]"
_mainWindow = None
_mainCanvas = None
_renderer = None
_gameInput = None
_currentScene = None
_title = "ParticlePlay Game"
_gameBG = Color(0, 0, 0)
_size = (640, 480)
_targetFPS = 30
_targetUPS = 30
_vSync = False
_showFPS = True
_running = False
_idleTime = 0.002
_gameScenes = {}
def setDebugMode(self, debug):
self._debugMode = debug
def setTitle(self, title):
self._title = title
if self._mainWindow is not None:
self._mainWindow.title(title)
def setSize(self, size):
self._size = size
def getSize(self):
return self._size
def getWidth(self):
return self._size[0]
def getHeight(self):
return self._size[1]
def setGameBG(self, color):
self._gameBG = color
def setTargetFPS(self, targetFPS):
self._targetFPS = targetFPS
def setTargetUPS(self, targetUPS):
self._targetUPS = targetUPS
def setIdleTime(self, idleTime):
self._idleTime = idleTime
def setShowFPS(self, showFPS):
self._showFPS = showFPS
def setVSync(self, vSync):
self._vSync = vSync
def getFPS(self):
return self._PSInfo[0]
def getUPS(self):
return self._PSInfo[1]
def addScene(self, sceneName, gameScene):
gameScene.game = self
gameScene.name = sceneName
self._gameScenes[sceneName] = gameScene
def getScene(self, sceneName):
return self._gameScenes[sceneName]
def removeScene(self, sceneName):
del self._gameScenes[sceneName]
def enterScene(self, scene, sceneName="UntitledScene"):
if isinstance(scene, str):
scene = self.getScene(scene)
elif isinstance(scene, Scene):
self.addScene(sceneName, scene)
if scene is not None:
if self._debugMode:
if sceneName == "UntitledScene":
print("Enter a new scene")
else:
print("Current Scene: " + scene.name)
startGame = self._currentScene is None
self._currentScene = scene.name
scene.onInit()
if startGame:
self.startGame()
def startGame(self):
if self._debugMode:
print("Initializing game...")
self._running = True
self._mainWindow = tk.Tk()
self._mainWindow.protocol("WM_DELETE_WINDOW", self.stopGame)
self._mainWindow.title(self._title)
self._mainWindow.resizable(0, 0)
self._renderer = Renderer(self)
self._gameInput = Input(self)
try:
self._mainCanvas = tk.Canvas(
self._mainWindow, width=self._size[0], height=self._size[1],
borderwidth=0
)
self._mainCanvas.pack()
self._mainCanvas.update()
except:
self._mainWindow = None
if self._debugMode:
print("!!! Unexpected error occurred on startGame.")
raise
if self._debugMode:
print("Game running...")
lastTimer = self.getTimeMicros()
lastTime = lastTimer
renderDelta = 0
updateDelta = 0
frames = 0
updates = 0
microPerRender = 1000000 / self._targetFPS
microPerUpdate = 1000000 / self._targetUPS
while self._running:
timeNow = self.getTimeMicros()
timeDelta = (timeNow-lastTime)
renderDelta += timeDelta
updateDelta += timeDelta
lastTime = timeNow
if updateDelta > microPerUpdate:
updateDelta -= microPerUpdate
updates += 1
if self._currentScene is not None:
self._gameScenes[self._currentScene].onUpdate(
self._gameInput, timeDelta/1000000.0
)
self._gameInput._update()
if not self._vSync or renderDelta > microPerRender:
renderDelta -= microPerRender
frames += 1
if self._currentScene is not None:
self._renderer.clearAll(self._gameBG)
self._gameScenes[self._currentScene].onRender(
self._renderer, renderDelta
)
if self._showFPS:
self._renderer.setColor(Color(255, 255, 255))
self._renderer.drawString(
(10, 5), self._infoText, tk.NW, tk.LEFT
)
self.sleep(self._idleTime)
if self.getTimeMicros() - lastTimer >= 1000000:
self._PSInfo = [frames, updates, timeDelta/1000.0]
self._infoText = "%d FPS, %d UPS [%0.2fms]" % (
frames, updates, timeDelta/1000.0
)
if self._debugMode:
print(self._infoText)
frames = 0
updates = 0
lastTimer = self.getTimeMicros()
if self._currentScene is not None:
self._gameScenes[self._currentScene].onExit()
tk.sys.exit(0)
def stopGame(self):
print("Attempting to close game...")
if (self._currentScene is not None
and not self._gameScenes[self._currentScene].willExit()):
return
if self._debugMode:
print("Closing game...")
self._running = False
def getTimeMicros(self):
return int(round(time.time() * 1000000))
def sleep(self, secs):
if self._mainWindow is None:
time.sleep(secs)
else:
self._mainWindow.update_idletasks()
self._mainWindow.after(int(1000 * secs), self._mainWindow.quit)
self._mainWindow.mainloop()