def acMain(ac_version):
global TYREINFO, optimal_spinner_id, optimal_spinner_shown
appWindow = ac.newApp("Tyre Temperatures")
ac.drawBackground(appWindow, background)
ac.drawBorder(appWindow, background)
ac.setBackgroundOpacity(appWindow, background)
ac.setSize(appWindow, x_app_size, y_app_size)
TYREINFO = Tyre_Info(appWindow, x_start, y_start)
ac.addRenderCallback(appWindow, onFormRender)
TYREINFO.optimal_temp = d_optimal_temp
TYREINFO.carinifilepath = inidir + getValidFileName(ac.getCarName(0)) + ".ini"
TYREINFO.needwriteini = 1
if os.path.exists(TYREINFO.carinifilepath):
f = open(TYREINFO.carinifilepath, "r")
TYREINFO.optimal_temp = int(f.readline()[8:])
f.close()
TYREINFO.needwriteini = 0
optimal_spinner_id = ac.addSpinner(appWindow, "optimal")
ac.setPosition(optimal_spinner_id, 0, y_app_size + 28)
ac.setStep(optimal_spinner_id, 1)
if inFahrenheit:
ac.setRange(optimal_spinner_id, int(CelsiusToFahrenheit(50)), int(CelsiusToFahrenheit(150)))
ac.setValue(optimal_spinner_id, int(CelsiusToFahrenheit(TYREINFO.optimal_temp)))
else:
ac.setRange(optimal_spinner_id, 50, 150)
ac.setValue(optimal_spinner_id, TYREINFO.optimal_temp)
ac.addOnValueChangeListener(optimal_spinner_id, onValueChanged)
optimal_spinner_shown = 1
ac.log("Danny Giusa Tyre Temperatures loaded")
return "Danny Giusa Tyre Temperatures"
def acMain(ac_version):
global appWindow, label1, logPrefix, appName, splitsRenderer
ac.console(logPrefix + "acMain")
try:
appWindow = ac.newApp(appName)
ac.setTitle(appWindow, "")
ac.setSize(appWindow, 300, 300)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0.3)
resetBtn = ac.addButton(appWindow, "R")
ac.setPosition(resetBtn, 5, 30)
ac.setSize(resetBtn, 30, 30)
ac.addOnClickedListener(resetBtn, onResetClicked)
newSplitBtn = ac.addButton(appWindow, "N")
ac.setPosition(newSplitBtn, 40, 30)
ac.setSize(newSplitBtn, 30, 30)
ac.addOnClickedListener(newSplitBtn, onNewSplitClicked)
#label1 = ac.addLabel(appWindow, "____")
#ac.setPosition(label1, 0, 70)
splitsRenderer = SplitsRenderer(2, 62, 10, 10)
ac.addRenderCallback(appWindow, onRender)
ac.addOnAppActivatedListener(appWindow, onActivate)
ac.addOnAppDismissedListener(appWindow, onDismiss)
ac.console(logPrefix + "Initialized")
except:
printExceptionInfo("acMain")
return appName
def acMain(ac_version):
global updater, appHeight, appWidth, appWindow, numSecondsSpinner
appWindow = ac.newApp("Traction Circle")
ac.setSize(appWindow, appWidth, appHeight)
ac.drawBorder(appWindow, 0)
try:
model = TractionCircleModel()
assetto_corsa = AssettoCorsa()
maxTimeSpan = 3
numSecondsSpinner = ac.addSpinner(appWindow, 'Time Span(s)')
ac.setPosition(numSecondsSpinner, 0, appHeight - 20)
ac.setSize(numSecondsSpinner, 100, 20)
ac.setRange(numSecondsSpinner, 1, 10)
ac.setValue(numSecondsSpinner, maxTimeSpan)
ac.addOnValueChangeListener(numSecondsSpinner, updateMaxTimeRange)
gPlotter = GPlotter(appWidth, appHeight, maxG, maxG)
view = TractionCircleView(appWindow, model, gPlotter, MovingAveragePlotter(10) )
updater = TractionCircleUpdater(assetto_corsa, view, model, maxTimeRange=maxTimeSpan)
ac.addRenderCallback(appWindow, doUpdate)
except Exception as e:
ac.log(str(traceback.format_exc()))
return "Traction Circle"
def acMain(ac_version):
global version, appName, mainApp, x_app_size, y_app_size, backgroundOpacity, customFontName
try:
debug("starting version " + version)
mainApp = ac.newApp(appName)
ac.setTitle(mainApp, "")
ac.drawBorder(mainApp, 0)
ac.setIconPosition(mainApp, 0, -10000)
ac.setBackgroundOpacity(mainApp, backgroundOpacity)
# ac.initFont(0, customFontName, 0, 0)
ac.setSize(mainApp, x_app_size, y_app_size)
ac.addOnAppActivatedListener(mainApp, onMainAppActivatedListener)
ac.addOnAppDismissedListener(mainApp, onMainAppDismissedListener)
ac.addRenderCallback(mainApp, onMainAppFormRender)
getSettings()
createUI()
return appName
except exception:
debug(repr(traceback.format_exception(exc_type, exc_value, exc_traceback)))
showMessage("Error: " + traceback.format_exc())
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 acMain(ac_version): #app window init; global variables for later updating go here
global appWindow
appWindow = ac.newApp(appName)
ac.setTitle(appWindow, appName)
ac.setSize(appWindow, width, height)
ac.log("z3D Gauge loaded")
ac.console("z3D Gauge console test")
####################################################declaring gauge elements
# gonna need new textures like
# rpm_bar = ac.newTexture(app_path + theme_path + "rpm_bar.png")
global l_kmph, l_rpm, l_gear, acceleration
global ascii_RPM
l_kmph = ac.addLabel(appWindow, "KMPH")
l_rpm = ac.addLabel(appWindow, "RPM")
l_gear = ac.addLabel(appWindow, "Current gear")
ascii_RPM = ac.addLabel(appWindow, "")
acceleration = ac.addLabel(appWindow, "")
#l_TC = ac.addLabel(appWindow, "TC on/off") #non-functional
#l_ABS = ac.addLabel(appWindow, "ABS on/off") #non-functional
ac.setPosition(l_kmph, 3, 30)
ac.setPosition(l_rpm, 3, 60)
ac.setPosition(l_gear, 3, 80)
ac.setPosition(ascii_RPM, 3, 160)
ac.setPosition(acceleration, 3, 580)
ac.addRenderCallback(appWindow, appGL) # -> links this app's window to an OpenGL render function
return appName
def setup(self):
ac.addRenderCallback(self.appWindow, onRender)
ac.setSize(self.appWindow,333,424)
ac.drawBorder(self.appWindow,0)
ac.drawBackground(self.appWindow, 0)
for el in self.uiElements:
el.setup()
self.setupButtons()
def acMain(ac_version):
try:
global multiLapsApp, configApp, config
global showHeader, fontSize, opacity, showBorder
global lapDisplayedCount, showDelta, deltaColor, redAt, greenAt
global reference, showCurrent, showReference, showTotal
global updateTime, logLaps, logBest, lockBest
global trackName, trackConf, carName, bestLapFile
global nurbTourist
if ac_version < 1.0:
return "MultiLaps"
config = configparser.ConfigParser()
config.read("apps/python/MultiLaps/MultiLaps_config/config.ini")
showHeader = config.getint("SETTINGS", "showHeader")
fontSize = config.getint("SETTINGS", "fontSize")
opacity = config.getint("SETTINGS", "opacity")
showBorder = config.getint("SETTINGS", "showBorder")
lapDisplayedCount = config.getint("SETTINGS", "lapDisplayedCount")
showDelta = config.getint("SETTINGS", "showDelta")
deltaColor = config.get("SETTINGS", "deltaColor")
redAt = config.getint("SETTINGS", "redAt")
greenAt = config.getint("SETTINGS", "greenAt")
reference = config.get("SETTINGS", "reference")
showCurrent = config.getint("SETTINGS", "showCurrent")
showTotal = config.getint("SETTINGS", "showTotal")
showReference = config.getint("SETTINGS", "showReference")
updateTime = config.getint("SETTINGS", "updateTime")
logLaps = config.getint("SETTINGS", "logLaps")
logBest = config.get("SETTINGS", "logBest")
lockBest = config.getint("SETTINGS", "lockBest")
trackName = ac.getTrackName(0)
trackConf = ac.getTrackConfiguration(0)
carName = ac.getCarName(0)
if trackConf == "":
bestLapFile = "apps/python/MultiLaps/MultiLaps_bestlap/{0} - {1}.ini".format(
trackName, carName)
else:
bestLapFile = "apps/python/MultiLaps/MultiLaps_bestlap/{0} [{1}] - {2}.ini".format(
trackName, trackConf, carName)
if trackName == "ks_nordschleife" and trackConf == "touristenfahrten":
nurbTourist = True
multiLapsApp = MultiLaps("MultiLaps", "Laps")
multiLapsApp.refreshParameters()
ac.addRenderCallback(multiLapsApp.window, onRenderCallback)
configApp = MultiLaps_config("MultiLaps_config", "MultiLaps config", fontSizeConfig, 0)
configApp.updateView()
return "MultiLaps"
except Exception as e:
ac.log("MultiLaps: Error in acMain: %s" % e)
def acMain(ac_version):
try:
deltabar_data.app_id = ac.newApp('deltabar')
ac.addRenderCallback(deltabar_data.app_id, onRender)
return deltabar_app.acMain(ac_version)
except:
log_error()
raise
def acMain(ac_version):
global appWindow
appWindow = ac.newApp("Analog Speedometer")
ac.setTitle(appWindow, "")
ac.setIconPosition(appWindow, 0, -10000)
ac.setSize(appWindow, width, height)
ac.drawBorder(appWindow, 0)
ac.addRenderCallback(appWindow, drawNeedle)
def acMain(ac_version):
global appWindow, CamberIndicators, CheckBoxes, Buttons, Options, Labels, UIData
loadOptions()
appWindow = ac.newApp("CamberExtravaganza")
ac.setSize(appWindow, 200, 200)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
ac.setIconPosition(appWindow, 0, -10000)
# Only enable rendering if app is activated
ac.addOnAppActivatedListener(appWindow, onAppActivated)
ac.addOnAppDismissedListener(appWindow, onAppDismissed)
# Target Camber Labels
Labels["target"] = ac.addLabel(appWindow, "Target:")
ac.setPosition(Labels["target"], 85, 100)
ac.setFontSize(Labels["target"], 10)
Labels["targetCamberF"] = ac.addLabel(appWindow, "")
ac.setPosition(Labels["targetCamberF"], 75, 76)
ac.setFontSize(Labels["targetCamberF"], 24)
Labels["targetCamberR"] = ac.addLabel(appWindow, "")
ac.setPosition(Labels["targetCamberR"], 75, 105)
ac.setFontSize(Labels["targetCamberR"], 24)
# Options Checkbox
CheckBoxes["options"] = ac.addCheckBox(appWindow, "Options")
ac.setPosition(CheckBoxes["options"], 50, 225)
ac.addOnCheckBoxChanged(CheckBoxes["options"], checkboxHandler)
# Option Buttons
uidata = [
["drawGraphs", "Draw Graphs", drawGraphsHandler],
["normalize", "Normalize", normalizeHandler],
["useSpectrum", "Use Spectrum", useSpectrumHandler]
]
x = 50
y = 255
dy = 30
for d in uidata:
Buttons[d[0]] = ac.addButton(appWindow, d[1])
ac.setPosition(Buttons[d[0]], x, y)
ac.setSize(Buttons[d[0]], 100, 25)
ac.addOnClickedListener(Buttons[d[0]], d[2])
ac.setVisible(Buttons[d[0]], 0)
y += dy
# Get optimal camber from files
loadTireData()
CamberIndicators["FL"] = CamberIndicator(appWindow, 25, 75)
CamberIndicators["FR"] = CamberIndicator(appWindow,125, 75)
CamberIndicators["RL"] = CamberIndicator(appWindow, 25,175)
CamberIndicators["RR"] = CamberIndicator(appWindow,125,175)
ac.addRenderCallback(appWindow, onFormRender)
return "CamberExtravaganza"
def acMain(ac_version):
global appWindow, Labels, gearSpacing, fontSize, gears, PxPer1000RPM, RPMdivs
appWindow = ac.newApp("Reventach")
ac.setSize(appWindow, appWidth, appHeight)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
ac.setIconPosition(appWindow, 0, -10000)
ac.setTitle(appWindow, "")
# Only enable rendering if app is activated
ac.addOnAppActivatedListener(appWindow, onAppActivated)
ac.addOnAppDismissedListener(appWindow, onAppDismissed)
loadCarData()
PxPer1000RPM = 1000 * appHeight / CarData["maxRPM"]
RPMdivs = CarData["maxRPM"] // 10000 + 1
#~ fontSize = PxPer1000RPM * 0.5 * RPMdivs
fontSize = appHeight / 15
y = appHeight - PxPer1000RPM * RPMdivs
count = RPMdivs
while y > -1:
dx = (appHeight - y) / lineSlope
Labels["rpmL" + str(count)] = ac.addLabel(appWindow, str(count))
ac.setPosition(Labels["rpmL" + str(count)], dx - fontSize,
y - fontSize / 2)
ac.setFontSize(Labels["rpmL" + str(count)], fontSize)
ac.setFontAlignment(Labels["rpmL" + str(count)], "center")
Labels["rpmR" + str(count)] = ac.addLabel(appWindow, str(count))
ac.setPosition(Labels["rpmR" + str(count)], appWidth - dx + fontSize,
y - fontSize / 2)
ac.setFontSize(Labels["rpmR" + str(count)], fontSize)
ac.setFontAlignment(Labels["rpmR" + str(count)], "center")
if y < PxPer1000RPM * RPMdivs - 1:
ac.setFontColor(Labels["rpmL" + str(count)], 0.7, 0.0, 0.0, 0.9)
ac.setFontColor(Labels["rpmR" + str(count)], 0.7, 0.0, 0.0, 0.9)
y -= (PxPer1000RPM * RPMdivs)
count += RPMdivs
for n in range(CarData["totalGears"]):
gears.insert(0, str(n + 1))
gearSpacing = appHeight / (CarData["totalGears"] + 2)
fontSize = gearSpacing * 0.8
for n, c in enumerate(gears):
Labels["gear" + c] = ac.addLabel(appWindow, c)
ac.setPosition(Labels["gear" + c], appWidth / 2, (n * gearSpacing))
ac.setFontSize(Labels["gear" + c], fontSize)
ac.setFontAlignment(Labels["gear" + c], "center")
ac.addRenderCallback(appWindow, onFormRender)
return "Reventach"
def setup(self):
ac.addRenderCallback(self.appWindow, onRender)
ac.setSize(self.appWindow, 800, 100)
ac.drawBorder(self.appWindow, 0)
ac.drawBackground(self.appWindow, 0)
for el in self.uiElements:
el.setup()
ac.setPosition(self.graph, 0, 100)
ac.setSize(self.graph, 800, 100)
ac.setRange(self.graph, 0.0, 600, 2000)
def acMain(ac_version):
global rpm_display, boost_display, gear_display, speed_display, fuel_display
global min_rpm_spinner_Label, min_rpm_spinner, max_rpm_spinner_Label, max_rpm_spinner, settings_box_Label
global units_spinner_Label, units_spinner
global rpm_tag, speed_tag, boost_tag, fuel_tag
appWindow = ac.newApp("RevHunterSkunkworks")
ac.setTitle(appWindow, " ")
ac.setSize(appWindow, windowx, windowy)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
ac.addRenderCallback(appWindow, onFormRender)
rpm_display = Label(appWindow, "").setSize(0, 0).setPosition(
(2.05 * windowx / 3),
(1.05 * windowy / 3)).setFontSize(50).setFontAlign("right")
gear_display = Label(appWindow).setSize(0, 0).setPosition(
(windowx / 2), -50).setFontSize(140).setFontAlign("center")
speed_display = Label(appWindow, "").setSize(0, 0).setPosition(
(1.25 * windowx / 3),
(1.05 * windowy / 3)).setFontSize(50).setFontAlign("right")
fuel_display = Label(appWindow, "").setSize(0, 0).setPosition(
(0.8 * windowx / 3),
(1.25 * windowy / 3)).setFontSize(35).setFontAlign("right")
settings_box_Label = Label(appWindow, "").setSize(0, 0).setPosition(
940, 83).setFontSize(15).setFontAlign("left")
rpm_tag = Label(appWindow, "").setText("RPM").setSize(0, 0).setPosition(
(2.06 * windowx / 3),
(2.1 * windowy / 3)).setFontSize(15).setFontAlign("left")
speed_tag = Label(appWindow, "").setText("MPH").setSize(0, 0).setPosition(
(1.26 * windowx / 3),
(2.1 * windowy / 3)).setFontSize(15).setFontAlign("left")
fuel_tag = Label(appWindow, "").setText("%FUEL").setSize(0, 0).setPosition(
(0.81 * windowx / 3),
(1.9 * windowy / 3)).setFontSize(15).setFontAlign("left")
min_rpm_spinner = ac.addSpinner(appWindow, "Min %RPM")
spinnerConfig(min_rpm_spinner, 0, 125, 80, 20, 0, 1, 100, 80, setMinRPM, 0)
max_rpm_spinner = ac.addSpinner(appWindow, "Max %RPM")
spinnerConfig(max_rpm_spinner, 100, 125, 80, 20, 90, 1, 100, 97, setMaxRPM,
0)
units_spinner = ac.addSpinner(appWindow, "Units")
spinnerConfig(units_spinner, 200, 125, 80, 20, 1, 1, 2, 1, setUnits, 0)
settings_box = ac.addCheckBox(appWindow, "")
ac.setPosition(settings_box, 950, 95)
ac.setSize(settings_box, 10, 10)
ac.addOnCheckBoxChanged(settings_box, toggle_settings_visiblity)
return "RevHunterSkunkworks"
def acMain(ac_version):
global appWindow, timeLabel
appWindow=ac.newApp("Time")
ac.setTitle(appWindow,"Time")
ac.setSize(appWindow,160,60)
ac.drawBorder(appWindow,0)
ac.setBackgroundOpacity(appWindow,0)
theTime=datetime.now()
timeLabel=ac.addLabel(appWindow, "{}".format(theTime.strftime("%H:%M")))
ac.setPosition(timeLabel,70,30)
ac.addRenderCallback(appWindow , onFormRender)
return "Time"
def acMain(ac_version):
global fuelUsage
appWindow = ac.newApp("Fuel Usage")
ac.drawBackground(appWindow, background)
ac.drawBorder(appWindow, background)
ac.setBackgroundOpacity(appWindow, background)
ac.setSize(appWindow, x_app_size, y_app_size)
fuelUsage = Fuel_Usage(appWindow, x_start, y_start)
ac.addRenderCallback(appWindow, onFormRender)
ac.log("Fuel Usage App loaded")
return "Fuel Usage App"
def __init__(self, name, tyre=None, render_function=None):
self.window = ac.newApp(name)
self.tyre = tyre
ac.setIconPosition(self.window, 9999999, 99999999) # hide the icon
ac.setSize(self.window, TyreWindow.width, TyreWindow.height)
self.opt_label = ac.addLabel(self.window, "Opt:")
ac.setPosition(self.opt_label, 5, 50)
self.slip_label = ac.addLabel(self.window, "Slip:\nSkid:")
ac.setPosition(self.slip_label, 5, 70)
self.starting_label_no = ac.addLabel(self.window, "")
ac.addRenderCallback(self.window, render_function)
ac.setFontSize(self.starting_label_no, 25)
ac.setPosition(self.starting_label_no, 35, 20)
def acMain(ac_version):
# DEBUG
t = threading.Thread(target=pyroserver)
t.daemon = True
t.start()
try:
deltabar_data.app_id = ac.newApp('deltabar')
ac.addRenderCallback(deltabar_data.app_id, onRender)
return deltabar_lib.deltabar_lib.deltabar_app.acMain(ac_version)
except:
log_error()
raise
def acMain(ac_version):
# DEBUG
t = threading.Thread(target=pyroserver)
t.daemon = True
t.start()
try:
hot_app_data.app_id = ac.newApp('hot_app')
ac.addRenderCallback(hot_app_data.app_id, onRender)
return hot_app_lib.hot_app_lib.my_hot_app.acMain(ac_version)
except:
log_error()
raise
def acMain(ac_version):
# DEBUG
t = threading.Thread(target=pyroserver)
t.daemon = True
t.start()
try:
hot_app_data.app_id = ac.newApp('hot_app')
ac.addRenderCallback(hot_app_data.app_id, onRender)
return hot_app_lib.hot_app_lib.my_hot_app.acMain(ac_version)
except:
log_error()
raise
def acMain(ac_version): #----------------------------- App window Init
# Don't forget to put anything you'll need to update later as a global variables
global appWindow # <- you'll need to update your window in other functions.
appWindow = ac.newApp(appName)
ac.setTitle(appWindow, appName)
ac.setSize(appWindow, width, height)
ac.addRenderCallback(
appWindow,
appGL) # -> links this app's window to an OpenGL render function
return appName
def init():
"""Add the info window/app."""
global info_telemetry
window_info = ac.newApp("Info")
ac.setSize(window_info, 160, 205)
ac.addRenderCallback(window_info, render_app)
info_telemetry = TelemetryProvider()
compound_label = CompoundLabel(info_telemetry)
optimum_temps_label = OptimumTempsLabel(info_telemetry)
abs_label = ABSLabel(info_telemetry)
tc_label = TractionControlLabel(info_telemetry)
lateral_force_label = LateralForceLabel(info_telemetry)
transverse_force_label = TransverseForceLabel(info_telemetry)
drs_image_label = DRSImageLabel(info_telemetry)
abs_image_label = ABSImageLabel(info_telemetry)
tc_image_label = TCImageLabel(info_telemetry)
background_label = BackgroundLabel()
for label in (compound_label, optimum_temps_label, abs_label, tc_label,
lateral_force_label, transverse_force_label, drs_image_label,
abs_image_label, tc_image_label, background_label):
label.window = window_info
# Prepei na mpei teleytaio gia na fortwnei meta to prasino eikonidio gia na
# kratietai to diafano...
car_name = ac.getCarName(0)
car_upgrade = ''
if car_name.endswith(('_s1', '_s2', '_s3', '_drift', '_dtm')):
car_upgrade = car_name.split('_')[-1]
car_upgrade_img_path = os.path.join(
APP_DIR, "Images/Info{}.png".format(car_upgrade or 'STD'))
background_label.bg_texture = car_upgrade_img_path
image_arrow_left = LeftLateralForceImage(
info_telemetry, pos_x=131, pos_y=147, width=20, height=20,
color=(1, 1, 0, 1), filename='arrowLeft.png')
image_arrow_right = RightLateralForceImage(
info_telemetry, pos_x=132, pos_y=147, width=20, height=20,
color=(1, 1, 0, 1), filename='arrowRight.png')
image_arrow_up = PositiveTransverseForceImage(
info_telemetry, pos_x=104, pos_y=119, width=20, height=20,
color=(1, 1, 0, 1), filename='arrowUp.png')
image_arrow_down = NegativeTransverseForceImage(
info_telemetry, pos_x=104, pos_y=120, width=20, height=20,
color=(1, 1, 0, 1), filename='arrowDown.png')
def acMain(ac_version):
global app_speedometer, speedometer
app_name = "ACRM"
x = 200
y = 200
w = 450
h = 300
# Speedometer
app_speedometer = gui.App(app_name, x, y, w, h)
speedometer = gui.Speedometer(app_speedometer.app, w, h)
app_speedometer.children.append(speedometer)
ac.addRenderCallback(app_speedometer.app, glRender)
return app_name
def acMain(ac_version):
"""Main function that is invoked by Assetto Corsa."""
global app_window
app_window = ac.newApp("")
ac.setSize(app_window, 343, 78)
ac.drawBorder(app_window, 0)
app_dir = os.path.dirname(os.path.realpath(__file__))
ac.setBackgroundTexture(app_window, app_dir + "/Images/Dashboard.png")
ac.addRenderCallback(app_window, render_app)
CAR.name = ac.getCarName(0)
dashboard_elements.init(MAIN_APP_TELEMETRY, app_window, CAR.name)
tyre_apps.init(MAIN_APP_TELEMETRY)
info_app.init()
threading.Thread(target=read_static_shared_memory).start()
return "AC Dashboard"
def acMain(ac_version):
"""Run upon startup of Assetto Corsa.
Args:
ac_version (str): Version of Assetto Corsa.
AC passes this argument automatically.
"""
# Read config
global cfg
cfg = Config()
# Initialize session data object
global session
session = Session(cfg)
# Set up app window
global app_window
app_window = AppWindow(cfg)
ac.addRenderCallback(app_window.id, app_render)
# Initialize fonts
ac.initFont(0, 'ACRoboto300', 0, 0)
ac.initFont(0, 'ACRoboto700', 0, 0)
# Set up labels
global label_speed, label_gear
label_speed = ACLabel(app_window.id, font='ACRoboto300', alignment='center')
label_speed.fit_height(
Point(cfg.app_width * 0.5,
cfg.app_height * cfg.app_padding),
cfg.app_scale * 100)
# Speed unit selection
if cfg.use_kmh:
label_speed.set_postfix(" km/h")
else:
label_speed.set_postfix(" mph")
label_gear = ACLabel(app_window.id, font='ACRoboto700', alignment='center')
label_gear.fit_height(
Point(cfg.app_width * 0.5,
cfg.app_scale * 200),
cfg.app_scale * 250)
def acMain(ac_version):
global appWindow, flag_textures
# Initialise app
appWindow = ac.newApp(APP_NAME)
ac.setSize(appWindow, WINDOW_WIDTH, WINDOW_HEIGHT)
ac.setIconPosition(appWindow, 0, -999999)
ac.setTitle(appWindow, " ")
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, NO_FLAG_BACKGROUND_OPACITY)
ac.addRenderCallback(appWindow, onWindowRender)
# Load flag textures
flag_textures = {
flag_value: ac.newTexture(TEXTURE_DIR + flag.texture)
for flag_value, flag in FLAGS.items()
}
return APP_NAME
def acMain(ac_version):
try:
global appHeight, appWidth, appWindow, flLabel, frLabel, rlLabel, rrLabel, upperDistance, distanceFromLeft, tyreWidth, tyreHeight
distanceFromLeft = tyreWidth * 3
upperDistance = distanceFromLeft
appWindow = ac.newApp("Traction Loss")
appWidth = distanceFromLeft * 2 + tyreWidth * 3
appHeight = upperDistance * 2 + tyreHeight * 3
ac.setSize(appWindow, appWidth, appHeight)
define_tachometer()
if debug:
create_debug_labels()
#ac.drawBorder(appWindow, 0)
ac.addRenderCallback(appWindow, on_update)
return "Traction Loss"
except Exception as e:
ac.console("TractionLoss: Error in function acMain(): %s" % e)
ac.log("TractionLoss: Error in function acMain(): %s" % e)
def acMain(ac_version):
global appWindow, appName, logPrefix, flag1Label, flag2Label, flag3Label
global cfg_flag1Image
global cfg_flag2Image
global cfg_flag3Image
global cfg_flagWidth, cfg_flagHeight
ac.console(logPrefix + "acMain")
try:
appWindow = ac.newApp(appName)
ac.setTitle(appWindow, "")
ac.setIconPosition(appWindow, -7000, -3000)
ac.setSize(appWindow, cfg_flagWidth, cfg_flagHeight + 30)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
flag1Label = ac.addLabel(appWindow, "")
ac.setPosition(flag1Label, 0, 30)
ac.setSize(flag1Label, cfg_flagWidth, cfg_flagHeight)
ac.setBackgroundTexture(flag1Label, cfg_flag1Image)
ac.setVisible(flag1Label, 0)
flag2Label = ac.addLabel(appWindow, "")
ac.setPosition(flag2Label, 0, 30)
ac.setSize(flag2Label, cfg_flagWidth, cfg_flagHeight)
ac.setBackgroundTexture(flag2Label, cfg_flag2Image)
ac.setVisible(flag2Label, 0)
flag3Label = ac.addLabel(appWindow, "")
ac.setPosition(flag3Label, 0, 30)
ac.setSize(flag3Label, cfg_flagWidth, cfg_flagHeight)
ac.setBackgroundTexture(flag3Label, cfg_flag3Image)
ac.setVisible(flag3Label, 0)
ac.addRenderCallback(appWindow, onRender)
ac.console(logPrefix + "Initialized")
except:
ac.console(logPrefix + "Initialize failed:", sys.exc_info()[0])
return appName
def acMain(ac_version):
global appWindow, carCount, playerModule1, cars
ac.log("trainingHelper - start")
ac.console("trainingHelper - start")
appWindow = ac.newApp("Training Helper")
ac.setSize(appWindow, 400, 400)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
ac.setFontSize(appWindow, 15)
generalData = getGeneralData()
carCount = generalData['carCount']
playerModule1 = Module1(
appWindow,
generalData['trackName'] + generalData['trackConfiguration'], carCount)
for i in range(carCount):
playerData = getGeneralDataForCar(i)
car = Car(playerData['carName'], playerData['driverName'], i)
cars.append(car)
#ac.log(playerData['carName'])
#ac.setText(playerModule1.labelCarName, "{0}".format(playerData['carName']))
ac.addRenderCallback(appWindow, onFormRender)
return "Training Helper"
def acMain(ac_version):
global rpm_display, boost_display, gear_display, speed_display, fuel_display
global min_rpm_spinner_Label, min_rpm_spinner, max_rpm_spinner_Label, max_rpm_spinner, settings_box_Label
global units_spinner_Label, units_spinner
global rpm_tag, speed_tag, boost_tag, fuel_tag
appWindow=ac.newApp("RevHunterSkunkworks")
ac.setTitle(appWindow, " ")
ac.setSize(appWindow,windowx,windowy)
ac.drawBorder(appWindow,0)
ac.setBackgroundOpacity(appWindow,0)
ac.addRenderCallback(appWindow, onFormRender)
rpm_display = Label(appWindow, "").setSize(0,0).setPosition((2.05*windowx/3),(1.05*windowy/3)).setFontSize(50).setFontAlign("right")
gear_display = Label(appWindow).setSize(0,0).setPosition((windowx / 2),-50).setFontSize(140).setFontAlign("center")
speed_display= Label(appWindow, "").setSize(0,0).setPosition((1.25*windowx/3),(1.05*windowy/3)).setFontSize(50).setFontAlign("right")
fuel_display = Label(appWindow, "").setSize(0,0).setPosition((0.8*windowx/3),(1.25*windowy/3)).setFontSize(35).setFontAlign("right")
settings_box_Label = Label(appWindow, "").setSize(0,0).setPosition(940,83).setFontSize(15).setFontAlign("left")
rpm_tag = Label(appWindow, "").setText("RPM").setSize(0,0).setPosition((2.06*windowx/3),(2.1*windowy/3)).setFontSize(15).setFontAlign("left")
speed_tag=Label(appWindow, "").setText("MPH").setSize(0,0).setPosition((1.26*windowx/3),(2.1*windowy/3)).setFontSize(15).setFontAlign("left")
fuel_tag = Label(appWindow, "").setText("%FUEL").setSize(0,0).setPosition((0.81*windowx/3),(1.9*windowy/3)).setFontSize(15).setFontAlign("left")
min_rpm_spinner = ac.addSpinner(appWindow, "Min %RPM")
spinnerConfig(min_rpm_spinner,0,125,80,20,0,1,100,80,setMinRPM,0)
max_rpm_spinner = ac.addSpinner(appWindow, "Max %RPM")
spinnerConfig(max_rpm_spinner,100,125,80,20,90,1,100,97,setMaxRPM,0)
units_spinner = ac.addSpinner(appWindow, "Units")
spinnerConfig(units_spinner,200,125,80,20,1,1,2,1,setUnits,0)
settings_box = ac.addCheckBox(appWindow, "")
ac.setPosition(settings_box,950,95)
ac.setSize(settings_box,10,10)
ac.addOnCheckBoxChanged(settings_box,toggle_settings_visiblity)
return "RevHunterSkunkworks"
def acMain(ac_version):
import time
global appWindow, hSession, dbgLabel, texture_radar, texture_indicator_left, texture_indicator_right, z
ac.log("helipicapew::acMain Start {}".format(time.localtime(time.time())))
try:
import helipicapewconfig
helipicapewconfig.handleIni('helipicapew')
z = helipicapewcar.guiZoomFactor
appWindow = ac.newApp("helipicapew")
ac.setSize(appWindow, 200 * z, 200 * z)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
ac.setTitle(appWindow, "helipicapew v{}".format(version))
ac.addRenderCallback(appWindow, onFormRender)
ac.addOnAppActivatedListener(appWindow, onAppActivated)
appWindowActivated = time.clock()
showWindowTitle = True
dbgLabel = ac.addLabel(appWindow, "")
ac.setPosition(dbgLabel, 15, 405)
texture_radar = ac.newTexture("apps/python/helipicapew/img/radar.png")
texture_indicator_left = ac.newTexture(
"apps/python/helipicapew/img/indicatorL.png")
texture_indicator_right = ac.newTexture(
"apps/python/helipicapew/img/indicatorR.png")
hSession = helipicapewsession.HeliPicaPewSession()
ac.log("helipicapew::acMain finished")
except Exception as e:
ac.log("helipicapew::acMain() %s" % e)
return "helipicapew"
def acMain(ac_version):
global TYREINFO, optimal_spinner_id, optimal_spinner_shown
appWindow = ac.newApp("Tyre Temperatures")
ac.drawBackground(appWindow, background)
ac.drawBorder(appWindow, background)
ac.setBackgroundOpacity(appWindow, background)
ac.setSize(appWindow, x_app_size, y_app_size)
TYREINFO = Tyre_Info(appWindow, x_start, y_start)
ac.addRenderCallback(appWindow, onFormRender)
TYREINFO.optimal_temp = d_optimal_temp
TYREINFO.carinifilepath = inidir + getValidFileName(
ac.getCarName(0)) + ".ini"
TYREINFO.needwriteini = 1
if os.path.exists(TYREINFO.carinifilepath):
f = open(TYREINFO.carinifilepath, "r")
TYREINFO.optimal_temp = int(f.readline()[8:])
f.close()
TYREINFO.needwriteini = 0
optimal_spinner_id = ac.addSpinner(appWindow, "optimal")
ac.setPosition(optimal_spinner_id, 0, y_app_size + 28)
ac.setStep(optimal_spinner_id, 1)
if inFahrenheit:
ac.setRange(optimal_spinner_id, int(CelsiusToFahrenheit(50)),
int(CelsiusToFahrenheit(150)))
ac.setValue(optimal_spinner_id,
int(CelsiusToFahrenheit(TYREINFO.optimal_temp)))
else:
ac.setRange(optimal_spinner_id, 50, 150)
ac.setValue(optimal_spinner_id, TYREINFO.optimal_temp)
ac.addOnValueChangeListener(optimal_spinner_id, onValueChanged)
optimal_spinner_shown = 1
ac.log("Danny Giusa Tyre Temperatures loaded")
return "Danny Giusa Tyre Temperatures"
def render_callback(self, render_callback):
self._render_callback = render_callback
if self._ac_obj is not None:
ac.addRenderCallback(self._ac_obj, self._render_callback)
def setRenderCallback(self, callback):
self._callback = callback
ac.addRenderCallback(self.ac_obj, callback)
def onRenderCallback(self, func): ac.addRenderCallback(self.app, func) return self
def acMain(ac_version):
global imperial, debug_mode, window_x_pos, window_y_pos, tyre_mon_xpos, tyre_mon_ypos
global gear_color, gear_background, speed_color, speed_background, throttle_gauge_color, brake_gauge_color, clutch_gauge_color, boost_bar_color, fuel_bar_color
global draw_digital_speedo, draw_shift_light, draw_gear_indicator, draw_speedometer, draw_tachometer, draw_odometer, draw_g_meter, draw_boost_gauge
global draw_fuel_gauge, draw_throttle_gauge, draw_brake_gauge, draw_clutch_gauge, draw_tyre_monitor, draw_background
global tach_needle_end, speedo_needle_end, tach_radius, speedo_radius, rpm_pivot_y, speed_pivot_y, rpm_pivot_x, speed_pivot_x, speedo_tl_x, speedo_tl_y
global speedo_total_width, speedo_total_height
global tach_redline_color, tach_bigline_color, tach_smallline_color, tach_needle_color1
global speedo_bigline_color, speedo_smallline_color, speedo_needle_color1
global throttle_gauge_inner_radius, throttle_gauge_outer_radius, throttle_gauge_min_y, throttle_gauge_max_y
global brake_gauge_inner_radius, brake_gauge_outer_radius, brake_gauge_min_y, brake_gauge_max_y
global clutch_gauge_inner_radius, clutch_gauge_outer_radius, clutch_gauge_min_y, clutch_gauge_max_y
global throttle_gauge_root_x, throttle_gauge_root_y
global brake_gauge_root_x, brake_gauge_root_y
global clutch_gauge_root_x, clutch_gauge_root_y
global throttle_gauge_right, brake_gauge_right, clutch_gauge_right
global boost_radius, fuel_radius, boost_pivot_y, fuel_pivot_y, boost_pivot_x, fuel_pivot_x, boost_needle_end, fuel_needle_end, boost_needle_color, fuel_needle_color
global odometer_fg, odometer_bg, g_meter_range, g_meter_x_anchor, g_meter_y_anchor, g_meter_opacity, window_width, window_height, background_image_path, background_image_path_noboost
global tyre_monitor_opacity, g_meter_opacity
global window, debug_label, indicated_max_rpm
global flt_label1, frt_label1, rlt_label1, rrt_label1
global flt_label2, frt_label2, rlt_label2, rrt_label2
global fuel_warning_label
global config
global telemetry_client
global draw_abs_status, draw_tcs_status, abs_label, abs_off_label, tcs_label, tcs_off_label
global gear_x, gear_y, shift_light_x, shift_light_y, shift_light_radius, gear_width, gear_height
global tach_min_angle, tach_max_angle, speedo_min_angle, speedo_max_angle
global shift_light_on_color, shift_light_off_color
global rpms_file
config_file = configparser.ConfigParser()
config_file.read('apps/python/AnalogInstruments/settings.ini')
config = config_file[config_file['settings']['theme']]
rpms_file = configparser.ConfigParser()
rpms_file.read('apps/python/AnalogInstruments/rpms.ini')
# SETTINGS #
# Change this to 'True' to have speed measured in MPH
imperial = config.getboolean('imperial')
# Debug mode (basically just some numbers)
debug_mode = config.getboolean('debug_mode')
# Main window positions, change those if you're not using a single monitor 1080p setup
window_x_pos = int(config['window_x_pos'])# (Your horz. res-1320)/2
window_y_pos = int(config['window_y_pos']) # Your vert. res - 250
# These are relative to the window's position
tyre_mon_xpos = int(config['tyre_mon_x_pos'])# 20 px from the left on single mon 1080p
tyre_mon_ypos = int(config['tyre_mon_y_pos'])# 920 px from the top
# Color settings
gear_color = parse_color(config['gear_color'])
gear_background = parse_color(config['gear_background'])
speed_color = parse_color(config['digi_speedo_color'])
speed_background = parse_color(config['digi_speedo_background'])
throttle_gauge_color = parse_color(config['throttle_gauge_color'])
brake_gauge_color = parse_color(config['brake_gauge_color'])
clutch_gauge_color = parse_color(config['clutch_gauge_color'])
boost_bar_color = parse_color(config['boost_bar_color'])
fuel_bar_color = parse_color(config['fuel_bar_color'])
shift_light_on_color = parse_color(config['shift_light_on_color'])
shift_light_off_color = parse_color(config['shift_light_off_color'])
# Some more settings, hopefully pretty self-explanatory
draw_digital_speedo = config.getboolean('draw_digital_speedo')
draw_shift_light = config.getboolean('draw_shift_light')
draw_gear_indicator = config.getboolean('draw_gear_indicator')
draw_speedometer = config.getboolean('draw_speedometer')
draw_tachometer = config.getboolean('draw_tachometer')
draw_odometer = config.getboolean('draw_odometer')
draw_g_meter = config.getboolean('draw_g_meter')
draw_boost_gauge = config.getboolean('draw_boost_gauge')
draw_fuel_gauge = config.getboolean('draw_fuel_gauge')
draw_throttle_gauge = config.getboolean('draw_throttle_gauge')
draw_brake_gauge = config.getboolean('draw_brake_gauge')
draw_clutch_gauge = config.getboolean('draw_clutch_gauge')
draw_tyre_monitor = config.getboolean('draw_tyre_monitor')
draw_background = config.getboolean('draw_background')
draw_abs_status = config.getboolean('draw_abs_status')
draw_tcs_status = config.getboolean('draw_tcs_status')
# Dimensions of things, mess with those at your own risk
tach_needle_end = int(config['tach_needle_end'])
speedo_needle_end = int(config['speedo_needle_end'])
tach_radius = int(config['tach_radius'])
speedo_radius = int(config['speedo_radius'])
rpm_pivot_y = int(config['tach_y_anchor'])
speed_pivot_y = int(config['speedo_y_anchor'])
rpm_pivot_x = int(config['tach_x_anchor'])
speed_pivot_x = int(config['speedo_x_anchor'])
speedo_tl_x = int(config['digi_speedo_x'])
speedo_tl_y = int(config['digi_speedo_y'])
speedo_total_width = int(config['digi_speedo_width'])
speedo_total_height = int(config['digi_speedo_height'])
tach_min_angle = int(config['tach_min_angle'])
tach_max_angle = int(config['tach_max_angle'])
speedo_min_angle = int(config['speedo_min_angle'])
speedo_max_angle = int(config['speedo_max_angle'])
tach_redline_color = parse_color(config['tach_redline_color'])
tach_bigline_color = parse_color(config['tach_bigline_color'])
tach_smallline_color = parse_color(config['tach_smallline_color'])
tach_needle_color1 = parse_color(config['tach_needle_color1'])
speedo_bigline_color = parse_color(config['speedo_bigline_color'])
speedo_smallline_color = parse_color(config['speedo_smallline_color'])
speedo_needle_color1 = parse_color(config['speedo_needle_color1'])
# G-Meter: 500-820
# Brake/Throttle Max Y: 70 Min: 160
throttle_gauge_inner_radius = int(config['throttle_gauge_inner_radius'])
throttle_gauge_outer_radius = int(config['throttle_gauge_outer_radius'])
throttle_gauge_min_y = int(config['throttle_gauge_min_y'])
throttle_gauge_max_y = int(config['throttle_gauge_max_y'])
throttle_gauge_root_x = int(config['throttle_gauge_root_x'])
throttle_gauge_root_y = int(config['throttle_gauge_root_y'])
throttle_gauge_right = config.getboolean('throttle_gauge_right')
brake_gauge_inner_radius = int(config['brake_gauge_inner_radius'])
brake_gauge_outer_radius = int(config['brake_gauge_outer_radius'])
brake_gauge_min_y = int(config['brake_gauge_min_y'])
brake_gauge_max_y = int(config['brake_gauge_max_y'])
brake_gauge_root_x = int(config['brake_gauge_root_x'])
brake_gauge_root_y = int(config['brake_gauge_root_y'])
brake_gauge_right = config.getboolean('brake_gauge_right')
clutch_gauge_inner_radius = int(config['clutch_gauge_inner_radius'])
clutch_gauge_outer_radius = int(config['clutch_gauge_outer_radius'])
clutch_gauge_min_y = int(config['clutch_gauge_min_y'])
clutch_gauge_max_y = int(config['clutch_gauge_max_y'])
clutch_gauge_root_x = int(config['clutch_gauge_root_x'])
clutch_gauge_root_y = int(config['clutch_gauge_root_y'])
clutch_gauge_right = config.getboolean('clutch_gauge_right')
boost_radius = int(config['boost_radius'])
fuel_radius = int(config['fuel_radius'])
boost_pivot_y = int(config['boost_y_anchor'])
fuel_pivot_y = int(config['fuel_y_anchor'])
boost_pivot_x = int(config['boost_x_anchor'])
fuel_pivot_x = int(config['fuel_x_anchor'])
boost_needle_end = int(config['boost_needle_end'])
fuel_needle_end = int(config['fuel_needle_end'])
boost_needle_color = parse_color(config['boost_needle_color'])
fuel_needle_color = parse_color(config['fuel_needle_color'])
odometer_fg = parse_color(config['odometer_foreground'])
odometer_bg = parse_color(config['odometer_background'])
tyre_monitor_opacity = float(config['tyre_monitor_opacity'])
g_meter_range = int(config['g_meter_range'])
g_meter_x_anchor = int(config['g_meter_x_anchor'])
g_meter_y_anchor = int(config['g_meter_y_anchor'])
g_meter_opacity = float(config['g_meter_opacity'])
gear_x = int(config['gear_x'])
gear_y = int(config['gear_y'])
gear_width = int(config['gear_width'])
gear_height = int(config['gear_height'])
shift_light_x = int(config['shift_light_x'])
shift_light_y = int(config['shift_light_y'])
shift_light_radius = int(config['shift_light_radius'])
# Kind of configurable but you'll have change most of the dimensions above so not recommended
window_width = int(config['window_width'])
window_height = int(config['window_height'])
background_image_path = config['background_path']
background_image_path_noboost = config['background_noboost_path']
abs_img = config['abs_img']
abs_off_img = config['abs_off_img']
tcs_img = config['tcs_img']
tcs_off_img = config['tcs_off_img']
window = ac.newApp("AnalogInstruments")
ac.setTitle(window," ")
ac.setBackgroundOpacity(window,0)
ac.drawBorder(window,0)
ac.setIconPosition(window,0,-10000)
if draw_background:
ac.drawBackground(window,1)
ac.setBackgroundTexture(window,background_image_path)
ac.setSize(window,window_width,window_height)
ac.setPosition(window,window_x_pos,window_y_pos)
debug_label = ac.addLabel(window,"")
ac.setPosition(debug_label,20,window_height/10*9)
ac.addRenderCallback(window,onWindowRender)
# Setting up the tyre monitor labels (this can be done here because it doesn't depend on any car info)
if draw_tyre_monitor:
flt_label1 = ac.addLabel(window," ")
ac.setPosition(flt_label1,tyre_mon_xpos+37,tyre_mon_ypos+5)
flt_label2 = ac.addLabel(window," ")
ac.setPosition(flt_label2,tyre_mon_xpos+37,tyre_mon_ypos+37)
frt_label1 = ac.addLabel(window," ")
ac.setPosition(frt_label1,tyre_mon_xpos+117,tyre_mon_ypos+5)
frt_label2 = ac.addLabel(window," ")
ac.setPosition(frt_label2,tyre_mon_xpos+117,tyre_mon_ypos+37)
rlt_label1 = ac.addLabel(window," ")
ac.setPosition(rlt_label1,tyre_mon_xpos+37,tyre_mon_ypos+101)
rlt_label2 = ac.addLabel(window," ")
ac.setPosition(rlt_label2,tyre_mon_xpos+37,tyre_mon_ypos+133)
rrt_label1 = ac.addLabel(window," ")
ac.setPosition(rrt_label1,tyre_mon_xpos+117,tyre_mon_ypos+101)
rrt_label2 = ac.addLabel(window," ")
ac.setPosition(rrt_label2,tyre_mon_xpos+117,tyre_mon_ypos+133)
if draw_fuel_gauge:
fuel_warning_label = ac.addLabel(window,"")
ac.setSize(fuel_warning_label,12,14)
ac.setPosition(fuel_warning_label,fuel_pivot_x - 6,fuel_pivot_y - 30)
ac.setBackgroundTexture(fuel_warning_label,fuel_icon_warning_path)
if draw_abs_status:
abs_label = ac.addLabel(window,"")
ac.setSize(abs_label,window_width,window_height)
ac.setPosition(abs_label,0,0)
ac.setBackgroundTexture(abs_label,abs_img)
abs_off_label = ac.addLabel(window,"")
ac.setSize(abs_off_label,window_width,window_height)
ac.setPosition(abs_off_label,0,0)
ac.setBackgroundTexture(abs_off_label,abs_off_img)
if draw_tcs_status:
tcs_label = ac.addLabel(window,"")
ac.setSize(tcs_label,window_width,window_height)
ac.setPosition(tcs_label,0,0)
ac.setBackgroundTexture(tcs_label,tcs_img)
tcs_off_label = ac.addLabel(window,"")
ac.setSize(tcs_off_label,window_width,window_height)
ac.setPosition(tcs_off_label,0,0)
ac.setBackgroundTexture(tcs_off_label,tcs_off_img)
return "Analog Instruments"
def acMain(ac_version):
global appWindow, dbgLabel
global xyro_dev
global DebugInput, DebugInput2, DebugInput3
global BtnStart, BtnStop
try:
import sam_secondz_xyro_config
sam_secondz_xyro_config.handleIni('3secondz_xyro')
ac.log("3secondz_xyro:: xyro created")
xyro_dev = xyrodevice.XyroDevice(UDP_IP, UDP_PORT, DEVICE_ID,
FW_VERSION, STEERING_ANGLE_RANGE,
ALIVE_PACKET_PERIOD,
CAN_PACKET_PERIOD, NAV_PACKET_PERIOD,
MEAS_PACKET_PERIOD)
appWindow = ac.newApp("3secondz_xyro")
ac.setSize(appWindow, 300, 100)
ac.drawBorder(appWindow, 0)
ac.setBackgroundOpacity(appWindow, 0)
ac.setTitle(appWindow, '3secondz_xyro')
IPAddrInput = ac.addTextInput(appWindow, "TEXT_INPUT")
ac.setPosition(IPAddrInput, 10, 30)
ac.setSize(IPAddrInput, 120, 20)
ac.setText(IPAddrInput, str(UDP_IP))
PortInput = ac.addTextInput(appWindow, "TEXT_INPUT")
ac.setPosition(PortInput, 140, 30)
ac.setSize(PortInput, 50, 20)
ac.setText(PortInput, str(UDP_PORT))
DebugInput = ac.addTextInput(appWindow, "TEXT_INPUT")
ac.setPosition(DebugInput, 10, 60)
ac.setSize(DebugInput, 280, 20)
ac.setText(DebugInput, "")
DebugInput2 = ac.addTextInput(appWindow, "TEXT_INPUT")
ac.setPosition(DebugInput2, 10, 90)
ac.setSize(DebugInput2, 280, 20)
ac.setText(DebugInput2, "")
DebugInput3 = ac.addTextInput(appWindow, "TEXT_INPUT")
ac.setPosition(DebugInput3, 10, 120)
ac.setSize(DebugInput3, 280, 20)
ac.setText(DebugInput3, "")
BtnStart = ac.addButton(appWindow, "Start")
ac.setPosition(BtnStart, 10, 150)
ac.setSize(BtnStart, 90, 20)
ac.addOnClickedListener(BtnStart, onClickBtnStart)
BtnStop = ac.addButton(appWindow, "Stop")
ac.setPosition(BtnStop, 110, 150)
ac.setSize(BtnStop, 90, 20)
ac.addOnClickedListener(BtnStop, onClickBtnStop)
ac.addRenderCallback(appWindow, onFormRender)
ac.addOnAppActivatedListener(appWindow, onAppActivated)
appWindowActivated = time.clock()
showWindowTitle = True
dbgLabel = ac.addLabel(appWindow, "")
ac.setPosition(dbgLabel, 15, 405)
#xyro_dev.turnOn()
ac.log("3secondz_xyro::acMain finished")
except Exception as e:
ac.log("3secondz_xyro::acMain() %s" % e)
return "3secondz_xyro"
def setup(self):
ac.addRenderCallback(self.appWindow, onRender)
ac.setSize(self.appWindow,333,70)
ac.drawBorder(self.appWindow,0)
def render_callback(self, render_callback: callable):
self._render_callback = render_callback
if self.has_id:
ac.addRenderCallback(self.id, render_callback)
def acMain(ac_version: str) -> None:
""" Initiates the program. """
global ACD_OBJ
global CONFIGS
global LT_VERSION
log("Starting Live Telemetry {} on AC Python API version {}...".format(
LT_VERSION, ac_version))
log("Loading configs...")
CONFIGS = Config(LT_VERSION)
log("Loading {} info...".format(ac.getCarName(0)))
ACD_OBJ = ACD("content/cars/{}".format(ac.getCarName(0)))
log("Loaded correctly")
log("Loading options window...")
global OPTIONS_INFO
OPTIONS_INFO = OptionsInfo(CONFIGS)
ac.addOnClickedListener(
OPTIONS_INFO.get_button_id("Camber"), on_click_camber)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id("Dirt"), on_click_dirt)
ac.addOnClickedListener(
OPTIONS_INFO.get_button_id("Height"), on_click_height)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id("Load"), on_click_load)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id("Lock"), on_click_lock)
ac.addOnClickedListener(
OPTIONS_INFO.get_button_id("Logging"), on_click_logging)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id(
"Pressure"), on_click_pressure)
ac.addOnClickedListener(
OPTIONS_INFO.get_button_id("RPMPower"), on_click_rpm)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id("Size"), on_click_size)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id(
"Suspension"), on_click_suspension)
ac.addOnClickedListener(
OPTIONS_INFO.get_button_id("Temps"), on_click_temps)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id("Tire"), on_click_tire)
ac.addOnClickedListener(OPTIONS_INFO.get_button_id("Wear"), on_click_wear)
log("Loading engine window...")
global ENGINE_INFO
ENGINE_INFO = EngineInfo(ACD_OBJ, CONFIGS)
window_id = ENGINE_INFO.get_window_id()
ac.addOnAppActivatedListener(window_id, on_activation)
ac.addOnAppDismissedListener(window_id, on_dismiss)
ac.addRenderCallback(ENGINE_INFO.get_window_id(), on_render_engine)
log("Loading wheel windows...")
global WHEEL_INFOS
for index in range(4):
info = WheelInfo(ACD_OBJ, CONFIGS, index)
window_id = info.get_window_id()
ac.addOnAppActivatedListener(window_id, on_activation)
ac.addOnAppDismissedListener(window_id, on_dismiss)
WHEEL_INFOS[info.get_id()] = info
ac.addRenderCallback(WHEEL_INFOS["FL"].get_window_id(), on_render_fl)
ac.addRenderCallback(WHEEL_INFOS["FR"].get_window_id(), on_render_fr)
ac.addRenderCallback(WHEEL_INFOS["RL"].get_window_id(), on_render_rl)
ac.addRenderCallback(WHEEL_INFOS["RR"].get_window_id(), on_render_rr)
log("Live Telemetry started.")
return "Live Telemetry"
def _create_widget(self):
self.widget = ac.newApp('Racing Line')
ac.setSize(self.widget, app_size_x, app_size_y)
ac.addRenderCallback(self.widget, onFormRender)
