GetTags

ObjectTags := Object.GetTags()
            
            # Get required skill and level
            RequiredSkill := GetRequiredSkill(ObjectTags)
            RequiredLevel := GetRequiredLevel(ObjectTags)

            # Get player's skill level

OnButtonInteraction(Agent : agent) : void =
        if:
            Button := button_device[Agent]
            Tags := Button.GetTags()
        then:
            if (Tags.Has(audio_tags_module.radio_tag{})):
                HandleRadioInteraction(Agent, Button)
            if (Tags.Has(audio_tags_module.tv_tag{})):
                HandleTVInteraction(Agent, Button)
            if (Tags.Has(audio_tags_module.bgm_tag{})):
                HandleBGMInteraction(Agent, Button)
            if (Tags.Has(audio_tags_module.fight_music_tag{})):
                HandleFightMusicInteraction(Agent, Button)

var MessageDevice<public> : ?hud_message_device = false
    
    # Handle Pickup action
    HandlePickup<public>(Agent : agent, Object : creative_object_interface, ObjectName : string):void =
        Logger.Print("Pickup: {ObjectName}")
        
        ObjectTags := Object.GetTags()
        
        # Step 1: Check for SPECIFIC denial tags FIRST (too_heavy, too_big, etc.)
        if (HasDenialTag[ObjectTags]):
            # Has a denial tag - show word_map message
            DenialMessage := GetPickupDenialMessage(Object)
            ShowMessage(Agent, DenialMessage)
            Logger.Print("Pickup denied: {ObjectName} has denial tag")
            return
        
        # Step 2: Check if object has search_pickup_tag (allows pickup)
        if (not ObjectTags.Has[search_pickup_tag{}]):
            # Not pickupable - use GetPickupDenialMessage for word_map response
            DenialMessage := GetPickupDenialMessage(Object)
            ShowMessage(Agent, DenialMessage)
            Logger.Print("Not pickupable: {ObjectName}")
            return
        
        # Step 2: Has pickup tag - find matching resource
        ResourceName := FindMatchingResource(ObjectTags, ObjectName)
        
        if (ResName := ResourceName?):
            # Found resource - pick it up!
            if (ResController := ResourceController?):
                ResController.GetResource(Agent, ResName)
                # Use TagToString for rich display name
                DisplayName := TagSystem.TagToString(Object)
                ShowMessage(Agent, "Picked up {DisplayName}")
                Logger.Print("Picked up {ObjectName} as resource {ResName}")
                
                # Hide object in world
                if (Prop := creative_prop[Object]):
                    Prop.Hide()
            else:

ObjectTags := Object.GetTags()

        # Priority 2: Try to get texture from ResourceSystem
        GameData := SaveSystem.GetGameData()
        Resources := GameData.ResourceIDLookup.GetValues()

        for (Resource : Resources):

if (TagCtrl := TagController?):
            # Check what type of interaction this object supports
            ObjectTags := Object.GetTags()
            
            # Check for ATM tag - open bank UI
            if (ObjectTags.Has[atm_tag{}]):
                if (Bank := BankDevice?):
                    Logger.Print("Opening bank UI for ATM: {ObjectName}")
                    Bank.ShowUI(Agent)
                    ShowMessage(Agent, "Accessing ATM...")
                else:
                    Logger.Print("Bank device not configured", ?Level := log_level.Error)
                    ShowMessage(Agent, "ATM is not available.")
            
            # Check for VHS player tag - interact with VHS tape device
            else if (ObjectTags.Has[vhs_player_tag{}]):
                Logger.Print("VHS Player use action detected for: {ObjectName}")
                HandleVHSPlayerUse(Agent, ObjectTags, ObjectName)
            
            #else if (ObjectTags.Has[payphone_tag{}]):
            #    OnPayphone(Agent, ObjectName)
                    
            # Check for search_use_tag (generic use action on ANY trigger_device)
            else if (ObjectTags.Has[search_use_tag{}]):
                # This is a trigger_device tagged for "Use" action
                # We trigger it directly here so we can pass the Agent vs the interactive_objects_controller
                if (ObjectTags.Has[vhs_player_tag{}]):
                    Logger.Print("VHS Player use action detected for: {ObjectName}")

                if (TriggerObj := trigger_device[Object]):
                    Logger.Print("Triggering use action on trigger device: {ObjectName}")
                    TriggerObj.Trigger(Agent)
                    ShowMessage(Agent, "You use the {ObjectName}.")
                if (TriggerObj := audio_player_device[Object]):
                    Logger.Print("Triggering use action on audio player device: {ObjectName}")
                    TriggerObj.Play()
                    ShowMessage(Agent, "You use the {ObjectName}.")
                if (TriggerObj := customizable_light_device[Object]):
                    Logger.Print("Triggering use action on customizable light device: {ObjectName}")
                    TriggerObj.Toggle()

