o3de/Assets/Engine/Scripts/Entities/Triggers/ProximityTrigger.lua

----------------------------------------------------------------------------------------------------
--
-- All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-- its licensors.
--
-- For complete copyright and license terms please see the LICENSE at the root of this
-- distribution (the "License"). All use of this software is governed by the License,
-- or, if provided, by the license below or the license accompanying this file. Do not
-- remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--
-- Original file Copyright Crytek GMBH or its affiliates, used under license.
--
--
--    Description: Network-ready Proximity Trigger
--
----------------------------------------------------------------------------------------------------
ProximityTrigger =
{
    Properties =
    {
        DimX = 5,
        DimY = 5,
        DimZ = 5,

        bEnabled = 1,
        EnterDelay = 0,
        ExitDelay = 0,

        bOnlyPlayer = 1,
        bOnlyMyPlayer = 0,
        bOnlyAI = 0,
        bOnlySpecialAI = 0,
        esFactionFilter = "",

        OnlySelectedEntity = "None",

        bRemoveOnTrigger = 0,
        bTriggerOnce = 0,
        ScriptCommand = "",
        PlaySequence = "",
        bInVehicleOnly = 0,
        bOnlyOneEntity = 0,

        UsableMessage = "",
        bActivateWithUseButton = 0,

        MultiplayerOptions =
        {
            bNetworked = 0,
            bPerPlayer = 0,
        },
    },

    Client={},
    Server={},

    Editor =
    {
        Model="Editor/Objects/T.cgf",
        Icon="Trigger.bmp",
        ShowBounds = 1,
        IsScalable = false;
        IsRotatable = false;
    },
}


Net.Expose
{
    Class = ProximityTrigger,
    ClientMethods = 
    {
        ClEnter = { RELIABLE_ORDERED, PRE_ATTACH, ENTITYID, INT8},
        ClLeave = { RELIABLE_ORDERED, PRE_ATTACH, ENTITYID, INT8},
    },
    ServerMethods = 
    {
        SvRequestUse = { RELIABLE_ORDERED, PRE_ATTACH, ENTITYID },
    },
    ServerProperties = {}
}


function ProximityTrigger:OnPropertyChange()
    self:OnReset();
end


function ProximityTrigger:OnReset()
    -- Precalcs some CVars used to test triggering entities based in their names. ("selectedEntity" is a misleading name for all this)
    self.bUsesExactSelectedEntity = false;
    self.bUsesWildcardSelectedEntity = false;

    if (self.Properties.OnlySelectedEntity~="None" and self.Properties.OnlySelectedEntity~="") then
        local indexChar = string.find( self.Properties.OnlySelectedEntity, "*" );
        if (indexChar and indexChar>1) then
            if (indexChar<5) then
                LogWarning( "proximity trigger: '%s' is using a too much generic name for 'selectedEntity' field", self:GetName() );
            end
            self.bUsesWildcardSelectedEntity = true;
            self.stringRootSelectedEntity = string.sub( self.Properties.OnlySelectedEntity, 1, indexChar - 1 );
        else
            self.bUsesExactSelectedEntity = true;
        end
    end

    if (self.timers) then
        for i,v in pairs(self.timers) do
            self:KillTimer(i);
        end
    end
    self.timerId = 0;

    self.enabled = nil;
    self.usable = tonumber(self.Properties.bActivateWithUseButton)~=0;
    self.triggerOnce = tonumber(self.Properties.bTriggerOnce)~=0;
    self.localOnly = self.Properties.MultiplayerOptions.bNetworked==0;
    self.perPlayer = tonumber(self.Properties.MultiplayerOptions.bPerPlayer)~=0;

    self.isServer=CryAction.IsServer();
    self.isClient=CryAction.IsClient();

    self.inside={};
    self.timers={};

    if (not self.localOnly) then
        self.triggeredPP={};
        self.triggeredOncePP={};
    else
        self:SetFlags(ENTITY_FLAG_CLIENT_ONLY,0);
    end

    self.triggeredOnce=nil;
    self.triggered=nil;

    self.insideCount=0;


    local min = { x=-self.Properties.DimX/2, y=-self.Properties.DimY/2, z=-self.Properties.DimZ/2 };
    local max = { x=self.Properties.DimX/2, y=self.Properties.DimY/2, z=self.Properties.DimZ/2 };

    self:SetUpdatePolicy( ENTITY_UPDATE_PHYSICS );

    self:SetTriggerBBox( min, max );

    self:Enable(tonumber(self.Properties.bEnabled)~=0);

    self:InvalidateTrigger();

    self:ActivateOutput("NrOfEntitiesInside", 0);
