def moveTowards(self, point):
"""
Move towards a Line
:param point: [x, y]
:return:
"""
lWheel = self.rover.LWheel
rWheel = self.rover.RWheel
# Get the highest point of the line
horzMiddle = self.rover.camera.resolution[0] / 2
vertMax = self.rover.camera.resolution[1]
xMag = (point[0] - horzMiddle
) / horzMiddle # -1 to 1, where -1 is left and 1 is right
yMag = (vertMax -
point[1]) / vertMax # 0 to 1, where 1 is toop and 0 is bottom
turnSpeed = (
self.targetSpeed * .4
) * xMag # * yMag # clamp(self.targetSpeed * yMag, self.targetSpeed*.5, self.targetSpeed)
lSpeed = self.targetSpeed * .6 + turnSpeed # Where -1 xmag will lower left turning speed
rSpeed = self.targetSpeed * .6 - turnSpeed # Where -1 xmag will raise the right turning speed
lSpeed = clamp(int(lSpeed), -self.targetSpeed * .1, self.targetSpeed)
rSpeed = clamp(int(rSpeed), -self.targetSpeed * .1, self.targetSpeed)
# Make sure stuff doesn't get too fast!
if lSpeed + rSpeed >= self.targetSpeed * 2:
amountOver = lSpeed + rSpeed - self.targetSpeed * 2
lSpeed -= amountOver / 2
rSpeed -= amountOver / 2
lWheel.setSpeed(lSpeed)
rWheel.setSpeed(rSpeed)
print("Left: ", lSpeed, "\tRight: ", rSpeed, "\txMag", xMag, "\tyMag",
yMag)
# if point[0] < horzMiddle:
# print("Left")
# lWheel.setSpeed(0)
# rWheel.setSpeed(self.targetSpeed)
# return
#
# if point[0] > horzMiddle:
# print("Right")
# lWheel.setSpeed(self.targetSpeed)
# rWheel.setSpeed(0)
# return
"""
def setPower(self, power):
"""
Set the power to the motor
:param power: A value from 0 to 100
"""
# Sanitize power values
power = clamp(power, -100, 100)
if int(power) == self.power: return # Avoid repeat commands
self.power = power
# Set motor PWMs
if power > 0:
self.A_PWM.ChangeDutyCycle(power)
self.B_PWM.ChangeDutyCycle(0)
self.A_PWM.ChangeFrequency(power + 5)
if power < 0:
power = abs(power)
self.A_PWM.ChangeDutyCycle(0)
self.B_PWM.ChangeDutyCycle(power)
self.B_PWM.ChangeFrequency(power + 5)
if power == 0:
self.A_PWM.ChangeDutyCycle(0)
self.B_PWM.ChangeDutyCycle(0)
def OnCVarChanged( self, name, oldvalue, newvalue ):
global weaponList
if name == "ar_numrounds":
# Clamp the roundlimit
val = clamp( int( newvalue ), 0, 10 )
if val != self.RoundLimit:
if self.RoundNumber > val and val > 0:
GERules.EndMatch()
self.RoundLimit = val
elif name == "ar_randomweapons":
val = int( newvalue )
if val == 0 and self.RandomWeapons:
self.RandomWeapons = False
weaponList = list( weaponListCopy )
if not GERules.IsIntermission():
GERules.EndRound()
elif val != 0 and not self.RandomWeapons:
self.RandomWeapons = True
if not GERules.IsIntermission():
GERules.EndRound()
elif name == "ar_warmuptime":
if self.warmupTimer.IsInWarmup():
val = int( newvalue )
self.warmupTimer.StartWarmup( val )
if val <= 0:
GERules.EndRound( False )
def OnCVarChanged(self, name, oldvalue, newvalue):
global weaponList
if name == "ar_numrounds":
# Clamp the roundlimit
val = clamp(int(newvalue), 0, 10)
if val != self.RoundLimit:
if self.RoundNumber > val and val > 0:
GERules.EndMatch()
self.RoundLimit = val
elif name == "ar_randomweapons":
val = int(newvalue)
if val == 0 and self.RandomWeapons:
self.RandomWeapons = False
weaponList = list(weaponListCopy)
if not GERules.IsIntermission():
GERules.EndRound()
elif val != 0 and not self.RandomWeapons:
self.RandomWeapons = True
if not GERules.IsIntermission():
GERules.EndRound()
elif name == "ar_warmuptime":
if self.warmupTimer.IsInWarmup():
val = int(newvalue)
self.warmupTimer.StartWarmup(val)
if val <= 0:
GERules.EndRound(False)
def set_input(self, flow: float) -> float:
"""Turns on the heating unit by a certain amount.
Arguments:
flow {float} -- The percentage (0 to 1) flow of hot air coming out of the heating unit.
"""
self._flow = clamp(flow, 0.0, 1.0)
def ft_flagsdesired( self ):
if GEMPGameRules.IsTeamplay():
fd = min( min( GEMPGameRules.GetTeam( GEGlobal.TEAM_MI6 ).GetNumPlayers(), GEMPGameRules.GetTeam( GEGlobal.TEAM_JANUS ).GetNumPlayers() ), self.FLAGLIST_LIMIT )
fd = clamp( fd, 1, fd - max( 0, int( GEUtil.GetCVarValue( "ld_teamguardians" ) ) ) )
else:
playersperflag = max( 1, int( GEUtil.GetCVarValue( "ld_playersperflag" ) ) )
fd = min( int( ( GEMPGameRules.GetNumActivePlayers() + playersperflag - 1 ) / playersperflag ), self.FLAGLIST_LIMIT )
return fd
def set_input(self, val: float) -> float:
"""Set the voltage to the wheels of the RobotWheel.
Arguments:
val {float} -- The voltage of the wheel (ranges from -1 to 1 for simplicity)
"""
# Add in a bit of randomness to the system
entropy = random.uniform(-self._entropy, self._entropy)
val = val * (1 + entropy)
self._voltage = clamp(val, self._min_input, self._max_input)
def lld_baron_voodoo_recover( self, damage ):
if GEUtil.GetCVarValue( self.CVAR_BLOODLUST ) == "0":
return
casts = self.lld_baron_voodoo_castsremaining()
self.baron_voodoo += choice( damage >= 80, self.BARON_VOODOO_BLOODLUST_BODY, self.BARON_VOODOO_BLOODLUST_LIMB )
self.baron_voodoo = clamp( self.baron_voodoo, 0, self.BARON_VOODOO_MAX )
self.lld_baron_update_voodoobar()
if casts < self.lld_baron_voodoo_castsremaining():
baron = self.lld_Baron()
if baron:
GEUtil.PlaySoundTo( baron, "GEGamePlay.Token_Chime" )
def __init__(self, realnumprocs=cpu_count()):
threading.Thread.__init__(self)
self.daemon = True
self.realnumprocs = clamp(realnumprocs, 1, cpu_count())
self.procs = []
self.sharer = ObjectSharer()
self.syncEvent = Event()
self.syncEvent2 = Event()
self.syncCounter = Value('i', 0)
self.syncLock = Lock()
self.jobqueue = queue.Queue()
self.progress = Array('l', self.realnumprocs)
self.objsrv = ObjectServer()
self.stopEvent = Event()
def OnCVarChanged(self, name, oldvalue, newvalue):
if name == "tdm_fraglimit":
# Clamp the fraglimit
val = clamp(int(newvalue), 0, 100)
if val != self.FragLimit:
self.FragLimit = val
elif name == "tdm_fragmessages":
val = int(newvalue)
if val == 0 and self.FragMessages:
self.FragMessages = False
elif val != 0 and not self.FragMessages:
self.FragMessages = True
elif name == "tdm_warmuptime":
if self.warmupTimer.IsInWarmup():
val = int(newvalue)
self.warmupTimer.StartWarmup(val)
if val <= 0:
GERules.EndRound(False)
def ft_flagsdesired(self):
if GEMPGameRules.IsTeamplay():
fd = min(
min(
GEMPGameRules.GetTeam(GEGlobal.TEAM_MI6).GetNumPlayers(),
GEMPGameRules.GetTeam(
GEGlobal.TEAM_JANUS).GetNumPlayers()),
self.FLAGLIST_LIMIT)
fd = clamp(
fd, 1,
fd - max(0, int(GEUtil.GetCVarValue("ld_teamguardians"))))
else:
playersperflag = max(1,
int(GEUtil.GetCVarValue("ld_playersperflag")))
fd = min(
int((GEMPGameRules.GetNumActivePlayers() + playersperflag - 1)
/ playersperflag), self.FLAGLIST_LIMIT)
return fd
def OnCVarChanged( self, name, oldvalue, newvalue ):
if name == "tdm_fraglimit":
# Clamp the fraglimit
val = clamp( int( newvalue ), 0, 100 )
if val != self.FragLimit:
self.FragLimit = val
elif name == "tdm_fragmessages":
val = int( newvalue )
if val == 0 and self.FragMessages:
self.FragMessages = False
elif val != 0 and not self.FragMessages:
self.FragMessages = True
elif name == "tdm_warmuptime":
if self.warmupTimer.IsInWarmup():
val = int( newvalue )
self.warmupTimer.StartWarmup( val )
if val <= 0:
GERules.EndRound( False )
def OnPlayerSpawn( self, player ):
assert isinstance( player, GEPlayer.CGEMPPlayer )
self.lld_progress()
self.lld_costume_failsafe( player )
if self.lld_player_isbaron( player ):
self.lld_baron_spawn( player )
if self.baron_health_cache >= 0:
player.SetHealth( clamp( self.baron_health_cache, 0, 160 ) )
self.baron_health_cache = -1
else:
player.SetSpeedMultiplier( 1.0 )
player.SetScoreBoardColor( GEGlobal.SB_COLOR_NORMAL )
if not self.pltracker[player][TR_INROUND]:
if self.gamestate >= self.GAMESTATE_SHUT:
GEUtil.ClientPrint( None, GEGlobal.HUD_PRINTTALK, "#GES_GP_NOJOIN", player.GetPlayerName() )
player.SetScoreBoardColor( GEGlobal.SB_COLOR_ELIMINATED )
else:
self.lld_authorize_player( player )
def lld_baron_speedamp( self ):
baron = self.lld_Baron()
if baron:
players = self.lld_num_inround_players();
factor = clamp( ( 20.0 / ( float( players ) + 14.5 ) ) ** 0.5, 0.91, 1.1 )
baron.SetSpeedMultiplier( factor )
def lld_baron_levelup( self ):
self.baron_level = clamp( self.baron_level + 1, 1, self.BARON_LEVEL_MAX )
if self.baron_level <= self.BARON_WEAPON_LIMIT:
GEUtil.ClientPrint( None, GEGlobal.HUD_PRINTTALK, plural( self.baron_level, "#GES_GP_LALD_WEAPON" ), str( self.baron_level ) )
else:
GEUtil.ClientPrint( None, GEGlobal.HUD_PRINTTALK, "#GES_GP_LALD_DAMAGE", str( self.lld_baron_damageamp() ) )
def lld_baron_damagefactor( self ):
if self.lld_Baron and self.baron_level >= self.BARON_WEAPON_LIMIT:
amp = ( self.baron_level - self.BARON_WEAPON_LIMIT ) * self.BARON_HANDICAP_RATE
amp = 2.0 ** ( amp / 3.0 )
return clamp( amp, 1.0, 21.0 )
return 1.0
def exp_this_level(self, req_level):
return (clamp(req_level, 1, self.LEVEL_LIMIT) + 2) * 10
def ft_escapee_armorup(self, flag, player):
flag.armor_up = clamp(int(player.GetArmor() + flag.escape_ap), 0,
GEGlobal.GE_MAX_ARMOR)
flag.escape_ap = 0
def main():
settings = Settings()
analytics = Analytics()
novelty = Novelty()
cmd_line_args_success = settings.update_command_line_args()
if not cmd_line_args_success:
return
print("Settings:" +
"\n".join([f"{i} : {j}" for i, j in vars(settings).items()]))
hws = [
Hardware(None, i, settings.min_program_length,
settings.max_program_length) for i in range(settings.pop_size)
]
game = FlappyDarwin(
hws, settings.ticks_per_update,
settings.num_tests if settings.selection == "lexicase" else 1,
(lambda: 0) if settings.fitness == "novelty" else (lambda: time()))
inst_lib = generate_inst_lib(game)
for hw in hws:
hw.inst_lib = inst_lib
[hw.generate_program() for hw in hws]
best_fitness = [0]
fitness_data = []
gen = 1
if settings.save_file:
print(F"LOADING FROM EXISTING SAVED GP FILE: {settings.save_file}")
hws, gen, gen_finished_test = load_programs(inst_lib, settings)
game.generation = gen
game.gen_finished_test = gen_finished_test
if settings.fitness == "novelty":
load_novelty_archive(novelty)
while not game.QUIT_SIGNAL:
print(F"Generation: {gen}")
game.set_hardware(hws)
game.start()
for i, hw in enumerate(hws):
hw.cache_fitness(game.birds[i].fitness)
local_best = max(hws, key=lambda hw: min(hw.fitness))
fitness_data.append(sum(local_best.fitness) / len(local_best.fitness))
if min(local_best.fitness) > min(best_fitness):
best_fitness = local_best.fitness
print(local_best)
print("Finished with fitness", local_best.fitness)
print("____________________________")
if settings.fitness == "novelty":
assert settings.selection != "lexicase", "Lexicase is not compatible with Novelty."
dists = novelty.select([(bird.rect.x + bird.last_frame_alive,
clamp(bird.rect.y, 0, game.HEIGHT))
for bird in game.birds])
for i, hw in enumerate(hws):
hw.cache_fitness(dists[i])
copy_best = local_best.copy()
copy_best.traits = 0
if settings.selection == "tournament":
hws = tournament(hws)
elif settings.selection == "elite":
hws = elite(hws, len(hws) // 2)
elif settings.selection == "lexicase":
hws = lexicase(hws)
elif settings.selection == "roulette":
hws = roulette(hws)
else:
raise NotImplementedError(
F"Invalid Selection Scheme: {settings.selection}")
[mutate(hw) for hw in hws]
recombination(hws)
for i, hw in enumerate(hws):
hw.traits = i
# Keep around the best performing from the previous generation & reset its hardware
hws[0] = copy_best
hws[0].traits = 0
gen += 1
if gen in {10, 50, 100, 250, 500, 1500, 2500} or not gen % 1000:
save_programs(gen, hws, game.gen_finished_test)
analytics.save(gen, fitness_data)
fitness_data.clear()
if settings.fitness == "novelty":
save_novelty_archive(novelty)
def lld_baron_weaponlevel( self ):
if self.baron_level > 0:
return clamp( self.baron_level, 1, self.BARON_WEAPON_LIMIT )
return 0
def exp_this_level( self, req_level ):
return ( clamp( req_level, 1, self.LEVEL_LIMIT ) + 2 ) * 10
def cycle(self):
self.cycle_count += 1
if len(self.instr) < 1:
return
instr = self.fetch()
if self.blocked:
return
#print '[', self.id, ']', self.ip, self.state, ':', instr, self.regs
is_jumping = False
# MOV
if instr.type == INSTR_MOV:
self.blocked = True
src = instr.src
dest = instr.dest
value = None
if instr.src_type == SRC_TYPE_INT:
value = int(src)
elif src in PORT_REGISTERS:
value = self.read_from(src)
if value is None:
return
else:
value = self.regs[dest] = self.regs[src]
if dest in PORTS_LIST:
self.write(dest, value)
return
else:
self.regs[dest] = value
self.blocked = False
# ADD
elif instr.type == INSTR_ADD:
src = instr.src
if src in PORT_REGISTERS:
self.blocked = True
value = self.read_from(src)
if value is None:
return
self.regs[REG_ACC] = clamp(self.regs[REG_ACC] + value)
self.blocked = False
elif instr.src_type == SRC_TYPE_REG:
self.regs[REG_ACC] = clamp(self.regs[REG_ACC] + self.regs[src])
elif instr.src_type == SRC_TYPE_INT:
self.regs[REG_ACC] = clamp(self.regs[REG_ACC] + int(src))
else:
raise Exception()
# SUB
elif instr.type == INSTR_SUB:
src = instr.src
if src in PORT_REGISTERS:
self.blocked = True
value = self.read_from(src)
if value is None:
return
self.regs[REG_ACC] = clamp(self.regs[REG_ACC] - value)
self.blocked = False
elif instr.src_type == SRC_TYPE_REG:
self.regs[REG_ACC] = clamp(self.regs[REG_ACC] - self.regs[src])
elif instr.src_type == SRC_TYPE_INT:
self.regs[REG_ACC] = clamp(self.regs[REG_ACC] - int(src))
else:
raise Exception()
# NEG
elif instr.type == INSTR_NEG:
self.regs[REG_ACC] = -self.regs[REG_ACC]
# SAV
elif instr.type == INSTR_SAV:
self.regs[REG_BAK] = self.regs[REG_ACC]
# SWP
elif instr.type == INSTR_SWP:
tmp = self.regs[REG_BAK]
self.regs[REG_BAK] = self.regs[REG_ACC]
self.regs[REG_ACC] = tmp
# JMP
elif instr.type == INSTR_JMP:
addr = self.symtable.get(instr.src)
self.ip = int(addr)
is_jumping = True
# JEZ
elif instr.type == INSTR_JEZ:
if self.regs[REG_ACC] == 0:
addr = self.symtable.get(instr.src)
self.ip = int(addr)
is_jumping = True
# JNZ
elif instr.type == INSTR_JNZ:
if self.regs[REG_ACC] != 0:
addr = self.symtable.get(instr.src)
self.ip = int(addr)
is_jumping = True
# JGZ
elif instr.type == INSTR_JGZ:
if self.regs[REG_ACC] > 0:
addr = self.symtable.get(instr.src)
self.ip = int(addr)
is_jumping = True
# JLZ
elif instr.type == INSTR_JLZ:
if self.regs[REG_ACC] < 0:
addr = self.symtable.get(instr.src)
self.ip = int(addr)
is_jumping = True
# JRO
elif instr.type == INSTR_JRO:
addr = self.regs[REG_ACC]
self.ip = addr
is_jumping = True
# HALT
elif instr.type == INSTR_HCF:
# HCF Halt and Catch Fire
self.halted = True
elif instr.type == INSTR_NOP:
pass
else:
print 'Unknown opcode',
self.state = NODE_STATE_RUN
#print self.regs
if not is_jumping:
self.fetch_next()
def level_by_playercount( self, pc ):
self.level = clamp( self.LEVEL_LIMIT + 1 - pc , 0, self.LEVEL_LIMIT )
def predict(self, features: np.ndarray) -> np.ndarray:
return clamp(self.classifier.predict(features))
def predict(self, features: np.ndarray) -> np.ndarray:
return clamp(self.get_model().predict(features,
batch_size=self.batch_size))
def ft_escapee_armorup( self, flag, player ):
flag.armor_up = clamp( int( player.GetArmor() + flag.escape_ap ), 0, GEGlobal.GE_MAX_ARMOR )
flag.escape_ap = 0;
def level_by_playercount(self, pc):
self.level = clamp(self.LEVEL_LIMIT + 1 - pc, 0, self.LEVEL_LIMIT)
