def Down(event):
global screenoffset
screenoffset = (screenoffset[0], screenoffset[1] + 1)
Move()
def Move():
global screenoffset
for p, val in livecells.items():
pphys = pfroml((p[0] + screenoffset[0], p[1] + screenoffset[1]))
val[0].position = pphys
val[1].position = pphys
App.listenMouseEvent('mousedown', MouseDown)
App.listenMouseEvent('mouseup', MouseUp)
App.listenMouseEvent('mousemove', MouseMove)
App.listenKeyEvent('keypress', 'space', Spacebar)
App.listenKeyEvent('keydown', 'left arrow', Left)
App.listenKeyEvent('keydown', 'right arrow', Right)
App.listenKeyEvent('keydown', 'up arrow', Up)
App.listenKeyEvent('keydown', 'down arrow', Down)
print("Press <space> to start and stop.")
print("Use mouse to set initial living cells.")
print("Use cursor keys to move the screen.")
myapp = App()
myapp.run(step)
# Sierpinsky demo
from ggame import CircleAsset, Sprite, App, Color, LineStyle
GASKET_SIZE = 64
black = Color(0x000000, 1.0)
thinline = LineStyle(1, black)
asset = CircleAsset(0.25, thinline, black)
# Draw a Sierpinsky Gasket of width and height d,
# with upper left at (x, y).
def draw_sierpinsky(x, y, d):
if d <= 1:
Sprite(asset, (x, y)) # base case
else:
# recurse on upper left quadrant
draw_sierpinsky(x, y, d/2)
# recurse on upper right quadrant
draw_sierpinsky(x + d/2, y, d/2)
# recurse on lower right quadrant
draw_sierpinsky(x + d/2, y + d/2, d/2)
draw_sierpinsky(0, 0, GASKET_SIZE)
App().run()
def countneighbors(self, addr):
count = 0
for naddr in self.neighboraddresses(addr):
count += self.population(naddr)
return count
def birthnew(self, nextgen, addr):
if addr not in self.livingcells:
if self.countneighbors(addr) == 3:
nextgen[addr] = 0
def step(self):
nextgen = {}
for addr in self.livingcells:
n = self.countneighbors(addr)
if n in (2, 3):
nextgen[addr] = self.livingcells[addr]+1
for naddr in self.neighboraddresses(addr):
self.birthnew(nextgen, naddr)
for s in self.getSpritesbyClass(Cell):
s.visible = False
s.destroy()
self.livingcells = nextgen
for c in self.livingcells:
isnew = self.livingcells[c] == 0
Cell(isnew, (c[0]*CELLDIAMETER, c[1]*CELLDIAMETER))
App = ConwayGame()
App.run()
youwin = TextAsset("Congrats, you win!!")
youlose = TextAsset("Sorry, but you lose :(")
for s in secondslist:
s.visible = False
for s in blocklist:
s.visible = False
blocklist[0].visible = True
wintext = Sprite(youwin, (0, 0))
wintext.visible = False
losetext = Sprite(youlose, (0, 365))
losetext.visible = False
blockcount = 0
#Mouse clicks
def mouseClick(event):
global blockcount
if gameend == False:
if blockcount >= len(blocklist):
return
if event.x >= blocklist[blockcount].x and event.y >= blocklist[blockcount].y and event.x <= blocklist[blockcount].x + 50 and event.y <= blocklist[blockcount].y + 50:
if event.x >= rect11.x and event.y >= rect11.y and event.x <= rect11.x + 50 and event.y <= rect11.y + 50:
wintext.visible = True
#blocklist[blockcount].visible = False
blockcount = blockcount + 1
blocklist[blockcount].visible = True
myapp = App()
myapp.listenMouseEvent('click', mouseClick)
myapp.run(step)
brn = Color(0x5C3317, 0.9)
pale = Color(0xFFFACD, 0.4)
bl_line = LineStyle(3, black)
thinline = LineStyle(1, black)
brkhr = RectangleAsset(130, 32, bl_line, brn)
head = EllipseAsset(120, 100, bl_line, pale)
nose = PolygonAsset([(50, 60), (75, 40), (100, 60), (50, 60)], thinline, turqo)
eye = CircleAsset(20, thinline, Lgreen)
pupil = CircleAsset(8, thinline, purp)
mouth = PolygonAsset([(0, 0), (100, 0), (80, 20), (20, 20), (0, 0)], bl_line,
Orange)
hat = RectangleAsset(80, 20, thinline, turqo)
neck = EllipseAsset(60, 75, bl_line, pale)
arm = PolygonAsset([(30, 50), (125, 50), (145, 80), (30, 80)], thinline, brn)
Sprite(head, (150, 140))
Sprite(brkhr, (90, 10))
Sprite(nose, (75, 70))
Sprite(eye, (190, 80))
Sprite(eye, (110, 80))
Sprite(pupil, (190, 80))
Sprite(pupil, (110, 80))
Sprite(mouth, (100, 170))
Sprite(hat, (115, 15))
Sprite(neck, (150, 300))
Sprite(arm, (160, 180))
my2app = App()
my2app.run()
roof2 = PolygonAsset ([(400, 300), (400, 175), (680, 300)], thinline, green) Sprite(roof2) windowellipse = EllipseAsset (75, 30, thinline, aqua) Sprite(windowellipse, (250, 250)) windowline = PolygonAsset ([(175, 251), (175, 250), (325, 251), (325, 250)], thinline, black) Sprite(windowline) windowline2 = PolygonAsset ([(200, 225), (201, 225), (200, 275), (201, 275)], thinline, black) Sprite(windowline2) windowline3 = PolygonAsset ([(249, 200), (250, 200), (249, 300), (250, 300)], thinline, black) Sprite(windowline3) windowline4 = PolygonAsset ([(299, 200), (300, 200), (299, 300), (300, 300)], thinline, black) Sprite(windowline4) # add your code here /\ /\ /\ myapp = App() myapp.run()
elif neighbors[i][j] > 3:
grid[i][j] = 0
elif grid[i][j] != 0:
grid[i][j] += 1
elif neighbors[i][j] == 3:
grid[i][j] += 1
# Displays live cells
displayCells()
# Get dimensions from user
# Width of grid
gridcolumns = int(input("How wide would you like the simulation to be? "))
# Height of grid
gridrows = int(input("How tall would you like the simulation to be? "))
# Start w/ random initial conditions or user determined?
# Grid[row][column]
grid = []
# Create random grid
for i in range(0, gridrows):
grid.append([0] * gridcolumns)
for j in range(0, gridcolumns):
grid[i][j] = random.randint(0, 1)
if grid[i][j] == 1:
grid[i][j] = random.randint(1, 7)
myapp = App()
myapp.run(tick)
"""
"""
You may use code supplied in the graphics tutorials as a starting point.
Live cells in your program may be represented as rectangles, circles, or any other shape that you would like to use. The example in the video above uses small circles.
The initial state of live cells may be preset or randomized by you, but it must be possible to start the game with a blank screen.
As the Wikipedia article described, your "playing area" may have fixed boundaries, boundaries that wrap around top and bottom, or may be entirely unbounded (in some ways, the easiest approach!).
The user must be able to "turn on" cells by clicking on them with the mouse, or by click-dragging across the window.
If your playing area is unbounded, then the up/down/right/left cursor keys should allow the user to scroll the playing area within the window.
Your live cells should be two different colors: one for its first day of “life”, the second for all subsequent days.
"""
print("click and drag to add a cell. Old cells are blue, new cells are red.")
from ggame import App, Color, LineStyle, Sprite
from ggame import RectangleAsset, CircleAsset, EllipseAsset, PolygonAsset
o = 0
myapp = App()
go = False
#colors
invis = Color(0xffffff, 1)
red = Color(0xff0000, 1.0)
green = Color(0x00ff00, 1.0)
blue = Color(0x0000ff, 1.0)
black = Color(0x000000, 1.0)
width = myapp.width
height = myapp.height
#list of coords of cells
newcells = []
oldcells = []
def test_app(self):
a3 = App(100,100)
# event handling
a3.listenKeyEvent(KeyEvent.keydown, "space", self.spacehandler)
a3.listenMouseEvent(MouseEvent.mousewheel, self.wheelhandler)
key = keyevent('keydown', 32)
a3._keyEvent(key)
mouse = mouseevent('wheel', 1, 2, 99)
a3._mouseEvent(mouse)
# confirm no events after unlisten
a3.unlistenKeyEvent(KeyEvent.keydown, "space", self.spacehandler)
a3.unlistenMouseEvent(MouseEvent.mousewheel, self.wheelhandler)
a3._keyEvent(key)
a3._mouseEvent(mouse)
# assert that each handler was executed only once
self.assertEqual(self.keyevtx, 1)
self.assertEqual(self.mouseevtx, 1)
# run the app
a3.run()
# and destroy it
a3.destroy('dummy')
def test_app(self):
a3 = App(100,100)
# event handling
a3.listenKeyEvent(KeyEvent.keydown, "space", self.spacehandler)
a3.listenMouseEvent(MouseEvent.mousewheel, self.wheelhandler)
key = keyevent('keydown', 32)
a3._keyEvent(key)
mouse = mouseevent('wheel', 1, 2, 99)
a3._mouseEvent(mouse)
# confirm no events after unlisten
a3.unlistenKeyEvent(KeyEvent.keydown, "space", self.spacehandler)
a3.unlistenMouseEvent(MouseEvent.mousewheel, self.wheelhandler)
a3._keyEvent(key)
a3._mouseEvent(mouse)
# assert that each handler was executed only once
self.assertEqual(self.keyevtx, 1)
self.assertEqual(self.mouseevtx, 1)
# run the app
a3.run()
# and destroy it
a3._destroy()
See:
https://github.com/HHS-IntroProgramming/Sine-Cosine/blob/master/README.md
for a detailed list of requirements for this assignment.
https://github.com/HHS-IntroProgramming/Standards-and-Syllabus/wiki/Displaying-Graphics
for general information on how to use ggame.
https://github.com/HHS-IntroProgramming/Standards-and-Syllabus/wiki/Programmed-Graphics
for general information on using list comprehensions to generate graphics.
http://brythonserver.github.io/ggame/
for detailed information on ggame.
"""
from ggame import App, Color, LineStyle, Sprite, CircleAsset
from math import sin, cos, radians
app = App()
app.run()
xcoords = [x for x in range(0, 360, 10)]
x = list(range(0, 360, 10))
red = Color(0xff0000, 1.0)
blue = Color(0x0000ff, 1.0)
print('Its Purple If I Say it is!')
purple = Color(0x000000, 1.0)
#Blue Circles
x = list(range(0, 360, 10))
#y = 100+100**sin(radians(x))
myline = LineStyle(1, blue)
Mycircle = CircleAsset(5, myline, blue)
sprites = [Sprite(Mycircle, (x, 100 + 100 * sin(radians(x)))) for x in xcoords]
#Red Circles
Myline2 = LineStyle(1, red)
return l1
def spaceKey(event):
global lifelist
lifelist = conway(lifelist)
def click(event):
mcx = int(event.x)
mcy = int(event.y)
acx = int(mcx / pixelsize)
acy = int(mcy / pixelsize)
if acx < 0 or acy < 0 or acx > xsize or acy > ysize:
return
place = [acx, acy]
place2 = l2.index(place)
pixel = lifelist[place2]
if pixel == "none":
lifelist[place2] = "life1"
if pixel == "life1" or pixel == "life2":
lifelist[place2] = "none"
printing(lifelist)
printing(lifelist)
myapp = App()
step = myapp.listenKeyEvent('keydown', 'space', spaceKey)
clickity = myapp.listenMouseEvent('click', click)
myapp.run(step)
from ggame import App, ImageAsset, Sprite
# Create a displayed object using an image asset
Sprite(ImageAsset("ggame/bunny.png"), (100,100))
# Create the app, with a 500x500 pixel stage
app = App(500,500)
# Run the app
app.run()
from ggame import App, RectangleAsset, ImageAsset, Sprite, LineStyle, Color, Frame, CircleAsset
PrettyColors={'Green':'0x00ff00', 'Red':'0xff000', 'Blue':'0x0000ff'}
class Circle(App):
def __init__(self, radius):
super().__init__(radius)
radius=int(input("Radius?"))
black=Color(0,1)
red=Color(0xA62A2A)
ogline=Linestyle(1, black)
Circle_Asset=CircleAsset(radius, ogline, red)
Circle=Sprite(Circle_Asset, (100,100))
myapp = App(Circle)
myapp.run()
from ggame import App, Color, LineStyle, Sprite from ggame import RectangleAsset, CircleAsset, EllipseAsset, PolygonAsset # Three primary colors with no transparency (alpha = 1.0) red = Color(0xff0000, 1.0) green = Color(0x00ff00, 1.0) blue = Color(0x0000ff, 1.0) black = Color(0x000000, 1.0) # Define a line style that is a thin (1 pixel) wide black line thinline = LineStyle(1, black) # A graphics asset that represents a rectangle rectangle = RectangleAsset(50, 20, thinline, blue) # Now display a rectangle Sprite(rectangle) myapp = App()
def countneighbors(self, addr):
count = 0
for naddr in self.neighboraddresses(addr):
count += self.population(naddr)
return count
def birthnew(self, nextgen, addr):
if addr not in self.livingcells:
if self.countneighbors(addr) == 3:
nextgen[addr] = 0
def step(self):
nextgen = {}
for addr in self.livingcells:
n = self.countneighbors(addr)
if n in (2, 3):
nextgen[addr] = self.livingcells[addr] + 1
for naddr in self.neighboraddresses(addr):
self.birthnew(nextgen, naddr)
for s in self.getSpritesbyClass(Cell):
s.visible = False
s.destroy()
self.livingcells = nextgen
for c in self.livingcells:
isnew = self.livingcells[c] == 0
Cell(isnew, (c[0] * CELLDIAMETER, c[1] * CELLDIAMETER))
App = ConwayGame()
App.run()
if ball.go:
ball.x += ball.dir
if ball.x + ball.width > SCREEN_WIDTH or ball.x < 0:
ball.x -= ball.dir
reverse(ball)
# Handle the space key
def spaceKey(event):
ball.go = not ball.go
pop.play()
pew1.play()
# Handle the "reverse" key
def reverseKey(event):
reverse(ball)
pop.play()
# Handle the mouse click
def mouseClick(event):
ball.x = event.x
ball.y = event.y
pew1.play()
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
myapp.listenKeyEvent('keydown', 'space', spaceKey)
myapp.listenKeyEvent('keydown', 'r', reverseKey)
myapp.listenMouseEvent('click', mouseClick)
myapp.run(step)
from ggame import App, RectangleAsset, ImageAsset, SoundAsset
from ggame import LineStyle, Color, Sprite, Sound
myapp = App()
# define colors and line style
green = Color(0x00ff00, 1)
black = Color(0, 1)
noline = LineStyle(0, black)
# a rectangle asset and sprite to use as background
bg_asset = RectangleAsset(myapp.width, myapp.height, noline, green)
bg = Sprite(bg_asset, (0, 0))
# A ball! This is already in the ggame-tutorials repository
ball_asset = ImageAsset("images/orb-150545_640.png")
ball = Sprite(ball_asset, (0, 0))
# Original image is too big. Scale it to 1/10 its original size
ball.scale = 0.1
# custom attributes
ball.direction = 1
ball.go = True
# reverse - change the ball direction
def reverse(b):
b.direction *= -1
# Set up function for handling screen refresh
def step():
if ball.go:
ace = 1
elif o == AD:
yourscore += 1
ace = 1
else:
yourscore += 10
if yourscore > 21.5:
print("You busted")
t = 3
yb = 5
allowbet = 1
money = int(money) - int(bet)
print("You have $" + str(money))
print("Press space to start another round")
bet = 0
m = 2
n = 2
#changing you score
#Note: This game is for educational use only
myapp = App()
app = App(500, 500)
app.run(step)
myapp.listenKeyEvent('keydown', 'space', pauseplay)
myapp.listenKeyEvent('keydown', 's', stay)
myapp.listenKeyEvent('keydown', 'enter', begin)
myapp.listenKeyEvent('keydown', 'h', hit)
myapp.listenKeyEvent('keydown', 'b', betting)
myapp.listenKeyEvent('keydown', 'r', rules)
if bungo.x >= collision[jum].x - 35 and bungo.x <= collision[
jum].x + 35:
if bungo.y >= collision[
jum].y - 35 and bungo.y <= collision[jum].y + 35:
bungo.x = posendtickx
jum += 1
if bungo.y >= 667:
bungo.y = posendticky
jump = 0
if bungo.y <= 0:
vertvel = 0
bungo.y = posendticky
if bungo.x >= 998 or bungo.x <= 0:
bungo.x = posendtickx
#app stuff
for j in range(1):
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
myapp.listenMouseEvent('click', mouseClick)
myapp.listenKeyEvent('keydown', 'w', wallPlaceKey)
myapp.listenKeyEvent('keydown', 'b', bungoKey)
myapp.listenKeyEvent('keydown', 'j', jumpyKey)
myapp.listenKeyEvent('keydown', 'up arrow', jumpgo)
myapp.listenKeyEvent('keydown', 'left arrow', leftgo)
myapp.listenKeyEvent('keydown', 'right arrow', rightgo)
myapp.listenKeyEvent('keyup', 'right arrow', rightstop)
myapp.listenKeyEvent('keyup', 'left arrow', leftstop)
myapp.run(step)
ball.x += ball.dir
if ball.x + ball.width > SCREEN_WIDTH or ball.x < 0:
ball.x -= ball.dir
reverse(ball)
# Handle the space key
def spaceKey(event):
ball.go = not ball.go
# Handle the "reverse" key
def reverseKey(event):
reverse(ball)
# Handle the mouse click
def mouseClick(event):
ball.x = event.x
ball.y = event.y
pew1.play()
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
# Set up event handlers for the app
myapp.listenKeyEvent('keydown', 'space', spaceKey)
myapp.listenKeyEvent('keydown', 'r', reverseKey)
myapp.listenMouseEvent('click', mouseClick)
myapp.run(step)
thickgreen = LineStyle(7, green)
thinwhite = LineStyle(1, white)
thingreen = LineStyle(1, green)
ground = RectangleAsset(500, 20, thinline, brown)
Sprite((ground), (0, 220))
pipe1 = RectangleAsset(30, 50, thingreen, green)
Sprite((pipe1), (350, 180))
pipe2 = EllipseAsset(25, 10, thickgreen, black)
Sprite((pipe2), (337.5, 170))
block = RectangleAsset(15, 15, thinline, brown)
Sprite((block), (200, 100))
Sprite((block), (230, 100))
Sprite((block), (215, 100))
goomba = PolygonAsset([(0, 0), (10, -15), (20, 0), (0, 0)], thinbrown, brown)
Sprite((goomba), (215, 75))
geyes = CircleAsset(1, thinwhite, black)
Sprite((geyes), (222.5, 80))
Sprite((geyes), (226.5, 80))
gleg = RectangleAsset(1, 10, thinline, black)
Sprite((gleg), (222.5, 90))
Sprite((gleg), (227.5, 90))
#its ugly but its supposed to be a goomba, mario and a pipe
# add your code here \/ \/ \/
#no
Sprite(ImageAsset("Small-mariogood5.png"), (100, 200))
app = App(500, 500)
app.run()
# add your code here /\ /\ /\
window = RectangleAsset(25, 50, thinline, black) knob = CircleAsset(5, thinline, khaki) Sprite(sky, (0, 0)) Sprite(sun, (50, 50)) Sprite(grass, (0, 500)) Sprite(house, (500, 200)) Sprite(chim, (725, 75)) Sprite(roof, (450, 100)) Sprite(pond, (850, 525)) Sprite(door, (600, 325)) Sprite(window, (620, 350)) Sprite(window, (655, 350)) Sprite(knob, (680, 425)) myapp = App() myapp.width = 1600 myapp.height = 900 myapp.run()
def collidingWithSprites(sun, sclass=None):
if sclass is None:
slist = App.spritelist
else:
slist = App.getSpritesbyClass(sclass)
return list(filter(self.collidingWith, slist))
def downKey(event):
spaceship.ygo = True
spaceship.go = False
spaceship.thrust = 1
spaceship.rotation = 3.141592653589793238462643383
down(spaceship)
def downUp(event):
spaceship.go = False
spaceship.ygo = False
spaceship.thrust = 1
down(spaceship)
def returnDown(event):
tab(spaceship)
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
myapp.listenKeyEvent('keydown', 'a', leftKey)
myapp.listenKeyEvent('keyup', 'a', leftUp)
myapp.listenKeyEvent('keydown', 'd', rightKey)
myapp.listenKeyEvent('keyup', 'd', rightUp)
myapp.listenKeyEvent('keydown', 'w', upKey)
myapp.listenKeyEvent('keyup', 'w', upUp)
myapp.listenKeyEvent('keydown', 's', downKey)
myapp.listenKeyEvent('keyup', 's', downUp)
myapp.listenKeyEvent('keydown', 'tab', returnDown)
myapp.run(step)
""" platformer.py Author: Emma Supattapone Credit: Abby Feyrer, Mr. Dennison Assignment: Write and submit a program that implements the sandbox platformer game: https://github.com/HHS-IntroProgramming/Platformer """ from ggame import App myapp = App() SCREEN_WIDTH = 600 SCREEN_HEIGHT = 400 from ggame import App, Color, LineStyle, Sprite, Frame from ggame import RectangleAsset, CircleAsset, EllipseAsset, PolygonAsset red = Color(0xff0000, 1.0) green = Color(0x00ff00, 1.0) blue = Color(0x0000ff, 1.0) black = Color(0x000000, 1.0) white = Color(0xffffff, 1.0) orange = Color(0xffa500,1.0) purple = Color(0xa020f0,1.0) thinline = LineStyle(1, black) notthinline = LineStyle(3, green) mouseposition = (0, 0) yum=0
from ggame import App, RectangleAsset, ImageAsset, SoundAsset
from ggame import LineStyle, Color, Sprite, Sound
myapp = App()
# define colors and line style
green = Color(0x00ff00, 1)
black = Color(0, 1)
noline = LineStyle(0, black)
# a rectangle asset and sprite to use as background
bg_asset = RectangleAsset(myapp.width, myapp.height, noline, green)
bg = Sprite(bg_asset, (0, 0))
# A ball! This is already in the ggame-tutorials repository
ball_asset = ImageAsset("images/orb-150545_640.png")
ball = Sprite(ball_asset, (0, 0))
# Original image is too big. Scale it to 1/10 its original size
ball.scale = 0.1
# custom attributes
ball.direction = 1
ball.go = True
# Sounds
pew1_asset = SoundAsset("sounds/pew1.mp3")
pew1 = Sound(pew1_asset)
pop_asset = SoundAsset("sounds/reappear.mp3")
pop = Sound(pop_asset)
def reverse(b):
b.direction *= -1
#Acts on actions lists to accomplish changes simultaneously
for cell in birthcell:
coord[cell] = 1
for cell in agecell:
coord[cell] = 2
for cell in killcell:
coord[cell] = 0
display():
#Function called by mouse clicks to change cells manually
def change(info):
x = int(info.x/10)
y = int(info.y/10)
if x >= mapsize or y >= mapsize or x <= 0 or y <= 0:
return
elif coord[(x,y)] == 0:
coord[(x,y)] = 1
Sprite(newcell,(x*10,y*10))
else:
coord[(x,y)] = 0
Sprite(deadcell,(x*10,y*10))
display():
App.listenKeyEvent("keydown", "space", ticker)
App.listenMouseEvent("mousedown", change)
app = App()
app.run()
"""
Trivial example of a minimal ggame App with Sprite.
"""
from ggame import App, ImageAsset, Sprite
# Create a displayed object at 100,100 using an image asset
Sprite(ImageAsset("bunny.png"), (100, 100))
# Create the app, with a default stage
APP = App()
# Run the app
APP.run()
""" Patrick Daley """ from ggame import App, Color, LineStyle, Sprite, TextAsset from ggame import RectangleAsset, CircleAsset, EllipseAsset, PolygonAsset, ImageAsset, Frame from math import floor myapp = App(1017,512) blue = Color(0x2EFEC8, 1.0) black = Color(0x000000, 1.0) pink = Color(0xFF00FF, 1.0) red = Color(0xFF5733, 1.0) white = Color(0xFFFFFF, 1.0) red = Color(0xff0000, 1.0) green = Color(0x00ff00, 1.0) blue = Color(0x0000ff, 1.0) black = Color(0x000000, 1.0) white = Color(0xffffff, 1.0) grey = Color(0xC0C0C0, 1.0) thinline = LineStyle(2, black) blkline = LineStyle(1, black) noline = LineStyle(0, white) coolline = LineStyle(1, grey) blueline = LineStyle(2, blue) redline = LineStyle(1, red) greenline = LineStyle(1, green) gridline = LineStyle(1, grey) grid=RectangleAsset(30,30,gridline,white)
rectangle = RectangleAsset(500, 600, thinline, blue) circle = CircleAsset(50, thinline, red) ellipse = EllipseAsset(60, 100, thinline, red) triangle = PolygonAsset([(50, 50), (100, 200), (0, 80)], thinline, green) rectangle2 = RectangleAsset(100, 100, thinline, blue) circle2 = CircleAsset(250, thinline, black) rectangle3 = RectangleAsset(50, 600, thinline, red) ellipse2 = EllipseAsset(300, 100, thinline, green) triangle2 = PolygonAsset([(50, 50), (100, 200), (500, 80)], thinline, red) triangle3 = PolygonAsset([(89, 500), (300, 200), (0, 80)], thinline, blue) triangle4 = PolygonAsset([(300, 100), (100, 260), (0, 80)], thinline, green) #display the shapes Sprite(rectangle, (600, 50)) Sprite(circle2, (900, 150)) Sprite(circle, (900, 150)) Sprite(ellipse, (400, 400)) Sprite(triangle, (500, 600)) Sprite(rectangle2, (200, 50)) Sprite(rectangle3, (500, 50)) Sprite(ellipse2, (400, 0)) Sprite(triangle2, (300, 400)) Sprite(triangle3, (100, 450)) Sprite(triangle4, (345, 90)) # add your code here /\ /\ /\ myapp = App() myapp.run()
from ggame import App, RectangleAsset, ImageAsset, Sprite, LineStyle, Color, Frame
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
# Background
black = Color(0, 1)
noline = LineStyle(0, black)
bg_asset = RectangleAsset(SCREEN_WIDTH, SCREEN_HEIGHT, noline, black)
bg = Sprite(bg_asset, (0,0))
class SpaceGame(App):
"""
Tutorial4 space game example.
"""
def __init__(self, width, height):
super().__init__(width, height)
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
myapp.run()
beach.x += beach.dir
if beach.x + beach.width > SCREEN_WIDTH or beach.x < 0:
beach.x -= beach.dir
reverse(beach)
def spaceKey(event):
ball.go = not ball.go
# Handle the "reverse" key
def reverseKey(event):
reverse(ball)
# Handle the mouse click
def mouseClick(event):
ball.x = event.x
ball.y = event.y
pew1.play()
reverse(ball)
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
# Set up event handlers for the app
myapp.listenKeyEvent("keydown", "space", spaceKey)
myapp.listenKeyEvent("keydown", "r", reverseKey)
myapp.listenMouseEvent("click", mouseClick)
myapp.run(step)
if ball.go:
ball.x += ball.dir
if ball.x + ball.width > SCREEN_WIDTH or ball.x < 0:
ball.x -= ball.dir
reverse(ball)
# Handle the space key
def spaceKey(event):
ball.go = not ball.go
# Handle the "reverse" key
def reverseKey(event):
reverse(ball)
# Handle the mouse click
def mouseClick(event):
ball.x = event.x
ball.y = event.y
myapp.listenKeyEvent('keydown', 'space', spaceKey)
myapp.listenKeyEvent('keydown', 'r', reverseKey)
myapp.listenMouseEvent('click', mouseClick)
pew1_asset = SoundAsset("sounds/pew1.mp3")
pew1 = Sound(pew1_asset)
pop_asset = SoundAsset("sounds/reappear.mp3")
pop = Sound(pop_asset)
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
myapp.run(step)
from ggame import App, RectangleAsset, ImageAsset, SoundAsset
from ggame import LineStyle, Color, Sprite, Sound
rectangle dimensions:1728 862
# A ball! This is already in the ggame-tutorials repository
ball_asset = ImageAsset("images/orb-150545_640.png")
ball = Sprite(ball_asset, (0, 0))
ball.fxcenter = 0.7
ball.fycenter = 0.6
# Original image is too big. Scale it to 1/10 its original size
ball.scale = 0.05
#Handle the mouse movement
def mouseMove(event):
ball.x = event.x
ball.y = event.y
myapp = App()
myapp.listenMouseEvent('mousemove', mouseMove)
myapp.run()
spaceship.ygo = True
spaceship.go = False
spaceship.thrust = 1
spaceship.rotation = 0
up(spaceship)
def downKey(event):
spaceship.ygo = True
spaceship.go = False
spaceship.thrust = 1
spaceship.rotation = 3.141592653589793238462643383
down(spaceship)
# Handle the mouse click
def mouseClick(event):
spaceship.x = event.x
spaceship.y = event.y
myapp = App(SCREEN_WIDTH, SCREEN_HEIGHT)
myapp.listenKeyEvent('keydown', 'space', spaceKey)
myapp.listenMouseEvent('click', mouseClick)
myapp.listenKeyEvent('keydown', 'a', leftKey)
myapp.listenKeyEvent('keydown', 'd', rightKey)
myapp.listenKeyEvent('keydown', 'w', upKey)
myapp.listenKeyEvent('keydown', 's', downKey)
#myapp.run(ystep)
myapp.run(astr)
from ggame import TextAsset, App, Sprite a = App() a.run()
def map(file,scale):
picture=ImageAsset("images/" + file)
picture_sprite=Sprite(picture, (0,0))
picture_sprite.scale = scale
myapp = App()
myapp.run()
