elitelighting/elitelights.py

# A standalone script to control lights according to events in Elite: Dangerous.
# Coded in two afternoons with lots of coffee by Katie.
# This is meant to be a personal project, so I didn't really bother with expandability and such.
# Perhaps I'll revisit this in the future and make it so it can be expended upon easier. Don't count on it.
#
# (C) Innovation Science 2022

try:
    import tinytuya
except ModuleNotFoundError:
    print("You MUST install tinytuya first.")
    print("pip install tinytuya OR python -m pip install tinytuya")
    exit()

import time
import random
import json
import os

Version = "0.1.1"

# Use the classes below to configure your lights.
# You MUST go through the following setup process: https://github.com/jasonacox/tinytuya#setup-wizard---getting-local-keys
class PortLight:
    # Actual light config.
    DeviceID: str =     "DEVICEID HERE"
    IP: str =           "BULB.IP.ADDRESS.HERE"
    LocalID: str =      "LOCALID HERE"
    # Color config. I've left it as my own preferences, but commented out the defaults as well.
    red: int =          230
    green: int =        100
    blue: int =         235

class StarboardLight:
    DeviceID: str =     "DEVICEID HERE"
    IP: str =           "BULB.IP.ADDRESS.HERE"
    LocalID: str =      "LOCALID HERE"
    red: int =          230
    green: int =        100
    blue: int =         235

class HazardLight:
    DeviceID: str =     "DEVICEID HERE"
    IP: str =           "BULB.IP.ADDRESS.HERE"
    LocalID: str =      "LOCALID HERE"
    red: int =          255
    green: int =        0
    blue: int =         0

# Below are the colors for the default hud colors. I'm estimating again, but it's close enough.
# red: int =            255
# green: int =          100
# blue: int =           0


# Elite Dangerous flags

#ED_Docked =                 0x0000000000000001
#ED_Landed =                 0x0000000000000002
#ED_LandingGearDown =        0x0000000000000004
#ED_ShieldsUp =              0x0000000000000008
#ED_Supercruise =            0x0000000000000010
#ED_FlightAssistOff =        0x0000000000000020
#ED_HardpointsDeployed =     0x0000000000000040
#ED_InWing =                 0x0000000000000080

#ED_LightsOn =               0x0000000000000100
#ED_CargoScoopDeployed =     0x0000000000000200
#ED_SilentRunning =          0x0000000000000400
#ED_ScoopingFuel =           0x0000000000000800
#ED_SRVHandbrake =           0x0000000000001000
#ED_SRVTurret =              0x0000000000002000
#ED_SRVTurretRetracted =     0x0000000000004000
#ED_SRVDriveAssist =         0x0000000000008000

#ED_FSDMassLocked =          0x0000000000010000
#ED_FSDCharging =            0x0000000000020000
#ED_FSDCooldown =            0x0000000000040000
#ED_LowFuel =                0x0000000000080000
#ED_OverHeating =            0x0000000000100000
#ED_HasLatLong =             0x0000000000200000
#ED_IsInDanger =             0x0000000000400000
#ED_BeingInterdicted =       0x0000000000800000

#ED_InMainShip =             0x0000000001000000
#ED_InFighter =              0x0000000002000000
#ED_InSRV =                  0x0000000004000000
#ED_HudInAnalysisMode =      0x0000000008000000
#ED_NightVision =            0x0000000010000000

# Status file stuff
# StatusDir will usually be: "C:\\Users\\{YOUR USERNAME HERE}\\Saved Games\\Frontier Developments\\Elite Dangerous"
StatusDir = "C:\\Users\\Sam\\Saved Games\\Frontier Developments\\Elite Dangerous"
CurrentLog = ""
StatusJSON = ""
StatusFlags = 0x00000000
StatusFlagsStr = ""

# Makes the infinate loop... loop.
ContinueFlag = True

# States
DoFlicker = False
DoHazards = False
LightsOn = True
LightsDim = False
LastHullHealth = 0
CurrentHullHealth = 0


# Initialize light variables and set version
port = tinytuya.BulbDevice(PortLight.DeviceID, PortLight.IP, PortLight.LocalID, dev_type="default")
starboard = tinytuya.BulbDevice(StarboardLight.DeviceID, StarboardLight.IP, StarboardLight.LocalID, dev_type="default")
hazards = tinytuya.BulbDevice(HazardLight.DeviceID, HazardLight.IP, HazardLight.LocalID, dev_type="default")

# Set Tuya versions
port.set_version(3.3)
starboard.set_version(3.3)
hazards.set_version(3.3)

