def key_input(event): counter = 1 offStep = 34 ct.init() #print 'Key:', event.char key_press = event.char sleep_time = 0.030 # Define keys if key_press.lower() == 'w': t0 = time.time() t_end = t0 + running_time while time.time() < t_end: ct.init() if counter % offStep == 0: ct.turnLeft(sleep_time) else: ct.forward(sleep_time) sys.stdout.write("\rTime elapsed: %.2f" % round(time.time() - t0, 2)) sys.stdout.flush() counter = counter + 1 else: time.sleep(sleep_time)
def init(): # Resources path resources_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "../resources") # Init Window game.screen = Window() # Accept default size and title # Load First Level game.current_level = Level("level_1.todo", resources_path) # Init Controls controls.init()
def driveRoute(actionList): # Start C script to get MPU6050 running and wait for initialisation process = subprocess.Popen('../C_GyroReader/mstest') time.sleep(4) print( "------------------------------------------------------------------------" ) velocity = 20 # cm / sec sleep_time = 0.030 accel_bias = 0.2 try: for elem in actionList: angle = elem[0] # FIRST: ANGLE pathLen = elem[1] # SECOND: PATH # no bias if no distance if pathLen == 0: accel_bias = 0 # show/start rotating process print "Rotating " + str(angle) + " deg." if angle != 0: rotate(angle, process) print print "Rotating finished." # time = cm / (cm/sec) runtime = pathLen / velocity t0 = time.time() t_end = t0 + runtime + accel_bias # acceleration bias # counter drift to right counter = 1 offStep = 34 # show/start driving process print "Driving " + str(pathLen) + " cm." while time.time() < t_end: ctr.init() if counter % offStep == 0: ctr.turnLeft(sleep_time) else: ctr.forward(sleep_time) print "Driving done." finally: process.kill()
def takeNscans(n, t): if (n <= 0 or t <= 0): print( "Invalid scan number or scan duration provided. See takeNscans function." ) sys.exit() # Create list for distances to be measured distances = [] # do a scan of n measurements towards left for x in range(n): ct.init() ct.pivotLeft(t) time.sleep(0.5) dist = myround(int(distance() + 0.5)) distances.append(dist) return distances
def scan(turnDur, turns): distances = np.zeros([turns, turnDur]) for y in range(0, turns, 1): distanceZ = [] for z in range(turnDur): ct.init() ct.pivotLeft(0.075) time.sleep(0.5) dist = round(distance(), 2) distanceZ.append(dist) distances[y] = distanceZ print("Round " + str(y + 1) + " of " + str(turns) + " done.") # mean over all turns distances = np.mean(distances, axis=0) return distances
def init(): syscmd("jack_control start") # GPIO setup GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) sensors.init() devices.init() #controls init must be after devices and sensors, because it using them controls.init() controls.set_telegram_warning_handle(send_warning_telegram) sound.init() # must be after controls # arguments parser = argparse.ArgumentParser() parser.add_argument("--time") parser.add_argument("--check_water_level", action='store_true') args = parser.parse_args() if args.time: config.DEF_TIME_WATER_S = int(args.time) #just check water level if args.check_water_level: my_logging.logger.info( "water level: " + ("ok" if check_water_level() else "low")) exit() my_logging.logger.info("this is "+socket.gethostname()+" and we will run server and telegram bot") web_server.run(__name__) start_bot() status=devices.get_status_str()+sensors.get_status_str()+controls.get_status_str() my_logging.logger.info(status) TTS.init() # this must be before STT # sopare_plugin.init() STT.init() # this must be at the end watch_thread.init() my_logging.logger.info("end init")
def key_input(event): ct.init() #print 'Key:', event.char key_press = event.char sleep_time = 0.040 # Define keys if key_press.lower() == 'w': ct.forward(sleep_time) elif key_press.lower() == 's': ct.backward(sleep_time) elif key_press.lower() == 'a': ct.turnLeft(sleep_time) elif key_press.lower() == 'd': ct.turnRight(sleep_time) elif key_press.lower() == 'q': ct.pivotLeft(sleep_time) elif key_press.lower() == 'e': ct.pivotRight(sleep_time) else: time.sleep(sleep_time)
import ika from engine import Engine from intro import intro, menu import sound import saveload import controls ika.SetCaption('Winter') ika.Video.DrawRect(0,0,320,240,0) controls.init() import subscreen subscreen.init() try: c = controls.readConfig('controls.cfg') except IOError: #file not found, write defaults to a config file and reload it c = controls.defaultControls controls.writeConfig('controls.cfg', c) try: controls.setConfig(c) except: controls.writeConfig('controls_bak.cfg', c) controls.setConfig(controls.defaultControls) #any fails (missing gamepad usually), default to original controls introMusic = ika.Sound('music/Existing.s3m') #while not controls.attack():
def check_front(): # initialise gpio pins and check first distance ctr.init() dist = se.minDistance() printDist(dist) # check if distance is below 30cm, if so change direction if (dist < 30): #print("Too close, distance: ", dist) ctr.init() ctr.backward(1) ctr.init() ctr.pivotRight(0.65) dist = se.minDistance() printDist(dist) # check new distance and again, if below 30cm change direction again if (dist < 30): #print("Too close, distance: ", dist) ctr.init() ctr.backward(1.5) ctr.init() ctr.pivotLeft(0.65) dist = se.minDistance() printDist(dist) # check new distance and again, if below 30cm change direction again if (dist < 30): #print("Too close, distance: ", dist) ctr.init() ctr.backward(2) ctr.init() ctr.pivotLeft(2) dist = se.minDistance() printDist(dist) # check new distance and again, if below 30cm give up if (dist < 30): print("Too close, giving up with dist: ", dist) sys.exit()
if (dist < 30): #print("Too close, distance: ", dist) ctr.init() ctr.backward(1.5) ctr.init() ctr.pivotLeft(0.65) dist = se.minDistance() printDist(dist) # check new distance and again, if below 30cm change direction again if (dist < 30): #print("Too close, distance: ", dist) ctr.init() ctr.backward(2) ctr.init() ctr.pivotLeft(2) dist = se.minDistance() printDist(dist) # check new distance and again, if below 30cm give up if (dist < 30): print("Too close, giving up with dist: ", dist) sys.exit() tf = 0.04 for z in range(500): check_front() ctr.init() ctr.forward(tf)
def rotate(angle, process): # Need to fix 90 degrees if angle == 180: angle = 179 # counter drift due to inertia driftBias = 20 # set sleep_time sleep_time = 0.03 if angle == 0: return # Degree conversion if angle > 360: angle = angle % 360 if angle < -360: angle = angle % -360 if angle > 180 and angle < 360: angle = -(360 - angle) if angle < -180 and angle < -360: angle = 360 - angle # Conversion to unit angles (90°=45u) uAngle = angle / 2 # Path of buffer file buffDir = "../C_GyroReader/rotationBuff" # desired rotation (90deg are 45 units) endRot = uAngle right = True shift = -999 if endRot < 0: endRot = -(endRot) right = False # get start rotation value try: f = open(buffDir, "rb") byte = f.read(4) startRot = struct.unpack('f', byte) startRot = startRot[0] f.seek(0, 0) f.close() finally: f.close() # endRot is in [1 to 90] interval # for the bias: [1 90-bias] interval endRot = endRot - driftBias if endRot <= 0: endRot = 1 try: while int(shift) < int(endRot): # move to the right (increase the rotation) ctr.init() if right: ctr.pivotRight(sleep_time) else: ctr.pivotLeft(sleep_time) # read new rotation f = open(buffDir, "rb") byte = f.read(4) newRot = struct.unpack('f', byte) newRot = newRot[0] shift = abs(startRot - newRot) inDeg = shift * 2 + driftBias * 2 sys.stdout.write("\rTurning = %.2f" % inDeg) sys.stdout.flush() f.seek(0, 0) f.close() finally: f.close()
txt += 'Играть(1)\n' txt += 'Настройки(2)' canv.create_text(400, 300, text=txt, font='Verdana 50') def Open(self): self.closed = 0 root.bind('<Key-1>', o1) root.bind('<Key-2>', o2) def Close(self): self.closed = 1 import gun gun.init(root, canv) controls.init(root, canv) i = 0 def Pause(a): global i if i: gun.stop() else: gun.start() i = 1 - i state = 0 windows = []
def gameLoop(currentScene, optional): # Support libraries import pygame # temp is used to transfer data import temp keys = [[pygame.K_a,"a"],[pygame.K_b,"b"],[pygame.K_c,"c"],[pygame.K_d,"d"],[pygame.K_e,"e"],[pygame.K_f,"f"],[pygame.K_g,"g"], [pygame.K_h, "h"],[pygame.K_i,"i"],[pygame.K_j,"j"],[pygame.K_k,"k"],[pygame.K_l,"l"],[pygame.K_m,"m"],[pygame.K_n,"n"], [pygame.K_o, "o"],[pygame.K_p,"p"],[pygame.K_q,"q"],[pygame.K_r,"r"],[pygame.K_s,"s"],[pygame.K_t,"t"],[pygame.K_u,"u"], [pygame.K_v, "v"],[pygame.K_w,"w"],[pygame.K_x,"x"],[pygame.K_y,"y"],[pygame.K_z,"z"]] f = open("controls.txt","r") #The current control scheme. Name is the name of the control, key is the key assigned, found is whether the key was #found when iterating through heldKeys #[[name,key,found],[name,key,found]] controlScheme = [["left",int(f.readline()),False],["right",int(f.readline()),False],["jump",int(f.readline()),False],["attack 1",int(f.readline()),False],["attack 2",int(f.readline()),False],["attack 3",int(f.readline()),False],["block",int(f.readline()),False],["pause",int(f.readline()),False]] f.close() cL = 0 cR = 1 cJ = 2 c1 = 3 c2 = 4 c3 = 5 cB = 6 cP = 7 # the backdrop of the scene backdrop = "" # Later used to load the backdrop bg = None # Make the image path for the current backdrop backdrop = "graphics/" + currentScene + ".PNG" # load the image bg = pygame.image.load(backdrop) # get its dimensions windowWidth = bg.get_width() windowHeight = bg.get_height() # place the floor 1 tenth of the window size above the bottom floor = round((43 / 50) * windowHeight) # transfer the dimensions to temp temp.width = windowWidth temp.height = windowHeight temp.floor = floor # game modules import objects import game # Enemies import troll numEnemies = 1 # if the scene is forest if currentScene == "forest": # import the scene module import forest # update knight stats based on window size game.knight.speed = round(windowWidth / 30) game.knight.jumpHeight = round(windowHeight / 4) # initialize player player = game.knight("player") entities = [player] player.attacks = player.setAttacks() # update troll stats based on window size game.troll.speed = round(windowWidth / 100) game.troll.jumpHeight = round(windowHeight / 10) game.enemyEntities = [] # initialize enemy1 for i in range(numEnemies): game.enemyEntities.append(game.troll("enemy" + str(i + 1))) game.enemyEntities[-1].__init__("enemy" + str(i + 1)) # add all game objects to entities array for enemy in game.enemyEntities: entities.append(enemy) # find the player game object # store it for quicker access later for currentEntity in entities: if currentEntity.name == "player": playerEntity = currentEntity # initialize graphic objects based on window size forest.sceneObjects = forest.init(entities, windowWidth, windowHeight,numEnemies) # get list of objects sceneObjects = forest.sceneObjects # if the current scene is mainMenu elif currentScene == "mainMenu": # import the module import mainMenu # initialize the graphic objects based on window size mainMenu.sceneObjects = mainMenu.init(windowWidth, windowHeight) sceneObjects = mainMenu.sceneObjects elif currentScene == "controls": # import the module import controls # initialize the graphic objects based on window size controls.sceneObjects = controls.init(windowWidth, windowHeight, controlScheme) sceneObjects = controls.sceneObjects # Used to store which key is currently being remapped. currentKey = -1 elif currentScene == "newScore": import newScore newScore.sceneObjects = newScore.init(optional) sceneObjects = newScore.sceneObjects elif currentScene == "leaderboard": import leaderboard leaderboard.sceneObjects = leaderboard.init(optional) sceneObjects = leaderboard.sceneObjects # find the player graphic object playerObject = None # by scanning through the list of graphic objects for currentObject in sceneObjects: if currentObject.name == "player": playerObject = currentObject # if the object's name starts with "enemy" add it a list of enemies elif currentObject.name[0:5] == "enemy": game.enemyObjects.append(currentObject) # Initialize pygame pygame.init() # Rate of height gain due to jumping (px/s) jumpSpeed = round(windowHeight * 0.08) # rate of falling due to gravity (px/s) gravity = round(windowHeight * 0.07) # Initialize the game window window = pygame.display.set_mode((windowWidth, windowHeight)) pygame.display.set_caption("RPG Game") # Initialize game clock gameClock = pygame.time.Clock() FPS = 15 # track how many more times to show the noStamina animation noStamina = 0 paused = False # keys currently down heldKeys = [] # Game has is not quitting yet gameQuit = False quitTimer = 30 # the number of kills the player got. only used on gameQuit kills = 0 # ID of the current attack being run attackID = 0 # While the game is not quitting... while quitTimer > 0: # if the player exists if playerObject != None: # if the player is executing an attack if playerObject.state in playerEntity.attackNames: # execute the next frame playerEntity.attack(playerObject, playerEntity, windowWidth, attackID) # Check for events for event in pygame.event.get(): # If the quit button (X) has been pressed if event.type == pygame.QUIT: # Quit the game pygame.quit() return "quitGame" # If ANY mouse button has pressed elif event.type == pygame.MOUSEBUTTONDOWN: # If it was left click if event.button == 1: # Check through all loaded graphic objects for currentObject in range(len(sceneObjects)): # is the object we're checking clickable? if sceneObjects[currentObject].clickable: # Is the mouse over the object? if sceneObjects[currentObject].x - 1 < event.pos[0] < sceneObjects[currentObject].x + \ sceneObjects[currentObject].width + 1 and sceneObjects[currentObject].y - 1 < \ event.pos[1] < sceneObjects[currentObject].y + sceneObjects[ currentObject].height + 1: # Say so (will be used later) # print(sceneObjects[currentObject].name) if sceneObjects[currentObject].name == "quitGame": pygame.quit() return "quitGame" if currentScene == "newScore": if len(sceneObjects[0].text) > 0: return sceneObjects[0].text if currentScene == "controls": if sceneObjects[currentObject].name == "menu": f = open("controls.txt","w") for control in controlScheme: f.write(str(control[1]) + "\n") return "menu" else: if currentKey != -1: sceneObjects[currentKey].colour = objects.white for control in range(len(controlScheme)): if controlScheme[control][0] == sceneObjects[currentObject + 1].text: sceneObjects[currentKey + 2].text = "= " + pygame.key.name(controlScheme[control][1]) currentKey = currentObject else: return sceneObjects[currentObject].name # If a key has been pressed elif event.type == pygame.KEYDOWN: # add it to an array of held keys heldKeys.append(event.key) # if a key was lifted elif event.type == pygame.KEYUP: # see if it was held before for current in heldKeys: # if it was if current == event.key: # remove it from the array of held keys heldKeys.remove(current) if currentScene == "newScore": for key in heldKeys: if key == pygame.K_BACKSPACE and len(sceneObjects[0].text) > 0: sceneObjects[0].text = sceneObjects[0].text[0:len(sceneObjects[0].text) - 1] elif len(sceneObjects[0].text) < 10: for letter in keys: if letter[0] == key: sceneObjects[0].text = sceneObjects[0].text + letter[1] elif currentScene == "controls": if currentKey != -1: sceneObjects[currentKey].colour = objects.green sceneObjects[currentKey + 2].text = "Press a key..." if len(heldKeys) > 0: for control in range(len(controlScheme)): if controlScheme[control][0] == sceneObjects[currentKey + 1].text: controlScheme[control][1] = heldKeys[0] print(controlScheme[control][1]) sceneObjects[currentKey].colour = objects.white key = pygame.key.name(heldKeys[0]) if len(key) > 2 and key[0] == "[" and key[-1] == "]": key = "Keypad " + key[1:-1] sceneObjects[currentKey + 2].text = "= " + key currentKey = -1 break # default to disabled disabled = True # if the player exists if playerObject is not None: # check if the player is in a state where keys should not be pressed disabled = playerObject.state in ["jump", "drop", "knockback", "pant","block"] or playerObject.state in playerEntity.attackNames or playerEntity.stamina <= 0 # default all recognised keys to not pressed controlScheme[cL][2] = controlScheme[cR][2] = controlScheme[cJ][2] = controlScheme[c1][2] = controlScheme[c2][2] = controlScheme[c3][2] = controlScheme[cB][2] = False # check through all keys currently down for key in heldKeys: # if it's pause if key == controlScheme[cP][1] or paused == True: # pause paused = True for currentObject in sceneObjects: if currentObject.name == "pauseText": currentObject.toRender = True break while paused: for event in pygame.event.get(): # If the quit button (X) has been pressed if event.type == pygame.QUIT: # Quit the game pygame.quit() return "quitGame" # If pause was pressed elif event.type == pygame.KEYDOWN: if event.key == controlScheme[cP][1]: # unpause paused = False currentObject.toRender = False # add it to an array of held keys heldKeys.append(event.key) # if a key was lifted elif event.type == pygame.KEYUP: # see if it was held before for current in heldKeys: # if it was if current == event.key: # remove it from the array of held keys heldKeys.remove(current) font = pygame.font.SysFont(None, currentObject.size) # Render the text shownText = font.render(currentObject.text, currentObject.antialiasing, currentObject.colour) # blit it onto the screen window.blit(shownText, [currentObject.x, currentObject.y]) pygame.display.flip() gameClock.tick(FPS) # if it's a if key == controlScheme[cL][1]: # note that the key was found controlScheme[cL][2] = True # if the player isnt walking already if not disabled: if playerObject.state != "walk": # walk playerObject.changeState("walk") # left playerObject.face = "l" # if it's d if key == controlScheme[cR][1]: controlScheme[cR][2] = True # walk right if not disabled: if playerObject.state != "walk": playerObject.changeState("walk") playerObject.face = "r" # if both a and d are down if controlScheme[cL][2] and controlScheme[cR][2]: # stand if playerObject.state != "stand" and not disabled: playerObject.changeState("stand") # if it's space if key == controlScheme[cJ][1]: # jump if playerObject.state != "jump" and not disabled: playerObject.changeState("jump") controlScheme[cL][2] = True # if it's KP1 if key == controlScheme[c1][1]: controlScheme[c1][2] = True # execute attack 1 if not disabled: if playerEntity.stamina >= playerEntity.attacks[0][1]: playerEntity.attack(playerObject, playerEntity, windowWidth, 0) else: noStamina = 7 attackID = 0 controlScheme[c1][2] = True # if it's KP2 if key == controlScheme[c2][1]: controlScheme[c2][2] = True # execute attack 2 if not disabled: if playerEntity.stamina >= playerEntity.attacks[1][1]: playerEntity.attack(playerObject, playerEntity, windowWidth, 1) else: noStamina = 7 attackID = 1 # if it's KP3 if key == controlScheme[c3][1]: controlScheme[c3][2] = True # execute attack 3 if not disabled: if playerEntity.stamina >= playerEntity.attacks[2][1]: playerEntity.attack(playerObject, playerEntity, windowWidth, 2) else: noStamina = 7 attackID = 2 if key == controlScheme[cB][1]: controlScheme[cB][2] = True #block if playerObject.state != "block" and not disabled: if playerEntity.stamina >= round(currentEntity.maxStamina / (FPS * 5)): playerObject.changeState("block") else: noStamina = 7 # if no keys were found if True not in [controlScheme[cL][2], controlScheme[cR][2], controlScheme[cJ][2], controlScheme[c1][2], controlScheme[c2][2], controlScheme[c3][2], controlScheme[cB][2]] and not disabled: # stand if playerObject.state != "stand": playerObject.changeState("stand") # entity actions for currentObject in sceneObjects: if currentObject.name == "noStamina": if noStamina > 0: if currentObject.current == currentObject.totalStates - 2: noStamina -= 1 if currentObject.state == 0: currentObject.state = 1 elif currentObject.state == 1: currentObject.state = 0 # if the current graphic object being scanned is an entity if currentObject.objectType == "entity": # associate entities with their game class counterpart (e.g knight/mage for the player etc) for currentEntity in entities: if currentObject.name == currentEntity.name: # if the entity is out of stamina if currentEntity.stamina <= 0: # Make sure it isn't negative currentEntity.stamina = 0 # If the entity is not disabled if not (currentObject.state in ["jump", "drop", "knockback", "pant","block"] or currentObject.state in currentEntity.attackNames): # make them pant currentObject.changeState("pant") noStamina = 7 # if the entity is panting if currentObject.state == "pant": # if the entity's stamina has reached the minimum to stop if currentEntity.stamina >= round(currentEntity.maxStamina / 4): # revert to standing currentObject.changeState("stand") # add stamina naturally if not (currentObject.state in ["jump", "drop", "knockback","block"] or currentObject.state in currentEntity.attackNames): if currentEntity.maxStamina - currentEntity.stamina >= round(currentEntity.maxStamina / (FPS * 5)): currentEntity.stamina += round(currentEntity.maxStamina / (FPS * 5)) else: currentEntity.stamina = currentEntity.maxStamina # if the entity is out of health if currentEntity.health <= 0: if currentObject.name == "player": # store the player's kills kills = playerEntity.kills # remove them from the list of objects sceneObjects.remove(currentObject) entities.remove(currentEntity) # start game quit gameQuit = True # if an enemy was defeated, add it to the players kill count if currentObject.name[0:5] == "enemy": # reset their current attack tracker currentEntity.currentAttackID = None playerEntity.kills += 1 position = 0 distance = 0 while distance < round(windowWidth/3): position = random.randint(0,windowWidth) # if the player is on the right of the enemy if playerObject.x > position: # get the distance between the enemy and the player distance = playerObject.x - position # if the player is on the left of the enemy else: # get the distance between the enemy and the player distance = position - playerObject.x # if the attack delay isnt 0 # initialize the enemy currentObject.__init__(currentObject.name, position, round(windowHeight / 2), currentObject.clickable, currentObject.toRender,currentObject.states, "stand",currentObject.folder, "l") currentEntity.getHealth() currentEntity.setHealth() # if game is quitting, take 1 from the timer if gameQuit: quitTimer -= 1 # load the entity's current frame image = pygame.image.load( "graphics/" + currentObject.folder + "/" + currentObject.state + "/" + str( currentObject.current) + ".PNG") # get the y value of the entity's feet feet = currentObject.y + image.get_height() # Make sure entities are above the ground if feet > floor: currentObject.y = floor - image.get_height() # Make sure entities are on the screen if currentObject.x < 0: currentObject.x = 0 elif currentObject.x + image.get_width() > windowWidth: currentObject.x = windowWidth - image.get_width() # blocking if currentObject.state == "block": if currentObject.name == "player" and (not controlScheme[cB][2] or playerEntity.stamina < round(currentEntity.maxStamina / (FPS * 5))): playerObject.changeState("stand") if playerEntity.stamina < round(currentEntity.maxStamina / (FPS * 5)): noStamina = 7 else: currentEntity.stamina -= round(currentEntity.maxStamina / (FPS * 5)) elif currentEntity.armour != currentEntity.maxArmour: currentEntity.armour = currentEntity.maxArmour # gravity # if the entity is not jumping, dropping or being knocked back AND the feet are above the floor if (currentObject.state not in ["jump", "drop", "knockback"]) and ( not currentObject.state in currentEntity.attackNames) and (feet < floor): # make the entity drop if floor - feet >= gravity: currentObject.changeState("drop") else: currentObject.y += floor - feet # if the entity is dropping if currentObject.state == "drop": # if the distance between the entity's feet and the floor is more than or equal to the distance the entity moves per frame due to gravity if floor - feet >= gravity: # move the entity down at the rate of game gravity currentObject.y += gravity # if the distance is less than the amount needed for normal gravity else: # move the entity down the remaining distance currentObject.y += floor - feet # if the entity is attacking and the entity's feet are above the ground # if currentObject.state in currentEntity.attackNames and feet < floor: # # move them back onto the ground # currentObject.y = floor - image.get_height() # if the entity is dropping but they have reached the ground if currentObject.y + image.get_height() == floor: # revert to standing currentObject.changeState("stand") # if the entity is being knocked back if currentObject.state == "knockback": # Reset the enemy's attack if currentObject.name[0:5] == "enemy": currentEntity.currentAttackID = None # keep them facing the right way currentObject.face = currentObject.knockbackFace # if the entity is below half way through the knockback sequence if currentObject.knockbackDistance >= round(currentObject.knockbackDistanceMax / 2): # make them gain height at half jump rate currentObject.y -= round(jumpSpeed / 2) # if the entity is above half way through the knockback sequence elif currentObject.knockbackDistance != 0: # make them lose weight at jump speed, in the same way as gravity if floor - feet >= round(jumpSpeed / 2): currentObject.y += round(jumpSpeed / 2) else: currentObject.y += floor - feet # if the remaining knockback distance is more than 1.5 * the jump speed if currentObject.knockbackDistance >= round(1.5 * jumpSpeed): # add 1.5 * the jump speed to the x position if currentObject.face == "l": currentObject.x -= round(1.5 * jumpSpeed) else: currentObject.x += round(1.5 * jumpSpeed) # take the amount moved from the remaining distance currentObject.knockbackDistance -= 1.5 * jumpSpeed # if the remaining distance is less than 1.5 * the jump speed elif currentObject.knockbackDistance != 0: # add the remaining distance if currentObject.face == "l": currentObject.x -= currentObject.knockbackDistance else: currentObject.x += currentObject.knockbackDistance # reset knockback currentObject.knockbackDistance = 0 # if there is no knockback remaining else: # if the entity is on the ground if currentObject.y == 0: # stand currentObject.changeState("stand") # if the entity is in the air else: # drop currentObject.changeState("drop") # walking # if: # the entity is walking # OR # they're walking AND they were walking before they jumped # OR # they're dropping AND they were last walking OR the state before last was walk if currentObject.state == "walk" or ( currentObject.state == "jump" and currentObject.previous[-1] == "walk") or ( currentObject.state == "drop" and ( currentObject.previous[-1] == "walk" or currentObject.previous[ -2] == "walk")): # move the entity based on their game entity's walk speed if currentObject.face == "l": currentObject.x -= currentEntity.speed else: currentObject.x += currentEntity.speed # jumping # if the entity is jumping if currentObject.state == "jump": # if the entity is below the jump height if currentObject.y > floor - image.get_height() - currentEntity.jumpHeight: # if the difference between the entity and the jump height is 15 or more if currentObject.y - ( floor - image.get_height() - currentEntity.jumpHeight) >= jumpSpeed: # move up 15 currentObject.y -= jumpSpeed # if the difference is less than 15 else: # set the y to max jump height currentObject.y = floor - image.get_height() - currentEntity.jumpHeight # if the entity is at or above jump height if currentObject.y <= floor - image.get_height() - currentEntity.jumpHeight: # switch to dropping currentObject.changeState("drop") # enemy attack continuation and AI call # if they are not the player and they are not disabled if currentObject.name[0:5] == "enemy" and currentObject.state not in ["jump", "drop", "knockback", "pant"]: # if they are not attacking if not currentObject.state in currentEntity.attackNames: # call their AI file troll.react(currentObject, currentEntity, playerObject, playerEntity, windowWidth) # if they just finished attacking, revert to standing elif currentEntity.currentAttack == "none": currentObject.changeState("stand") currentEntity.currentAttackID = None # if they are attacking else: currentEntity.currentAttackID = None # continue the attack currentEntity.attack(playerObject, playerEntity, currentObject, windowWidth, currentEntity.currentAttack) # Wipe the screen window.fill(objects.white) # If the current scene has a backdrop if backdrop != "": # blit it onto the screen window.blit(bg, [0, 0]) ########GRAPHIC OBJECT BEHAVIOUR # Check through all loaded objects for currentObject in range(len(sceneObjects)): # If the current object is visible if sceneObjects[currentObject].toRender: # "shortcut" to the current object's class instance workingObject = sceneObjects[currentObject] # if the object is a rectangle if workingObject.objectType == "rectangle": # draw it pygame.draw.rect(window, workingObject.colour, [workingObject.x, workingObject.y, workingObject.width, workingObject.height]) # If it's text elif workingObject.objectType == "text": # initialize the font font = pygame.font.SysFont(None, workingObject.size) # Render the text shownText = font.render(workingObject.text, workingObject.antialiasing, workingObject.colour) # blit it onto the screen window.blit(shownText, [workingObject.x, workingObject.y]) # If it's an image elif workingObject.objectType == "image": # load image = pygame.image.load(workingObject.file).convert_alpha() # blit window.blit(image, [workingObject.x, workingObject.y]) # if it's an animated image elif workingObject.objectType == "animation": # if the animation is running if workingObject.state == 1: # load its current image, taken from the images array inside of its folder image = pygame.image.load("graphics/" + workingObject.folder + "/" + str( workingObject.current) + ".PNG").convert_alpha() # get the height of the old frame if workingObject.totalStates > 1: if workingObject.current == 0: oldHeight = pygame.image.load( "graphics/" + workingObject.folder + "/" + str(workingObject.totalStates - 1) + ".PNG").get_height() else: oldHeight = pygame.image.load( "graphics/" + workingObject.folder + "/" + str(workingObject.current - 1) + ".PNG").get_height() newHeight = image.get_height() # if the new feet are different to the old, move to compensate if newHeight < oldHeight: workingObject.y += oldHeight - newHeight elif newHeight > oldHeight: workingObject.y -= newHeight - oldHeight # blit window.blit(image, [workingObject.x, workingObject.y]) # reset current image id if the last image has been drawn if workingObject.current == workingObject.totalStates - 1: workingObject.current = 0 else: # increment current image workingObject.current += 1 # if it's an entity. entities are used for associating the state of an entity with multiple animations # entity animations are always running elif workingObject.objectType == "entity": # load the current image from it's state folder, from the entity's folder image = pygame.image.load( "graphics/" + workingObject.folder + "/" + workingObject.state + "/" + str( workingObject.current) + ".PNG").convert_alpha() # if the image is facing left, flip it if workingObject.face == "l": image = pygame.transform.flip(image, True, False) # blit window.blit(image, [workingObject.x, workingObject.y]) # reset if last image is reached. if workingObject.current >= workingObject.totalStates - 1: workingObject.current = 0 elif workingObject.totalStates > 1: # increment current image workingObject.current += 1 # if it's a health bar elif workingObject.objectType == "healthBar": # update the health bar's position workingObject.update() # draw the green section pygame.draw.rect(window, objects.green, [workingObject.x, workingObject.y, workingObject.gwidth, workingObject.height]) # draw the red section pygame.draw.rect(window, objects.red, [workingObject.x + workingObject.gwidth, workingObject.y, workingObject.rwidth, workingObject.height]) if workingObject.object.name == "player": font = pygame.font.SysFont(None, round(workingObject.entityWidth * 25 / 320)) else: font = pygame.font.SysFont(None, round(workingObject.entityWidth * 25 / 100)) shownText = font.render(str(workingObject.entity.health) + "/" + str(workingObject.entity.maxHealth), True, objects.green) # blit it onto the screen if workingObject.object.name == "player": window.blit(shownText, [workingObject.x + workingObject.entityWidth, workingObject.y]) else: window.blit(shownText, [workingObject.x, workingObject.y - font.size(str(workingObject.entity.health))[1]]) # if it's a stamina bar elif workingObject.objectType == "staminaBar": # update the stamina bar's position workingObject.update() # draw the green section pygame.draw.rect(window, objects.lblue, [workingObject.x, workingObject.y, workingObject.bwidth, workingObject.height]) # draw the red section pygame.draw.rect(window, objects.grey, [workingObject.x + workingObject.bwidth, workingObject.y, workingObject.gwidth, workingObject.height]) elif workingObject.objectType == "killCounter": font = pygame.font.SysFont(None, round(windowWidth * 25 / 800)) shownText = font.render("Kills: " + str(workingObject.entity.kills), True, objects.yellow) window.blit(shownText, [windowWidth - round(windowWidth / 100) - font.size("Kills: " + str(workingObject.entity.kills))[0], round(windowWidth / 100)]) # update all loaded graphic objects pygame.display.flip() # tick the game clock gameClock.tick(FPS) # outside of game loop, so the game must be ending. Quit pygame. pygame.quit() if currentScene == "forest": return kills
def rotate(angle): if angle == 0: return # Degree conversion if angle > 360: angle = angle % 360 if angle < -360: angle = angle % -360 if angle > 180 and angle < 360: angle = -(360 - angle) if angle < -180 and angle < -360: angle = 360 - angle # Conversion to unit angles (90°=45u) uAngle = angle / 2 # Start C script to get MPU6050 running and wait for initialisation process = subprocess.Popen('../C_GyroReader/mstest') time.sleep(4) print( "------------------------------------------------------------------------" ) # Path of buffer file buffDir = "../C_GyroReader/rotationBuff" # desired rotation (90deg are 45 units) endRot = uAngle right = True shift = -999 if endRot < 0: endRot = -(endRot) right = False # get start rotation value try: f = open(buffDir, "rb") byte = f.read(4) startRot = struct.unpack('f', byte) startRot = startRot[0] f.seek(0, 0) f.close() finally: f.close() try: while int(shift) < int(endRot): # move to the right (increase the rotation) ctr.init() if right: ctr.pivotRight(0.030) else: ctr.pivotLeft(0.030) # read new rotation f = open(buffDir, "rb") byte = f.read(4) newRot = struct.unpack('f', byte) newRot = newRot[0] shift = abs(startRot - newRot) sys.stdout.write("\rTurning = %.2f" % shift) sys.stdout.flush() f.seek(0, 0) f.close() finally: f.close() process.kill() process.kill() print