end


function ProximityTrigger:Enable(enable)
    self.enabled=enable;
    self:RegisterForAreaEvents(enable and 1 or 0);
end


function ProximityTrigger:OnSpawn()
    self:OnReset();
end


function ProximityTrigger:OnDestroy()
end


function ProximityTrigger:OnSave(tbl)
    tbl.enabled = self.enabled;
    tbl.triggered = self.triggered;
    tbl.triggeredOnce = self.triggeredOnce;
end


function ProximityTrigger:OnLoad(tbl)
    self:OnReset();
    self.enabled = tbl.enabled;
    self.triggered = tbl.triggered;
    self.triggeredOnce = tbl.triggeredOnce;
end


function ProximityTrigger:Event_Enter(entityId)

    if (not self.enabled) then return; end; -- TODO: might need a self.active here
    if (self.triggerOnce) then
        if (self.localOnly) then
            if (self.triggeredOnce) then
                return;
            end
        elseif (self.perPlayer and self.triggeredOncePP[entityId]) then -- TODO: will need to skip this for non-player entities
            return;
        elseif (not self.perPlayer and self.triggeredOnce) then
            return;
        end
    end

    self.triggered=true;
    self.triggeredOnce=true;

    if (not self.localOnly and entityId) then
        self.triggeredPP[entityId]=true;
        self.triggeredOncePP[entityId]=true;
    end

--    Log(" ProximityTrigger: %s:Event_Enter(%s) inside: %d", self:GetName(), EntityName(entityId), self.insideCount);

    self:Trigger(entityId, self.insideCount);

    --BroadcastEvent(self, "Enter");
    self:ActivateOutput("Enter", entityId or NULL_ENTITY);

    if (not self.localOnly and self.isServer) then
        self.otherClients:ClEnter(g_localChannelId, entityId or NULL_ENTITY, self.insideCount);
    end
end


function ProximityTrigger.Client:ClEnter(entityId, insideCount)
--    Log("ProximityTrigger: %s.Client:ClEnter(%s) count: %d", self:GetName(), EntityName(entityId), insideCount);

    self:Trigger(entityId, insideCount);
    --BroadcastEvent(self, "Enter");
    self:ActivateOutput("Enter", entityId);
end


function ProximityTrigger:Event_Leave(entityId)
    if (not self.enabled) then return; end;
    if (self.localOnly and not self.triggered) then return; end;

    if (self.perPlayer) then
        if (not self.localOnly and entityId) then
            if (not self.triggeredPP[entityId]) then
                return;
            end;
        end
    else
        if (not self.triggered) then
            return;
        end;
    end

    --only disable triggered when all players are gone
    if(self.insideCount == 0) then
        self.triggered=nil;
    end

    if (not self.localOnly and entityId and self.insideCount == 0) then
        self.triggeredPP[entityId]=nil;
    end

    --Log("%s:Event_Leave(%s)", self:GetName(), EntityName(entityId));

    self:ActivateOutput("Sender", entityId or NULL_ENTITY);
    self:ActivateOutput("NrOfEntitiesInside", self.insideCount);

    --BroadcastEvent(self, "Leave");
    self:ActivateOutput("Leave", entityId or NULL_ENTITY);

    if (not self.localOnly and self.isServer) then
        self.otherClients:ClLeave(g_localChannelId, entityId or NULL_ENTITY, self.insideCount);
    end
end


function ProximityTrigger.Client:ClLeave(entityId, inside)
--    Log("%s.Client:ClLeave(%s, %s)", self:GetName(), EntityName(entityId), tostring(inside));

    self:ActivateOutput("Sender", entityId);
    self:ActivateOutput("NrOfEntitiesInside", inside);

    self:ActivateOutput("Leave", entityId);
    --BroadcastEvent(self, "Leave");
end


function ProximityTrigger:Event_Enable()
    if (self.enabled) then return; end;

    -- Act as if everyone entered the trigger
    self.enabled = true;
    for k,v in pairs(self.inside) do
        self:Event_Enter( k );
    end;

    self:ActivateOutput("NrOfEntitiesInside", self.insideCount);
    BroadcastEvent(self, "Enable");