def SetupLights(): # Initializes lights
    # Set light modes to color
    port.set_mode(mode='colour')
    starboard.set_mode(mode='colour')
    hazards.set_mode(mode='colour')

    # Turn on the lights
    port.turn_on()
    starboard.turn_on()
    hazards.turn_on()

    # Set light colors
    port.set_colour(PortLight.red, PortLight.green, PortLight.blue)
    starboard.set_colour(StarboardLight.red, StarboardLight.green, StarboardLight.blue)
    hazards.set_colour(HazardLight.red, HazardLight.green, HazardLight.blue)

    # Set light brightness (port and starboard are dim, whereas hazard is bright.)
    port.set_brightness_percentage(brightness=1)
    starboard.set_brightness_percentage(brightness=1)
    hazards.set_brightness_percentage(brightness=100)

    # Turn off hazard.
    hazards.turn_off()

def NormalLights(): # Returns lights to normal operation (used when exiting)
    # Change lights back to white mode.
    port.set_mode(mode='white')
    starboard.set_mode(mode='white')
    hazards.set_mode(mode='white')

    # Set brightness to full to blind the user.
    port.set_brightness_percentage(brightness=100)
    starboard.set_brightness_percentage(brightness=100)
    hazards.set_brightness_percentage(brightness=100)

def FlickerLights():
    # So far, I've made it so there are four types of flickers possible (0 being no flicker.)
    choices = [0, 1, 2, 3, 4]
    choice = random.choice(choices) # Randomly choose a flicker type
    flickertime = random.random()   # Randomly choose a flicker time (0 to 1 sec)

    # Welcome to if-else hell! I'm using python 3.9.6 so no pattern matching for me, and I don't care enough to deal with dictionaries.
    # If you would like to add more flicker patterns, add them here and add a new number to the choices list.
    if(choice==0):
        # Nothing happens.
        pass
    elif(choice==1):
        # Flicker port
        port.turn_off()
        time.sleep(flickertime)
        port.turn_on()
    elif(choice==2):
        # Flicker starboard
        starboard.turn_off()
        time.sleep(flickertime)
        starboard.turn_on()
    elif(choice==3):
        # Flicker both, port first
        port.turn_off()
        starboard.turn_off()
        time.sleep(flickertime)
        port.turn_on()
        starboard.turn_on()
    elif(choice==4):
        starboard.turn_off()
        port.turn_off()
        time.sleep(flickertime)
        starboard.turn_on()
        port.turn_on()
    else:
        print("How did we get here?")

def MainLightsOn(): # Turns main (port and starboard) lights on
    port.turn_on()
    starboard.turn_on()

def MainLightsOff(): # Turns main (port and starboard) lights off
    port.turn_off()
    starboard.turn_off()

def DimAllLights():  # Dims all lights. Used when FSD is charging to make it look like it's heavily loading the powerplant.
    port.set_brightness_percentage(brightness=0)
    starboard.set_brightness_percentage(brightness=0)
    hazards.set_brightness_percentage(brightness=80)

def LightsStandard(): # Standard brightness configuration for lights.
    port.set_brightness_percentage(brightness=1)
    starboard.set_brightness_percentage(brightness=1)
    hazards.set_brightness_percentage(brightness=100)

def HazardsOn():      # Turns the hazard light on
    hazards.turn_on()

def HazardsOff():     # Turns the hazard light off
    hazards.turn_off()

def ReloadFlags():    # Reloads Elite: Dangerous status flags and sets flicker, hazard on/off, lights on/off, and dimming variables for later processing
    global StatusDir
    global StatusJSON
    global StatusFlags
    global StatusFlagsStr
    global DoFlicker
    global DoHazards
    global LightsOn
    global LightsDim
    global ContinueFlag
    
    # Open the status file
    f = open(StatusDir + "\\Status.json", "r")
    try:
        StatusJSON = json.loads(f.read()) # Read the json from the Status.json file. 
    except:
        #print("JSONDecodeError in ReloadFlags(). Continuing.")
        pass # Sometimes it guffs up reading (JSONDecodeError), and I can't really fix this.
    else:                                               # This makes the logic below use the previous status flags if an exception is raised
        StatusFlags = "0x%8x" % StatusJSON["Flags"]     # Extrapolate the flags from the json file and make it a known length (8 hex digits)
    f.close() # Close Status.json

    try:
        StatusFlagsStr = str(StatusFlags)
        
        # Convert the ship state (3rd from right) byte (LightsOn, Cargo Scoop Deployed, Silent Running, Scooping Fuel)
        ShipStateByte = bin(int(StatusFlagsStr[-3]))[2:].zfill(4)
        ShipStateByteStr = str(ShipStateByte)

        # Convert the FSD (5th from right) byte (FSD MassLocked, FSD Charging, FSD Cooldown, Low Fuel (<25%))
        FSDByte = bin(int(StatusFlagsStr[-5]))[2:].zfill(4)
        FSDByteStr = str(FSDByte)
        
        # Convert the hazards (6th from right) byte (Overheating (>100%), Has Lat Long, IsInDanger, Being Interdicted)
        HazardByte = bin(int(StatusFlagsStr[-6]))[2:].zfill(4)
        HazardByteStr = str(HazardByte)
        
        # If you would like to add more effects to the lights, add them here.

        if(HazardByteStr[-1] == "1" or LastHullHealth > CurrentHullHealth):
            DoFlicker = True                                # Overheating and taking damage causes lights to flicker
        else:
            DoFlicker = False

        if(int(StatusFlagsStr[-6]) > 0):                    # If there's any hazard, hazard light is turned on
            DoHazards = True
        else:
            DoHazards = False
        
        if(ShipStateByteStr[-3] == "1"):                    # Port and starboard lights turn off when rigged for silent running
            LightsOn = False
        else:
            LightsOn = True

        if(FSDByteStr[-2] == "1"):                          # Lights dim when the FSD is charging
            LightsDim = True
        else:
            LightsDim = False
    except ValueError:
        print("ValueError! More than likely, Elite: Dangerous is closed. Exiting.")
        ContinueFlag = False
    #except IndexError:
    #    print("IndexError encountered in ReloadFlags. This may be recoverable. Continuing.")

