init 2 python:

###### coxClothing() class            codeBlc
##
## Making a class for individual clothes, because lists just became silly at some point. Skin, hair, eye etc. is in coxBody() class, further down.

    if True is True:
        class coxClothing():
            def __init__(self, name, constants = 0, tags = None,
                bra_set_num = None,         bra_texture = None,     bra_boob_texture = None,                                    bra_skindentation_texture = None, bra_skindentation_boob_texture = None,
                panties_set_num = None,     panties_texture = None, panties_butt_texture = None, panties_upskirt_texture = None, panties_masturbation_texture = None, panties_skindentation_texture = None, panties_skindentation_butt_texture = None, panties_skindentation_upskirt_texture = None, panties_skindentation_masturbation_texture = None,
                shirt_set_num = None,       shirt_texture = None,   shirt_boob_texture = None,                                  shirt_skindentation_texture = None, shirt_skindentation_boob_texture = None,
                pants_set_num = None,       pants_texture = None,   pants_butt_texture = None,                                  pants_skindentation_texture = None, pants_skindentation_butt_texture = None,
                socks_set_num = None,       socks_texture = None,   socks_butt_texture = None, socks_upskirt_texture = None, socks_masturbation_texture = None, socks_skindentation_texture = None, socks_skindentation_butt_texture = None, socks_skindentation_upskirt_texture = None, socks_skindentation_masturbation_texture = None,
                shoes_set_num = None,       shoes_texture = None,   shoes_skindentation_texture = None,
                accessory_set_num = None,   accessory_texture = None, accessory_skindentation_texture = None,
                neck_texture = None,        neck_boob_texture = None, neck_blowjob_texture = None,  # Implemented as a makeshift way to make chokers, collars, necklaces, etc.
                piercings_face_texture = None, piercings_face_blowjob_texture = None,
                piercings_nipples_texture = None, piercings_nipples_boob_texture = None,
                piercings_other_texture = None, piercings_other_boob_texture = None, piercings_other_butt_texture = None, piercings_other_blowjob_texture = None, piercings_other_handjob_texture = None, piercings_other_upskirt_texture = None, piercings_other_masturbation_texture = None,
                force_breast_lift = None, force_pinch_thighs = None,
                corruption_requirement = 0, visible = True, unlocked = False, price = None,
                visiblekey = None, unlockedkey = None):
    
                self.name = name  # String. The name that will show up in the store or closet, when deciding your outfit
                
                self.constants = constants # Used with the binary constants above, with bitwise operators. E.g.: constants=CONST_COVERS_NIPPLES | CONST_COVERS_PUSSY
                
                if tags is None: # List of additional tags as strings, to add when saving as an outfit. I add a tag corresponding to the list I put the clothing in, e.g. lListTubeTops -> "TubeTop". Also a good place to add a unique identifier if you want an event to interact with a specific clothing in some way.
                    self.tags = []
                elif isinstance(tags, list):
                    self.tags = tags
                else:
                    self.tags = [tags]
                
                
                self.bra_set_num = bra_set_num
                self.bra_texture = bra_texture  # Every texture swap in this bra category should have TEXTURE_BRA as texture_id. Same for the other categories.
                self.bra_boob_texture = bra_boob_texture
                self.bra_skindentation_texture = bra_skindentation_texture  # the skindentation textures are meant to be for making a mask for the skin in places the clothes press the skin in, to look squishy
                self.bra_skindentation_boob_texture = bra_skindentation_boob_texture
                
                
                self.panties_set_num = panties_set_num
                self.panties_texture = panties_texture
                self.panties_butt_texture = panties_butt_texture
                self.panties_upskirt_texture = panties_upskirt_texture
                self.panties_masturbation_texture = panties_masturbation_texture
                self.panties_skindentation_texture = panties_skindentation_texture
                self.panties_skindentation_butt_texture = panties_skindentation_butt_texture
                self.panties_skindentation_upskirt_texture = panties_skindentation_upskirt_texture
                self.panties_skindentation_masturbation_texture = panties_skindentation_masturbation_texture
                
                
                self.shirt_set_num = shirt_set_num
                self.shirt_texture = shirt_texture
                self.shirt_boob_texture = shirt_boob_texture
                self.shirt_skindentation_texture = shirt_skindentation_texture
                self.shirt_skindentation_boob_texture = shirt_skindentation_boob_texture
                
                
                self.pants_set_num = pants_set_num
                self.pants_texture = pants_texture
                self.pants_butt_texture = pants_butt_texture
                self.pants_skindentation_texture = pants_skindentation_texture
                self.pants_skindentation_butt_texture = pants_skindentation_butt_texture
                
                
                self.socks_set_num = socks_set_num
                self.socks_texture = socks_texture
                self.socks_butt_texture = socks_butt_texture
                self.socks_upskirt_texture = socks_upskirt_texture
                self.socks_masturbation_texture = socks_masturbation_texture
                self.socks_skindentation_texture = socks_skindentation_texture
                self.socks_skindentation_butt_texture = socks_skindentation_butt_texture
                self.socks_skindentation_upskirt_texture = socks_skindentation_upskirt_texture
                self.socks_skindentation_masturbation_texture = socks_skindentation_masturbation_texture
                
                
                self.shoes_set_num = shoes_set_num
                self.shoes_texture = shoes_texture
                self.shoes_skindentation_texture = shoes_skindentation_texture
                
                
                self.accessory_set_num = accessory_set_num
                self.accessory_texture = accessory_texture
                self.accessory_skindentation_texture = accessory_skindentation_texture
                
                
                self.neck_texture = neck_texture
                self.neck_boob_texture = neck_boob_texture
                self.neck_blowjob_texture = neck_blowjob_texture
                
                
                self.piercings_face_texture = piercings_face_texture
                self.piercings_face_blowjob_texture = piercings_face_blowjob_texture
                
                self.piercings_nipples_texture = piercings_nipples_texture
                self.piercings_nipples_boob_texture = piercings_nipples_boob_texture
                
                self.piercings_other_texture = piercings_other_texture
                self.piercings_other_boob_texture = piercings_other_boob_texture
                self.piercings_other_butt_texture = piercings_other_butt_texture
                self.piercings_other_blowjob_texture = piercings_other_blowjob_texture
                self.piercings_other_handjob_texture = piercings_other_handjob_texture
                self.piercings_other_upskirt_texture = piercings_other_upskirt_texture
                self.piercings_other_masturbation_texture = piercings_other_masturbation_texture
                
                
                self.force_breast_lift = force_breast_lift # Set to 1 if you want the breast lift. 
                self.force_pinch_thighs = force_pinch_thighs # Set to 1 if you want the thigh pinch
    
                self.corruption_requirement = corruption_requirement # The corruption level you need to wear or buy this. The highest number will be the outfit requirement.
                self.visible = visible # Added to a list to make it mutable, meaning that the value can change and other things will actually notice. If visible returns as False, it will not show up in either closet or store. Mostly used as a condition for if something is not unlocked for sale in store, or if, for instance, you've bought it from store, so it's unlocked, but you want it physically delivered, so it doesn't show up in closet yet.
                self.unlocked = unlocked # If unlocked is True, it will show up in closet, but not in store. Basically, if it's unlocked, you own it. 
                self.price = price # If None, clothing will not show up in store. If it has a value, even if that value is 0, it will show up in store, if visible is True and unlocked is False
                
                self.unlockedkey = unlockedkey # If you assign unlocked as a function, assign unlockedkey a list of arguments you want the unlocked function to have. E.g.: Clothing(unlocked=chore_list.has_tag, unlockedkey=["thetagyouwant"])
                self.visiblekey = visiblekey # same as above, but for visible. Note that if you assign unlocked or visible with a variable that points to an integer, you can also assign a dict with how to test those integers, test method as key, number as value. E.g.: Clothing(unlocked=amount_of_blowjobs_given, unlockedkey={"GreaterOrEqual":6}). It can test for more than one, but only one has to be True, not all of them.
            
            def is_unlocked(self):                                              # Function to check if this is unlocked. Checking the .unlocked attribute
                if isinstance(self.unlocked, Outfit):                               # if it's an Outfit
                    return getattr(self.unlocked, "unlocked")                           # return the unlocked state of that Outfit. Unlocking that, will unlock this.
                    
                elif isinstance(self.unlocked, (coxClothing, coxBody)):             # if it's a Clothing/Body
                    return self.unlocked.is_unlocked()                                  # run this exact function on that
                    
                elif callable(self.unlocked):                                       # if it's a function  (don't type in the parenthesis or arguments, if any. unlockedkey is the argument(s))
                    if self.unlockedkey is None:                                        # if there are no arguments
                        return self.unlocked()                                              # return the result of the function with no arguments
                    elif isinstance(self.unlockedkey, list):                            # if the argument is a list
                        return self.unlocked(*self.unlockedkey)                             # unpack the list as arguments for the function    (this means, if your argument is supposed to be a list, it needs to be packed in another list, like this: unlockedkey=[list_variable])
                    else:
                        return self.unlocked(self.unlockedkey)                          # if the argument is not a list, use it as an argument
                
                elif isinstance(self.unlocked, basestring):                         # if it's a string
                    return getattr(renpy.store, self.unlocked, False)                   # return the variable with the name of the string, or return False if it can't be found
                        
                elif isinstance(self.unlocked, bool):                               # if it's a boolean (True/False)
                    return self.unlocked                                                # return the boolean
                    
                elif isinstance(self.unlocked, int):                                # if it's an integer (let's call the integer n)
                    if isinstance(self.unlockedkey, dict):                              # and if unlockedkey is a dictionary
                        if "==" in self.unlockedkey:                                        # if "==" is a key in unlockedkey
                            if self.unlocked == self.unlockedkey["=="]:                         # and if n equals the value in the dictionary tied to the key "=="
                                return True                                                         # return True
                        if "!=" in self.unlockedkey:                                        # or if "!=" is a key
                            if self.unlocked != self.unlockedkey["!="]:                         # and if n does not equal the value in the dictionary tied to the key "!="
                                return True                                                         # return True
                        if ">=" in self.unlockedkey:                                        # or if ">=" is a key
                            if self.unlocked >= self.unlockedkey[">="]:                         # and if n is greater or equal to the value in the dictionary tied to the key ">="
                                return True                                                         # return True
                        if "<=" in self.unlockedkey:                                        # etc.
                            if self.unlocked <= self.unlockedkey["<="]:
                                return True
                        if ">" in self.unlockedkey:
                            if self.unlocked > self.unlockedkey[">"]:
                                return True
                        if "<" in self.unlockedkey:                                         # these are all tested, and only one of them needs to be True to return True, so it is possible to test an integer in multiple ways
                            if self.unlocked < self.unlockedkey["<"]:
                                return True
                return False                                                        # if none of these tests are relevant, return False
                
            def is_visible(self):   # To check if visible
                if isinstance(self.visible, Outfit):
                    return getattr(self.visible, "unlocked")                    
                    
                elif isinstance(self.visible, (coxClothing, coxBody)):
                    return self.visible.is_unlocked()                                  # Note that if an Clothing/Body class is given, is_visible also checks if unlocked is true, not visible.
                    
                elif callable(self.visible):
                    if self.visiblekey is None:
                        return self.visible()
                    elif isinstance(self.visiblekey, list):
                        return self.visible(*self.visiblekey)
                    else:
                        return self.visible(self.visiblekey)
                
                elif isinstance(self.visible, basestring):  # Use a variable name as a string to return its value. So, best if it's a boolean.
                    return getattr(renpy.store, self.visible, False)
                        
                elif isinstance(self.visible, bool):
                    return self.visible
                    
                elif isinstance(self.visible, int):
                    if isinstance(self.visiblekey, dict):
                        if "==" in self.visiblekey:
                            if self.visible == self.visiblekey["=="]:
                                return True
                        elif "!=" in self.visiblekey:
                            if self.visible != self.visiblekey["!="]:
                                return True
                        elif ">=" in self.visiblekey:
                            if self.visible >= self.visiblekey[">="]:
                                return True
                        elif "<=" in self.visiblekey:
                            if self.visible <= self.visiblekey["<="]:
                                return True
                        elif ">" in self.visiblekey:
                            if self.visible > self.visiblekey[">"]:
                                return True
                        elif "<" in self.visiblekey:
                            if self.visible < self.visiblekey["<"]:
                                return True
                return False
                
            def in_closet(self):    # Checks if it satisfies the criteria for being listed in the closet
                if self.is_unlocked() and self.is_visible():
                    return True
                return False
            
            def in_store(self):     # Checks if it satisfies the criteria for being listed in the store
                if not self.is_unlocked() and self.is_visible() and self.price is not None:
                    return True
                return False
                
            
            def has_tag(self, the_tag): # Just in case.
                if isinstance(the_tag, basestring):
                    the_tag = [the_tag]
                
                for a_tag in the_tag:
                    if a_tag in self.outfit_tags:
                        return True
                return False

    # endBlc

    # coxBody() codeBlc
        class coxBody():
            def __init__(self, name, constants=0, tags = None, is_bra = False, is_panties = False, is_shirt = False, is_pants = False,
                force_hair_num = None, hair_texture = None, hair_blowjob_texture = None,
                water_hair_texture = None, water_hair_blowjob_texture = None,   # While the hair doesn't actually have any water in the blowjob frame yet, I figured that might happen at some point anyway. No point using it for now.
                pubes_texture = None, pubes_upskirt_texture = None, pubes_masturbation_texture = None,
                skin_texture = None, skin_boob_texture = None, skin_butt_texture = None, skin_upskirt_texture = None, skin_masturbation_texture = None, skin_blowjob_texture = None, skin_handjob_texture = None,
                water_texture = None, water_boob_texture= None, water_butt_texture= None, water_upskirt_texture = None, water_masturbation_texture = None, water_blowjob_texture = None, water_handjob_texture = None, # Handjob doesn't have water texture yet
                nipple_texture= None, nipple_boob_texture = None,
                eyeshadow_texture = None, eyeshadow_blowjob_texture = None,
                blush_texture = None, blush_blowjob_texture = None,
                eye_texture = None, eye_blowjob_texture = None,
                lips_texture = None, lips_blowjob_texture = None,
                force_breast_lift = None, force_pinch_thighs = None,
                corruption_requirement = 0, visible = True, unlocked = False, price = None,
                visiblekey = None, unlockedkey = None):
    
                self.name = name  # String. The name that will show up in the store or closet, when deciding your outfit
                
                if tags is None: # List of additional tags as strings, to add when saving as an outfit.
                    self.tags = []
                elif isinstance(tags, list):
                    self.tags = tags
                else:
                    self.tags = [tags]
                    
                self.is_bra = is_bra            # Argument to use if you reskin the character and give it clothing that covers the boobs. Basically, if body texture is used in place of bra_set_num. Don't use it if it's just pasties, or something, use CONST_COVERS_NIPPLES then
                self.is_panties = is_panties    # Same, except for panties_set_num
                self.is_shirt = is_shirt        # Same, except for shirt_set_num
                self.is_pants = is_pants        # Same as above, except for pants_set_num.
                
                self.constants = constants
                
                
                self.force_hair_num = force_hair_num
                self.hair_texture = hair_texture
                self.hair_blowjob_texture = hair_blowjob_texture
                
                self.water_hair_texture = water_hair_texture
                self.water_hair_blowjob_texture = water_hair_blowjob_texture
                
                self.pubes_texture = pubes_texture
                self.pubes_upskirt_texture = pubes_upskirt_texture
                self.pubes_masturbation_texture = pubes_masturbation_texture
                
                self.eyeshadow_texture = eyeshadow_texture
                self.eyeshadow_blowjob_texture = eyeshadow_blowjob_texture
                
                self.blush_texture = blush_texture
                self.blush_blowjob_texture = blush_blowjob_texture
                
                self.skin_texture = skin_texture
                self.skin_boob_texture = skin_boob_texture
                self.skin_butt_texture = skin_butt_texture
                self.skin_upskirt_texture = skin_upskirt_texture
                self.skin_masturbation_texture = skin_masturbation_texture
                self.skin_blowjob_texture = skin_blowjob_texture
                self.skin_handjob_texture = skin_handjob_texture
                
                self.water_texture = water_texture
                self.water_boob_texture = water_boob_texture
                self.water_butt_texture = water_butt_texture
                self.water_upskirt_texture = water_upskirt_texture
                self.water_masturbation_texture = water_masturbation_texture
                self.water_blowjob_texture = water_blowjob_texture
                self.water_handjob_texture = water_handjob_texture
                
                self.nipple_texture = nipple_texture
                self.nipple_boob_texture = nipple_boob_texture
                
                self.eye_texture = eye_texture
                self.eye_blowjob_texture = eye_blowjob_texture
                
                self.lips_texture = lips_texture
                self.lips_blowjob_texture = lips_blowjob_texture
                
                self.force_breast_lift = force_breast_lift # Set to 1 if you want the breast lift. 
                self.force_pinch_thighs = force_pinch_thighs # Set to 1 if you want the thigh pinch
                
                self.corruption_requirement = corruption_requirement # The corruption level you need to wear or buy this. The highest number will be the outfit requirement.
                self.visible = visible # Added to a list to make it mutable, meaning that the value can change and other things will actually notice. If visible returns as False, it will not show up in either closet or store. Mostly used as a condition for if something is not unlocked for sale in store, or if, for instance, you've bought it from store, so it's unlocked, but you want it physically delivered, so it doesn't show up in closet yet.
                self.unlocked = unlocked # If unlocked is True, it will show up in closet, but not in store. Basically, if it's unlocked, you own it. 
                self.price = price # If None, clothing will not show up in store. If it has a value, even if that value is 0, it will show up in store, if visible is True and unlocked is False
                
                self.unlockedkey = unlockedkey # If you assign unlocked as a function, this will be the argument. E.g.: Clothing(unlocked=chore_list.has_tag, unlockedkey="thetagyouwant"). Using a function MUST take an argument. Because I can't figure out how to test if a function takes arguments or not.
                self.visiblekey = visiblekey # same as above, but for visible
            
            def is_unlocked(self):                                              # Function to check if this is unlocked. Checking the .unlocked attribute
                if isinstance(self.unlocked, Outfit):                               # if it's an Outfit
                    return getattr(self.unlocked, "unlocked")                           # return the unlocked state of that Outfit. Unlocking that, will unlock this.
                    
                elif isinstance(self.unlocked, (coxClothing, coxBody)):             # if it's a Clothing/Body
                    return self.unlocked.is_unlocked()                                  # run this exact function on that
                    
                elif callable(self.unlocked):                                       # if it's a function  (don't type in the parenthesis or arguments, if any. unlockedkey is the argument(s))
                    if self.unlockedkey is None:                                        # if there are no arguments
                        return self.unlocked()                                              # return the result of the function with no arguments
                    elif isinstance(self.unlockedkey, list):                            # if the argument is a list
                        return self.unlocked(*self.unlockedkey)                             # unpack the list as arguments for the function    (this means, if your argument is supposed to be a list, it needs to be packed in another list, like this: unlockedkey=[list_variable])
                    else:
                        return self.unlocked(self.unlockedkey)                          # if the argument is not a list, use it as an argument
                
                elif isinstance(self.unlocked, basestring):                         # if it's a string
                    return getattr(renpy.store, self.unlocked, False)                   # return the variable with the name of the string, or return False if it can't be found
                        
                elif isinstance(self.unlocked, bool):                               # if it's a boolean (True/False)
                    return self.unlocked                                                # return the boolean
                    
                elif isinstance(self.unlocked, int):                                # if it's an integer (let's call the integer n)
                    if isinstance(self.unlockedkey, dict):                              # and if unlockedkey is a dictionary
                        if "==" in self.unlockedkey:                                        # if "==" is a key in unlockedkey
                            if self.unlocked == self.unlockedkey["=="]:                         # and if n equals the value in the dictionary tied to the key "=="
                                return True                                                         # return True
                        if "!=" in self.unlockedkey:                                        # or if "!=" is a key
                            if self.unlocked != self.unlockedkey["!="]:                         # and if n does not equal the value in the dictionary tied to the key "!="
                                return True                                                         # return True
                        if ">=" in self.unlockedkey:                                        # or if ">=" is a key
                            if self.unlocked >= self.unlockedkey[">="]:                         # and if n is greater or equal to the value in the dictionary tied to the key ">="
                                return True                                                         # return True
                        if "<=" in self.unlockedkey:                                        # etc.
                            if self.unlocked <= self.unlockedkey["<="]:
                                return True
                        if ">" in self.unlockedkey:
                            if self.unlocked > self.unlockedkey[">"]:
                                return True
                        if "<" in self.unlockedkey:                                         # these are all tested, and only one of them needs to be True to return True, so it is possible to test an integer in multiple ways
                            if self.unlocked < self.unlockedkey["<"]:
                                return True
                return False                                                        # if none of these tests are relevant, return False
                
            def is_visible(self):   # To check if visible
                if isinstance(self.visible, Outfit):
                    return getattr(self.visible, "unlocked")                    
                    
                elif isinstance(self.visible, (coxClothing, coxBody)):
                    return self.visible.is_unlocked()                                  # Note that if an Clothing/Body class is given, is_visible also checks if unlocked is true, not visible.
                    
                elif callable(self.visible):
                    if self.visiblekey is None:
                        return self.visible()
                    elif isinstance(self.visiblekey, list):
                        return self.visible(*self.visiblekey)
                    else:
                        return self.visible(self.visiblekey)
                
                elif isinstance(self.visible, basestring):  # use a variable name as a string to return its value
                    return getattr(renpy.store, self.visible, False)
                        
                elif isinstance(self.visible, bool):
                    return self.visible
                    
                elif isinstance(self.visible, int):
                    if isinstance(self.visiblekey, dict):
                        if "==" in self.visiblekey:
                            if self.visible == self.visiblekey["=="]:
                                return True
                        elif "!=" in self.visiblekey:
                            if self.visible != self.visiblekey["!="]:
                                return True
                        elif ">=" in self.visiblekey:
                            if self.visible >= self.visiblekey[">="]:
                                return True
                        elif "<=" in self.visiblekey:
                            if self.visible <= self.visiblekey["<="]:
                                return True
                        elif ">" in self.visiblekey:
                            if self.visible > self.visiblekey[">"]:
                                return True
                        elif "<" in self.visiblekey:
                            if self.visible < self.visiblekey["<"]:
                                return True
                return False
                
            def in_closet(self):    # Checks if it satisfies the criteria for being listed in the closet
                if self.is_unlocked() and self.is_visible():
                    return True
                return False
            
            def in_store(self):     # Checks if it satisfies the criteria for being listed in the store
                if not self.is_unlocked() and self.is_visible() and self.price is not None:
                    return True
                return False
            
            def has_tag(self, the_tag):
                if isinstance(the_tag, basestring):
                    the_tag = [the_tag]
                
                for a_tag in the_tag:
                    if a_tag in self.outfit_tags:
                        return True
                return False

    #endBlc
