from pygame.key import get_pressed, get_mods
from pygame.font import Font
from pygame.locals import *
from esp_hadouken.pgfw.GameChild import GameChild
class Calibrator(GameChild):
def __init__(self, parent):
GameChild.__init__(self, parent)
self.display_surface = self.get_screen()
self.font = Font(self.parent.font_path, 10)
self.delegate = self.get_delegate()
self.load_configuration()
self.render()
self.place()
self.subscribe(self.respond, KEYDOWN)
def load_configuration(self):
config = self.get_configuration("engine")
self.step = config["calibrator-step"]
def render(self):
string = str(self)
self.text = self.font.render(string, False, (0, 0, 0), (255, 255, 255))
self.string = string
def __str__(self):
engine = self.parent
accelerator = engine.accelerator
pattern = "v {0:.2f} a {1:.2f} r {2:.2f} t {3:.2f} pa {4:.2f} " + \
"pd {5:.2f} lna {6:.2f} lnd {7:.2f} hna {8:.2f} d {9:.2f}"
return pattern.format(engine.max_velocity, accelerator.attack,
accelerator.release, accelerator.initial_thrust,
accelerator.peak_acceleration,
accelerator.peak_distance,
accelerator.min_negative_acceleration,
accelerator.min_negative_acceleration_distance,
accelerator.max_negative_acceleration,
engine.deceleration)
def place(self):
rect = self.text.get_rect()
rect.bottomleft = self.display_surface.get_rect().bottomleft
self.rect = rect
def respond(self, event):
if self.parent.parent.is_active():
if get_mods() & KMOD_CTRL and event.key == K_COMMA:
profile = self.parent.profile
profile.add(increment_index=True)
profile.write()
def update(self):
self.calibrate()
self.draw()
def calibrate(self):
state = get_pressed()
step = self.step
engine = self.parent
accelerator = engine.accelerator
if state[K_1]:
engine.max_velocity += step
if state[K_q]:
engine.max_velocity -= step
if state[K_2]:
accelerator.attack += step
if state[K_w]:
accelerator.attack -= step
if state[K_3]:
accelerator.release += step
if state[K_e]:
accelerator.release -= step
if state[K_4]:
accelerator.initial_thrust += step
if state[K_r]:
accelerator.initial_thrust -= step
if state[K_5]:
accelerator.peak_acceleration += step
if state[K_t]:
accelerator.peak_acceleration -= step
if state[K_6]:
accelerator.peak_distance += step
if state[K_y]:
accelerator.peak_distance -= step
if state[K_7]:
accelerator.min_negative_acceleration += step
if state[K_u]:
accelerator.min_negative_acceleration -= step
if state[K_8]:
accelerator.min_negative_acceleration_distance += step
if state[K_i]:
accelerator.min_negative_acceleration_distance -= step
if state[K_9]:
accelerator.max_negative_acceleration += step
if state[K_o]:
accelerator.max_negative_acceleration -= step
if state[K_0]:
engine.deceleration += step
if state[K_p]:
engine.deceleration -= step
def draw(self):
if self.string != str(self):
self.render()
self.display_surface.blit(self.text, self.rect)
from esp_hadouken.pgfw.GameChild import GameChild
class Profile(GameChild, list):
def __init__(self, parent):
GameChild.__init__(self, parent)
self.delegate = self.get_delegate()
self.load_configuration()
self.load()
self.apply()
self.subscribe(self.respond)
def load_configuration(self):
self.path = self.get_resource("engine", "profile-path")
def load(self):
list.__init__(self)
for line in file(self.path):
self.add(line.split())
self.index = 0
def add(self, values=None, increment_index=False):
if not values:
engine = self.parent
accelerator = engine.accelerator
values = "NAME-ME", engine.max_velocity, accelerator.attack, \
accelerator.release, accelerator.initial_thrust, \
accelerator.peak_acceleration, accelerator.peak_distance, \
accelerator.min_negative_acceleration, \
accelerator.min_negative_acceleration_distance, \
accelerator.max_negative_acceleration, \
engine.deceleration, 1
self.append([values[0]] + map(float, values[1:-1]) + \
[bool(int(values[-1]))])
if increment_index:
self.increment_index()
def apply(self):
engine = self.parent
profile = self[self.index]
engine.set(profile[1], profile[-2])
engine.accelerator.set(profile[2:-2])
def respond(self, event):
if self.parent.parent.is_active():
if self.delegate.compare(event, "select"):
self.rotate()
def rotate(self):
self.set_next_active()
self.apply()
def set_next_active(self):
while True:
self.increment_index()
if self[self.index][-1]:
break
def increment_index(self):
index = self.index + 1
if index >= len(self):
index = 0
self.index = index
def write(self):
stream = file(self.path, "w")
for profile in self:
stream.write(" ".join(map(str, profile[:-1]) + \
[str(int(profile[-1]))]) + "\n")
from esp_hadouken.pgfw.GameChild import GameChild
from esp_hadouken.pgfw.Vector import Vector
from esp_hadouken.dot.engine.accelerator.Pedal import Pedal
class Accelerator(GameChild, list):
N, NE, E, SE, S, SW, W, NW = range(8)
def __init__(self, parent):
GameChild.__init__(self, parent)
self.input = self.get_input()
self.load_configuration()
self.init_list()
def load_configuration(self):
config = self.get_configuration("engine")
self.display_flag = config["accelerator-display-flag"]
def init_list(self):
list.__init__(self, [Pedal(self, ii) for ii in range(8)])
def set(self, values):
self.attack = values[0]
self.release = values[1]
self.initial_thrust = values[2]
self.peak_acceleration = values[3]
self.peak_distance = values[4]
self.min_negative_acceleration = values[5]
self.min_negative_acceleration_distance = values[6]
self.max_negative_acceleration = values[7]
def set_slopes(self):
self.apply_to_pedals("set_slopes")
def apply_to_pedals(self, method):
for pedal in self:
getattr(pedal, method)()
def reset(self):
self.apply_to_pedals("reset")
def update(self):
S, E, N, W = self.input.get_axes().values()
self[self.N].update(N and not W and not E)
self[self.NE].update(N and E)
self[self.E].update(E and not N and not S)
self[self.SE].update(E and S)
self[self.S].update(S and not E and not W)
self[self.SW].update(S and W)
self[self.W].update(W and not S and not N)
self[self.NW].update(W and N)
def get_sum(self):
total = Vector()
for pedal in self:
total += pedal
return total