end


function ProximityTrigger:Event_Disable()
    if (not self.enabled) then return; end;

    -- Act as if everyone left the trigger
    self.enabled = false;
    for k,v in pairs(self.inside) do
        self:Event_Leave( k );
    end;
    
    self:ActivateOutput("NrOfEntitiesInside", 0);
    BroadcastEvent(self, "Disable");
end


function ProximityTrigger:CreateTimer(entityId, time, leave)
    local timerId=self.timerId;
    if (timerId>1023) then
        timerId=0;
    end
    timerId=timerId+1;
    self.timerId=timerId;

    if (leave) then
        timerId=timerId+1024;
    end
    self.timers[timerId]=entityId;
    self:SetTimer(timerId, time);
end


function ProximityTrigger.Client:OnTimer(timerId, msec)
    if (self.localOnly and not self.isServer) then
        self:OnTimer(timerId, msec);
    end
end


function ProximityTrigger.Server:OnTimer(timerId, msec)
    self:OnTimer(timerId, msec);
end


function ProximityTrigger:OnTimer(timerId, msec)
    if (timerId==2048) then
        self:CheckAIDeaths()
        return;
    end

    local entityId=self.timers[timerId];
    if (not entityId) then return; end;

    if (timerId>1023) then
        self:Event_Leave(entityId);
    else
        self:Event_Enter(entityId);
    end
end


function ProximityTrigger:CheckAIDeaths()
    local amountInside = 0;

    for k,v in pairs(self.inside) do
        local entity = System.GetEntity( k );
        if (entity~=nil and entity.ai~=nil and entity.lastHealth<=0) then
            self.inside[k] = nil;
        else
            amountInside = amountInside + 1;
        end
    end

    if (amountInside~=self.insideCount) then
        self.insideCount = amountInside;
        if (self.enabled) then
            self:ActivateOutput("NrOfEntitiesInside", self.insideCount);
        end
    end

    if (amountInside~=0) then
        self:CreateAIDeathsCheckTrigger();
    else
        self.timers[2048]=false; --to know that we are not using the AI trigger now
    end
end


-- this timer should be created only when it is a trigger that reacts to AI (which should be only a few), and there are AIs inside
function ProximityTrigger:CreateAIDeathsCheckTrigger()
    self.timers[2048]=true; -- to know that we are using the AI timer. 2048 is the AI timer id
    self:SetTimer( 2048, 3000);
end


function ProximityTrigger.Server:SvRequestUse(userId)
    local entity=System.GetEntity(userId);
    if (entity) then
        self:OnUsed(entity);
    end
end


function ProximityTrigger:OnUsed(user)
    if (not self:CanTrigger(user)) then return; end;

    Log("%s:OnUsed(%s)", self:GetName(), EntityName(user));

    self:LockUsability();

    if (self.localOnly or self.isServer) then
        self:CreateTimer(user.id, self.Properties.EnterDelay*1000);
    else
        self.server:SvRequestUse(user.id);
    end
end


function ProximityTrigger:Trigger(entityId, inside)
    if (self.enabled) then
        self:ActivateOutput("NrOfEntitiesInside", inside);
    end

    if(self.Properties.ScriptCommand and self.Properties.ScriptCommand~="")then
        local f = loadstring(self.Properties.ScriptCommand);
        if (f~=nil) then
            f();
        end
    end

    if(self.Properties.PlaySequence~="")then
        Movie.PlaySequence(self.Properties.PlaySequence);
    end

    self:ActivateOutput("Sender", entityId or NULL_ENTITY);
    
    if(AI ~= nil) then
        self:ActivateOutput("Faction", AI.GetFactionOf(entityId or NULL_ENTITY) or "");
    end
    
    
    local isAPlayer = ActorSystem.IsPlayer(entityId);
    if self.Properties.bRemoveOnTrigger ~= 0 and not isAPlayer then
        System.RemoveEntity(entityId);
    end
end


function ProximityTrigger:EnteredArea(entity, areaId)
    if (not self:CanTrigger(entity, areaId)) then
        return;
    end

    if (tonumber(self.Properties.bOnlyOneEntity)~=0 and self.insideCount>0) then
        return;
    end

    self.inside[entity.id]=true;
    self.insideCount=self.insideCount+1;

    if (not entity.ai) then
        if (self.Properties.bActivateWithUseButton~=0) then
            return;
        end
    end

    if (not self.enabled) then return; end;

    self:CreateTimer(entity.id, self.Properties.EnterDelay*1000);
    if (entity.ai and self.timers[2048]~=true) then  -- 2048 is the special timer id used to check the deaths of AIs
        self:CreateAIDeathsCheckTrigger();
    end
