Trixy/Stats/DeviceStats.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import time
import os.path
import TextConfig
from lib.RepeatTimer import RepeatTimer
import configparser

class DeviceStats(object):

    #TODO: via config.ini deaktivierbare Stats, z.B. angry dauerhaft auf 0 setzen
    #TODO: Abhängigkeit der Mondphase einbauen - Bei Vollmond gehen manche Stats schneller höch
    #TODO: Abhängigkeit der Blauen Stunde / Goldenen Stunde, bedingt an Wetter und Wolken

    MAX_VALUE:float = 1000
    SAVE_STATS_INTERVAL = 1

    #angry = 0.0
    #aroused = 0.0
    #hungry = 0.0
    #happyness = 0.0
    #funny = 0.0
    #annoyed = 0.0
    #irritated = 0.0
    #bored = 0.0
    #intelligent = 0.0
    #sleepy = 0.0
    #energy = 0.0
    #exhausted = 0.0
    #depressive = 0.0
    #sad = 0.0
    #useless = 0.0
    #usefull = 0.0
    #compfortable = 0.0
    #temperate = 0.0 # Wohl temperiert - ist die Temperatur angenehm
    #shy = 0.0
    #excited = 0.0
    #toLoud = 0.0 # Zu laut
    #toQuiet = 0.0 # Zu leise
    #playful = 0.0
    #naiv = 0.0
    #freezy = 0.0
    #hot = 0.0
    #humanity = 0.0
    #lonely = 0.0
    #soziality = 0.0

    #lastTimeToLoud = 0
    #lastTimeToQuiet = 0
    #lastTimeAngry = 0
    #lastTimeLonely = 0
    lastUpdate = 0

    def __init__(self):
        self._angry = 0.0
        self._aroused = 0.0
        self._hungry = 0.0
        self._happyness = 0.0
        self._funny = 0.0
        self._annoyed = 0.0
        self._irritated = 0.0
        self._bored = 0.0
        self._intelligent = 0.0
        self._sleepy = 0.0
        self._energy = 0.0
        self._exhausted = 0.0
        self._depressive = 0.0
        self._sad = 0.0
        self._useless = 0.0
        self._usefull = 0.0
        self._compfortable = 0.0
        self._temperate = 0.0
        self._shy = 0.0
        self._excited = 0.0
        self._toLoud = 0.0
        self._toQuiet = 0.0
        self._playful = 0.0
        self._naiv = 0.0
        self._freezy = 0.0
        self._hot = 0.0
        self._lonely = 0.0
        self._humanity = 0.0
        self._soziality = 0.0


        self._lastTimeToLoud = 0.0
        self._lastTimeToQuiet = 0.0
        self._lastTimeAngry = 0.0
        self._lastTimeLonely = 0.0

        self._locked_angry = -1.0
        self._locked_aroused = -1.0
        self._locked_hungry = -1.0
        self._locked_happyness = -1.0
        self._locked_funny = -1.0
        self._locked_annoyed = -1.0
        self._locked_irritated = -1.0
        self._locked_bored = -1.0
        self._locked_intelligent = -1.0
        self._locked_sleepy = -1.0
        self._locked_energy = -1.0
        self._locked_exhausted = -1.0
        self._locked_depressive = -1.0
        self._locked_sad = -1.0
        self._locked_useless = -1.0
        self._locked_usefull = -1.0
        self._locked_compfortable = -1.0
        self._locked_temperate = -1.0
        self._locked_shy = -1.0
        self._locked_excited = -1.0
        self._locked_toLoud = -1.0
        self._locked_toQuiet = -1.0
        self._locked_playful = -1.0
        self._locked_naiv = -1.0
        self._locked_freezy = -1.0
        self._locked_hot = -1.0
        self._locked_lonely = -1.0
        self._locked_humanity = -1.0
        self._locked_soziality = -1.0

        self.textconfig = TextConfig.TextConfig("cache/stats.txt")
        self.Load()
        self.Thread_Save = RepeatTimer(self.SAVE_STATS_INTERVAL*60, self.Save)
        self.Thread_Save.start()
        if(True):
            config = configparser.ConfigParser()
            config.read('config/stats.ini')
            if "Locked_Stats" in config:
                if "angry" in config["Locked_Stats"]:
                    self._locked_angry = float(config["Locked_Stats"]["angry"])
                if "aroused" in config["Locked_Stats"]:
                    self._locked_aroused = float(config["Locked_Stats"]["aroused"])
                if "hungry" in config["Locked_Stats"]:
                    self._locked_hungry = float(config["Locked_Stats"]["hungry"])
                if "happyness" in config["Locked_Stats"]:
                    self._locked_happyness = float(config["Locked_Stats"]["happyness"])
                if "funny" in config["Locked_Stats"]:
                    self._locked_funny = float(config["Locked_Stats"]["funny"])
                if "annoyed" in config["Locked_Stats"]:
                    self._locked_annoyed = float(config["Locked_Stats"]["annoyed"])
                if "irritated" in config["Locked_Stats"]:
                    self._locked_irritated = float(config["Locked_Stats"]["irritated"])
                if "bored" in config["Locked_Stats"]:
                    self._locked_bored = float(config["Locked_Stats"]["bored"])
                if "intelligent" in config["Locked_Stats"]:
                    self._locked_intelligent = float(config["Locked_Stats"]["intelligent"])
                if "sleepy" in config["Locked_Stats"]:
                    self._locked_sleepy = float(config["Locked_Stats"]["sleepy"])
                if "energy" in config["Locked_Stats"]:
                    self._locked_energy = float(config["Locked_Stats"]["energy"])
                if "exhausted" in config["Locked_Stats"]:
                    self._locked_exhausted = float(config["Locked_Stats"]["exhausted"])
                if "depressive" in config["Locked_Stats"]:
                    self._locked_depressive = float(config["Locked_Stats"]["depressive"])
                if "sad" in config["Locked_Stats"]:
                    self._locked_sad = float(config["Locked_Stats"]["sad"])
                if "useless" in config["Locked_Stats"]:
                    self._locked_useless = float(config["Locked_Stats"]["useless"])
                if "usefull" in config["Locked_Stats"]:
                    self._locked_usefull = float(config["Locked_Stats"]["usefull"])
                if "compfortable" in config["Locked_Stats"]:
                    self._locked_compfortable = float(config["Locked_Stats"]["compfortable"])
                if "temperate" in config["Locked_Stats"]:
                    self._locked_temperate = float(config["Locked_Stats"]["temperate"])
                if "shy" in config["Locked_Stats"]:
                    self._locked_shy = float(config["Locked_Stats"]["shy"])
                if "excited" in config["Locked_Stats"]:
                    self._locked_excited = float(config["Locked_Stats"]["excited"])
                if "toLoud" in config["Locked_Stats"]:
                    self._locked_toLoud = float(config["Locked_Stats"]["toLoud"])
                if "toQuiet" in config["Locked_Stats"]:
                    self._locked_toQuiet = float(config["Locked_Stats"]["toQuiet"])
                if "playful" in config["Locked_Stats"]:
                    self._locked_playful = float(config["Locked_Stats"]["playful"])
                if "naiv" in config["Locked_Stats"]:
                    self._locked_naiv = float(config["Locked_Stats"]["naiv"])
                if "freezy" in config["Locked_Stats"]:
                    self._locked_freezy = float(config["Locked_Stats"]["freezy"])
                if "hot" in config["Locked_Stats"]:
                    self._locked_hot = float(config["Locked_Stats"]["hot"])
                if "lonely" in config["Locked_Stats"]:
                    self._locked_lonely = float(config["Locked_Stats"]["lonely"])
                if "humanity" in config["Locked_Stats"]:
                    self._locked_humanity = float(config["Locked_Stats"]["humanity"])
                if "soziality" in config["Locked_Stats"]:
                    self._locked_soziality = float(config["Locked_Stats"]["soziality"])
            

    

    @property
    def angry(self) -> float:
        if self._locked_angry >= 0:
            return self._locked_angry
        return self._angry

    @angry.setter
    def angry(self, value:float):
        if value<0:
            self._angry = 0
        elif value > self.MAX_VALUE:
            self._angry = self.MAX_VALUE
        else:
            self._angry = value
        if value > 0:
            self._lastTimeAngry = time.time()

    @property
    def aroused(self) -> float:
        if self._locked_aroused >= 0:
            return self._locked_aroused
        return self._aroused

    @aroused.setter
    def aroused(self, value:float):
        if value<0:
            self._aroused = 0
        elif value > self.MAX_VALUE:
            self._aroused = self.MAX_VALUE
        else:
            self._aroused = value

    @property
    def hungry(self) -> float:
        if self._locked_hungry >= 0:
            return self._locked_hungry
        return self._hungry

    @hungry.setter
    def hungry(self, value:float):
        if value<0:
            self._hungry = 0
        elif value > self.MAX_VALUE:
            self._hungry = self.MAX_VALUE
        else:
            self._hungry = value

    @property
    def happyness(self) -> float:
        if self._locked_happyness >= 0:
            return self._locked_happyness
        return self._happyness

    @happyness.setter
    def happyness(self, value:float):
        if value<0:
            self._happyness = 0
        elif value > self.MAX_VALUE:
            self._happyness = self.MAX_VALUE
        else:
            self._happyness = value

    @property
    def funny(self) -> float:
        if self._locked_funny >= 0:
            return self._locked_funny
        return self._funny

    @funny.setter
    def funny(self, value:float):
        if value<0:
            self._funny = 0
        elif value > self.MAX_VALUE:
            self._funny = self.MAX_VALUE
        else:
            self._funny = value

    @property
    def annoyed(self) -> float:
        if self._locked_annoyed >= 0:
            return self._locked_annoyed
        return self._annoyed

    @annoyed.setter
    def annoyed(self, value:float):
        if value<0:
            self._annoyed = 0
        elif value > self.MAX_VALUE:
            self._annoyed = self.MAX_VALUE
        else:
            self._annoyed = value

    @property
    def irritated(self) -> float:
        if self._locked_irritated >= 0:
            return self._locked_irritated
        return self._irritated

    @irritated.setter
    def irritated(self, value:float):
        if value<0:
            self._irritated = 0
        elif value > self.MAX_VALUE:
            self._irritated = self.MAX_VALUE
        else:
            self._irritated = value

    @property
    def bored(self) -> float:
        if self._locked_bored >= 0:
            return self._locked_bored
        return self._bored

    @bored.setter
    def bored(self, value:float):
        if value<0:
            self._bored = 0
        elif value > self.MAX_VALUE:
            self._bored = self.MAX_VALUE
        else:
            self._bored = value

    @property
    def intelligent(self) -> float:
        if self._locked_intelligent >= 0:
            return self._locked_intelligent
        return self._intelligent

    @intelligent.setter
    def intelligent(self, value:float):
        if value<0:
            self._intelligent = 0
        elif value > self.MAX_VALUE:
            self._intelligent = self.MAX_VALUE
        else:
            self._intelligent = value

    @property
    def sleepy(self) -> float:
        if self._locked_sleepy >= 0:
            return self._locked_sleepy
        return self._sleepy

    @sleepy.setter
    def sleepy(self, value:float):
        if value<0:
            self._sleepy = 0
        elif value > self.MAX_VALUE:
            self._sleepy = self.MAX_VALUE
        else:
            self._sleepy = value

    @property
    def energy(self) -> float:
        if self._locked_energy >= 0:
            return self._locked_energy
        return self._energy

    @energy.setter
    def energy(self, value:float):
        if value<0:
            self._energy = 0
        elif value > self.MAX_VALUE:
            self._energy = self.MAX_VALUE
        else:
            self._energy = value

    @property
    def exhausted(self) -> float:
        if self._locked_exhausted >= 0:
            return self._locked_exhausted
        return self._exhausted

    @exhausted.setter
    def exhausted(self, value:float):
        if value<0:
            self._exhausted = 0
        elif value > self.MAX_VALUE:
            self._exhausted = self.MAX_VALUE
        else:
            self._exhausted = value

    @property
    def depressive(self) -> float:
        if self._locked_depressive >= 0:
            return self._locked_depressive
        return self._depressive

    @depressive.setter
    def depressive(self, value:float):
        if value<0:
            self._depressive = 0
        elif value > self.MAX_VALUE:
            self._depressive = self.MAX_VALUE
        else:
            self._depressive = value

    @property
    def sad(self) -> float:
        if self._locked_sad >= 0:
            return self._locked_sad
        return self._sad

    @sad.setter
    def sad(self, value:float):
        if value<0:
            self._sad = 0
        elif value > self.MAX_VALUE:
            self._sad = self.MAX_VALUE
        else:
            self._sad = value

    @property
    def useless(self) -> float:
        if self._locked_useless >= 0:
            return self._locked_useless
        return self._useless

    @useless.setter
    def useless(self, value):
        if value<0:
            self._useless = 0
        elif value > self.MAX_VALUE:
            self._useless = self.MAX_VALUE
        else:
            self._useless = value

    @property
    def usefull(self) -> float:
        if self._locked_usefull >= 0:
            return self._locked_usefull
        return self._usefull

    @usefull.setter
    def usefull(self, value:float):
        if value<0:
            self._usefull = 0
        elif value > self.MAX_VALUE:
            self._usefull = self.MAX_VALUE
        else:
            self._usefull = value

    @property
    def compfortable(self) -> float:
        if self._locked_compfortable >= 0:
            return self._locked_compfortable
        return self._compfortable

    @compfortable.setter
    def compfortable(self, value:float):
        if value<0:
            self._compfortable = 0
        elif value > self.MAX_VALUE:
            self._compfortable = self.MAX_VALUE
        else:
            self._compfortable = value

    @property
    def temperate(self) -> float:
        if self._locked_temperate >= 0:
            return self._locked_temperate
        return self._temperate

    @temperate.setter
    def temperate(self, value:float):
        if value<0:
            self._temperate = 0
        elif value > self.MAX_VALUE:
            self._temperate = self.MAX_VALUE
        else:
            self._temperate = value

    @property
    def shy(self) -> float:
        if self._locked_shy >= 0:
            return self._locked_shy
        return self._shy

    @shy.setter
    def shy(self, value:float):
        if value<0:
            self._shy = 0
        elif value > self.MAX_VALUE:
            self._shy = self.MAX_VALUE
        else:
            self._shy = value

    @property
    def excited(self) -> float:
        if self._locked_excited >= 0:
            return self._locked_excited
        return self._excited

    @excited.setter
    def excited(self, value:float):
        if value<0:
            self._excited = 0
        elif value > self.MAX_VALUE:
            self._excited = self.MAX_VALUE
        else:
            self._excited = value

    @property
    def toLoud(self) -> float:
        if self._locked_toLoud >= 0:
            return self._locked_toLoud
        return self._toLoud

    @toLoud.setter
    def toLoud(self, value:float):
        if value<0:
            self._toLoud = 0
        elif value > self.MAX_VALUE:
            self._toLoud = self.MAX_VALUE
        else:
            self._toLoud = value
        if value > 0:
            lastTimeToLoud = time.time()

    @property
    def toQuiet(self) -> float:
        if self._locked_toQuiet >= 0:
            return self._locked_toQuiet
        return self._toQuiet

    @toQuiet.setter
    def toQuiet(self, value:float):
        if value<0:
            self._toQuiet = 0
        elif value > self.MAX_VALUE:
            self._toQuiet = self.MAX_VALUE
        else:
            self._toQuiet = value
        if value > 0:
            lastTimeToQuiet = time.time()
            
    @property
    def playful(self) -> float:
        if self._locked_playful >= 0:
            return self._locked_playful
        return self._playful

    @playful.setter
    def playful(self, value:float):
        if value<0:
            self._playful = 0
        elif value > self.MAX_VALUE:
            self._playful = self.MAX_VALUE
        else:
            self._playful = value

    @property
    def naiv(self) -> float:
        if self._locked_naiv >= 0:
            return self._locked_naiv
        return self._naiv

    @naiv.setter
    def naiv(self, value:float):
        if value<0:
            self._naiv = 0
        elif value > self.MAX_VALUE:
            self._naiv = self.MAX_VALUE
        else:
            self._naiv = value

    @property
    def freezy(self) -> float:
        if self._locked_freezy >= 0:
            return self._locked_freezy
        return self._freezy

    @freezy.setter
    def freezy(self, value:float):
        if value<0:
            self._freezy = 0
        elif value > self.MAX_VALUE:
            self._freezy = self.MAX_VALUE
        else:
            self._freezy = value

    @property
    def hot(self) -> float:
        if self._locked_hot >= 0:
            return self._locked_hot
        return self._hot

    @hot.setter
    def hot(self, value:float):
        if value<0:
            self._hot = 0
        elif value > self.MAX_VALUE:
            self._hot = self.MAX_VALUE
        else:
            self._hot = value

    @property
    def humanity(self) -> float:
        if self._locked_humanity >= 0:
            return self._locked_humanity
        return self._humanity

    @humanity.setter
    def humanity(self, value:float):
        if value<0:
            self._humanity = 0
        elif value > self.MAX_VALUE:
            self._humanity = self.MAX_VALUE
        else:
            self._humanity = value

    @property
    def lonely(self) -> float:
        if self._locked_lonely >= 0:
            return self._locked_lonely
        return self._lonely

    @lonely.setter
    def lonely(self, value:float):
        if value<0:
            self._lonely = 0
        elif value > self.MAX_VALUE:
            self._lonely = self.MAX_VALUE
        else:
            self._lonely = value
        if value > 0:
            self._lastTimeLonely = time.time()

    @property
    def soziality(self) -> float:
        if self._locked_soziality >= 0:
            return self._locked_soziality
        return self._soziality

    @soziality.setter
    def soziality(self, value:float):
        if value<0:
            self._soziality = 0
        elif value > self.MAX_VALUE:
            self._soziality = self.MAX_VALUE
        else:
            self._soziality = value


    @property
    def lastTimeToQuiet(self):
        return self._lastTimeToQuiet

    @property
    def lastTimeToLoud(self):
        return self._lastTimeToLoud

    @property
    def lastTimeAngry(self):
        return self._lastTimeAngry

    @property
    def lastTimeLonely(self):
        return self._lastTimeLonely


    def set(self, name:str, val:float) -> bool:
        """
        Setzt den Wert der entsprechenden Property
        """
        n = name.lower()
        if n=="angry": self.angry = val
        elif n=="aroused": self.aroused = val
        elif n=="hungry": self.hungry = val
        elif n=="happyness": self.happyness = val
        elif n=="funny": self.funny = val
        elif n=="annoyed": self.annoyed = val
        elif n=="irritated": self.irritated = val
        elif n=="bored": self.bored = val
        elif n=="intelligent": self.intelligent = val
        elif n=="sleepy": self.sleepy = val
        elif n=="energy": self.energy = val
        elif n=="exhausted": self.exhausted = val
        elif n=="depressive": self.depressive = val
        elif n=="sad": self.sad = val
        elif n=="useless": self.useless = val
        elif n=="usefull": self.usefull = val
        elif n=="compfortable": self.compfortable = val
        elif n=="temperate": self.temperate = val
        elif n=="shy": self.shy = val
        elif n=="excited": self.excited = val
        elif n=="toloud": self.toLoud = val
        elif n=="toquiet": self.toQuiet = val
        elif n=="playful": self.playful = val
        elif n=="naiv": self.naiv = val
        elif n=="freezy": self.freezy = val
        elif n=="hot": self.hot = val
        elif n=="humanity": self.humanity = val
        elif n=="lonely": self.lonely = val
        elif n=="soziality": self.soziality = val
        else: return False
        return True

    def force(self, name:str, val:float) -> bool:
        """
        Setzt im Gegenteil zu 'set()' den Wert der Variable.
        Es findet keine Überprüfung auf _locked, min und max statt
        """
        n = name.lower()
        if n=="angry": self._angry = val
        elif n=="aroused": self._aroused = val
        elif n=="hungry": self._hungry = val
        elif n=="happyness": self._happyness = val
        elif n=="funny": self._funny = val
        elif n=="annoyed": self._annoyed = val
        elif n=="irritated": self._irritated = val
        elif n=="bored": self._bored = val
        elif n=="intelligent": self._intelligent = val
        elif n=="sleepy": self._sleepy = val
        elif n=="energy": self._energy = val
        elif n=="exhausted": self._exhausted = val
        elif n=="depressive": self._depressive = val
        elif n=="sad": self._sad = val
        elif n=="useless": self._useless = val
        elif n=="usefull": self._usefull = val
        elif n=="compfortable": self._compfortable = val
        elif n=="temperate": self._temperate = val
        elif n=="shy": self._shy = val
        elif n=="excited": self._excited = val
        elif n=="toloud": self._toLoud = val
        elif n=="toquiet": self._toQuiet = val
        elif n=="playful": self._playful = val
        elif n=="naiv": self._naiv = val
        elif n=="freezy": self._freezy = val
        elif n=="hot": self._hot = val
        elif n=="humanity": self._humanity = val
        elif n=="lonely": self._lonely = val
        elif n=="soziality": self._soziality = val
        else: return False
        return True

    def lock(self, name:str, val:float) -> bool:
        """
        Setzt einen Lock Wert für die entsprechende Variable
        """
        n = name.lower()
        if n=="angry": self._locked_angry = val
        elif n=="aroused": self._locked_aroused = val
        elif n=="hungry": self._locked_hungry = val
        elif n=="happyness": self._locked_happyness = val
        elif n=="funny": self._locked_funny = val
        elif n=="annoyed": self._locked_annoyed = val
        elif n=="irritated": self._locked_irritated = val
        elif n=="bored": self._locked_bored = val
        elif n=="intelligent": self._locked_intelligent = val
        elif n=="sleepy": self._locked_sleepy = val
        elif n=="energy": self._locked_energy = val
        elif n=="exhausted": self._locked_exhausted = val
        elif n=="depressive": self._locked_depressive = val
        elif n=="sad": self._locked_sad = val
        elif n=="useless": self._locked_useless = val
        elif n=="usefull": self._locked_usefull = val
        elif n=="compfortable": self._locked_compfortable = val
        elif n=="temperate": self._locked_temperate = val
        elif n=="shy": self._locked_shy = val
        elif n=="excited": self._locked_excited = val
        elif n=="toloud": self._locked_toLoud = val
        elif n=="toquiet": self._locked_toQuiet = val
        elif n=="playful": self._locked_playful = val
        elif n=="naiv": self._locked_naiv = val
        elif n=="freezy": self._locked_freezy = val
        elif n=="hot": self._locked_hot = val
        elif n=="humanity": self._locked_humanity = val
        elif n=="lonely": self._locked_lonely = val
        elif n=="soziality": self._locked_soziality = val
        else: return False
        return True

    def get(self, name:str) -> float:
        """
        Gibt die entsprechende Einstellung zurück
        """
        n = name.lower()
        if n=="angry": return self.angry
        elif n=="aroused": return self.aroused
        elif n=="hungry": return self.hungry
        elif n=="happyness": return self.happyness
        elif n=="funny": return self.funny
        elif n=="annoyed": return self.annoyed
        elif n=="irritated": return self.irritated
        elif n=="bored": return self.bored
        elif n=="intelligent": return self.intelligent
        elif n=="sleepy": return self.sleepy
        elif n=="energy": return self.energy
        elif n=="exhausted": return self.exhausted
        elif n=="depressive": return self.depressive
        elif n=="sad": return self.sad
        elif n=="useless": return self.useless
        elif n=="usefull": return self.usefull
        elif n=="compfortable": return self.compfortable
        elif n=="temperate": return self.temperate
        elif n=="shy": return self.shy
        elif n=="excited": return self.excited
        elif n=="toloud": return self.toLoud
        elif n=="toquiet": return self.toQuiet
        elif n=="playful": return self.playful
        elif n=="naiv": return self.naiv
        elif n=="freezy": return self.freezy
        elif n=="hot": return self.hot
        elif n=="humanity": return self.humanity
        elif n=="lonely": return self.lonely
        elif n=="soziality": return self.soziality
        else: return -1.0

    def raw(self, name:str) -> float:
        """
        Gibt im gegensatz zu 'get()' den Wert der Variable zurück
        Es findet keine Überprüfung auf _locked, min und max statt
        """
        n = name.lower()
        if n=="angry": return self._angry
        elif n=="aroused": return self._aroused
        elif n=="hungry": return self._hungry
        elif n=="happyness": return self._happyness
        elif n=="funny": return self._funny
        elif n=="annoyed": return self._annoyed
        elif n=="irritated": return self._irritated
        elif n=="bored": return self._bored
        elif n=="intelligent": return self._intelligent
        elif n=="sleepy": return self._sleepy
        elif n=="energy": return self._energy
        elif n=="exhausted": return self._exhausted
        elif n=="depressive": return self._depressive
        elif n=="sad": return self._sad
        elif n=="useless": return self._useless
        elif n=="usefull": return self._usefull
        elif n=="compfortable": return self._compfortable
        elif n=="temperate": return self._temperate
        elif n=="shy": return self._shy
        elif n=="excited": return self._excited
        elif n=="toloud": return self._toLoud
        elif n=="toquiet": return self._toQuiet
        elif n=="playful": return self._playful
        elif n=="naiv": return self._naiv
        elif n=="freezy": return self._freezy
        elif n=="hot": return self._hot
        elif n=="humanity": return self._humanity
        elif n=="lonely": return self._lonely
        elif n=="soziality": return self._soziality
        else: return -1.0


    def Save(self):
        self.textconfig.setValue({
            "max": self.MAX_VALUE,
            "angry": self._angry,
            "aroused": self.aroused,
            "hungry": self.hungry,
            "happyness": self._happyness,
            "funny": self._funny,
            "annoyed":self._annoyed,
            "irritated": self.irritated,
            "bored": self.bored,
            "intelligent": self.intelligent,
            "sleepy": self.sleepy,
            "energy": self.energy,
            "exhausted": self.exhausted,
            "depressive": self.depressive,
            "sad": self.sad,
            "useless": self.useless,
            "usefull": self.usefull,
            "compfortable": self.compfortable,
            "temperate": self.temperate,
            "shy": self.shy,
            "excited": self.excited,
            "toLoud": self.toLoud,
            "toQuiet": self.toQuiet,
            "playful": self.playful,
            "naiv": self.naiv,
            "freezy": self.freezy,
            "hot": self.hot,
            "humanity": self.humanity,
            "lonely": self.lonely,
            "soziality": self.soziality,
            "lastTimeToLoud": self.lastTimeToLoud,
            "lastTimeToQuiet": self.lastTimeToQuiet,
            "lastTimeAngry": self.lastTimeAngry,
            "lastTimeLonely": self.lastTimeLonely,
            "lastUpdate": self.lastUpdate
        })
        self.textconfig.Save()

    def Save(self, file = "stats.txt"):
        """
        Speichert die Daten in einer TextConfig
        """
        if os.path.isfile(file):
            os.remove(file)
        with open(file, 'w') as f:
            f.writelines([
                "max "+str(self.MAX_VALUE)+"\n",
                "angry "+str(self.angry)+"\n",
                "aroused "+str(self.aroused)+"\n",
                "hungry "+str(self.hungry)+"\n",
                "happyness "+str(self.happyness)+"\n",
                "funny "+str(self.funny)+"\n",
                "annoyed "+str(self.annoyed)+"\n",
                "irritated "+str(self.irritated)+"\n",
                "bored "+str(self.bored)+"\n",
                "intelligent "+str(self.intelligent)+"\n",
                "sleepy "+str(self.sleepy)+"\n",
                "energy "+str(self.energy)+"\n",
                "exhausted "+str(self.exhausted)+"\n",
                "depressive "+str(self.depressive)+"\n",
                "sad "+str(self.sad)+"\n",
                "useless "+str(self.useless)+"\n",
                "usefull "+str(self.usefull)+"\n",
                "compfortable "+str(self.compfortable)+"\n",
                "temperate "+str(self.temperate)+"\n",
                "shy "+str(self.shy)+"\n",
                "excited "+str(self.excited)+"\n",
                "toLoud "+str(self.toLoud)+"\n",
                "toQuiet "+str(self.toQuiet)+"\n",
                "playful "+str(self.playful)+"\n",
                "naiv "+str(self.naiv)+"\n",
                "freezy "+str(self.freezy)+"\n",
                "hot "+str(self.hot)+"\n",
                "humanity "+str(self.humanity)+"\n",
                "lonely "+str(self.lonely)+"\n",
                "soziality "+str(self.soziality)+"\n",
                "\n",
                "lastTimeToLoud "+str(self.lastTimeToLoud)+"\n",
                "lastTimeToQuiet "+str(self.lastTimeToQuiet)+"\n",
                "lastTimeAngry "+str(self.lastTimeAngry)+"\n",
                "lastTimeLonely "+str(self.lastTimeLonely)+"\n",
                "lastUpdate "+str(self.lastUpdate)+"\n"
            ])

    def Load(self, file = "stats.txt"):
        """
        Läd die Daten aus einer TextConfig
        """
        if os.path.isfile(file) == False:
            return False
        #lines=[]
        count=0
        max = self.MAX_VALUE
        
        #lines = self._loadTextConfig("stats.txt")
        self.textconfig.Load()
        lines = self.textconfig.getItems()
        count = self.textconfig.count

        if count>0:
            for c in range(0, count):
                itm = lines[c]
                if itm["var"]=="angry": self.angry = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="aroused": self.aroused = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="hungry": self.hungry = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="happyness": self.happyness = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="funny": self.funny = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="annoyed": self.annoyed = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="irritated": self.irritated = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="bored": self.bored = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="intelligent": self.intelligent = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="sleepy": self.sleepy = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="energy": self.energy = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="exhausted": self.exhausted = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="depressive": self.depressive = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="sad": self.sad = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="useless": self.useless = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="usefull": self.usefull = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="compfortable": self.compfortable = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="temperate": self.temperate = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="shy": self.shy = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="excited": self.excited = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="toLoud": self.toLoud = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="toQuiet": self.toQuiet = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="playful": self.playful = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="naiv": self.naiv = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="freezy": self.freezy = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="hot": self.hot = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="humanity": self.humanity = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="lonely": self.lonely = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="soziality": self.soziality = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="lastTimeToLoud": self._lastTimeToLoud = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="lastTimeToQuiet": self._lastTimeToQuiet = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="lastTimeAngry": self._lastTimeAngry = float(itm["val"]) / max * self.MAX_VALUE
                elif itm["var"]=="lastTimeLonely": self._lastTimeLonely = float(itm["val"]) / max * self.MAX_VALUE
            self.lastUpdate = time.time
            return True
        return False



    def __del__(self):
        print("Del DeviceStats")
        self.Thread_Save.cancel()
        del self._angry
        del self._annoyed
        del self._aroused
        del self._bored
        del self._compfortable
        del self._depressive
        del self._energy
        del self._excited
        del self._exhausted
        del self._freezy
        del self._funny
        del self._happyness
        del self._hot
        del self._humanity
        del self._hungry
        del self._intelligent
        del self._irritated
        del self._lastTimeToLoud
        del self._lastTimeToQuiet
        del self._lonely
        del self._naiv
        del self._playful
        del self._sad
        del self._shy
        del self._sleepy
        del self._soziality
        del self._temperate
        del self._toLoud
        del self._toQuiet
        del self._usefull
        del self._useless

        del self._locked_angry
        del self._locked_annoyed
        del self._locked_aroused
        del self._locked_bored
        del self._locked_compfortable
        del self._locked_depressive
        del self._locked_energy
        del self._locked_excited
        del self._locked_exhausted
        del self._locked_freezy
        del self._locked_funny
        del self._locked_happyness
        del self._locked_hot
        del self._locked_humanity
        del self._locked_hungry
        del self._locked_intelligent
        del self._locked_irritated
        del self._locked_lastTimeToLoud
        del self._locked_lastTimeToQuiet
        del self._locked_lonely
        del self._locked_naiv
        del self._locked_playful
        del self._locked_sad
        del self._locked_shy
        del self._locked_sleepy
        del self._locked_soziality
        del self._locked_temperate
        del self._locked_toLoud
        del self._locked_toQuiet
        del self._locked_usefull
        del self._locked_useless

        del self.Thread_Save


    def getJson(self):
        return {
            "angry": self.angry,
            "aroused": self.aroused,
            "hungry": self.hungry,
            "happyness": self.happyness,
            "funny": self.funny,
            "annoyed": self.annoyed,
            "irritated": self.irritated,
            "bored": self.bored,
            "intelligent": self.intelligent,
            "sleepy": self.sleepy,
            "energy": self.energy,
            "exhausted": self.exhausted,
            "depressive": self.depressive,
            "sad": self.sad,
            "useless": self.useless,
            "usefull": self.usefull,
            "compfortable": self.compfortable,
            "temperate": self.temperate,
            "shy": self.shy,
            "excited": self.excited,
            "toLoud": self.toLoud,
            "toQuiet": self.toQuiet,
            "playful": self.playful,
            "naiv": self.naiv,
            "freezy": self.freezy,
            "hot": self.hot,
            "humanity": self.humanity,
            "lonely": self.lonely,
            "soziality": self.soziality,
            
            "lastTimeToLoud":self.lastTimeToLoud,
            "lastTimeToQuiet":self.lastTimeToQuiet,
            "lastTimeAngry":self.lastTimeAngry,
            "lastTimeLonely":self.lastTimeLonely,
            "lastUpdate":self.lastUpdate
        }