# Handle Talk action
    HandleTalk<public>(Agent : agent, Object : creative_object_interface, ObjectName : string):void =
        Logger.Print("Talk: {ObjectName}")
        
        # Check if object has npc_tag
        ObjectTags := Object.GetTags()
        
        if (ObjectTags.Has[npc_tag{}]):
            # This is an NPC - integrate with TalkSystem
            HandleNPCTalk(Agent, Object, ObjectName)
        else:
            # Not an NPC - show humorous default response
            HandleNonNPCTalk(Agent, ObjectName)

LootTaggedObject(Object: creative_object_interface, ObjectTag: tag)<suspends>:void =
        Logger.Print("NOT SETUP IN CODE! - LootTaggedObject tags_module", ?Level := log_level.Error)
        #SpawnLootType(Object, ObjectTag)
    
    # Handle Use action - for VHS players and other usable objects
    UseObject<private>(Object: creative_object_interface, SearchTag: tag)<suspends>:void =
        ObjectTags := Object.GetTags()
        
        # Check if this has search_use_tag (can be on any trigger_device)
        if (ObjectTags.Has[search_use_tag{}]):
            # This is a trigger_device tagged for "Use" action
            if (TriggerObj := trigger_device[Object]):
                TriggerObj.Trigger()
                Logger.Print("Triggered use action on device")
            else:
                Logger.Print("Object has search_use_tag but is not a trigger_device", ?Level := log_level.Warning)
        else:
            # Generic use action (can expand for other usable objects)
            Logger.Print("Used object (no specific handler for this object type)")

TagCategoryDispatcher(TagView)

    # Updated TagToString function - tries lookup first, falls back to category handlers
    # ENHANCED: Now checks tag_definition from tag_list_device
    TagToString<public>(Object:creative_object_interface):string =

        TagView := Object.GetTags()
        TagData := GetTagDescription(TagView)
        return ReplaceWords(TagData.Description)

    #############################################################################################################
    # GetTagData - Get full tag_data struct for an object based on its tags
    # Returns: tag_data struct with TagID, Name, Description, InspectTexture, Category

set ObjectStates[NextObjectId] = object_state{IsOpen := false, IsLocked := false, IsCooldown := false, IsLooted := false}
                set ObjectMap[NextObjectId] = Button
            then:
                Button.InteractedWithEvent.SubscribeAgent(OnObjectInteraction, NextObjectId)

                 # Set interaction text based on object type
                ObjectTags := Object.GetTags()
                if (ObjectTags.HasAny[SkillController.AvailableSkills]):
                    # Get required skill info for interaction text
                    SkillType := SkillController.GetRequiredSkill(Object.GetTags())
                    SkillLevel := SkillController.GetRequiredLevel(Object.GetTags())
                    Button.SetInteractionText(SkillController.GetSkillInteractionText(Object, SkillType, SkillLevel, ObjectName))
                else:

var OpenLargeOffset<public> : float = 300.0
    #>

    # Function to get the open offset for an object based on its tags
    GetOpenOffset<public>(Object: creative_object_interface, OpenSmallOffset: float, OpenMediumOffset: float, OpenLargeOffset: float): vector3 =
        ObjectTags := Object.GetTags()
        
        # Calculate offsets for each axis in local space
        var OffsetX : float = CalculateAxisOffset(ObjectTags, "X", OpenSmallOffset, OpenMediumOffset, OpenLargeOffset)
        var OffsetY : float = CalculateAxisOffset(ObjectTags, "Y", OpenSmallOffset, OpenMediumOffset, OpenLargeOffset)
        var OffsetZ : float = CalculateAxisOffset(ObjectTags, "Z", OpenSmallOffset, OpenMediumOffset, OpenLargeOffset)
       
        # Apply inversion if necessary
        set OffsetX = ApplyInversion(ObjectTags, OffsetX, "X")
        set OffsetY = ApplyInversion(ObjectTags, OffsetY, "Y")
        set OffsetZ = ApplyInversion(ObjectTags, OffsetZ, "Z")
        
        # Return the offset in local space
        return vector3{X := OffsetX, Y := OffsetY, Z := OffsetZ}