end


function ProximityTrigger:LeftArea(entity, areaId)
    if (not self:CanTrigger(entity, areaId)) then
        return;
    end

    self.inside[entity.id]=nil;
    self.insideCount=self.insideCount-1;

    if(self.Properties.ExitDelay==0) then
        self.Properties.ExitDelay=0.01;
    end

    if (not self.enabled) then return; end;

    self:CreateTimer(entity.id, self.Properties.ExitDelay*1000, true);
end


function ProximityTrigger.Server:OnEnterArea(entity, areaId)
    if (self:CanTrigger(entity)) then
        self:EnteredArea(entity, areaId);
    end
end


function ProximityTrigger.Server:OnLeaveArea(entity, areaId)
    self:LeftArea(entity, areaId);
end


function ProximityTrigger.Client:OnEnterArea(entity, areaId)
    if (not self:CanTrigger(entity)) then return; end;

    if (entity.actor) then
        if (self.usable and self.enabled) then
            self:LockUsability(true);
        end
    end

    if (not self.localOnly or self.isServer) then return; end;

    self:EnteredArea(entity, areaId);
end


function ProximityTrigger.Client:OnLeaveArea(entity, areaId)
    if (entity.actor) then
        if (self.usable and self.enabled) then
            self:LockUsability(true);
        end
    end

    if (not self.localOnly or self.isServer) then return; end;

    self:LeftArea(entity, areaId);
end


function ProximityTrigger:CanTrigger(entity)
    local Properties = self.Properties;

    if (entity.ai and entity.lastHealth and (entity.lastHealth <= 0)) then
        return false;
    end
    
    local isAPlayer = ActorSystem.IsPlayer(entity.id);
    if (Properties.bOnlyPlayer ~= 0 and not(isAPlayer)) then
        return false;
    end

    if (Properties.bOnlySpecialAI ~= 0 and entity.ai and entity.Properties.special==0) then
        return false;
    end

    if (Properties.bOnlyAI ~=0 and not entity.ai) then
        return false;
    end

    if (Properties.bOnlyMyPlayer ~= 0 and entity ~= g_localActor) then
        return false;
    end

    if (Properties.bInVehicleOnly ~= 0 and not entity.vehicleId) then
        return false;
    end

    -- looks for exact name match, if defined
    if (self.bUsesExactSelectedEntity and entity:GetName()~=Properties.OnlySelectedEntity) then
        return false;
    end

    -- looks for generic (wildcard) name match, if defined
    if (self.bUsesWildcardSelectedEntity) then
        local indexStringFound = string.find( entity:GetName(), self.stringRootSelectedEntity );
        if (indexStringFound~=1) then
        return false;
        end
    end

    if (Properties.esFactionFilter ~= "") then
        local faction = AI.GetFactionOf(entity.id) or "";
        if (faction ~= Properties.esFactionFilter) then
            return false
        end
    end

    return true;
end


function ProximityTrigger:IsUsable(user)
    return self.usable and self.enabled;
end


function ProximityTrigger:LockUsability(lock)
    local player=g_localActor;
    if (player) then
        if (lock) then
            player.actor:SetExtensionParams("Interactor", {locker = self.id, lockId = self.id, lockIdx = 1});
        else
            player.actor:SetExtensionParams("Interactor", {locker = self.id, lockId = NULL_ENTITY, lockIdx = 0});
        end
    end
end


function ProximityTrigger:GetUsableMessage()
    return self.Properties.UsableMessage or "";
end



ProximityTrigger.FlowEvents =
{
    Inputs =
    {
        Disable = { ProximityTrigger.Event_Disable, "bool" },
        Enable = { ProximityTrigger.Event_Enable, "bool" },
        Enter = { ProximityTrigger.Event_Enter, "bool" },
        Leave = { ProximityTrigger.Event_Leave, "bool" },
    },

    Outputs =
    {
        NrOfEntitiesInside = "int",
        Disable = "bool",
        Enable = "bool",
        Enter = "entity",
        Leave = "entity",
        Sender = "entity",
        Faction = "string",
    },
}