def setValue(self, value, deltaT, optimal):
global Options
try:
self.value = value
deg = math.degrees(self.value)
#~ otherdeg = math.degrees(othervalue)
#~ diff = deg - otherdeg
ac.setText(self.valueLabel, "{0:.3f}°".format(deg))
#~ text = getGripFactor(Options["dcamber0"], Options["dcamber1"], value)
#~ ac.setText(self.valueLabel,"{0:.1f}%".format(text)
self.color = getColor(deg, optimal)
self.serie.append({"value": deg, "color": self.color})
serieSum = 0
for s in self.serie:
serieSum += s["value"]
self.avgValue = serieSum / len(self.serie)
ac.setFontColor(self.avgValueLabel, self.color['r'],
self.color['g'], self.color['b'], self.color['a'])
ac.setText(self.avgValueLabel, "{0:.3f}°".format(self.avgValue))
except Exception:
ac.log("CamberExtravaganza ERROR: setValue(): %s" %
traceback.format_exc())
def onValidateInput(self, string):
text = ac.getText(self.textInput)
ac.setText(self.textInput, "")
ac.setFocus(self.textInput, 1)
if len(text) > 0:
if ac.sendChatMessage(text) == -1:
self.delayedChat = text
def acUpdate(deltaT):
global l_velocity, last_rec, f, first
curr_milliseconds = time.time() * 1000
if curr_milliseconds - last_rec >= 250:
if first:
first = False
else:
f.write(',')
last_rec = curr_milliseconds
timestamp = datetime.utcnow()
acceleration_g = ac.getCarState(0, acsys.CS.AccG)
local_angular_velocity = ac.getCarState(0, acsys.CS.LocalAngularVelocity)
ac.setText(l_velocity, "Velocity: {}".format(acceleration_g))
f.write('\n\t("0x610-0", "' + str(clamp(acceleration_g[0], -16, 16)) + '", "' + str(timestamp) + '"),')
f.write('\n\t("0x610-1", "' + str(clamp(acceleration_g[1], -16, 16)) + '", "' + str(timestamp) + '"),')
f.write('\n\t("0x610-2", "' + str(clamp(acceleration_g[2], -16, 16)) + '", "' + str(timestamp) + '"),')
f.write('\n\t("0x611-0", "' + str(local_angular_velocity[0]) + '", "' + str(timestamp) + '"),')
f.write('\n\t("0x611-1", "' + str(local_angular_velocity[1]) + '", "' + str(timestamp) + '"),')
f.write('\n\t("0x611-2", "' + str(local_angular_velocity[2]) + '", "' + str(timestamp) + '")')
def acMain(ac_version):
global appWindow, label1, logPrefix, appName, cfg, ui_enableButton
ac.console(logPrefix + "acMain")
try:
appWindow = ac.newApp(appName)
cfg = Configuration()
cfg.load()
ac.setTitle(appWindow, "")
ac.setSize(appWindow, 400, 200)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
ac.addRenderCallback(appWindow, onRender)
ui_enableButton = ac.addButton(appWindow, "Enable")
ac.setPosition(ui_enableButton, 0, 30)
ac.setSize(ui_enableButton, 70, 30)
ac.addOnClickedListener(ui_enableButton, onEnableButtonClicked)
label1 = ac.addLabel(appWindow, "____")
ac.setPosition(label1, 0, 65)
if cfg.enable > 0:
ac.setText(ui_enableButton, "Disable")
startTelemetry()
ac.console(logPrefix + "Initialized")
except:
printExceptionInfo("acMain")
return appName
def acUpdate(delta_t):
ac.setBackgroundOpacity(toe_app, 0)
ac.setBackgroundOpacity(rpm_app, 0)
rpm = ac.getCarState(0, acsys.CS.RPM)
boost = ac.getCarState(0, acsys.CS.TurboBoost)
fuel = simInfo.physics.fuel
ac.setText(rpm_label, str(round(rpm)) + "\n" + str(round(boost, 3)) + "\n" + str(round(fuel, 1)))
value_fl = ac.getCarState(0, acsys.CS.ToeInDeg, acsys.WHEELS.FL)
value_fr = ac.getCarState(0, acsys.CS.ToeInDeg, acsys.WHEELS.FR)
value_rl = ac.getCarState(0, acsys.CS.ToeInDeg, acsys.WHEELS.RL)
value_rr = ac.getCarState(0, acsys.CS.ToeInDeg, acsys.WHEELS.RR)
toeP(prev_fl, value_fl)
toeP(prev_fr, value_fr)
toeP(prev_rl, value_rl)
toeP(prev_rr, value_rr)
ac.setText(
toe_label,
toeSl(prev_fl, value_fl)
+ "\t"
+ toeSr(prev_fr, value_fr)
+ "\n"
+ toeSl(prev_rl, value_rl)
+ "\t"
+ toeSr(prev_rr, value_rr),
)
def acUpdate(deltaT):
global l_lapcount, lapcount, l_laptime, laptime
# Don't write anything to the console from here unless it's in an if statement - it causes a crash, deltaT must
# be approx every ms
# Update current lap time in app window
laptime = (ac.getCarState(0, acsys.CS.LapTime)) / 1000
ac.setText(l_laptime, "Current lap (s): {}".format(laptime))
# if statement using difference between lapcount and the laps output from AC to record data
laps = ac.getCarState(0, acsys.CS.LapCount)
if laps > lapcount:
# Uses the difference between laps and lap count to limit recording to once per lap
lapcount = laps
ac.setText(l_lapcount, "Laps Completed: {}".format(lapcount))
# Write last lap data to csv
last_lap_raw = ((ac.getCarState(0, acsys.CS.LastLap))) / 1000
ac.console("**Last_lap recorded")
last_lap_m = last_lap_raw // 60
last_lap_s = last_lap_raw % 60
ac.console("**Last_lap split into minutes and seconds")
with open('stintoutputfile.csv', 'a') as f:
f.write("{},{:.0f}:{:.3f}\n".format(lapcount, last_lap_m,
last_lap_s))
ac.console("** stint tracker: lap written to file")
ac.console("{},{:.0f}:{:.3f}\n".format(lapcount, last_lap_m,
last_lap_s))
def getDriverInformation(detectionArea):
global labelStorage, appPosX, appPosY, spinner_y_offset, fov_setting
triangle = Triangle(detectionArea[0], detectionArea[1], detectionArea[2])
setLabel = 0
for x in range(ac.getCarsCount()):
posX, posZ, posY = ac.getCarState(x, acsys.CS.WorldPosition)
if triangle.isInside((posX, posY)) and x != 0:
vect_x = posX - detectionArea[0][0]
vect_y = posY - detectionArea[0][1]
distance = math.sqrt(math.pow(vect_x, 2) + math.pow(vect_y, 2))
newPosition = getRenderPosition(x, detectionArea, (posX, posY))
ac.setText(labelStorage[setLabel], ac.getDriverName(x))
fov_angle = ac.getValue(fov_setting)
xPos = (((newPosition * windowSizeX) / fov_angle) - appPosX)
yOffset = ac.getValue(spinner_y_offset)
yPos = (((windowSizeY / 2) - 20) - appPosY) + int(yOffset)
fontSize = (10 *
(1 /
(distance / 100))) * (ac.getValue(scale_factor) / 10)
ac.setPosition(labelStorage[setLabel], xPos, yPos)
ac.setFontSize(labelStorage[setLabel], fontSize)
setLabel += 1
for z in range(ac.getCarsCount() - setLabel):
ac.setText(labelStorage[setLabel + z], "")
def acUpdate(ms):
global BEST_LOGGED_LAP, LAP_HISTORY, UPDATE_DELTA, CURRENT_LAP_VALID, LAP_VALID_INDICATOR
if ACTIVE:
if CURRENT_LAP_VALID and info.physics.numberOfTyresOut > TIRES_THRESHOLD:
ac.setText(LAP_VALID_INDICATOR, 'Dirty')
CURRENT_LAP_VALID = False
#UPDATE_DELTA += ms
#if UPDATE_DELTA < UPDATE_THRESHOLD:
# return
#UPDATE_DELTA = 0
last_lap = ac.getCarState(DRIVER_ID_SELF, acsys.CS.LastLap)
valid = CURRENT_LAP_VALID and not ac.getCarState(
DRIVER_ID_SELF, acsys.CS.LapInvalidated)
if last_lap and (not LAP_HISTORY or not last_lap == LAP_HISTORY[-1]):
ac.console('Last lap: %s%s' %
(last_lap, '' if valid else ' (invalid)'))
reportLap({
'driver': DRIVER,
'track': TRACK,
'car': CAR,
'lap': last_lap
})
refreshLapDisplay()
# reset lap tracking
ac.setText(LAP_VALID_INDICATOR, 'Clean')
CURRENT_LAP_VALID = True
LAP_HISTORY.append(last_lap)
def setDelta(label, delta):
ac.setText(label, deltaToString(delta))
if delta >= redAt:
ac.setFontColor(label, 1, 0, 0, 1)
elif delta <= greenAt:
ac.setFontColor(label, 0, 1, 0, 1)
else:
if deltaColor == "yellow":
if delta > 0:
# color factor [0..1]
colorFactor = float(delta)/redAt
ac.setFontColor(label, 1, 1-colorFactor, 0, 1)
else:
# color factor [0..1]
colorFactor = float(delta)/greenAt
ac.setFontColor(label, 1-colorFactor, 1, 0, 1)
elif deltaColor == "white":
if delta > 0:
# color factor [0..1]
colorFactor = float(delta)/redAt
ac.setFontColor(label, 1, 1-colorFactor, 1-colorFactor, 1)
else:
# color factor [0..1]
colorFactor = float(delta)/greenAt
ac.setFontColor(label, 1-colorFactor, 1, 1-colorFactor, 1)
def FuelEvent(x):
global FuelSelection,amount,Gas
amount = ac.getValue(FuelSelection)
ac.setText(label3,"{}".format(round(amount)))
Gas = ac.getText(label3)
WriteData()
def onChatMessage(message, author) :
global messages, lines, maxLines, currentText
currentText = 1
messages.append([author, message])
if len(messages) > maxLines:
messages = messages[len(messages)-maxLines:]
for i in range(0, maxLines):
if i < len(messages):
msg = messages[len(messages)-1-i]
scale = abs(float(-2))
n_width = 14*len(msg[0])/scale
m_width = 14*len(msg[1])/scale
ac.setText(lines[maxLines-1-i][1], msg[1])
ac.setSize(lines[maxLines-1-i][0], n_width, 14*1.4)
ac.setSize(lines[maxLines-1-i][1], m_width, 14*1.4)
if msg[0].strip().find(driver) > -1:
ac.setFontColor(lines[maxLines-1-i][0], 0, 1, 0, 1)
else:
ac.setFontColor(lines[maxLines-1-i][0], random.random(), random.random(), random.random(), 1)
ac.setFontColor(lines[maxLines-1-i][1], 1, 1, 1, 1)
ac.setVisible(lines[maxLines-1-i][0], 1)
ac.setVisible(lines[maxLines-1-i][1], 1)
ac.setPosition(lines[maxLines-1-i][0], 0, ac.getPosition(lines[maxLines-1-i][0])[1])
ac.setFontAlignment(lines[maxLines-1-i][0], "left")
ac.setPosition(lines[maxLines-1-i][1], n_width+5, ac.getPosition(lines[maxLines-1-i][1])[1])
ac.setFontAlignment(lines[maxLines-1-i][1], "left")
ac.setText(lines[maxLines-1-i][0], msg[0]+":")
def rainStrengthDown(*args):
try:
ac.ext_rainParamsAdjust(-0.1, 0.0)
except:
ac.setText(
debug, "AccExtRain: Shaders Patch not active? : \n" +
traceback.format_exc())
def rainWiperSpeedUp(*args):
try:
ac.ext_rainParamsAdjust(0.0, 1.0)
except:
ac.setText(
debug, "AccExtRain: Shaders Patch not active? : \n" +
traceback.format_exc())
def acUpdate(delta_t):
global error, timer, day_offset, gWrapDebugText, gAppsize, gHideBG, gHideWeather
timer += delta_t
day_offset += speed * delta_t
if timer > 0.075:
timer = 0.0
if abs(day_offset) > 1:
try:
ac.ext_weatherTimeOffset(24 * 60 * 60 * day_offset / abs(day_offset))
except:
ac.log("AccExtWeatherFX: Unexpected error:" + traceback.format_exc())
day_offset = 0
if error < 1:
try:
if not gHideWeather:
s = ac.ext_weatherDebugText()
s = s.replace('current day:', ' > current day: ')
if gWrapDebugText==True:
s = '\n'.join(s.strip() for s in re.findall(r'.{1,80}(?:\s+|$)', s))
s = s.replace('>>> Sol weather: v', '\n>>> Sol weather: v')
ac.setText(label, s)
if gHideBG==True:
ac.setBackgroundOpacity(app,0)
ac.drawBorder(app,0)
except:
error = error + 1
ac.log("AccExtWeatherFX: Unexpected error:" + traceback.format_exc())
ac.setText(label, "Shaders patch not installed? Error: \n" + traceback.format_exc())
def updateLaps(self, lapsData):
self.__clear_labels()
for i, lapData in enumerate(lapsData):
if i >= len(self.labels):
break
lapLabels = self.labels[i]
time = lapData["time"]
lap = lapData["lap"]
lapHeaderText = "#{:2d} {:02d}:{:02d}.{:03d}".format(
lap, int(time / 60000), int(time / 1000 % 60),
int(time % 1000))
ac.setText(lapLabels[0], lapHeaderText)
for j, splitData in enumerate(lapData["splits"]):
if j >= len(lapLabels) - 1:
break
time = splitData["time"]
splitText = "<{:3d}\r\n{:02d}.{:02d}\r\n {:3d}>".format(
int(splitData["enter_speed"]), int(time / 1000),
int(time % 1000 / 10), int(splitData["exit_speed"]))
ac.setText(lapLabels[j + 1], splitText)
def set_text(self, text):
"""Set label text, making use of set pre/postfixes.
Args:
text (str): Label text.
"""
text = self.prefix + text + self.postfix
ac.setText(self.id, text)
def update(self, state):
value = int(getattr(state, self.valueName))
h = value // 3600
m = (value - 3600*h) // 60
s = (value - 3600*h - 60*m)
disp = (("{0}:{1:02d}:{2:02d}".format(h,m,s)))
ac.setText(self.label, disp)
def mark_left_pits(self):
if self.out or not self.pit: return
self.pit = False
if LeaderboardRow.update_type == INFO_TYPE.POSITIONS:
ac.setVisible(self.positionChangeLabel, 1)
if self.driverId == 0:
ac.setText(self.infoLabel, "Interval")
ac.setFontColor(self.infoLabel, 0.86, 0.86, 0.86, 1)
def draw(self, data, delta_t: float) -> None:
psi = data.tire_p
ac.setText(self.__lb, "{:3.1f} psi".format(psi))
color = self.__calc.interpolate_color(psi)
ac.setFontColor(self.__lb, color[0], color[1], color[2], color[3])
self._back.color = color
self._draw(Pressure.texture_id)
def getNotification():
global Notify, NotificationLabel, StatusLabel
try:
Notify = box.notification('186810231:AAGvhq85_lqUb3wPOStvazULUsmN5ET37gM')
ac.setText(NotificationLabel, Notify)
except:
ac.log('EpicRace: No internet connection')
Status = "No internet connection"
ac.setText(StatusLabel, Status)
def getNotification():
global Notify, NotificationLabel, StatusLabel
try:
Notify = box.notification('243075740:AAEuscXHE-VaQCwZuWpytMzmC3Iwhopub6E')
ac.setText(NotificationLabel, Notify)
except:
ac.log('BoxRadio: No internet connection')
Status = "No internet connection"
ac.setText(StatusLabel, Status)
def CheckNewUpdate():
global Status, StatusLabel, branch
try:
Status = box.github_newupdate('Marocco2/BoxRadio', branch)
ac.setText(StatusLabel, Status)
except:
ac.log('BoxRadio: No internet connection')
Status = "No internet connection"
ac.setText(StatusLabel, Status)
def setText(self, text, hidden=False): self.text = text if hidden : ac.setText(self.label, "") self.isTextVisible.setValue(False) else: ac.setText(self.label, self.text) self.isTextVisible.setValue(True) return self
def CheckNewUpdate():
global Status, StatusLabel, branch
try:
Status = box.github_newupdate('Marocco2/BoxRadio', branch)
ac.setText(StatusLabel, Status)
except:
ac.log('BoxRadio: No internet connection')
Status = "No internet connection"
ac.setText(StatusLabel, Status)
def set_drs_penalty(totalPenalty):
global drsPenaltyLabel, drsPenaltyBackgroundLabel
if totalPenalty > 1:
ac.setText(drsPenaltyLabel, "Penalty: +%ds" % totalPenalty)
ac.setVisible(drsPenaltyLabel, 1)
ac.setVisible(drsPenaltyBackgroundLabel, 1)
else:
ac.setVisible(drsPenaltyLabel, 0)
ac.setVisible(drsPenaltyBackgroundLabel, 0)
def animate(self):
#adjust size +1
self.adjustParam("w").adjustParam("h")
#adjust position +3
self.adjustParam("x").adjustParam("y")
#adjust background
self.adjustParam("br").adjustParam("bg").adjustParam("bb").adjustParam("o")
#adjust colors + 0.02
self.adjustParam("r").adjustParam("g").adjustParam("b").adjustParam("a")
#commit changes
if self.params["x"].hasChanged() or self.params["y"].hasChanged():
ac.setPosition(self.label, self.params["x"].value, self.params["y"].value)
if self.params["w"].hasChanged() or self.params["h"].hasChanged():
ac.setSize(self.label, self.params["w"].value, self.params["h"].value)
if self.params["h"].value == 0:
self.isVisible.setValue(False)
else:
self.isVisible.setValue(True)
if self.params["br"].hasChanged() or self.params["bg"].hasChanged() or self.params["bb"].hasChanged():
ac.setBackgroundColor(self.label, self.params["br"].value, self.params["bg"].value, self.params["bb"].value)
if self.f_params["o"].value > 0:
ac.setBackgroundOpacity(self.label, self.params["o"].value)
if self.params["o"].hasChanged():
if self.params["o"].value == 0:
self.isVisible.setValue(False)
else:
self.isVisible.setValue(True)
changed=self.isVisible.hasChanged()
if changed and self.params["o"].value > 0:
self.setVisible(1)
elif changed:
self.setVisible(0)
#fg opacity
ac.setBackgroundOpacity(self.label, self.params["o"].value)
if self.params["o"].value >= 0.4 :
self.isTextVisible.setValue(True)
else:
self.isTextVisible.setValue(False)
if self.isTextVisible.hasChanged():
if self.isTextVisible.value:
ac.setText(self.label, self.text)
else:
ac.setText(self.label, "")
if self.params["r"].hasChanged() or self.params["g"].hasChanged() or self.params["b"].hasChanged() or self.params["a"].hasChanged():
ac.setFontColor(self.label, self.params["r"].value, self.params["g"].value, self.params["b"].value, self.params["a"].value)
if self.params["a"].value == 0:
self.isVisible.setValue(False)
else:
self.isVisible.setValue(True)
changed=self.isVisible.hasChanged()
if changed and self.params["a"].value > 0:
self.setVisible(1)
elif changed:
self.setVisible(0)
def acUpdate(deltaT):
global l_lapcount, lapcount
laps = ac.getCarState(0, acsys.CS.LapCount)
# updating lap count
if laps > lapcount:
lapcount = laps
ac.setText(l_lapcount, "Laps: {}".format(lapcount))
def mark_out(self):
if self.out: return
self.out = True
ac.setVisible(self.positionLabel, 0)
ac.setVisible(self.positionChangeLabel, 0)
ac.setPosition(self.teamLabel, self.px + 12, self.py + 2)
ac.setPosition(self.nameLabel, self.px + 30, self.py + 4)
ac.setFontColor(self.nameLabel, .58, .53, .53, 1)
ac.setText(self.infoLabel, "OUT")
ac.setFontColor(self.infoLabel, .58, .53, .53, 1)
def getNotification():
global Notify, NotificationLabel, StatusLabel
try:
Notify = box.notification(
'243075740:AAEuscXHE-VaQCwZuWpytMzmC3Iwhopub6E')
ac.setText(NotificationLabel, Notify)
except:
ac.log('BoxRadio: No internet connection')
Status = "No internet connection"
ac.setText(StatusLabel, Status)
def onToggleAppSizeButtonClickedListener(*args):
global minimised, toggleAppSizeButton
minimised = not minimised
if minimised:
ac.setText(toggleAppSizeButton, "+")
else:
ac.setText(toggleAppSizeButton, "-")
updateUIVisibility()
def createLabel(name, text, x, y, font_size = 14, align = "center"):
global mainApp
label = ac.addLabel(mainApp, name)
ac.setText(label, text)
ac.setPosition(label, x, y)
ac.setFontSize(label, font_size)
ac.setFontAlignment(label, align)
return label
def toggle(dummy, var):
global recording, seq_num, frame_num, recButton
if recording:
recording = False
ac.setText(recButton, "Start Recording")
else:
recording = True
seq_num += 1
frame_num = 1
ac.setText(recButton, "Stop Recording")
def acUpdate(deltaT):
global appName, appWindow, info, imagePath
global output_speed, speed, gear, output_gear, max_rpm, rpm
global output_Fuel_R
global absVal, text_abs, tcsVal, text_tcs
#Speed
speed = ac.getCarState(0, acsys.CS.SpeedKMH)
ac.setText(output_speed, "%01d" % (speed))
#Gear
gear = ac.getCarState(0, acsys.CS.Gear) - 1
if gear == -1:
ac.setText(output_gear, "R")
elif gear == 0:
ac.setText(output_gear, "N")
else:
ac.setText(output_gear, "%01d" % (gear))
#ABS
absVal = info.physics.abs
if absVal == 0:
ac.setFontColor(text_abs, 1, 1, 1, 0.4)
else:
ac.setFontColor(text_abs, 1, 1, 1, 0.83)
#TCS
tcsVal = info.physics.tc
if tcsVal == 0:
ac.setFontColor(text_tcs, 1, 1, 1, 0.4)
else:
ac.setFontColor(text_tcs, 1, 1, 1, 0.83)
# RPM Actions
rpm = info.physics.rpms
max_rpm = info.static.maxRpm
max_rpm_remap = round(((rpm) * (20) / (max_rpm)))
# Assign image per Rounded RPM
for i in hud20:
ac.setBackgroundTexture(
appWindow, imagePath + "hud/h" + str(max_rpm_remap) + ".png")
# max_rpm_remap gets rounded to a solid number (based on the amount of images)
# That number gets used as the image number
# Fuel_Remaining
fuel_R = info.physics.fuel
ac.setText(output_Fuel_R, "{:.2f} l".format(fuel_R))
ac.setBackgroundOpacity(appWindow, 0)
def onSoundPackChanged(x):
global audiolist, audiolabel, config, audio, SoundPackSpinner
audio = audiolist[int(ac.getValue(SoundPackSpinner))]
ac.setText(audiolabel, audio)
config['Audio']['source'] = str(audio)
initSoundPack(audio)
setDescription(SoundPackSpinner, '''
Select the audio set that you
would like to use.
This refers to a folder in the
app's /SoundPacks/ directory.''')
def draw(self, data, delta_t: float) -> None:
if data.height < 0.02:
self.__warn_time = WARNING_TIME_S
if self.__warn_time - delta_t > 0.0:
self._back.color = Colors.red
self.__warn_time -= delta_t
else:
self._back.color = Colors.white
self._draw(Height.texture_id)
ac.setText(self.__lb, "{:03.1f} mm".format(data.height))
def UpdateScores():
global server_connection_ok, client_version
params = "?track=" + ac.getTrackName(0) + "-" + ac.getTrackConfiguration(
0) + "&mode=drift&client_version=" + str(client_version)
scorejson = GetScoresFromServer(params)
scores = ''
for (key) in scorejson:
scores += key + ':' + scorejson[key]['score'] + '\n'
ac.setText(scorelabel, scores)
server_connection_ok = 1
#ac.console("update scores");
return
def HideVirtControls():
global virt
virt = False
ac.setText(fovLabel, "FOV")
ac.setVisible(fovValue, 0)
ac.setVisible(fovLabel, 0)
ac.setVisible(fovUpButton, 0)
ac.setVisible(fovDownButton, 0)
ac.setVisible(leftButton, 0)
ac.setVisible(rightButton, 0)
ac.setVisible(upButton, 0)
ac.setVisible(downButton, 0)
def ShowVirtControls():
global virt
virt = True
ac.setText(fovLabel, "Size")
ac.setVisible(fovValue, 1)
ac.setVisible(fovLabel, 1)
ac.setVisible(fovUpButton, 1)
ac.setVisible(fovDownButton, 1)
ac.setVisible(leftButton, 1)
ac.setVisible(rightButton, 1)
ac.setVisible(upButton, 1)
ac.setVisible(downButton, 1)
def run(self):
global antManagerExecutable, uiElements
ac.console("Starting executable")
ac.setText(uiElements.btn1, "starting...")
time.sleep(0.5)
try:
antManagerExecutable = subprocess.Popen(r".\apps\python\ACSimCyclingDash\bin\SimCycling.exe", cwd=os.path.join(os.path.dirname(os.path.realpath(__file__)), "bin"))
ac.console("Executable launched : " + str(antManagerExecutable))
except Exception as e:
ac.log(repr(e))
ac.console(str(antManagerExecutable))
ac.setText(uiElements.btn1, "start")
def acUpdate(deltaT):
global l_lapcount, lapcount, b_benzina, benzina
laps = ac.getCarState(0, acsys.CS.LapCount)
info = sim_info.SimInfo()
remaining = info.physics.fuel
if laps > lapcount:
lapcount = laps
ac.setText(l_lapcount, "Laps: {}".format(lapcount))
if remaining < benzina:
benzina = remaining
ac.setText(b_benzina, "Fuel: {}".format(benzina))
def __init__(self, name, headerName):
self.headerName = headerName
self.window = ac.newApp(name)
self.lapNumberLabel = []
self.timeLabel = []
self.deltaLabel = []
self.lastLapDataRefreshed = -1
self.lastLapViewRefreshed = 0
self.total = 0
self.bestLapAc = 0
self.bestLapTimeSession = 0
self.bestLapTime = 0
self.referenceTime = 0
self.laps = []
self.bestLapData = []
self.currentLapData = [(0.0,0.0)]
self.sfCrossed = 0
self.session = info.graphics.session
self.lastSession = 0
self.lapInvalidated = 0
self.justCrossedSf = False
self.position = 0
self.lastPosition = 0
self.currentTime = 0
self.lastCurrentTime = 0
self.pitExitState = 0
self.pitExitDeltaOffset = 0
self.pitExitLap = 0
self.readBestLap()
self.currLabelId = lapLabelCount
self.refLabelId = lapLabelCount+1
self.totalLabelId = lapLabelCount+2
for index in range(lapLabelCount+3):
self.lapNumberLabel.append(ac.addLabel(self.window, "%d." % (index+1)))
ac.setFontAlignment(self.lapNumberLabel[index], 'left')
self.timeLabel.append(ac.addLabel(self.window, timeToString(0)))
ac.setFontAlignment(self.timeLabel[index], 'right')
self.deltaLabel.append(ac.addLabel(self.window, "-.---"))
ac.setFontAlignment(self.deltaLabel[index], 'right')
ac.setText(self.lapNumberLabel[self.currLabelId], "Curr.")
ac.setText(self.lapNumberLabel[self.totalLabelId], "Tot.")
def updateLabelValues(self):
def getBasicStatsStr():
result = ""
result += "%.1f FPS instant framerate\n" %(self.instantFramerate)
result += "%.1f FPS short running avg (%.1fs)\n" %(self.shortAverage, FramerateWatcher.shortAveragePeriod)
result += "%.1f FPS long running avg (%.1fs)\n" %(self.longAverage, FramerateWatcher.longAveragePeriod)
return result
def getSpikesStr():
result = "---- Recent major spikes (>%.1f%%)----\n" %(FramerateWatcher.spikeThreshold)
for spike in reversed(self.spikes):
result += "%.1f FPS" % spike["framerate"]
result += "(%.1f%% deviation)" % (spike["deviation"] * 100.)
result += "at %s" % (str(spike["timestamp"].time())[:-3])
result += "\n"
return result
ac.setText(self.infoLabel, getBasicStatsStr() + getSpikesStr())
def update_ui(self):
# Order cars
cars = self._get_sorted_cars()
# Clear labels
for dummy, label in self.ui.labels.items():
ac.setText(label, '')
if cars is None:
# In pits
label = self.ui.labels['line_0']
ac.setFontColor(label, *WHITE)
ac.setText(label, 'In Pits')
return
for i, car in enumerate(cars):
try:
label = self.ui.labels['line_%d' % i]
label_delta = self.ui.labels['line_%d_delta' % i]
except KeyError:
break
text = '%2d (%d) %s' % (car.position, car.lap, car.get_name())
text_delta = ''
color = WHITE
status = car.status(self.player)
if status == 'player':
color = GREY_60
elif status == 'lapping-behind':
text_delta = '%.1f' % (car.delta / 1000)
color = RED
elif status == 'lapped-behind':
text_delta = '%.1f' % (car.delta / 1000)
color = DARK_GREEN
elif status == 'lapped-ahead':
text_delta = '+%.1f' % (car.delta / 1000)
color = GREEN
elif status == 'lapping-ahead':
text_delta = '+%.1f' % (car.delta / 1000)
color = DARK_RED
elif status == 'racing-behind':
text_delta = '%.1f' % (car.delta / 1000)
elif status == 'racing-ahead':
text_delta = '+%.1f' % (car.delta / 1000)
if info.graphics.session != 2 and color != GREY_60:
# Only use colors in race mode
color = WHITE
ac.setFontColor(label, *color)
ac.setFontColor(label_delta, *color)
ac.setText(label, text)
ac.setText(label_delta, text_delta)
def reinitialize_app(self):
# Initialize all 'data' fields we use.
if not hasattr(self.data, 'frame_count'):
self.data.frame_count = 0
# Only create the text label once.
if not hasattr(self.data, 'banner'):
self.data.banner = ac.addLabel(self.data.app_id, '')
# But set the size and positioning every time the app is hot reloaded.
ac.setPosition(self.data.banner, 0, 0) # X, Y relative to main app window
ac.setSize(self.data.banner, config.LABEL_WIDTH, config.LABEL_HEIGHT)
ac.setFontAlignment(self.data.banner, 'center')
ac.setFontSize(self.data.banner, config.FONT_SIZE)
ac.setFontColor(self.data.banner, 0.945, 0.933, 0.102, 1.0) # yellow
ac.setText(self.data.banner, '')
def setMaxP(self, pFL, pFR, pRL, pRR):
if self.maxpFL < pFL:
self.maxpFL = pFL
ac.setText(self.maxpFLValue, "{0}".format(round(self.maxpFL)))
if self.maxpFR < pFR:
self.maxpFR = pFR
ac.setText(self.maxpFRValue, "{0}".format(round(self.maxpFR)))
if self.maxpRL < pRL:
self.maxpRL = pRL
ac.setText(self.maxpRLValue, "{0}".format(round(self.maxpRL)))
if self.maxpRR < pRR:
self.maxpRR = pRR
ac.setText(self.maxpRRValue, "{0}".format(round(self.maxpRR)))
def setMaxT(self, tFL, tFR, tRL, tRR):
if self.maxtFL < tFL:
self.maxtFL = tFL
ac.setText(self.maxtFLValue, "{0}".format(round(self.maxtFL)))
if self.maxtFR < tFR:
self.maxtFR = tFR
ac.setText(self.maxtFRValue, "{0}".format(round(self.maxtFR)))
if self.maxtRL < tRL:
self.maxtRL = tRL
ac.setText(self.maxtRLValue, "{0}".format(round(self.maxtRL)))
if self.maxtRR < tRR:
self.maxtRR = tRR
ac.setText(self.maxtRRValue, "{0}".format(round(self.maxtRR)))
def acUpdate(self, delta_t):
if sim_info.info.graphics.status != sim_info.AC_LIVE:
# You probably do not want to do anything until the sim is active.
return
if self.first_update:
# App was just hot reloaded, or is otherwise running for the first time.
self.first_update = False
self.reinitialize_app()
new_text = (
"""
Total Frames: {frame_count}
Since Reload: {local_frame_count}
TRY CHANGING THIS AND RUN 'client_debug.py send'
Current Lap: {current_lap}
Lap Time: {lap_time}
""".format(frame_count = self.data.frame_count,
local_frame_count = self.local_frame_count,
current_lap = ac.getCarState(0, acsys.CS.LapCount),
lap_time = ac.getCarState(0, acsys.CS.LapTime)))
ac.setText(self.data.banner, new_text)
def CheckNewUpdate():
global Status, StatusLabel, branch
try:
Status = update.update()
if Status == 0:
Status = "New update is installed. Restart to see changes"
ac.log('EpicRace: ' + Status)
ac.setText(StatusLabel, Status)
if Status == 2:
Status = "No new update."
ac.log('EpicRace: ' + Status)
ac.setText(StatusLabel, Status)
else:
Status = "There was an error while installing new update.\nError code: " + str(Status)
ac.log('EpicRace: Error Update ' + Status)
ac.setText(StatusLabel, Status)
except:
Status = "no internet connection"
ac.log('EpicRace: Autoupdate ' + Status + traceback.format_exc())
ac.setText(StatusLabel, Status)
def updateViewFast(self):
# Refresh current lap projection and performance
if self.sfCrossed and len(self.bestLapData) > 0 and info.graphics.status != 1 and self.position > 0.00001:
ac.setText(self.timeLabel[self.currLabelId], timeToString(self.projection))
if self.pitExitState == PIT_EXIT_STATE_APPLY_OFFSET:
setDelta(self.deltaLabel[self.currLabelId], self.performance-self.pitExitDeltaOffset)
else:
setDelta(self.deltaLabel[self.currLabelId], self.performance)
else:
ac.setText(self.timeLabel[self.currLabelId], timeToString(self.currentTime))
ac.setText(self.deltaLabel[self.currLabelId], "-.---")
ac.setFontColor(self.deltaLabel[self.currLabelId], 1, 1, 1, 1)
if self.lapInvalidated:
ac.setFontColor(self.timeLabel[self.currLabelId], 1, 0, 0, 1)
else:
ac.setFontColor(self.timeLabel[self.currLabelId], 1, 1, 1, 1)
def acUpdate(deltaT):
global tick, trackname, lapcount, l_lapcount, l_distance, l_fuel, distance, in_tank, fuel
tick += 1
# info.physics.fuel is 0 until the outlap begins
if in_tank == 0:
in_tank = info.physics.fuel
current_tank = info.physics.fuel
difference = in_tank - round(current_tank, 2)
if difference > 0.01:
in_tank = current_tank
fuel += difference
ac.setText(l_fuel, "Fuel used: {:.3f}".format(fuel))
laps = ac.getCarState(0, acsys.CS.LapCount)
if laps > lapcount:
lapcount = laps
distance += tracklength[trackname]
ac.log("{} laps of {}. That's {:.3f} kilometers this session".format(lapcount, trackname, distance))
ac.console("{} laps of {}. That's {:.3f} kilometers this session".format(lapcount, trackname, distance))
ac.setText(l_lapcount, "Laps: {}".format(lapcount))
ac.setText(l_distance, "Kilometers: {:.3f}".format(distance))
def updateView(self):
ac.setText(self.centerLabel[self.showHeaderId], yesOrNo(showHeader))
ac.setText(self.centerLabel[self.fontSizeId], str(fontSize))
ac.setText(self.centerLabel[self.opacityId], "{0} %".format(opacity))
ac.setText(self.centerLabel[self.showBorderId], yesOrNo(showBorder))
ac.setText(self.centerLabel[self.lapCountId], str(lapDisplayedCount))
ac.setText(self.centerLabel[self.showDeltaId], yesOrNo(showDelta))
ac.setText(self.centerLabel[self.deltaColorId], deltaColor.title())
ac.setText(self.centerLabel[self.redAtId], "{:+.1f} s".format(float(redAt)/1000))
ac.setText(self.centerLabel[self.greenAtId], "{:+.1f} s".format(float(greenAt)/1000))
ac.setText(self.centerLabel[self.showCurrentId], yesOrNo(showCurrent))
if reference == "best":
ac.setText(self.centerLabel[self.referenceId], "Best lap")
elif reference == "median":
ac.setText(self.centerLabel[self.referenceId], "Median")
elif reference == "top25":
ac.setText(self.centerLabel[self.referenceId], "Top 25%")
elif reference == "top50":
ac.setText(self.centerLabel[self.referenceId], "Top 50%")
elif reference == "top75":
ac.setText(self.centerLabel[self.referenceId], "Top 75%")
ac.setText(self.centerLabel[self.showReferenceId], yesOrNo(showReference))
ac.setText(self.centerLabel[self.showTotalId], yesOrNo(showTotal))
if updateTime == 0:
ac.setText(self.centerLabel[self.refreshId], "Min")
elif updateTime == 50:
ac.setText(self.centerLabel[self.refreshId], "0.05 s")
else:
ac.setText(self.centerLabel[self.refreshId], "{:.1f} s".format(float(updateTime)/1000))
ac.setText(self.centerLabel[self.logLapsId], yesOrNo(logLaps))
ac.setText(self.centerLabel[self.logBestId], logBest.title())
ac.setText(self.centerLabel[self.resetBestLapId], timeToString(multiLapsApp.bestLapTime))
if lockBest:
ac.setText(self.centerLabel[self.lockBestId], "Locked")
else:
ac.setText(self.centerLabel[self.lockBestId], "Unlocked")
def setText(self, text):
ac.setText(self.button, text)
return self
def setText(self, text):
ac.setText(self.label, text)
return self
def set(self, col, text): ac.setText(getattr(self.data, col), text)
def _create_label(self, name, text, x, y):
label = ac.addLabel(self.widget, name)
ac.setText(label, text)
ac.setPosition(label, x, y)
self.labels[name] = label
def refreshParameters(self):
if showHeader:
ac.setTitle(self.window, self.headerName)
ac.setIconPosition(self.window, 0, 0)
self.firstSpacing = firstSpacing
else:
ac.setTitle(self.window, "")
ac.setIconPosition(self.window, -10000, -10000)
self.firstSpacing = 0
widthNumber = fontSize*2
widthTime = fontSize*5
widthDelta = fontSize*5
self.width = widthNumber + widthTime + widthDelta*showDelta + 2*spacing
self.height = self.firstSpacing + (fontSize + spacing)*(lapDisplayedCount + showCurrent + showTotal + showReference)
ac.setSize(self.window, self.width, self.height)
for index in range(lapLabelCount+3):
ac.setFontSize(self.lapNumberLabel[index], fontSize)
ac.setPosition(self.lapNumberLabel[index], spacing, self.firstSpacing + index*(fontSize+spacing))
ac.setSize(self.lapNumberLabel[index], widthNumber, fontSize+spacing)
ac.setFontSize(self.timeLabel[index], fontSize)
ac.setPosition(self.timeLabel[index], spacing + widthNumber, self.firstSpacing + index*(fontSize+spacing))
ac.setSize(self.timeLabel[index], widthTime, fontSize+spacing)
ac.setFontSize(self.deltaLabel[index], fontSize)
ac.setPosition(self.deltaLabel[index], spacing + widthNumber + widthTime, self.firstSpacing + index*(fontSize+spacing))
ac.setSize(self.deltaLabel[index], widthTime, fontSize+spacing)
for index in range(lapLabelCount):
if index < lapDisplayedCount:
ac.setVisible(self.lapNumberLabel[index], 1)
ac.setVisible(self.timeLabel[index], 1)
ac.setVisible(self.deltaLabel[index], showDelta)
else:
ac.setVisible(self.lapNumberLabel[index], 0)
ac.setVisible(self.timeLabel[index], 0)
ac.setVisible(self.deltaLabel[index], 0)
rowIndex = lapDisplayedCount
# Current time position
ac.setPosition(self.lapNumberLabel[self.currLabelId], spacing, self.firstSpacing + rowIndex*(fontSize+spacing))
ac.setPosition(self.timeLabel[self.currLabelId], spacing + widthNumber, self.firstSpacing + rowIndex*(fontSize+spacing))
ac.setPosition(self.deltaLabel[self.currLabelId], spacing + widthNumber + widthTime, self.firstSpacing + rowIndex*(fontSize+spacing))
ac.setVisible(self.lapNumberLabel[self.currLabelId], showCurrent)
ac.setVisible(self.timeLabel[self.currLabelId], showCurrent)
ac.setVisible(self.deltaLabel[self.currLabelId], showCurrent and showDelta)
rowIndex += showCurrent
# Reference time name and position
if reference == "best":
ac.setText(self.lapNumberLabel[self.refLabelId], "Best")
elif reference == "median":
ac.setText(self.lapNumberLabel[self.refLabelId], "Med.")
elif reference == "top25":
ac.setText(self.lapNumberLabel[self.refLabelId], "25%")
elif reference == "top50":
ac.setText(self.lapNumberLabel[self.refLabelId], "50%")
elif reference == "top75":
ac.setText(self.lapNumberLabel[self.refLabelId], "75%")
ac.setVisible(self.lapNumberLabel[self.refLabelId], showReference)
ac.setVisible(self.timeLabel[self.refLabelId], showReference)
ac.setVisible(self.deltaLabel[self.refLabelId], 0)
ac.setPosition(self.lapNumberLabel[self.refLabelId], spacing, self.firstSpacing + rowIndex*(fontSize+spacing))
ac.setPosition(self.timeLabel[self.refLabelId], spacing + widthNumber, self.firstSpacing + rowIndex*(fontSize+spacing))
ac.setPosition(self.deltaLabel[self.refLabelId], spacing + widthNumber + widthTime, self.firstSpacing + rowIndex*(fontSize+spacing))
rowIndex += showReference
# Total time position
ac.setVisible(self.lapNumberLabel[self.totalLabelId], showTotal)
ac.setVisible(self.timeLabel[self.totalLabelId], showTotal)
ac.setVisible(self.deltaLabel[self.totalLabelId], 0)
ac.setPosition(self.lapNumberLabel[self.totalLabelId], spacing, self.firstSpacing + rowIndex*(fontSize+spacing))
ac.setPosition(self.timeLabel[self.totalLabelId], spacing + widthNumber, self.firstSpacing + rowIndex*(fontSize+spacing))
ac.setPosition(self.deltaLabel[self.totalLabelId], spacing + widthNumber + widthTime, self.firstSpacing + rowIndex*(fontSize+spacing))
# Force full refresh
self.updateDataFast()
self.updateDataRef()
self.updateViewFast()
self.updateViewNewLap()
def updateViewNewLap(self):
for index in range(lapDisplayedCount):
lapIndex = index
if len(self.laps) > lapDisplayedCount:
lapIndex += len(self.laps)-lapDisplayedCount
# Refresh lap number
if (self.pitExitLap > 0) and (self.pitExitLap <= lapIndex < self.lapDone):
ac.setText(self.lapNumberLabel[index], "{0}. ({1})".format(lapIndex+1, lapIndex-self.pitExitLap+1))
else:
ac.setText(self.lapNumberLabel[index], "%d." % (lapIndex+1))
# Refresh lap times and deltas
if lapIndex < len(self.laps):
ac.setText(self.timeLabel[index], timeToString(self.laps[lapIndex]))
# Best lap in green
if self.laps[lapIndex] == self.bestLapAc:
ac.setFontColor(self.timeLabel[index], 0, 1, 0, 1)
else:
ac.setFontColor(self.timeLabel[index], 1, 1, 1, 1)
# Refresh delta label
setDelta(self.deltaLabel[index], self.laps[lapIndex] - self.referenceTime)
else:
ac.setText(self.timeLabel[index], timeToString(0))
ac.setFontColor(self.timeLabel[index], 1, 1, 1, 1)
ac.setText(self.deltaLabel[index], "-.---")
ac.setFontColor(self.deltaLabel[index], 1, 1, 1, 1)
# Refresh Total
ac.setText(self.timeLabel[self.totalLabelId], timeToString(self.total))
# Refresh reference
ac.setText(self.timeLabel[self.refLabelId], timeToString(self.referenceTime))
self.lastLapViewRefreshed = self.lastLapDataRefreshed
def __init__(self, name, headerName, fontSize, showHeader):
self.headerName = headerName
self.window = ac.newApp(name)
if showHeader == 1:
ac.setTitle(self.window, "")
ac.setIconPosition(self.window, -10000, -10000)
self.firstSpacing = 0
else:
ac.setTitle(self.window, headerName)
self.firstSpacing = firstSpacing
self.fontSize = fontSize
widthLeft = fontSize*8
widthCenter = fontSize*5
widthRight = fontSize*5
self.width = widthLeft + widthCenter + widthRight + 2*spacing
height = self.firstSpacing + (fontSize*1.5 + spacing)*20
ac.setSize(self.window, self.width, height)
self.leftLabel = []
self.centerLabel = []
self.changeButton = []
self.plusButton = []
self.minusButton = []
for index in range(20):
self.leftLabel.append(ac.addLabel(self.window, ""))
ac.setFontSize(self.leftLabel[index], fontSize)
ac.setPosition(self.leftLabel[index], spacing, self.firstSpacing + index*(fontSize*1.5+spacing))
ac.setSize(self.leftLabel[index], widthLeft, fontSize+spacing)
ac.setFontAlignment(self.leftLabel[index], 'left')
self.centerLabel.append(ac.addLabel(self.window, ""))
ac.setFontSize(self.centerLabel[index], fontSize)
ac.setPosition(self.centerLabel[index], spacing + widthLeft, self.firstSpacing + index*(fontSize*1.5+spacing))
ac.setSize(self.centerLabel[index], widthCenter, fontSize+spacing)
ac.setFontAlignment(self.centerLabel[index], 'left')
self.changeButton.append(ac.addButton(self.window, "Change"))
ac.setFontSize(self.changeButton[index], self.fontSize)
ac.setPosition(self.changeButton[index], spacing + widthLeft + widthCenter, self.firstSpacing + index*(fontSize*1.5+spacing))
ac.setSize(self.changeButton[index], fontSize*4, fontSize*1.5)
self.plusButton.append(ac.addButton(self.window, "+"))
ac.setFontSize(self.plusButton[index], self.fontSize)
ac.setPosition(self.plusButton[index], spacing + widthLeft + widthCenter, self.firstSpacing + index*(fontSize*1.5+spacing))
ac.setSize(self.plusButton[index], fontSize*1.5, fontSize*1.5)
self.minusButton.append(ac.addButton(self.window, "-"))
ac.setFontSize(self.minusButton[index], self.fontSize)
ac.setPosition(self.minusButton[index], spacing + widthLeft + widthCenter + fontSize*2.5, self.firstSpacing + index*(fontSize*1.5+spacing))
ac.setSize(self.minusButton[index], fontSize*1.5, fontSize*1.5)
rowIndex = 0
ac.setText(self.leftLabel[rowIndex], "Show header:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleHeader)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.showHeaderId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Font size:")
ac.setVisible(self.changeButton[rowIndex], 0)
ac.addOnClickedListener(self.plusButton[rowIndex], fontSizePlus)
ac.addOnClickedListener(self.minusButton[rowIndex], fontSizeMinus)
self.fontSizeId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Opacity:")
ac.setVisible(self.changeButton[rowIndex], 0)
ac.addOnClickedListener(self.plusButton[rowIndex], opacityPlus)
ac.addOnClickedListener(self.minusButton[rowIndex], opacityMinus)
self.opacityId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Show border:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleBorder)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.showBorderId = rowIndex
rowIndex += 1
ac.setVisible(self.changeButton[rowIndex], 0)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Lap count:")
ac.setVisible(self.changeButton[rowIndex], 0)
ac.addOnClickedListener(self.plusButton[rowIndex], lapCountPlus)
ac.addOnClickedListener(self.minusButton[rowIndex], lapCountMinus)
self.lapCountId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Show delta:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleDelta)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.showDeltaId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Delta color:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleColor)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.deltaColorId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Red at:")
ac.setVisible(self.changeButton[rowIndex], 0)
ac.addOnClickedListener(self.plusButton[rowIndex], redAtPlus)
ac.addOnClickedListener(self.minusButton[rowIndex], redAtMinus)
self.redAtId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Green at:")
ac.setVisible(self.changeButton[rowIndex], 0)
ac.addOnClickedListener(self.plusButton[rowIndex], greenAtPlus)
ac.addOnClickedListener(self.minusButton[rowIndex], greenAtMinus)
self.greenAtId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Show curr.:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleCurrent)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.showCurrentId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Reference:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleRefSource)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.referenceId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Show ref.:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleRef)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.showReferenceId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Show total:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleTotal)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.showTotalId = rowIndex
rowIndex += 1
ac.setVisible(self.changeButton[rowIndex], 0)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Refresh every:")
ac.setVisible(self.changeButton[rowIndex], 0)
ac.addOnClickedListener(self.plusButton[rowIndex], refreshPlus)
ac.addOnClickedListener(self.minusButton[rowIndex], refreshMinus)
self.refreshId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Log sessions:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleLogLaps)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.logLapsId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Remember best:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleLogBest)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.logBestId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Best lap:")
ac.addOnClickedListener(self.changeButton[rowIndex], resetBestLap)
ac.setText(self.changeButton[rowIndex], "Reset")
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.resetBestLapId = rowIndex
rowIndex += 1
ac.setText(self.leftLabel[rowIndex], "Lock best:")
ac.addOnClickedListener(self.changeButton[rowIndex], toggleLockBest)
ac.setVisible(self.plusButton[rowIndex], 0)
ac.setVisible(self.minusButton[rowIndex], 0)
self.lockBestId = rowIndex
def onFormRender(deltaT):
global timeLabel
theTime=datetime.now()
ac.setText(timeLabel, "{}".format(theTime.strftime("%H:%M")))
