def on_event(id, event):
global LAUNCH_SPEED
if (event.GetType() == "GeneratorOutputEvent"):
if (event.mGeneratorID == id):
outputItems = event.mOutputs
playerPosition = fge.GetTransform(event.mPlayerID).GetPosition()
generatorTransform = fge.GetTransform(id)
generatorPosition = generatorTransform.GetPosition()
generatorScale = generatorTransform.GetScale()
for i in range(0, len(outputItems)):
outputItem = fge.CreateEntity(outputItems[i])
itemBody = fge.GetRuntimeBody(outputItem)
itemBody.Init()
if (i == 0):
pickupEvent = fge.GetPlayerPickupEvent()
pickupEvent.mPlayerID = event.mPlayerID
pickupEvent.mItemID = outputItem
fge.SendEvent(pickupEvent, event.mPlayerID)
else:
itemTransform = fge.GetRuntimeTransform(outputItem)
itemScale = itemTransform.GetScale()
itemTransform.SetPosition(
generatorPosition[0], generatorPosition[1] + 0.5 *
(generatorScale[1] + itemScale[1]),
generatorPosition[2])
toPlayer = [
playerPosition[0] - generatorPosition[0],
playerPosition[1] - generatorPosition[1],
playerPosition[2] - generatorPosition[2]
]
itemBody.SetVelocity(LAUNCH_SPEED * toPlayer[0],
LAUNCH_SPEED * toPlayer[1],
LAUNCH_SPEED * toPlayer[2])
print("reached YEET")
def on_update(id, dt):
global INITIAL_POS_Z
global PAUSED
cam = fge.GetCamera(id)
im = InputManager.GetInstance()
if (im.IsTriggered("cam1")):
cm = CameraManager.GetInstance()
cm.SetCurrentCamera(cam)
if (PAUSED):
return
cameraTransform = fge.GetTransform(id)
cameraPos = cameraTransform.GetPosition()
sumX = 0.0
sumZ = 6.0 * INITIAL_POS_Z
playerIDs = fge.GetEntities("Player")
numPlayers = len(playerIDs)
for playerID in playerIDs:
playerTransform = fge.GetTransform(playerID)
sumX += playerTransform.GetPosition()[0]
sumZ += playerTransform.GetPosition()[2] + INITIAL_POS_Z
sumX /= len(playerIDs) + 6
sumZ /= len(playerIDs) + 6
cameraPos[0] = cameraPos[0] + dt * (sumX - cameraPos[0]) * 0.001
cameraPos[2] = cameraPos[2] + dt * (sumZ - cameraPos[2]) * 0.001
cameraTransform.SetPosition(cameraPos[0], cameraPos[1], cameraPos[2])
def on_event(id, event):
if (event.GetType() == "PlayerPickupEvent"):
if (event.mPlayerID == id):
audio = fge.GetAudio(id)
audio.Load("cartoon_jump-002.wav")
audio.Play()
audio.Volume(0.1)
itemID = event.mItemID
playerHands = fge.GetCarrier(id)
itemBody = fge.GetBody(itemID)
if (itemBody is None):
itemBody = fge.GetRuntimeBody(itemID)
itemBody.mConstrainX = True
itemBody.mConstrainY = True
itemBody.mConstrainZ = True
playerHands.AddItem(itemID)
playerScale = fge.GetTransform(id).GetScale()
itemCollider = fge.GetCollider(itemID)
if (itemCollider is None):
itemCollider = fge.GetRuntimeCollider(itemID)
itemCollider.mIsTrigger = True
itemTransform = fge.GetTransform(itemID)
if (itemTransform is None):
itemTransform = fge.GetRuntimeTransform(itemID)
itemScale = itemTransform.GetScale()
itemTransform.SetLocalPosition(
0.0, playerScale[1] * 0.5,
0.5 + (itemScale[2] / playerScale[2]) / 2.0)
def on_init(id):
global WAYPOINT_WEIGHTS
global CURRENT_WAYPOINT
global NEXT_WAYPOINT
global WAYPOINT_IDS
ob = fge.GetObserver(id)
ob.SetValue("time", 0.0)
WAYPOINT_IDS = fge.GetEntities("GridWaypoint", True)
numWaypoints = len(WAYPOINT_IDS)
WAYPOINT_WEIGHTS.clear()
for i in range(numWaypoints):
WAYPOINT_WEIGHTS.append(1.0)
if (numWaypoints > 0):
CURRENT_WAYPOINT = -1
CURRENT_WAYPOINT = get_next()
NEXT_WAYPOINT = get_next()
entityTransform = fge.GetTransform(id)
currentPos = fge.GetTransform(CURRENT_WAYPOINT).GetPosition()
entityTransform.SetPosition(currentPos[0], currentPos[1] + 0.01,
currentPos[2])
waypoint = fge.GetGridWaypoint(CURRENT_WAYPOINT)
if (waypoint is not None):
ob.SetValue(
"time",
RNG.GetInstance().GenerateInteger(waypoint.GetMinDuration(),
waypoint.GetMaxDuration()))
def toggle_particles(running):
global CURRENT_WAYPOINT
global NEXT_WAYPOINT
currentPos = fge.GetTransform(CURRENT_WAYPOINT).GetPosition()
currentParticles = fge.GetParticles(CURRENT_WAYPOINT)
currentParticles.SetPosition(currentPos[0], currentPos[1], currentPos[2])
currentParticles.SetRunning(running)
nextPos = fge.GetTransform(NEXT_WAYPOINT).GetPosition()
nextParticles = fge.GetParticles(NEXT_WAYPOINT)
nextParticles.SetPosition(nextPos[0], nextPos[1], nextPos[2])
nextParticles.SetRunning(running)
def on_event(id, event):
global FORCE
if (event.GetType() == "ContactEvent"):
otherID = -1
if (event.mId1 == id):
otherID = event.mId2
else:
otherID = event.mId1
otherTransform = fge.GetTransform(otherID)
otherPosition = otherTransform.GetPosition()
rotatedForce = fge.rotate(FORCE, fge.GetTransform(id))
otherTransform.SetPosition(otherPosition[0] + rotatedForce[0],
otherPosition[1] + rotatedForce[1],
otherPosition[2] + rotatedForce[2])
def on_update(id, dt):
global CHANGE_TIME
global TOGGLE_TIME
global OPEN_ROTATION
global CLOSED_ROTATION
ob = fge.GetObserver(id)
changeTime = ob.GetValue("changeTime")
changeTime = changeTime - dt * .001
isOpen = int(ob.GetValue("isOpen")) == 1
toggleTime = ob.GetValue("toggleTime")
if (changeTime < 0.0):
isOpen = not isOpen
collider = fge.GetCollider(id)
if (isOpen):
collider.mIsTrigger = False
else:
collider.mIsTrigger = True
ob.SetValue("isOpen", isOpen)
toggleTime = 0.0
changeTime = CHANGE_TIME
if (toggleTime >= 0.0):
toggleTime = toggleTime + (1.0 / TOGGLE_TIME) * dt * .001
if (toggleTime > 1.0):
toggleTime = 1.0
transform = fge.GetTransform(id)
newRot = []
if (isOpen):
newRot = fge.lerp3(CLOSED_ROTATION, OPEN_ROTATION, toggleTime)
else:
newRot = fge.lerp3(OPEN_ROTATION, CLOSED_ROTATION, toggleTime)
transform.SetRotation(newRot[0], newRot[1], newRot[2])
if (toggleTime >= 1.0):
toggleTime = -1.0
ob.SetValue("changeTime", changeTime)
ob.SetValue("toggleTime", toggleTime)
def on_update(id, dt):
processor = fge.GetProcessor(id)
processorContainer = fge.GetCarrier(id)
processorRecipes = processor.GetRecipes()
for recipe in processorRecipes:
recipeMap = recipe[1]
recipeOutput = recipe[0]
recipeMatch = True
for resource in recipeMap:
recipeMatch = recipeMatch and (len(
processorContainer.GetItems(fge.DecodeResource(resource)))
== recipeMap[resource])
if (recipeMatch):
recipeMatchEvent = fge.GetRecipeMatchEvent()
recipeMatchEvent.mProcessorID = id
recipeMatchEvent.mOutput = recipeOutput
fge.SendEvent(recipeMatchEvent, id)
if (processor.IsWorking()):
t = processor.GetCurrentProcessingTime(
) / processor.GetMaxProcessingTime()
processorContainer = fge.GetCarrier(id)
itemIDs = processorContainer.GetItems()
for itemID in itemIDs:
itemTransform = fge.GetTransform(itemID)
itemPosition = itemTransform.GetLocalPosition()
x = (t - 1.0) * itemPosition[0]
y = (t - 1.0) * itemPosition[1] + 1.25 * t
z = (t - 1.0) * itemPosition[2]
itemTransform.SetLocalPosition(x, y, z)
def on_update(id, dt):
global MOVE_TIME
global START
global END
ob = fge.GetObserver(id)
movingUp = int(ob.GetValue("movingUp")) == 1
moveTime = ob.GetValue("moveTime")
moveTime = moveTime + (1.0 / MOVE_TIME) * dt * .001
if (moveTime > 1.0):
moveTime = 1.0
transform = fge.GetTransform(id)
newPos = []
if (movingUp):
newPos = fge.lerp3(END, START, moveTime)
else:
newPos = fge.lerp3(START, END, moveTime)
transform.SetPosition(newPos[0], newPos[1], newPos[2])
if (moveTime >= 1.0):
moveTime = 0.0
positionZ = transform.GetPosition()[2]
if (positionZ <= START[2]):
ob.SetValue("movingUp", 0.0)
if (positionZ >= END[2]):
ob.SetValue("movingUp", 1.0)
ob.SetValue("moveTime", moveTime)
def on_event(id, event):
global ITEM_SPACING
if (event.GetType() == "ContainerInputEvent"):
if (event.mContainerID == id):
audio = fge.GetAudio(id)
audio.Load("GameDeliver01.mp3", False)
audio.Play()
audio.Volume(0.1)
playerHands = fge.GetCarrier(event.mPlayerID)
heldItems = playerHands.GetItems()
inputItems = heldItems[:event.mNumItems]
dropEvent = fge.GetPlayerDropEvent()
dropEvent.mPlayerID = event.mPlayerID
fge.SendEvent(dropEvent, event.mPlayerID)
processorContainer = fge.GetCarrier(id)
for itemID in inputItems:
itemBody = fge.GetBody(itemID)
itemBody.mConstrainX = True
itemBody.mConstrainY = True
itemBody.mConstrainZ = True
containerLen = len(processorContainer.GetItems())
processorContainer.AddItem(itemID)
itemCollider = fge.GetCollider(itemID)
itemCollider.mIsTrigger = True
itemTransform = fge.GetTransform(itemID)
if (containerLen % 2) == 0:
itemTransform.SetLocalPosition(
0, 1.25,
math.ceil(containerLen / 2.0) * ITEM_SPACING)
else:
itemTransform.SetLocalPosition(
0, 1.25,
-1 * math.ceil(containerLen / 2.0) * ITEM_SPACING)
def on_init(id):
ob = fge.GetObserver(id)
transform = fge.GetTransform(id)
position = transform.GetPosition()
ob.SetValue("resetX", position[0])
ob.SetValue("resetY", position[1])
ob.SetValue("resetZ", position[2])
def on_event(id, event):
global ITEM_SPACING
if (event.GetType() == "ContainerInputEvent"):
if (event.mContainerID == id):
#audio = fge.GetAudio(id)
#audio.Load("GameDeliver01.mp3", False)
#audio.Play()
#audio.Volume(0.1)
playerHands = fge.GetCarrier(event.mPlayerID)
heldItems = playerHands.GetItems()
inputItems = heldItems[:event.mNumItems]
dropEvent = fge.GetPlayerDropEvent()
dropEvent.mPlayerID = event.mPlayerID
fge.SendEvent(dropEvent, event.mPlayerID)
blockContainer = fge.GetCarrier(id)
for itemID in inputItems:
itemBody = fge.GetBody(itemID)
itemBody.mConstrainX = True
itemBody.mConstrainY = True
itemBody.mConstrainZ = True
blockContainer.AddItem(itemID)
itemCollider = fge.GetCollider(itemID)
itemCollider.mIsTrigger = True
itemTransform = fge.GetTransform(itemID)
itemScale = itemTransform.GetLocalScale()
itemTransform.SetLocalPosition(0.0, 0.5 + 0.5 * itemScale[1],
0.0)
def on_init(id):
global MOVE_TIME
ob = fge.GetObserver(id)
ob.SetValue("moveTime", 0.0)
transform = fge.GetTransform(id)
ob.SetValue("movingUp", 0.0)
if (transform.GetPosition()[2] >= 5.0):
ob.SetValue("movingUp", 1.0)
def on_event(id,event):
global GRID_ID
if(event.GetType() == "SetCellEvent"):
GRID_ID = event.mGridID
if(event.GetType() == "ContainerInputEvent"):
if(event.mContainerID == id):
playerHands = fge.GetCarrier(event.mPlayerID)
heldItems = playerHands.GetItems()
inputItems = heldItems[:event.mNumItems]
dropEvent = fge.GetPlayerDropEvent()
dropEvent.mPlayerID = event.mPlayerID
fge.SendEvent(dropEvent, event.mPlayerID)
cellContainer = fge.GetCarrier(id)
cellTransform = fge.GetTransform(id)
cellPosition = cellTransform.GetPosition()
cellScale = cellTransform.GetScale()
for itemID in inputItems:
itemBody = fge.GetBody(itemID)
itemBody.mConstrainX = True
itemBody.mConstrainY = True
itemBody.mConstrainZ = True
containerLen = len(cellContainer.GetItems())
cellContainer.AddItem(itemID)
itemCollider = fge.GetCollider(itemID)
itemCollider.mIsTrigger = True
itemTransform = fge.GetTransform(itemID)
itemScale = itemTransform.GetScale()
itemTransform.SetPosition(cellPosition[0], cellPosition[1] + 0.5 * itemScale[1] + 0.5 * cellScale[1], cellPosition[2])
ob = fge.GetObserver(id)
resource = fge.DecodeResource(int(ob.GetValue("resource")))
if len(inputItems) > 0:
if resource == fge.GetType(inputItems[0]):
itemTransform = fge.GetTransform(inputItems[0])
itemScale = itemTransform.GetScale()
itemTransform.SetPosition(cellPosition[0], cellPosition[1] + 0.5 * itemScale[1] + 0.5 * cellScale[1] + 1.0, cellPosition[2])
cellUpdateEvent = fge.GetCellUpdateEvent()
cellUpdateEvent.mMatch = True
cellUpdateEvent.mCellID = id
cellUpdateEvent.mPlayerID = event.mPlayerID
fge.SendEvent(cellUpdateEvent, GRID_ID)
audio = fge.GetAudio(id)
audio.Load("GameDeliver01.mp3", False)
audio.Play()
audio.Volume(0.1)
EntityManager.GetInstance().ToggleEntityEnable(id, False)
def on_init(id):
global CHANGE_TIME
ob = fge.GetObserver(id)
ob.SetValue("changeTime", CHANGE_TIME)
ob.SetValue("toggleTime", -1.0)
transform = fge.GetTransform(id)
collider = fge.GetCollider(id)
collider.mIsTrigger = False
ob.SetValue("isOpen", 1.0)
if (transform.GetRotation()[0] < 0.0):
ob.SetValue("isOpen", 0.0)
collider.mIsTrigger = True
def on_update(id, dt):
con = fge.GetController(id)
player = fge.GetPlayer(id)
#update the player
speed = 8.0
x = y = 0
rot_num = 0
rot = 0
particles = fge.GetParticles(id)
if(con.IsPressed("up")):
rot += 180
rot_num +=1
y -= speed
elif(con.IsPressed("down")):
rot += 0
rot_num +=1
y += speed
if(con.IsPressed("left")):
if(con.IsPressed("up")):
rot += 270
else:
rot += -90
rot_num +=1
x -= speed
elif(con.IsPressed("right")):
rot += 90
rot_num +=1
x += speed
if(rot_num >= 1):
player.Rotate(rot/rot_num)
if(x!=0 or y != 0):
playerTransform = fge.GetTransform(id)
playerPos = playerTransform.GetPosition()
playerScale = playerTransform.GetScale()
particles.SetPosition(playerPos[0], playerPos[1], playerPos[2])
particles.SetRunning(True)
sprint = con.IsTriggered("Sprint")
if(sprint):
x = 2*x
y = 2*y
player.Move(x,y,sprint)
body = fge.GetBody(id)
vel = body.GetVelocity()
xV = vel[0]
zV = vel[2]
def on_event(id,event):
if(event.GetType() == "ContainerInputEvent"):
if(event.mContainerID == id):
playerHands = fge.GetCarrier(event.mPlayerID)
heldItems = playerHands.GetItems()
inputItems = heldItems[:event.mNumItems]
dropEvent = fge.GetPlayerDropEvent()
dropEvent.mPlayerID = event.mPlayerID
fge.SendEvent(dropEvent, event.mPlayerID)
container = fge.GetCarrier(id)
for itemID in inputItems:
itemBody = fge.GetBody(itemID)
itemBody.mConstrainX = True
itemBody.mConstrainY = True
itemBody.mConstrainZ = True
container.AddItem(itemID)
itemCollider = fge.GetCollider(itemID)
itemCollider.mIsTrigger = True
itemTransform = fge.GetTransform(itemID)
itemTransform.SetLocalPosition(0, -4, 0)
def on_update(id, dt):
transform = fge.GetTransform(id)
position = transform.GetPosition()
if (position[1] < -10.0):
carrier = fge.GetCarrier(id)
if (carrier is not None):
items = carrier.GetItems()
carrier.Void()
for item in items:
if (fge.GetType(item) == "Game"):
resetGridEvent = fge.GetResetGridEvent()
fge.BroadcastEvent(resetGridEvent)
fge.DeleteEntity(item)
ob = fge.GetObserver(id)
transform.SetPosition(ob.GetValue("resetX"), ob.GetValue("resetY"), ob.GetValue("resetZ"))
transform.SetRotation(0.0, 0.0, 0.0)
player = fge.GetPlayer(id)
player.Rotate(0.0)
body = fge.GetBody(id)
if (body is not None):
body.SetVelocity(0.0, 0.0, 0.0)
def UpdateIntro(id, dt):
global STATE
global CAMERA_START
global CAMERA_END
global TALLY
ob = fge.GetObserver(id)
time = ob.GetValue("time")
time = time + dt * 0.001
cameraID = CameraManager.GetInstance().GetCameraID()
if (cameraID != -1):
t = time
if (t > 1.0):
t = 1.0
newPos = fge.lerp3(CAMERA_START, CAMERA_END, t)
fge.GetTransform(cameraID).SetPosition(newPos[0], newPos[1], newPos[2])
if (time > 2.0):
Renderer.GetInstance().RenderText(
"Ready?", 0.0, -100.0, 5.0, 0, 0, 0,
1.0 - ((max(min(time, 4.0), 3.0) - 3.0) / (4.0 - 3.0)))
if (time > 4.0):
STATE = state.Gameplay
TALLY = 0.0
AudioManager.GetInstance().Load("ModuleDeliver01.mp3", False)
AudioManager.GetInstance().PlaySFX("ModuleDeliver01.mp3", 0.5, 0.5,
1.0, 1.0)
pauseEvent = fge.GetPauseEvent()
pauseEvent.mPause = False
fge.BroadcastEvent(pauseEvent)
time = 0.0
ob.SetValue("time", time)
def on_init(id):
global INITIAL_POS_Z
global INITIALIZED
INITIAL_POS_Z = fge.GetTransform(id).GetPosition()[2]
def teleport(id):
global NEXT_WAYPOINT
entityTransform = fge.GetTransform(id)
nextPos = fge.GetTransform(NEXT_WAYPOINT).GetPosition()
entityTransform.SetPosition(nextPos[0], nextPos[1] + 0.01, nextPos[2])
def on_event(id, event):
global PAUSED
global SCORE
global GAMES
global GAME_WEIGHTS
global METRIC
global UI_IDS
global MAX_TIME
global REQUEST_TIME
global REQUEST_TIME_MAX
global REWARD
global MUSIC
global FINISHED
global DIFFICULTY
global CHANGED
global LIMIT
global LEVEL_NUMBER
global STATE
global CAMERA_START
global CAMERA_END
global LEVEL_NAME
if (event.GetType() == "InitLevelEvent"):
FINISHED = 0
STARTED = False
CHANGED = False
playerIDs = fge.GetEntities("Player", True)
for playerID in playerIDs:
playerNum = fge.GetController(playerID).GetPlayer()
if (playerNum < event.mNumPlayers):
EntityManager.GetInstance().ToggleEntityEnable(playerID, True)
MAX_TIME = event.mTime
LIMIT = event.mGames
LEVEL_NAME = event.mLevelName
LEVEL_NUMBER = event.mLevelNumber
DIFFICULTY = difficulty.Easy.value
GAMES = function(LEVEL_NUMBER, DIFFICULTY)
MUSIC = event.mMusic
numGames = len(GAMES)
for game in GAMES:
GAME_WEIGHTS.append(1.0)
METRIC = event.mGrading
randomNum = numGames * RNG.GetInstance().GenerateFloat(0.0, 1.0)
selectionIndex = 0
comparisonSum = GAME_WEIGHTS[selectionIndex]
while randomNum > comparisonSum:
selectionIndex = selectionIndex + 1
comparisonSum = comparisonSum + GAME_WEIGHTS[selectionIndex]
gameInt = GAMES[selectionIndex]
# print("INTITNIT")
# print(gameInt)
requestMadeEvent = fge.GetRequestMadeEvent()
requestMadeEvent.mGame = gameInt
fge.BroadcastEvent(requestMadeEvent)
gridID = fge.GetEntities("Grid")
grid = fge.GetGrid(gridID[0])
recipeSize = len(grid.GetRecipe(gameInt))
REQUEST_TIME_MAX = 17.5 * recipeSize
REQUEST_TIME = REQUEST_TIME_MAX
REWARD = 2.0 * recipeSize
STATE = state.Intro
audio = fge.GetAudio(id)
audio.Load(event.mMusic, True)
audio.PlayLoop()
audio.Volume(0.1)
AudioManager.GetInstance().UnPauseAll()
fge.ClearRuntimeLists()
cameraID = CameraManager.GetInstance().GetCameraID()
if (cameraID != -1):
cameraTransform = fge.GetTransform(cameraID)
CAMERA_END = cameraTransform.GetPosition()
cameraFront = CameraManager.GetInstance().GetFront()
CAMERA_START = [
CAMERA_END[0] - 2.0 * cameraFront[0],
CAMERA_END[1] - 2.0 * cameraFront[1],
CAMERA_END[2] - 2.0 * cameraFront[2]
]
cameraTransform.SetPosition(CAMERA_START[0], CAMERA_START[1],
CAMERA_START[2])
pauseEvent = fge.GetPauseEvent()
pauseEvent.mPause = True
fge.BroadcastEvent(pauseEvent)
if (event.GetType() == "RequestFilledEvent"):
FINISHED += 1
#print("Finished = ",FINISHED)
game = event.mRequestedGame
deltaMultiplier = 0.5
if REQUEST_TIME >= 0.0:
if REQUEST_TIME > 0.5 * REQUEST_TIME_MAX:
deltaMultiplier = 2.0
else:
deltaMultiplier = 1.0
SCORE = SCORE + round(REWARD * deltaMultiplier)
#DIFFICULTY = difficulty.Medium.value if FINISHED == testChangeDiff.Easy else difficulty.Hard.value if FINISHED == testChangeDiff.Medium else DIFFICULTY
if FINISHED == LIMIT[0]:
DIFFICULTY = difficulty.Medium.value
CHANGED = True
if FINISHED == LIMIT[0] + LIMIT[1]:
DIFFICULTY = difficulty.Hard.value
CHANGED = True
# if FINISHED >= LIMIT[0] + LIMIT[1] + LIMIT[2] :
# DIFFICULTY = difficulty.All.value
# CHANGED = True
#print("DIff = ", DIFFICULTY)
GAMES = function(LEVEL_NUMBER, DIFFICULTY)
numGames = len(GAMES)
if CHANGED:
for game in GAMES:
GAME_WEIGHTS.append(1.0)
randomNum = numGames * RNG.GetInstance().GenerateFloat(
0.0, 1.0)
CHANGED = False
else:
weightSum = 0.0
for i in range(numGames):
if game == GAMES[i]:
GAME_WEIGHTS[i] = 0.5 * GAME_WEIGHTS[i]
else:
GAME_WEIGHTS[i] = 2.0 * GAME_WEIGHTS[i]
weightSum = weightSum + GAME_WEIGHTS[i]
randomNum = weightSum * RNG.GetInstance().GenerateFloat(
0.0, 1.0)
#for x in range(numGames):
# print(GAME_WEIGHTS[x])
selectionIndex = 0
comparisonSum = GAME_WEIGHTS[selectionIndex]
while randomNum > comparisonSum:
selectionIndex = selectionIndex + 1
comparisonSum = comparisonSum + GAME_WEIGHTS[selectionIndex]
gameInt = GAMES[selectionIndex]
requestMadeEvent = fge.GetRequestMadeEvent()
requestMadeEvent.mGame = gameInt
fge.BroadcastEvent(requestMadeEvent)
gridID = fge.GetEntities("Grid")
grid = fge.GetGrid(gridID[0])
recipeSize = len(grid.GetRecipe(gameInt))
REQUEST_TIME_MAX = 17.5 * recipeSize
REQUEST_TIME = REQUEST_TIME_MAX
REWARD = 2.0 * recipeSize
#for i in range(numGames):
# if i == selectionIndex:
# EntityManager.GetInstance().ToggleEntityEnable(UI_IDS[i], True)
# else:
# EntityManager.GetInstance().ToggleEntityEnable(UI_IDS[i], False)
if (event.GetType() == "PauseEvent"):
PAUSED = event.mPause
def UpdateEnding(id, dt):
global EXITING
global TALLY
global SCORE
global METRIC
global GRADES
global LEVEL_NAME
global STARTED_TALLY
ob = fge.GetObserver(id)
time = ob.GetValue("time")
time = time + dt * 0.001
pointsPerSecond = 25.0
if (time + dt * 0.001 > 2.0):
if (not STARTED_TALLY):
STARTED_TALLY = True
cameraID = CameraManager.GetInstance().GetCameraID()
if (cameraID is not -1):
windowID = fge.CreateEntity("Billboard", cameraID)
windowTransform = fge.GetRuntimeTransform(windowID)
cameraFront = CameraManager.GetInstance().GetFront()
cameraPos = fge.GetTransform(cameraID).GetPosition()
windowTransform.SetPosition(cameraPos[0] + cameraFront[0],
cameraPos[1] + cameraFront[1],
cameraPos[2] + cameraFront[2])
windowTransform.SetScale(0.6, 0.6, 0.6)
windowModel = fge.GetRuntimeModel(windowID)
windowModel.mpMaterial = ResourceManager.GetInstance(
).LoadMaterial("WindowGrey")
if (time > 2.0):
if (not EXITING):
TALLY = TALLY + pointsPerSecond * dt * 0.001
if (TALLY > SCORE):
TALLY = SCORE
if (InputManager.GetInstance().IsTriggered("Interact")):
TALLY = SCORE
EXITING = True
Renderer.GetInstance().Fade(False, 1.0)
grade = "F"
for i in range(len(METRIC)):
if METRIC[i] <= TALLY:
grade = GRADES[i]
else:
break
result_str = ""
if (math.isclose(TALLY, SCORE)):
if grade == "F":
result_str = "Fail"
else:
result_str = "Pass"
score_str = "Score: {:0.0f}".format(TALLY)
grade_str = "Grade: {}".format(grade)
Renderer.GetInstance().RenderText(LEVEL_NAME, -110.0, 150.0, 2.0, 0, 0,
0, 1)
Renderer.GetInstance().RenderText(score_str, -100.0, -0.0, 2.0, 0, 0,
0, 1)
Renderer.GetInstance().RenderText(grade_str, -100.0, -100.0, 2.0, 0, 0,
0, 1)
Renderer.GetInstance().RenderText(result_str, -25.0, -250.0, 2.0, 0, 0,
0, 1)
if (Renderer.GetInstance().GetFadeMultiplier() <= 0.0):
LevelCompleteEvent = fge.GetLevelCompleteEvent()
LevelCompleteEvent.mScore = 50
LevelCompleteEvent.mGrade = "A"
fge.BroadcastEvent(LevelCompleteEvent)
AudioManager.GetInstance().StopAll()
fge.ChangeScene("LevelScreenFinal")
ob.SetValue("time", time)
def on_update(id, dt):
con = fge.GetController(id)
player = fge.GetPlayer(id)
#update the player
speed = 8.0
x = y = 0
rot_num = 0
rot = 0
particles = fge.GetParticles(id)
if (con.IsPressed("up")):
rot += 180
rot_num += 1
y -= speed
elif (con.IsPressed("down")):
rot += 0
rot_num += 1
y += speed
if (con.IsPressed("left")):
if (con.IsPressed("up")):
rot += 270
else:
rot += -90
rot_num += 1
x -= speed
elif (con.IsPressed("right")):
rot += 90
rot_num += 1
x += speed
if (rot_num >= 1):
player.Rotate(rot / rot_num)
if (x != 0 or y != 0):
playerTransform = fge.GetTransform(id)
playerPos = playerTransform.GetPosition()
playerScale = playerTransform.GetScale()
#particles.SetPosition(playerPos[0], playerPos[1], playerPos[2])
particles.SetRunning(True)
sprint = con.IsTriggered("Sprint")
if (sprint):
x = 2 * x
y = 2 * y
player.Move(x, y, sprint)
else:
particles.SetRunning(False)
playerHands = fge.GetCarrier(id)
heldItems = playerHands.GetItems()
lenHeldItems = len(heldItems)
pickupAreaIDs = fge.GetChildren(id, "SearchArea")
for pickupAreaID in pickupAreaIDs:
pickupArea = fge.GetAreaSearch(pickupAreaID)
foundIDs = pickupArea.GetFound()
for foundID in foundIDs:
foundType = fge.GetType(foundID)
if (lenHeldItems == 0):
if (foundType == "Processor"):
container = fge.GetCarrier(foundID)
processor = fge.GetProcessor(foundID)
if (len(container.GetItems()) > 0
and not processor.IsWorking()):
if (con.IsTriggered("Interact")):
containerOutputEvent = fge.GetContainerOutputEvent(
)
containerOutputEvent.mPlayerID = id
containerOutputEvent.mContainerID = foundID
containerOutputEvent.mNumItems = 1
fge.SendEvent(containerOutputEvent, foundID)
else:
containerModel = fge.GetModel(foundID)
if containerModel is not None:
containerModel.Highlight()
break
if (foundType == "Block"):
container = fge.GetCarrier(foundID)
if (len(container.GetItems()) > 0):
if (con.IsTriggered("Interact")):
containerOutputEvent = fge.GetContainerOutputEvent(
)
containerOutputEvent.mPlayerID = id
containerOutputEvent.mContainerID = foundID
containerOutputEvent.mNumItems = 1
fge.SendEvent(containerOutputEvent, foundID)
else:
containerModel = fge.GetModel(foundID)
if containerModel is not None:
containerModel.Highlight()
break
elif (foundType == "Container"):
continue
elif (foundType == "Generator"):
inputType = ""
if (con.IsTriggered("Interact")):
inputType = "Interact"
if (con.IsTriggered("Sprint")):
inputType = "Sprint"
if (con.IsTriggered("action3")):
inputType = "action3"
if (con.IsTriggered("action4")):
inputType = "action4"
if (inputType != ""):
generatorInputEvent = fge.GetGeneratorInputEvent()
generatorInputEvent.mGeneratorID = foundID
generatorInputEvent.mPlayerID = id
generatorInputEvent.mInputType = inputType
fge.SendEvent(generatorInputEvent, foundID)
else:
highlightEvent = fge.GetHighlightEvent()
fge.SendEvent(highlightEvent, foundID)
itemModel = fge.GetModel(foundID)
if itemModel is not None:
itemModel.Highlight()
break
elif (foundType == "GridCell"):
container = fge.GetCarrier(foundID)
if (len(container.GetItems()) > 0):
if (con.IsTriggered("Interact")):
containerOutputEvent = fge.GetContainerOutputEvent(
)
containerOutputEvent.mPlayerID = id
containerOutputEvent.mContainerID = foundID
containerOutputEvent.mNumItems = 1
fge.SendEvent(containerOutputEvent, foundID)
else:
containerModel = fge.GetModel(foundID)
if containerModel is not None:
containerModel.Highlight()
break
elif (not fge.HasParent(foundID)
or fge.GetType(fge.GetParentID(foundID)) == "Platform"):
if (con.IsTriggered("Interact")):
pickupEvent = fge.GetPlayerPickupEvent()
pickupEvent.mPlayerID = id
pickupEvent.mItemID = foundID
fge.SendEvent(pickupEvent, id)
else:
itemModel = fge.GetModel(foundID)
if itemModel is not None:
itemModel.Highlight()
break
else:
if (fge.GetType(heldItems[0]) != "Game"):
if (foundType == "Processor"):
processor = fge.GetProcessor(foundID)
processorContainter = fge.GetCarrier(foundID)
if (processor.GetMaxInput() > len(
processorContainter.GetItems())):
if (con.IsTriggered("Interact")):
containerInputEvent = fge.GetContainerInputEvent(
)
containerInputEvent.mPlayerID = id
containerInputEvent.mContainerID = foundID
containerInputEvent.mNumItems = 1
fge.SendEvent(containerInputEvent, foundID)
else:
processorModel = fge.GetModel(foundID)
if processorModel is not None:
processorModel.Highlight()
break
if (foundType == "Block"):
container = fge.GetCarrier(foundID)
block = fge.GetBlock(foundID)
if (1 > len(container.GetItems())
and block.CanInput()):
if (con.IsTriggered("Interact")):
containerInputEvent = fge.GetContainerInputEvent(
)
containerInputEvent.mPlayerID = id
containerInputEvent.mContainerID = foundID
containerInputEvent.mNumItems = 1
fge.SendEvent(containerInputEvent, foundID)
else:
processorModel = fge.GetModel(foundID)
if processorModel is not None:
processorModel.Highlight()
break
if (foundType == "GridCell"):
cellContainter = fge.GetCarrier(foundID)
if (1 > len(cellContainter.GetItems())):
if (con.IsTriggered("Interact")):
containerInputEvent = fge.GetContainerInputEvent(
)
containerInputEvent.mPlayerID = id
containerInputEvent.mContainerID = foundID
containerInputEvent.mNumItems = 1
fge.SendEvent(containerInputEvent, foundID)
else:
cellModel = fge.GetModel(foundID)
if cellModel is not None:
cellModel.Highlight()
break
else:
if (foundType == "Container"):
if (con.IsTriggered("Interact")):
containerInputEvent = fge.GetContainerInputEvent()
containerInputEvent.mPlayerID = id
containerInputEvent.mContainerID = foundID
containerInputEvent.mNumItems = 1
fge.SendEvent(containerInputEvent, foundID)
else:
processorModel = fge.GetModel(foundID)
if processorModel is not None:
processorModel.Highlight()
break
if (len(foundIDs) == 0 and lenHeldItems > 0
and fge.GetType(heldItems[0]) != "Game"
and con.IsTriggered("Interact")):
dropEvent = fge.GetPlayerDropEvent()
dropEvent.mPlayerID = id
fge.SendEvent(dropEvent, id)
body = fge.GetBody(id)
vel = body.GetVelocity()
xV = vel[0]
zV = vel[2]
