def __init__(self):
coordList = []
self.currLocation = [0, 0, 90]
self.nSteps = len(coordList)
self.mov = Movement()
self.rad = 180 / 3.14
def __init__(self):
self.__arena = Arena()
self.__wall = Wall(self.__arena)
self.__snake = Snake(self.__arena)
self.__movement = Movement(self.__arena, self.__snake)
self.cls()
self.gameloop()
def experiment1():
mov = Movement()
mov.setAbsoluteSpeed(0.35)
mov.turnRightForRadius(0.25)
mov.moveForward(30)
mov.pause(30)
mov.turnRightForRadius(0.35)
mov.moveForward(30)
mov.pause(30)
mov.turnRightForRadius(0.45)
mov.moveForward(30)
mov.pause(30)
mov.turnRightForRadius(0.55)
mov.moveForward(30)
mov.pause(30)
#mov.moveForwardDist(3)
# mov.moveBackwardDist(2)
# mov.stop()
#mov.turnLeft(20)
# time.sleep(2)
# mov.turnLeft(40)
# time.sleep(2)
# mov.turnRight(20)
# time.sleep(2)
#mov.turnStraight()
mov.stop()
#mov.stop()
del mov
def update(self, entities_by_filter):
start_balls = base.mouseWatcherNode.is_button_down(
KeyboardButton.space(), )
if start_balls:
for entity in set(entities_by_filter['ball']):
entity.remove_component(Resting)
entity.add_component(Movement(value=Vec3(-1, 0, 0)))
def __init__(self, world, sprite, pos, power, timer=3000):
"""."""
self.sprite = sprite
self.sprite.position = pos
self.sprite.depth = 1
self.bombdata = BombData(power, timer)
self.movement = Movement(pos)
def generate_individuals(num, bench_press_fitness_mean,
bench_press_fitness_variance):
"""
Generates individuals to be used in the simulator
:param num: Number of individuals to generate.
:param bench_press_fitness_mean: The mean of the 1RM in bench press for the individuals
:param bench_press_fitness_variance: The variance in the 1RM for the individuals for a normal
distribution
:return: A list of individuals generated
"""
# Holds all individuals
individuals = []
# Normally distributed bench press fitnesses used to create bench press movementss
bench_press_performances = np.random.normal(bench_press_fitness_mean,
bench_press_fitness_variance,
num).astype("int")
for i in tqdm(range(num)):
banister_params = random_banister_parameters()
name = names.get_full_name()
bench_press_movement = Movement(0, 0, bench_press_performances[i],
banister_params["fitness_gain"],
banister_params["fatigue_gain"],
banister_params["fitness_decay"],
banister_params["fatigue_decay"])
individual = Individual(i, datetime.datetime.now(), name,
bench_press_movement)
individuals.append(individual)
return individuals
def update(self, entities_by_filter):
# Should resting balls be started?
start_key = KeyboardButton.space()
start_balls = base.mouseWatcherNode.is_button_down(start_key)
if start_balls:
for entity in set(entities_by_filter['ball']):
del entity[Resting]
entity[Movement] = Movement(value=Vec3(-1, 0, 0))
def __init__(self, character):
pygame.sprite.Sprite.__init__(self)
self.character = character
self.image = pygame.image.load(IMG + character).convert()
self.image.set_colorkey(WHITE)
self.rect = self.image.get_rect()
self.movement = Movement(self)
self.pos = VEC(WIDTH / 2 + 10, HEIGHT / 2)
self.rect.midbottom = self.pos
def bench_press():
"""Fixture for sample bench press movement with set parameters"""
return Movement(fitness=0,
fatigue=0,
basic_performance=300,
fitness_gain=1,
fatigue_gain=1,
fitness_decay=1,
fatigue_decay=0.99)
def speedAnalysis():
speedList = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
timeList = [30, 30, 20, 20, 10, 10, 5, 5, 4, 4]
mov = Movement()
for speed, time in zip(speedList, timeList):
print("Speed: ", speed, "\t Time: ", time, "\n")
mov.setSpeed(speed)
mov.moveForward(time)
mov.pause(15)
mov.stop()
del mov
def populate(self):
player = GameObject(400, 225)
player.add_behaviour(PlayerController())
player.add_behaviour(SquareRenderer())
self.game_objects.append(player)
for i in range(8):
obstacle = GameObject(0, 0)
obstacle.x = i * 100 + 50
obstacle.y = i * 50
obstacle.add_behaviour(Movement())
obstacle.add_behaviour(CircleRenderer())
self.game_objects.append(obstacle)
def __init__(self, width, height, title):
super().__init__()
self.screen = Window(width, height, title)
self.ball = Ball(20, (0, 0, 255), 2)
self.ball.position = (math.ceil(width / 2), math.ceil(height / 2))
self.movementObj = Movement(self.ball.x, self.ball.y, self.ball.radius)
self.speed = 1
self.createObjects([self.ball])
self.run()
def loadData(self, path):
global senseLen
movementList = []
with open(path) as f:
lines = f.readlines()
for line in lines:
ln = line.strip()
ln = ln.split(",")
senseInfoList = ln[:-1]
direction = ln[-1]
movement = Movement(senseInfoList, direction)
movementList.append(movement)
senseLen = len(senseInfoList)
return movementList
def update(self, entities_by_filter):
"""
Check whether the resting ball should be started?
Note that restarting the ball's movement means removing the Entity's
Resting Component, and adding it's Movement component with the desired
direction.
"""
start_key_is_pressed = base.mouseWatcherNode.is_button_down(
StartBallMotion.start_key)
if start_key_is_pressed:
for entity in set(entities_by_filter['ball']):
del entity[Resting]
entity[Movement] = Movement(
direction=Vec3(-0.1 * randrange(5, 10), 0, 0))
def __init__(
self,
visual: Visual,
parameters: Parameters,
history: History,
controllers,
plotting,
result,
):
self.visual = visual
self.parameters = parameters
self.history = history
self.movement = Movement(parameters, history)
self.controllers = controllers
self.plotting = plotting
self.result = result
def ManageMotion():
move = Movement()
while move.IsActive():
#FRAME infos
# Manage movement, gestures
move.GetInfoFromNextFrame()
#cv2.imshow('Current FrameDIFFF', move.currFrame)
if move.ElapsedTimeSinceLastMovement() > 5:
time.sleep(1)
gesture = move.TakeGesture()
threading.Thread(target=SendGesture, args=(gesture, )).start()
move.FreeDevices()
os._exit(1)
def __init__(self):
self.config = PepperConfiguration(_ROBOT_NAME)
if(not self.config.isAvailable()):
Logger.err("ControlFlow", "checkAvailability", "name: " + self.config.Name + ", ip: " + self.config.Ip + " not reachable!")
sys.exit(1) #Abort since robot is not available...
self.robot = Robot(self.config)
Speech(self.robot) #Initialize Speech (static class, no reference needed)
DoorChecker(self.robot) #Initialize DoorChecker (static class, no reference needed)
TabletHandler(self.robot) #Initialize TabletHandler (static class, no reference needed)
Filetransfer(self.config) #Initialize Filetransfer (static class, no reference needed)
#self.tracer = Tracer(self.robot) # enable to gather sensor data
self.sensorhandler = SensorHandler(self.robot)
self.planner = Planner()
self.movement = Movement(self.robot)
self.poscalib = PositionCalibrator(self.robot)
self.currentpos = _START_COORDINATE
def generate_data(game, winner):
board = CheckersBoard()
movement = Movement()
board.set_pieces_on_board_for_a_new_game()
game_states = ''
for move in game[:-1]:
board = movement.make_move(board, move)
board_state = board.get_wooden_board()
reduced_board_state = reduce_board(board_state)
reduced_board_state = [piece[item] for item in reduced_board_state]
game_states += ''.join(str(x) for x in reduced_board_state) + '\n'
timestamp = str(int(time.time() * 1000000))
file = open('games/' + winner + '/' + winner + timestamp, 'w+')
file.write(game_states)
file.close()
def __init__(self):
rospy.init_node('controller', anonymous=True)
navigation = actionlib.SimpleActionClient("move_base", MoveBaseAction)
navigation.wait_for_server()
self.poses = Poses()
self.movement = Movement(navigation, "/map", self.poses)
self.move = self.movement.move
self.object_detector = ObjectDetector("/object_detection/coordinates")
self.find_red_object = self.object_detector.find_red_object
self.arm = Arm()
print("I'm up")
def load_from_series(self, series):
"""Loads an individual from a given one-dimentional array (series).
:param series: The one-dimentional array (series) that the individual will be initialized from.
"""
self.id = series['ID']
self.name = series['Name']
self.bench_press_movement = Movement(
series["bench_press_fitness"],
series["bench_press_fatigue"],
series["bench_press_basic_performance"],
series["bench_press_fitness_gain"],
series["bench_press_fatigue_gain"],
series["bench_press_fitness_decay"],
series["bench_press_fatigue_decay"],
)
self.timestamp = pd.to_datetime(series["Timestamp"])
def generate_individuals(num, age_mean, age_variance, weight_mean, weight_variance,
bench_press_fitness_mean, bench_press_fitness_variance, gender_ratio):
"""
Generates individuals to be used in the simulator
:param num: Number of individuals to generate.
:param age_mean: The mean of the age for the individuals
:param age_variance: The variance in age for the individuals for a normal distribution
:param bench_press_fitness_mean: The mean of the 1RM in bench press for the individuals
:param bench_press_fitness_variance: The variance in the 1RM for the individuals for a normal
distribution
:param gender_ratio: The ratio of individuals with female sex characteristics
:return: A list of individuals generated
"""
# Holds all individuals
individuals = []
# Normally distributed ages used to create birth dates
ages = np.random.normal(age_mean, age_variance, num).astype("int")
now = datetime.datetime.now()
try:
birth_dates = [datetime.datetime(
now.year - age, now.month, now.day) for age in ages]
except ValueError:
# Date could not be set, defaulting
birth_dates = [datetime.datetime(now.year - age, 1, 1) for age in ages]
# Normally distributed bench press fitnesses used to create bench press movementss
bench_press_performances = np.random.normal(bench_press_fitness_mean, bench_press_fitness_variance,
num).astype("int")
weights = np.random.normal(weight_mean, weight_variance, num)
genders = np.ones(num)
genders[:int(num * gender_ratio)] = 0
np.random.shuffle(genders)
for i in range(num):
name = names.get_full_name(gender=gender_to_string(genders[i]))
bench_press_movement = Movement(
0, 0, bench_press_performances[i],
BASE_FITNESS_GAIN, BASE_FATIGUE_GAIN, BASE_FITNESS_DECAY, BASE_FATIGUE_DECAY)
individual = Individual(i, birth_dates[i], int(genders[i]),
name, weights[i], bench_press_movement)
individuals.append(individual)
return individuals
def __init__(self, graphics, root):
# global variables
self.k = K()
# piece - piece identifier. px, py - piece position(472x472). mx, my - mouse position(472x472)
self.data = {"piece": None, "px": 0, "py": 0, "mx": 0, "my": 0}
# keeps track of current turn
self.color = "token"
# true when menu is displayed, else false
self.menuOn = False
# tkinter root
self.root = root
# creates window and all images
self.graphics = graphics
# Canvas from graphics class. Tkinter object, draws images
self.canvas = graphics.canvas
# functions for special moves.
self.specialMoves = SpecialMoves(self.canvas)
# contains board and functions pertaining to position
self.position = Position(self.canvas, self.specialMoves)
self.position.updateBoard()
# contains functions for moving pieces
self.movement = Movement(self.canvas, self.position)
# handles menues
self.interface = Interface(graphics)
# creates highlights around boxes
self.highlight = Highlight(self.canvas, self.position)
# finds move for computer player
self.cpu = CPU(self.position, self.canvas)
# brings up main menu, starts game
self.showMain(0)
def load_from_series(self, series):
"""Loads an individual from a given one-dimentional array (series).
:param series: The one-dimentional array (series) that the individual will be initialized from.
"""
self.id = series['ID']
self.birth = datetime.strptime(series['Birth'], '%Y-%m-%d').date()
self.gender = series['Gender']
self.name = series['Name']
self.weight = series['Weight']
self.bench_press_movement = Movement(
series["bench_press_fitness"],
series["bench_press_fatigue"],
series["bench_press_basic_performance"],
series["bench_press_fitness_gain"],
series["bench_press_fatigue_gain"],
series["bench_press_fitness_decay"],
series["bench_press_fatigue_decay"],
)
def __init__(self,
id="",
birth: datetime = datetime(1, 1, 1),
name="",
bench_press_movement=Movement(0, 0, 0, 0, 0, 0, 0),
series=pd.Series()):
"""Constructor for the indivual class
:param id: An unique identifier.
:param name: The individual's name.
:param bench_press_movement: An instance of Movement representing benchpress.
:param series: Makes it possible to load an individual from an one-dimentional array (series).
"""
if series.empty:
self.name = name
self.id = id
self.bench_press_movement = bench_press_movement
else:
self.load_from_series(series)
def __init__(self):
"""Creates all the modules"""
print("class: Controller created.")
self.stances = ["default", "arm", "build", "dance", "battle_stance", ""]
self.stance = "default"
self.args = "|"
self.using_joysticks = False
self.speed1_x = 0
self.speed1_y = 0
self.speed2_x = 0
self.speed2_y = 0
self.arm = Arm()
self.builder = Builder()
self.dancing = Dancing()
self.direction = ObjectDetection()
self.movement = Movement()
self.sound = SoundRecognition()
self.reset = False
self.drive = False
# initialize bluetooth_connection connection
self.host = connect.Connect(1, "host", 'B8:27:EB:36:3E:F8', 4, self)
self.host.start()
time.sleep(20)
self.client = send.Send(2, "client", 'B8:27:EB:DE:5F:36', 5)
self.client.start()
time.sleep(10)
self.msg_received = False
# Add controller as observer to classes
self.arm.addObserver(self)
self.builder.addObserver(self)
self.dancing.addObserver(self)
self.direction.addObserver(self)
self.movement.addObserver(self)
self.sound.addObserver(self)
self.robot = robot.Robot(6, 3)
self.list = [self.arm, self.builder, self.dancing, self.direction, self.movement, self.sound]
def run():
# the execution of all code shall be started from within this function
print('Hello World')
planet = Planet()
odometry = Odometry()
movement_functions = Movement(motor_list = (ev3.LargeMotor('outB'), ev3.LargeMotor('outC')), odometry = odometry)
line_follower = follow.LineFollowing(colour_sensor = ev3.ColorSensor('in2'),
ts_list = (ev3.TouchSensor('in1'), ev3.TouchSensor('in4')), movement=movement_functions, odometry = odometry)
communication = Communication(planet = planet, odometry = odometry)
communication.connect()
line_follower.colour_calibration()
line_follower.line_following()
communication.first_communication()
sleep(2)
line_follower.path_recognising()
while True:
#odometry.odometry_calculations()
line_follower.line_following()
line_follower.path_recognising()
def enterGame(self):
# Set up important game logic variables
self.parent.level = None
self.parent.units = {}
self.parent.inactive_units = {}
self.parent.players = {}
self.parent.sel_unit_id = None
self.parent.turn_number = None
# task chain for threaded tasks
taskMgr.setupTaskChain('thread_1', numThreads = 2, tickClock = None,
threadPriority = TP_normal, frameBudget = None,
frameSync = None, timeslicePriority = None)
# Init SceneGraph manager
self.parent.sgm = SceneGraph(self.parent)
# Init Movement
self.parent.movement = Movement(self.parent)
# Init Camera
self.parent.camera = AppCamera(self.parent, 20, 20)
# Init Interface
self.parent.interface = Interface(self.parent)
# All of our graphics components are initialized, request graphics init
self.parent.sgm.initLights()
# Init combat
self.parent.combat = Combat()
# Turn number and player on turn
self.parent.turn_number = 0
self.parent.turn_player = None
self.parent._game_initialized = True
def __init__(self):
self.board = CheckersBoard()
self.board.set_pieces_on_board_for_a_new_game()
self.movement = Movement()
self.move_list_generator = MoveListGenerator()
self.players = cycle([piece_set_two, piece_set_one])
from flask import *
from camera import Camera
from movement import Movement
import os
htmlDir = os.path.abspath('HTML')
robot = Movement()
app = Flask(__name__, template_folder=htmlDir)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/camera')
def camera():
return render_template('camera.html')
@app.route('/video_stream')
def video_stream():
return Response(stream(Camera()),
mimetype='multipart/x-mixed-replace; boundary=frame')
@app.route('/move', methods=['POST'])
def move_forward():
param = request.form["param"]
if param == "forward":
robot.forward()
help='Name of bot')
args = parser.parse_args()
# Set up console logging
if args.debug:
logging.basicConfig(format='[%(asctime)s] %(message)s',
level=logging.DEBUG)
else:
logging.basicConfig(format='[%(asctime)s] %(message)s', level=logging.INFO)
# Connect to game server
gameServer = ServerComms(args.hostname, args.port)
# init information extraction library
infoExtraction = InformationExtraction(gameServer)
# init movement library
movement = Movement(gameServer)
# Spawn our tank
logging.info("Creating tank with name '{}'".format(args.name))
gameServer.sendMessage(ServerMessageTypes.CREATETANK, {'Name': args.name})
tankCreationMsg = gameServer.readMessage()
myTank = MyTank(tankCreationMsg)
# Main loop - read game messages, ignore them and randomly perform actions
def mainLoop():
message = gameServer.readMessage()
if 'Id' in message.keys():
if message['Id'] == myTank.getId():
myTank.updateInternalState(message)
