def load(state):
print("Enter name of image file to load: ")
imageName = input()
resetImage = dw.loadImage(imageName)
state['original'] = resetImage
state['processed'] = state['original'].copy()
state['needsDisplayUpdate'] = True
return state
def load(state):
print("Enter name of image file to load: ")
imageName = input()
resetImage = dw.loadImage(imageName)
state['original'] = resetImage
state['processed'] = state['original'].copy()
state['needsDisplayUpdate'] = True
return state
def load(state):
print("Enter name of image file to load: ")
imageName = input()
resetImage = dw.loadImage(imageName)
state.original = resetImage
state.processed = state.original.copy()
state.needsDisplayUpdate = True
return state
def load(state):
print("Enter name of image file to load: ")
imageName = input()
resetImage = dw.loadImage(imageName)
state.original = resetImage
state.processed = state.original.copy()
state.needsDisplayUpdate = True
return state
import image_processing as ip
import imagineFun as af
################################################################
# Initialize display
name = "Imaginator!"
width = 1200
height = 500
rw.newDisplay(width, height, name)
################################################################
# An image that we'll use when the system starts
initImage = dw.loadImage("cat.bmp")
# In our initial exercise with this simulation framework, we
# represented the "game state" as a tuple. A problem with that
# approach is that it doesn't give us good names for the fields
# of the tuples (records), so we end up with lots of cryptically
# subscripted tuple values, make it hard to write, reason about,
# debug, and enhance the code. We could of course write our own
# nicely named projection functions, and that would help. This
# is what we did in Idris, where we wrote functions such as
# first (fst) and second (snd) to extract fields from tuples.
# We then saw that the *record* construct enabled us to define
# tuple types with *named* fields. The compiler then provided
# projection functions with the names of the fields, making it
# much easier to write code where the intended interpretation
# is clarified by the use of meaningful field names.
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
VISOR = (170, 170, 170)
HELM = (150, 150, 150)
TORSO = (100, 100, 100)
SHIELD = (174, 88, 11)
# Initialize world
name = "Beauregarde of Flankingshire"
width = 1200
height = 800
screen = rw.newDisplay(width, height, name)
target1 = dw.loadImage("target1.png")
target2 = dw.loadImage("target2.png")
target3 = dw.loadImage("target3.png")
target4 = dw.loadImage("target4.png")
target5 = dw.loadImage("target5.png")
class Turret(object):
def __init__(self, X, Y, screen, kind, face=0):
self.Xcoord = X
self.Ycoord = Y
self.health = 100
self.alive = True
self.kind = kind
self.face = face
import runWorld as rw
import drawWorld as dw
import pygame as pg
from random import randint
name = "Move the cursor over the Soccer Ball to Stop it from Going in the Goal!"
width = 800
height = 800
rw.newDisplay(width, height, name)
myimage = dw.loadImage("soccer_ball_1.bmp")
goal = dw.loadImage("goal.bmp")
class State:
xpos = 400
ypos = 700
xvel = randint(-2,2)
yvel = randint(-12,-10)
def move(self):
self.xpos = self.xpos + self.xvel
self.ypos = self.ypos + self.yvel
initState = State()
def updateDisplay(state):
dw.fill(dw.white)
dw.draw(goal, (0, 0, 0, 0))
dw.draw(myimage, (state.xpos, state.ypos, state.xvel, state.yvel))
def updateState(state):
state.move()
import runWorld as rw
import drawWorld as dw
import pygame as pg
from random import randint
gameState = 0
counter = 0
name = "The Kevin Sullivan Game!"
width = 600
height = 600
rw.newDisplay(width, height, name)
myImage = dw.loadImage("sullivan_kevin.bmp")
class State:
def __init__(self, img, xpos, xvel, ypos, yvel):
self.img = img
self.xpos = xpos
self.xvel = xvel
self.ypos = ypos
self.yvel = yvel
ourState = State(myImage, 100, 1, 100, 1)
def updateDisplay(state):
dw.fill((100, 0, 70))
dw.draw(state.img, (state.xpos, state.ypos))
dw.draw(dw.makeLabel("Click to Survive! Score: " + str(counter), "Vendera", 25, dw.red), (12, 12))
import runWorld as rw
import drawWorld as dw
# Initialize world
name = "Cat Go!"
width = 500
height = 500
rw.newDisplay(width, height, name)
# World state will be single x coordinate at left edge of world
initState = 0
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("cat.bmp")
# state -> image (IO)
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, (state[0], height/2))
# We'll update the state on each tick by incrementing the x stateinate
# state -> state
def updateState(state):
return((state[0]+state[1], state[1]))
# We'll terminate when the x coordinate reaches the screen edge
# tells the simulation when it's over
#
# The simulation ends when either player leaves the "ring" by fleeing
# or by being pushed out by the other player's slaps.
################################################################
# Initialize world
name = "SMACK"
width = 1200
height = 800
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing two torsos with arms.
rightTorso = dw.loadImage("T_R.png")
rightHigh = dw.loadImage("R_H.png") # -150, +255
rightLow = dw.loadImage("R_L.png") # -150, -100
leftTorso = dw.loadImage("T_L.png")
leftHigh = dw.loadImage("L_H.png") # 200, +225
leftLow = dw.loadImage("L_L.png") # 200, -100
def updateDisplay(state):
dw.fill(dw.black)
if state.player1arm == 1:
dw.draw(leftHigh, (state.player1x + 200, state.player1y - 100))
else:
dw.draw(leftLow, (state.player1x + 200, state.player1y + 225))
if state.player2arm == 1:
print("The state is:", i)
state.position = i
break
else:
## print("this is Bin2", Bin)
## print("this is CP2", CumulProb[0, (i+1)])
Bin = Bin + CumulProb[0, (i + 1)]
## print("This is new Bin", Bin)
return state
################################################################
## Display the state by drawing the image at the current state's (x,y)
## pair
myimage = dw.loadImage("dog.jpg")
dot = dw.loadImage("white_dot.jpg")
def updateDisplay(state):
d = 0
dw.fill(dw.black)
while d < numofs - 1:
dw.draw(dot, (s[d][0], s[d][1]))
d += 1
dw.draw(state.image, (s[state.position][0], s[state.position][1]))
################################################################
## Terminates the simulation when the state is a given number
from random import randint
print(randint(1, 5))
################################################################
# Initialize world
name = "Trash it!"
width = 500
height = 500
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing trash and a trash can
myimage = dw.loadImage("papertrash.bmp")
otherimage = dw.loadImage("recycle.bmp")
# state -> image (IO)
# draw the trash at the bottom, center of the screne and
# paper trash at the top
def updateDisplay(state):
dw.fill(dw.white)
dw.draw(myimage, (state.xpos, state.yvel))
dw.draw(otherimage, (width / 2, height - 100))
################################################################
DRONE_SIZE = 48
DELIVERY_SIZE = 16
WIDTH = 1024
HEIGHT = 700
# Initialize world
name = "Drolivery - Fast & Accurate Drone Delivery"
rw.newDisplay(WIDTH, HEIGHT, name)
# Initialize font -> must be called after pygame.init() to avoid 'Font not Initialized' error
font = pg.font.Font(None, 35)
################################################################
# Loads the images
droneImage = dw.loadImage("drone.png")
deliveryImage = dw.loadImage("delivery.png")
"""
Update the display accordingly with the game state
"""
def updateDisplay(state):
dw.fill(dw.white)
global scoreText
global name
if (gameState == 0):
dw.draw(droneImage, (state[0], state[2]))
dw.draw(deliveryImage, (deliveryInitState[0], deliveryInitState[1]))
scoreText = font.render("Score: " + str(score), 1, (0, 0, 0))
dw.draw(scoreText, (WIDTH / 2, 5))
import runWorld as rw
import drawWorld as dw
import pygame as pg
from random import randint
################################################################
# Initialize world
name = "Cat Fun. Press the mouse (but not too fast)!"
width = 1000
height = 700
rw.newDisplay(width, height, name)
################################################################
myimage = dw.loadImage("realball.bmp")
secondimage = dw.loadImage("bballhoop.bmp")
class State:
BallXpos = randint(125, 375)
BallXvel = randint(1, 3)
BallYpos = randint(125, 375)
BallYvel = randint(1, 3)
HoopYpos = height/2
HoopYvel = randint(1, 3)
def updateDisplay(self):
dw.fill(dw.blue)
dw.draw(myimage, (self.BallXpos, self.BallYpos))
dw.draw(secondimage, (750, self.HoopYpos))
def updateState(self):
self.BallXpos = self.BallXpos + self.BallXvel
#
# The goal of the game is to keep Grumpy Cat alive by avoiding both
# the sides of the screen and the dog!
################################################################
# Initialize world
name = "Colorific Cat & Dog Fun!"
width = 750
height = 750
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat and a dog at their designated coordinates
catimage = dw.loadImage("grumpycat.bmp")
pugimage = dw.loadImage("pug.bmp")
color = (randint(0,255), randint(0,255), randint(0,255))
start = time.time()
# state -> image (IO)
# draw the cat and the dog at the points determined by the state tuple
# The cat and dog start at random points moving in a random directions in
# both x and y directions
class newState:
x_pos_cat = 300
y_pos_cat = 300
x_vel_cat = randint(-3,3)
y_vel_cat = randint(-3,3)
x_pos_pug = 600
#
# The simulation ends when the cat is allowed to reach either the left
# or the right edge of the screen.
################################################################
# Initialize world
name = "Cat Fun. Press the mouse (but not too fast)!"
width = 500
height = 500
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("10426306_10203780151533733_2057102321053958166_n.bmp")
# state -> image (IO)
# draw the cat halfway up the screen (height/2) and at the x
# coordinate given by the first component of the state tuple
#
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, (state[0], state[2]))
################################################################
# Change pos by delta-pos, leaving delta-pos unchanged
# Note that pos is accessed as state[0], and delta-pos
# as state[1]. Later on we'll see how to access state
from random import randint
#########
# Description goes here
#########
# Initialize World
name = "Name Goes Here"
width = 500
height = 500
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("Image Name Goes Here")
# state -> image (IO)
# draw the cat halfway up the screen (height/2) and at the x
# coordinate given by the first component of the state tuple
#
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, (state[0], state[1]))
################################################################
# Change pos by delta-pos, leaving delta-pos unchanged
# Note that pos is accessed as state[0], and delta-pos
# as state[1]. Later on we'll see how to access state
#
# The simulation ends when the cat is allowed to reach either the left
# or the right edge of the screen.
################################################################
# Initialize world
name = "Cat Fun. Press the mouse (but not too fast)!"
width = 1000
height = 1000
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("cat.bmp")
mouseimage = dw.loadImage("mouse.png")
# state -> image (IO)
# draw the cat halfway up the screen (height/2) and at the x
# coordinate given by the first component of the state tuple
#
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, [state[0], state[2]])
dw.draw(mouseimage, [state[0], state[3]])
################################################################
# Change pos by delta-pos, leaving delta-pos unchanged
name = "Arrow Simulation"
width = 1100
height = 750
rw.newDisplay(width, height, name)
class State:
x = 0
y = 600
v = 1
ballState = State()
myimage = dw.loadImage("soccer.jpeg")
goal=dw.loadImage("goall.gif")
player=dw.loadImage("p6.jpeg")
player2=dw.loadImage("p6.jpeg")
def updateDisplay(state):
dw.fill(dw.green)
dw.draw(myimage, (state.x, state.y))
dw.draw(goal, (870,550))
dw.draw(player,(0,500))
dw.draw(player2, (550,10))
def updateState(state):
if(state.x == 750 and state.v == 1):
print("Goal!")
state.x = state.x + state.v
from random import randint
name = "Planets"
width = 500
height = 500
rw.newDisplay(width, height, name)
def loadImage(filename):
imageSurface = pg.image.load(filename)
imageSurface.convert()
return imageSurface
sun = loadImage("sun2.jpeg")
earth = loadImage("earth1.jpeg")
comet = loadImage("comet.png")
impact = dw.loadImage("impact.jpg")
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(sun, (200, 200))
dw.draw(earth, (state[0], state[1]))
dw.draw(comet, (state[2], state[3]))
def updateState(state):
if (50 <= state[1] < 350 and state[0] == 50):
y_down_velocity = 1
location = (state[0], state[1]+y_down_velocity, state[2]+state[4], state[3]+state[5], state[4], state[5])
elif (state[1] == 350 and 50 <= state[0] < 350):
x_right_velocity = 1
location = (state[0]+x_right_velocity, state[1], state[2]+state[4], state[3]+state[5], state[4], state[5])
elif (50 < state[1] <= 350 and state[0] == 350):
speed5 = 2.4
#these are the initial acceleration base rates for each gear n.
#tweak these to make the car accelerate faster or slower within
#a given gear
accel1 = .029
accel2 = .025
accel3 = .019
accel4 = .015
accel5 = .01
# Display the state by drawing a car at that x coordinate
# the tach image is a blue bar. Bar moves up and down to simulate a
# a tachometer (RPM indicator).
#the gear indicators are .bmps that appear when their gear is active.
myimage = dw.loadImage("car.bmp")
tach = dw.loadImage("tach.bmp")
gear1 = dw.loadImage("gear1.bmp")
gear2 = dw.loadImage("gear2.bmp")
gear3 = dw.loadImage("gear3.bmp")
gear4 = dw.loadImage("gear4.bmp")
gear5 = dw.loadImage("gear5.bmp")
# define class
class Car:
def __init__(self, pos, velo, accel, rpm):
self.pos = pos
self.velo = velo
self.accel = accel
self.rpm = rpm
#
# The simulation ends when the cat is allowed to reach either the left
# or the right edge of the screen.
################################################################
# Initialize world
name = "Cat Fun. Press the mouse (but not too fast)!"
width = 500
height = 500
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("alligator.bmp")
# state -> image (IO)
# draw the cat halfway up the screen (height/2) and at the x
# coordinate given by the first component of the state tuple
#
def updateDisplay(state):
dw.fill(dw.white)
dw.draw(myimage, (state[0], state[1]))
################################################################
# Change pos by delta-pos, leaving delta-pos unchanged
# Note that pos is accessed as state[0], and delta-pos
# as state[1]. Later on we'll see how to access state
import drawWorld as dw
import pygame as pg
# Initialize world
name = "Cat Go!"
width = 1000
height = 1000
rw.newDisplay(width, height, name)
# World state will be single x coordinate at left edge of world
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("cat.bmp")
pondimage = dw.loadImage("pond.bmp")
dogimage = dw.loadImage("dog2.bmp")
waterimage = dw.loadImage("water.bmp")
beeimage = dw.loadImage("bee.bmp")
cactusimage = dw.loadImage("cactus.bmp")
faucetimage = dw.loadImage("faucet.bmp")
winimage = dw.loadImage("youwin.bmp")
catfood = dw.loadImage ("catfood.bmp")
def updateDisplay(state):
dw.fill(dw.sage)
dw.draw (catfood, [920,0])
dw.draw(myimage, (state.x, state.y))
dw.draw(dogimage, [200, 400])
#
# The simulation ends when the cat is allowed to reach either the left
# or the right edge of the screen.
################################################################
# Initialize world
name = "Catch the Dot to Win the Game!"
width = 500
height = 500
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("cat.png")
# state -> image (IO)
# draw the cat halfway up the screen (height/2) and at the x
# coordinate given by the first component of the state tuple
#
def updateDisplay(state):
dw.fill(dw.white)
dw.draw(myimage, (state[0], state[1]))
################################################################
# Change pos by delta-pos, leaving delta-pos unchanged
# Note that pos is accessed as state[0], and delta-pos
# as state[1]. Later on we'll see how to access state
import runWorld as rw
import drawWorld as dw
import pygame as pg
name = "UVA"
width = 1000
height = 1000
rw.newDisplay(width, height, name)
initState = (0,1)
myimage = dw.loadImage("uva.png")
mylabel = dw.makeLabel("Go Hoos!", "arial", 100, (0,0,255))
otherlabel = dw.makeLabel("Don't lose the Hoos", "serif", 80, (255,255,255))
def updateDisplay(state):
dw.fill(dw.blue)
dw.draw(otherlabel, (150,100))
dw.draw(myimage, (state[0], width/50))
dw.draw(mylabel, (250,250))
def updateState(state):
return((state[0]+state[1]),state[1])
def endState(state):
if (state[0] >= width or state[0] < -width):
return True
else:
import runWorld as rw
import drawWorld as dw
# Initialize world
name = "Cat Go!"
width = 500
height = 500
rw.newDisplay(width, height, name)
# World state will be single x coordinate at left edge of world
initState = 0
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("sullivan-kevin.bmp")
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, (state, width/2))
# We'll update the state on each tick by incrementing the x stateinate
def updateState(state):
return(state+1)
# We'll terminate when the x stateinate reaches the screen edge
def endState(state):
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
VISOR = (170, 170, 170)
HELM = (150, 150, 150)
TORSO = (100, 100, 100)
SHIELD = (174, 88, 11)
# Initialize world
name = "proj"
width = 1200
height = 800
screen = rw.newDisplay(width, height, name)
target1 = dw.loadImage("target1.png")
target2 = dw.loadImage("target2.png")
target3 = dw.loadImage("target3.png")
target4 = dw.loadImage("target4.png")
target5 = dw.loadImage("target5.png")
class Turret(object):
def __init__(self, X, Y, screen, kind, face=0):
self.Xcoord = X
self.Ycoord = Y
self.health = 100
self.alive = True
self.kind = kind
self.face = face
if (self.kind == "norm") or (self.kind == "direct"):
#
# The simulation ends when the cat is allowed to reach either the left
# or the right edge of the screen.
################################################################
# Initialize world
name = "Cat Fun. Press the mouse (but not too fast)!"
width = 1280
height = 720
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("target.bmp")
# state -> image (IO)
# draw the cat halfway up the screen (height/2) and at the x
# coordinate given by the first component of the state tuple
#
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, (state[0], state[2]))
################################################################
# Change pos by delta-pos, leaving delta-pos unchanged
# Note that pos is accessed as state[0], and delta-pos
# as state[1]. Later on we'll see how to access state
import imagineFun as af
################################################################
# Initialize display
name = "Imaginator!"
width = 1200
height = 500
rw.newDisplay(width, height, name)
################################################################
# An image that we'll use when the system starts
initImage = dw.loadImage("twoeyes.bmp")
# In our initial exercise with this simulation framework, we
# represented the "game state" as a tuple. A problem with that
# approach is that it doesn't give us good names for the fields
# of the tuples (records), so we end up with lots of cryptically
# subscripted tuple values, make it hard to write, reason about,
# debug, and enhance the code. We could of course write our own
# nicely named projection functions, and that would help. This
# is what we did in Idris, where we wrote functions such as
# first (fst) and second (snd) to extract fields from tuples.
# We then saw that the *record* construct enabled us to define
# tuple types with *named* fields. The compiler then provided
# projection functions with the names of the fields, making it
# much easier to write code where the intended interpretation
# is clarified by the use of meaningful field names.
import imagineFun as af
################################################################
# Initialize display
name = "Imaginator!"
width = 1200
height = 500
rw.newDisplay(width, height, name)
################################################################
# An image that we'll use when the system starts
initImage = dw.loadImage("twoeyes.bmp")
# In our initial exercise with this simulation framework, we
# represented the "game state" as a tuple. A problem with that
# approach is that it doesn't give us good names for the fields
# of the tuples (records), so we end up with lots of cryptically
# subscripted tuple values, make it hard to write, reason about,
# debug, and enhance the code. We could of course write our own
# nicely named projection functions, and that would help. This
# is what we did in Idris, where we wrote functions such as
# first (fst) and second (snd) to extract fields from tuples.
# We then saw that the *record* construct enabled us to define
# tuple types with *named* fields. The compiler then provided
# projection functions with the names of the fields, making it
# much easier to write code where the intended interpretation
# is clarified by the use of meaningful field names.
#
# The simulation ends when the cat is allowed to reach either the left
# or the right edge of the screen.
################################################################
# Initialize world
name = "Cat Fun. Press the mouse (but not too fast)!"
width = 500
height = 500
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("cat.bmp")
# state -> image (IO)
# draw the cat halfway up the screen (height/2) and at the x
# coordinate given by the first component of the state tuple
#
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, (state[0], state[1]))
################################################################
# Change pos by delta-pos, leaving delta-pos unchanged
# Note that pos is accessed as state[0], and delta-pos
# as state[1]. Later on we'll see how to access state
#
def handleEvent(state, event):
# print("Handling event: " + str(event))
if (event.type == pg.MOUSEBUTTONDOWN):
state.img_w1_.change_direction(0)
state.img_w2_.change_direction(1)
return(aniState(state.img_w1_, state.img_w2_))
else:
return(state)
################################################################
# World state will be single x coordinate at left edge of world
# The cat starts at the left, moving right
initState = aniState( image_wrapper(dw.loadImage("cat.bmp"),
randint(100,400), randint(100,400),
randint(-2,2), randint(-2,2)),
image_wrapper(dw.loadImage("rotunda.jpg"),
randint(100,400), randint(100,400),
randint(-2,2), randint(-2,2)))
# Run the simulation no faster than 60 frames per second
frameRate = 60
# Run the simulation!
rw.runWorld(initState, updateDisplay, updateState, handleEvent,
endState, frameRate)
# or the right edge of the screen.
################################################################
# Initialize world
name = "Cat Fun. Press the mouse (but not too fast)!"
width = 500
height = 500
fig = 20
tiffany = (66,199,249)
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("cat.bmp")
myfish= dw.loadImage("Fish.bmp")
myacpnt = dw.loadImage("circle.bmp")
inst_line1 = "When the cat catches the fish, you win!"
inst_line2 = "Every time the cat reaches one of the points, it would accelerate."
inst_line3 = "When the cat reaches the lower and upper bounds, it will bounce back."
inst_line4 = "When the cat touches the left and right sides, it will die and the game is over."
inst_line5 = "Click the mouse and get start. Enjoy!"
mylabel0 = dw.makeLabel("Instructions:","serif",24,dw.black)
mylabel1 = dw.makeLabel(inst_line1,"serif",12,dw.black)
mylabel2 = dw.makeLabel(inst_line2,"serif",12,dw.black)
mylabel3 = dw.makeLabel(inst_line3,"serif",12,dw.black)
mylabel4 = dw.makeLabel(inst_line4,"serif",12,dw.black)
mylabel5 = dw.makeLabel(inst_line5,"serif",12,dw.black)
firstdisp = True
import imagineFun as af
################################################################
# Initialize display
name = "Imaginator!"
width = 1200
height = 500
rw.newDisplay(width, height, name)
################################################################
# An image that we'll use when the system starts
initImage = dw.loadImage("cat.bmp")
# In our initial exercise with this simulation framework, we
# represented the "game state" as a tuple. A problem with that
# approach is that it doesn't give us good names for the fields
# of the tuples (records), so we end up with lots of cryptically
# subscripted tuple values, make it hard to write, reason about,
# debug, and enhance the code. We could of course write our own
# nicely named projection functions, and that would help. This
# is what we did in Idris, where we wrote functions such as
# first (fst) and second (snd) to extract fields from tuples.
# We then saw that the *record* construct enabled us to define
# tuple types with *named* fields. The compiler then provided
# projection functions with the names of the fields, making it
# much easier to write code where the intended interpretation
# is clarified by the use of meaningful field names.
#
# Team Wyatt and Friends is comprised of Matthew Boustany, Catherine
# Jin, and Simon Whittle (there is no Wyatt, we are just the friends).
################################################################
# Initialize world
name = "!~SMACK~!"
width = 1200
height = 800
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing two torsos with arms.
rightTorso = dw.loadImage("T_R.png")
rightHigh = dw.loadImage("R_H.png") # -150, +255
rightLow = dw.loadImage("R_L.png") # -150, -100
leftTorso = dw.loadImage("T_L.png")
leftHigh = dw.loadImage("L_H.png") # 200, +225
leftLow = dw.loadImage("L_L.png") # 200, -100
def updateDisplay(state):
dw.fill(dw.black)
if (state[4] == 1): # if state sub 4 is 1, draw left arm up
dw.draw(leftHigh, (state[0] + 200, state[1] - 100))
else: # else draw left arm down
dw.draw(leftLow, (state[0] + 200, state[1] + 225))
if (state[5] == 1): # if state sub 5 is 1, draw right arm up
# you can help it win if it is losing by clicking and changing
# the velocities
################################################################
# Initialize world
name = "Car Race! Press the mouse to help your car win!"
width = 800
height = 300
rw.newDisplay(width, height, name)
################################################################
#loads the two car images
myimage1 = dw.loadImage("racecar2.jpg")
myimage2 = dw.loadImage("blackcar.jpg")
def updateDisplay(state):
dw.fill(dw.white)
dw.draw(myimage1, (car1.xpos,car1.ypos))
dw.draw(myimage2, (car2.xpos,car2.ypos))
################################################################
# defines the movement of the two cars using two tuples of (x,dx,y,dy).
# also defines the change in direction caused by bouncing of the top and bottom.
################################################################
################################################################
# Initialize world
name = "Click to Move! Get the Cheese! Avoid the Cat!"
width = 500
height = 500
rw.newDisplay(width, height, name)
################################################################
# Display the state by drawing a cat at that x coordinate
myimage = dw.loadImage("level1.jpeg")
myimage2 = dw.loadImage("level2.jpeg")
myimage3 = dw.loadImage("level3.jpeg")
myimage4 = dw.loadImage("level4.jpeg")
myimage5 = dw.loadImage("level5.jpeg")
mymouse = dw.loadImage("mouse.jpeg")
mycheese = dw.loadImage("cheese.jpeg")
# state -> image (IO)
def updateDisplay(state):
dw.fill(dw.black)
dw.draw(myimage, (state[0], state[2]))
dw.draw(mymouse, (state[4], state[6]))
dw.draw(mycheese,(state[8],state[9]))
dw.draw(myimage2, (state[10],state[12]))