def GetCurrentLog(): # Gets the most recent log file left by Elite: Dangerous.
    global StatusDir


    LogName = ""
    # Changes working dir to the saved games dir temporarily, remembering the original working dir
    OriginalDir = os.getcwd()
    os.chdir(StatusDir)
    StatusDirContents = sorted(os.listdir(StatusDir), key=os.path.getmtime) # Get and sort the "saved game" directory from newest first.
    os.chdir(OriginalDir)

    for f in reversed(StatusDirContents):
        if(f[-4:] == ".log"): # Search for the newest .log file.
            LogName = f   # We found the file!
            break
    
    print("Discovered current log file: " + f)
    
    return LogName # Return the newest log file.
    
def GetDamageStats(): # Extrapolates damage taken from the log file. I'm not sure if this works quite yet.
    global StatusDir
    global CurrentLog
    try:
        f = open(StatusDir + "\\" + CurrentLog, "r") # Open the log file
    except:
        print("Error opening log. Continuing.")      # Error checking for if the log file cannot be opened.
        return
    try:
        Lines = f.readlines()                        # This should never happen.
    except:
        print("Error reading lines from log. Continuing")
    f.close() # Close the log file

    i = 0
    tempjson = ""
    for line in reversed(Lines): # Scan in reversed for the newest loadout readings
        i += 1
        try:
            tempjson = json.loads(line) # Attempt to load the line as JSON.
        except:
            continue                    # I'm willing to bet that we will encounter a similar JSONDecodeError here on occasion, so we skip that line.
                                        # This will probably lead to issues, but I'm not too worried about it.

        if(tempjson["event"] == "Loadout"):
            return tempjson["HullHealth"] # Returns HullHealth from Loadout event.
    

        

def RunStates(): # Processes light effect variables set by ReloadFlags()
    if(DoFlicker):
        FlickerLights()

    if(DoHazards):
        HazardsOn()
    else:
        HazardsOff()

    if(LightsOn):
        MainLightsOn()
    else:
        MainLightsOff()

    if(LightsDim):
        DimAllLights()
    else:
        LightsStandard()


# Program initialization

print("Elite Lighting v. " + Version)
print("If the program crashes in this stage, you either need to open Elite: Dangerous first or configure the program.")
print("To configure the program, follow the instructions at: https://git.innovation-inc.org/Innovation/elitelighting")
print("You will also need to read alongside: https://github.com/jasonacox/tinytuya#setup-wizard---getting-local-keys")
print("Failure to do so will cause a crash and may kill your cat(s).")
print("\n")

print("Setting up lights")
SetupLights() # Set up lights

print("Lights set up.")

print("Getting current Elite: Dangerous log")
CurrentLog = GetCurrentLog() # Get current Elite: Dangerous log

print("Ready. Press CTRL+C at any time to set lights back to normal operation.")

while ContinueFlag == True:
    try:
        LastHullHealth = CurrentHullHealth
        CurrentHullHealth = GetDamageStats()
        ReloadFlags()
        RunStates()
        time.sleep(0.25)
    except KeyboardInterrupt: # This makes it so CTRL+C begins the program exiting sequence, and so the program exits gracefully at any point during execution.
        break

HazardsOn() # Turn on hazards so that it isn't off when lights return to normal operation.

lightschoice = input("Would you like your lights off? Y/n > ") # Would you like to be light mode'd?
if(lightschoice != "n" and lightschoice != "N"):
    print("Turning off lights.")                               # No, I like having eyes.
    MainLightsOff()
    HazardsOff()

print("Returning lights to normal operation.")
NormalLights()                                                 # Return lights to normal operation (white mode, full brightness)
print("Goodbye.")