Scripts in radiant - Mapper Scripts

Hello mappers!
We at HaZardModding had a idea while working on the HZM Coop Mod for BT and SH (Allied Assault is already complete).

The idea is to allow mappers to take advantage of script features inside the radiant.

Let me explain that a little bit with my sales pitch:

Quote:

---

You have a map and you want scripting to be added to it.
But you don't really know someone to do it the way you like it
and getting into scripting with all its rules and quirks is
wasted time you rather spend inside the radiant ?

---

Quote:

---

Then we have the solution for you!
Use triggers and other entities to call a special script that executes
the script commands and works it all out for you based on the parameters
you apply to a trigger or entity inside the radiant.

---

Quote:

---

Our solution would be with proper error messages that tell you what is actually
wrong with your parameters providing a easy way to use scripts without hassle.

---

Here is a example picture how that would look like:
(the picture is from a different mod where we already have that feature)
Attachment 2221


In Mohaa that the values of a trigger would look like that:

Code:

---

setthread coop_mod/easyscript.scr::ai off
#time 10
$tname $hansTheGrandpaNazi
$name Hans The Old Nazi
note This Turns the AI off on actor after given time in seconds

---

Please let us know what you think of that, because we are evaluating the need for such a solution based on the responses we get and if there is little to no interest we will not go trough the trouble developing this solution.

If we should how ever work on such a solution, we would first integrate it into the HaZardModding Coop Mod, to support single and multiplayer usage.
A standalone version to be included with your singe/multiplayer map would also be possible, based on the feedback we are getting.

We are capable of doing this and we have proven that we have the know how to work things out with multiplayer scripting, so all we need is your feedback if you want that.


On a selfish note, we are still looking for additional experienced scripters to faster convert the singleplayer levels for the HZM Coop Mod, please contact us.
https://discord.gg/AZNKRCy

Cheers, Chrissstrahl

I think the concept is super cool, but I'm just not sure how useful it would be for modders and players. I don't play the game anymore, so I can't speak for everyone. I think the concept is very interesting and it could spark a lot of new interest in modding. I'll let other active players voice their opinion as well.

I think what you're doing is amazing though. If you can do something like this outside of mapping I think that would be an interesting idea. One of the biggest downfalls (maybe that's a bit exaggerated) is the "file collision" mechanism with different mods. The server admin always has to make sure files aren't being overwritten somewhere. dmprecache or mikestorso, or any of the state files, etc...

I also think that is very cool, I have been asked for something like this almost a decade ago for ef2, back then I wasn't able to do that.
But now I think only you and me do actually really care about that.
Mohaa allows to set a mod folder, does it not ? As startup parameter...

I'm not sure if it does. I mean you can certainly do it in the engine, but with stock MOHAA, I don't think I've seen that done before. I think everything is going through the "Main" directory.

Well, I was actually thinking about BT :D

So, if I understand correctly, this would be like a framework to convert key:value commands from entities to regular scripts?
or is it like a new Radiant?

Quote:

---

Originally Posted by chrissstrahl

Mohaa allows to set a mod folder, does it not ? As startup parameter...

---

The "fs_game" cvar is broken in mohaa, sh, bt. You can set it and launch a game but as soon as the first map is loaded the cvar resets and the mod folder is unloaded from the path

Quote:

---

Originally Posted by Zappa

So, if I understand correctly, this would be like a framework to convert key:value commands from entities to regular scripts?

---

Ya, kinda, scripts will read the values and do what ever they are meant to do with the given parameters.

This is the script from ef2 but it gives at least some idea of how that would be build.

PHP Code:

---

//-----------------------------------------------------------------------------------
// Script By:    Chrissstrahl
// Created on:    2009.12.26
// Organisation:    HaZardModding
//
//THIS FILE ALLOWS MAPPERS TO CREATE CO-OP MAPS WITHOUT SCRIPTING

//CALL THEM BY A TRIGGER OR CONSOLE ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//CALL THEM BY A TRIGGER OR CONSOLE ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//CALL THEM BY A TRIGGER OR CONSOLE ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//CALL THEM BY A TRIGGER OR CONSOLE ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//CALL THEM BY A TRIGGER OR CONSOLE ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//CALL THEM BY A TRIGGER OR CONSOLE ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//CALL THEM BY A TRIGGER OR CONSOLE ONLY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//HAZARDMODDING CO-OP SCRIPT MODIFICATION ©2006-2015 SOME RIGHTS RESERVED AND
//(IP)INTELLECTUAL PROPERTY HELD BY CHRISSSTRAHL.

//YOU ARE EXPLICITE FORBIDDEN TO USE/MODIFIE/REDISTRIBUTE/REPLICATE/RELEASE/REBUILD/COPY
//ANY MATERIALS OR INTELLECTUAL PROPERTY OF THIS FILE WITHOUT THE EXPLICIT
//WRITTEN PERMISSION OF THE RESPECTIVE OWNERS!

//
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------

//INCLUDE - Loads all other scripts which shall be avialable in the no-script extension
//-----------------------------------------------------------------------------------
#include "coop_mod/matrix/main.scr" //load co-op mod
#include "coop_mod/matrix/global/global_common.scr" //load global-common incase player decides to try with any else tutorials to learn scripting
//-----------------------------------------------------------------------------------

//DECLARE - Only declare the functions which are expected to be called by script
//-----------------------------------------------------------------------------------
void    coop_tryToReMoveTheGivenEntity(entity e);
void    coop_printMessageIfEntityExists(entity e,string s);
float    coop_checkAllUserVarsAreEmpty(entity e);
float    coop_checkIsNotPlayerHasModel(entity eActor);
float    coop_checkExistHasModelPrintWithTargetname(entity eActor,string s);
float    coop_checkExistHasModel(entity e);
float    coop_checkExistHasModelAndHealth(entity e);
float    coop_checkIsNpcOrPlayer(entity e);
void    coop_setHealth(entity e,float fAdd,float fMax);
void    coop_enableFF(entity e);
void    coop_disableFF(entity e);
void    coop_bindToOrigin(entity eSlave,entity eMaster);
void    coop_unbindThisEntity(entity eSlave);
void    coop_unbindAllFromOrigin(entity eMaster);
void    coop_setuplevel();
void    coop_selectionmovereset(entity e);
vector    coop_returnOrigin(entity eGetMyOrigin);
void    coop_printMessageToPlayer(entity ePlayer, string sMessage);
//added for forcefield stuff [b607]
void coop_forcefieldEnable( entity eFF );
void coop_forcefieldMakeInteractive( entity eMakeInteractiveFF );
void coop_forcefieldOnDamage();
void coop_forcefieldOnTouch();
void coop_forcefieldPlaySound(entity eForceField);
void coop_forcefieldDisable(entity eForceField);
void coop_forcefieldSetOnTouch(entity eOnTouch,string sThread);
void coop_forcefieldSetOnDamage(entity eOnDamage,string sThread);

//-----------------------------------------------------------------------------------
void coop_tryToReMoveTheGivenEntity(entity e)
//not meant to be called by a trigger! This will chrash the game!
//Does not remove the entiy if noremove is set in a uservar
{
    float fCounter=0;
    string sString;
    string sTargetname;
    if(doesEntityExist(e)){
        sTargetname = e.getRawTargetname();
        while(fCounter<4){
            fCounter++;
            sString=e.getStringVar("uservar"+fCounter);
            if(sString == "noremove"){
                fCounter=100;
            }
        }
        if(fCounter != 100){
            if( sTargetname != "world"){//do not allow to remove players, or world
                float fRoundsLimit = 10;
                while(doesEntityExist(e) == 1 && fRoundsLimit > 0){
                    fRoundsLimit--;
                    e.remove();
                    e = getNextEntity(e);
                }
            }
        }
    }
}

void coop_printMessageIfEntityExists(entity e,string s)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        globalCoop_main_print(s);
    }
}

float coop_checkAllUserVarsAreEmpty(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        if(    e.getStringVar("uservar1") == "" &&
            e.getStringVar("uservar2") == "" &&
            e.getStringVar("uservar3") == "" &&
            e.getStringVar("uservar4") == "")
        {
            return 1;
        }
    }
    return 0;
}

float coop_checkIsNotPlayerHasModel(entity eActor)
//not meant to be called by a trigger! This will chrash the game!
{
//EXITS AND HAS MODEL, we assume it is a NPC or PLAYER
    if(coop_checkExistHasModel(eActor)){
//NOT A PLAYER
        if(!globalCoop_check_entityValidPlayerTargetname(eActor)){
            return 1;
        }
    }
    return 0;
}

float coop_checkExistHasModelPrintWithTargetname(entity eActor,string s)
//not meant to be called by a trigger! This will chrash the game!
{
    if(coop_checkIsNotPlayerHasModel(eActor)){
        globalCoop_main_print(s+": "+eActor.getTargetname());
        return 1;
    }
    return 0;
}

float coop_checkExistHasModel(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
//EXITS AND HAS MODEL, we assume it is a NPC or PLAYER
    if(doesEntityExist(e)){
        if(e.getModelName() != ""){
            return 1;
        }
    }
    return 0;
}

float coop_checkExistHasModelAndHealth(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
//EXISTS, HAS MODEL, HAS HEALTH, OR IS A PLAYER
    if(coop_checkExistHasModel(e)){
        if(e.getHealth() != 0){
            return 1;
        }
    }
    return 0;
}

float coop_checkIsNpcOrPlayer(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
//EXISTS, HAS MODEL, HAS HEALTH, OR IS A PLAYER
    if(coop_checkExistHasModel(e)){
        if(e.getHealth() != 0 || globalCoop_check_entityValidPlayerTargetname(e) == 1){
            return 1;
        }
    }
    return 0;
}

void coop_unbindThisEntity(entity eSlave)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(eSlave)){
        globalCoop_main_print("coop_~()->UNBOUND: "+eSlave.getTargetname());    
        float fRoundsLimit = 10;
        while(doesEntityExist(eSlave) == 1 && fRoundsLimit > 0){
            fRoundsLimit--;
            eSlave.unbind();
            eSlave.setStringVar("coop_bindMaster","");
            eSlave = getNextEntity(eSlave);
            wait( coop_float_oneFrameTime );
        }
    }
}

void coop_unbindAllFromOrigin(entity eMaster)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(eMaster)){
        entity eSlave;
        float fBoundIndex;
        string sSlaveTargetname;
        do
        {
            fBoundIndex++;
            if(!doesEntityExist(eMaster)){
                return;
            }
            sSlaveTargetname = eMaster.getStringVar("coop_boundEntity"+fBoundIndex);
            thread coop_unbindThisEntity(getEntity(sSlaveTargetname));
            wait( coop_float_oneFrameTime );
        }while(sSlaveTargetname != "" || fBoundIndex <= 10);
    }
    else{
        globalCoop_main_print("coop_unbindAllFromOrigin()->ERROR: Unbind from $"+eMaster.getRawTargetname()+" has failed");
    }
}

void coop_bindToOrigin(entity eSlave,entity eMaster)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(eMaster) == 1 && doesEntityExist(eSlave) == 1){
        float fBoundIndex;
        float fBoundIndexCheck;
        string sSlaveRawTargetname;
        sSlaveRawTargetname = eSlave.getRawTargetname();
        fBoundIndex = eMaster.getFloatVar("coop_boundIndex");
        fBoundIndex++;
        eMaster.setFloatVar("coop_boundIndex",fBoundIndex);
        eSlave.bind(eMaster);
//CHECK IF TARGETNAME IS ALLREADY IN INDEX, DO NOT PUT SAME TARGETNAME IN INDEX ALL OVER AGAIN
        for(fBoundIndexCheck=0;fBoundIndexCheck < 11;fBoundIndexCheck++){
            if(sSlaveRawTargetname == eMaster.getStringVar("coop_boundEntity"+fBoundIndexCheck)){
                return;
            }
        }
//WRITE TARGETNAME IN INDEX
        eMaster.setStringVar("coop_boundEntity"+fBoundIndex,sSlaveRawTargetname);
        eSlave.setStringVar("coop_bindMaster",eMaster.getRawTargetname());
        globalCoop_main_print("coop_bind()->BOUND: $"+sSlaveRawTargetname+" to "+eMaster.getTargetname());
    }
    //else{
        //globalCoop_main_print("coop_bindToOrigin()->WARNING: Bind to $"+eMaster.getRawTargetname()+" has failed");
    //}
}

void coop_setHealth(entity e,float fAdd,float fMax)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        float fCurrent;
        fCurrent = e.gethealth();
        if(fCurrent < fMax){
            fAdd += fCurrent;
            if(fAdd > fMax){
                fAdd = fMax;
            }
            e.health(fAdd);
        }
    }
}

void coop_lockThisDoor(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        e.lock();
        globalCoop_main_print("coop_lock()->LOCKED: "+e.getTargetname());
    }
    else{
        globalCoop_main_print("coop_lockThisDoor()->WARNING: Could NOT find specified entity");
    }
}

void coop_unlockThisDoor(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        e.unlock();
        globalCoop_main_print("coop_unlock()->UNLOCKED: "+e.getTargetname());
    }
    else{
        globalCoop_main_print("coop_unlockThisDoor()->WARNING: Could NOT find specified entity");
    }
}

void coop_triggerEntity(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        triggerEntity(e);
    }
}

void coop_triggerableThis(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        e.triggerable();
        globalCoop_main_print("coop_triggerable()->ENABLED: "+e.getTargetname());
    }
    else{
        globalCoop_main_print("coop_triggerable()->WARNING: Could NOT find specified entity");
    }
}

void coop_notTriggerableThis(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        e.nottriggerable();
        globalCoop_main_print("coop_triggerable()->DISABLED: "+e.getTargetname());
    }
    else{
        globalCoop_main_print("coop_triggerable()->WARNING: Could NOT find specified entity");
    }
}

void coop_selectionmovereset(entity e)
{
//ALLOW SELECTION AGAIN, ALLOW ALL TRIGGERS AGAIN
        e.setFloatVar("coop_noscript_selectionActive",0);
        e.setFloatVar("coop_noscript_selectionDisable",0);
        e.setFloatVar("coop_noscript_selectionTriggerIdendity",0);
        e.setFloatVar("coop_noscript_selectionIndex",0);
}

vector coop_returnOrigin(entity eGetMyOrigin)
//returns the vector of the given entity if exist, otherwise it returns ZERO ZERO ZERO
{
    if(doesEntityExist(eGetMyOrigin)){
        return eGetMyOrigin.getOrigin();
    }
    return '0 0 0';
}

void coop_callvollume_activate()
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        thread coop_triggerEntity(getEntity(eTrigger.getStringVar("uservar1")));
    }
}

void coop_setuplevel()
{
    coop_string_levelAuthor = $world.getStringVar("uservar1");
    if(coop_string_levelAuthor==""){
        coop_string_levelAuthor="^7uservar1 in $world is empty";
    }
    if($world.getStringVar("uservar2") == ""){
        globalCoop_main_print("WARNING: $world uservar2 is empty, should contain background story in ENGLISH");
    }else{
        coop_string_story = ""+$world.getStringVar("uservar2");
    }
    if($world.getStringVar("uservar3") == ""){
        globalCoop_main_print("WARNING: $world uservar3 is empty, should contain background story in GERMAN");
    }else{
        coop_string_story_deu = ""+$world.getStringVar("uservar3");
    }
}

void coop_printMessageToPlayer(entity ePlayer, string sMessage)
//prints message to player, for sp or mp!
{
    if(sMessage == ""){
        return;
    }
    if(!cvar_bool_multiplayer)
    {
        centerPrint(sMessage+"\n");
    }
    else if(doesEntityExist(ePlayer)){
        ePlayer.hudprint(sMessage+"\n");
    }
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////SINGLEPLAYERONLY//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_singleplayeronly()
//triggres given entities only in SP, commonly func_spawn, but could be anything, trigger,door,func_spawn,etc
//uservar1=entity to trigger (triggred allways, if set/exists)
//uservar2=entity to trigger (triggred allways, if set/exists)
//uservar3=entity to trigger (triggred allways, if set/exists)
//uservar4=entity to trigger (triggred allways, if set/exists)
{
    float fRemove = 0;
    if(cvar_bool_multiplayer){
        fRemove = 1;
    }
    entity    eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger))
    {
        globalCoop_main_print("coop_singleplayeronly()->ERROR: this does not work from console!");
        return;
    }
    
    //execute these triggers in singleplayer only
    float i,iExist=0;
    entity eTriggerMe;
    string sString;
    for(i=1;i<5;i++){
        sString = eTrigger.getStringvar("uservar"+i);
        if(sString != ""){
            eTriggerMe = getEntity(sString);
            
            if(doesEntityExist(eTriggerMe)){
                if(fRemove == 1){
                    float fRoundsLimit = 10;
                    while(doesEntityExist(eTriggerMe) == 1 && fRoundsLimit > 0){
                        fRoundsLimit--;
                        eTriggerMe.remove();
                        eTriggerMe = getNextEntity(eTriggerMe);
                    
                    }
                }else{
                    thread coop_triggerEntity(eTriggerMe);
                }
                iExist++;
            }
        }
    }
    
    if(iExist < 1){
        globalCoop_main_print("coop_singleplayeronly()->Couldn't find any entity specified in uservar1 to 4");
    }
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////MULTIPLAYERONLY//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_multiplayeronly()
//triggres given entities ONLY in MP, commonly func_spawn, but could be anything, trigger,door,func_spawn,etc
//uservar1=entity to trigger (triggers when minimum player count is hit or exceeded)
//uservar2=entity to trigger (triggers when minimum player count +1 player is hit or exceeded)
//uservar3=entity to trigger (triggers when minimum player count +2 players is hit or exceeded)
//uservar4=minimum player count to start triggering, usually 1 or 2, but could also be 8 (coop_maximum)
{
    
    entity    eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger))
    {
        globalCoop_main_print("coop_multiplayeronly()->ERROR: this does not work from console!");
        return;
    }
    
    float fRemove = 0;    
    float i=0;
    i = eTrigger.getFloatVar("uservar4");
    
    float fQuantity;
    fQuantity = globalCoop_return_integerPlayersQuantity(1);
    
    if(!cvar_bool_multiplayer || fQuantity < i){
        fRemove = 1;
    }
    
    
    //execute these triggers in multiplayer only
    float iExist=0;
    entity eTriggerMe;    
    string sString;
    float fRoundsLimit = 10;
    
    //required players limit hit    
    if( fQuantity >= i || fRemove == 1 ){
        sString = eTrigger.getStringvar("uservar1");
        eTriggerMe = getEntity(sString);
        if(doesEntityExist(eTriggerMe)){
            if(fRemove == 1){
                while(doesEntityExist(eTriggerMe) == 1 && fRoundsLimit > 0){
                    fRoundsLimit--;
                    eTriggerMe.remove();
                    eTriggerMe = getNextEntity(eTriggerMe);
                }
            }else{
                thread coop_triggerEntity(eTriggerMe);
                iExist++;
            }
        }
    }
    //required players limit hit +1 player
    if( fQuantity >= (i + 1) || fRemove == 1 ){
        sString = eTrigger.getStringvar("uservar2");
        eTriggerMe = getEntity(sString);
        if(doesEntityExist(eTriggerMe)){
            if(fRemove == 1){
                fRoundsLimit = 10;
                while(doesEntityExist(eTriggerMe) == 1 && fRoundsLimit > 0){
                    fRoundsLimit--;
                    eTriggerMe.remove();
                    eTriggerMe = getNextEntity(eTriggerMe);
                }
            }else{
                thread coop_triggerEntity(eTriggerMe);
                iExist++;
            }
        }
    }
    //required players limit hit +2 players
    if( fQuantity >= (i + 2) || fRemove == 1 ){
        sString = eTrigger.getStringvar("uservar3");
        eTriggerMe = getEntity(sString);
        if(doesEntityExist(eTriggerMe)){
            if(fRemove == 1){
                fRoundsLimit = 10;
                while(doesEntityExist(eTriggerMe) == 1 && fRoundsLimit > 0){
                    fRoundsLimit--;
                    eTriggerMe.remove();
                    eTriggerMe = getNextEntity(eTriggerMe);
                }
            }else{
                thread coop_triggerEntity(eTriggerMe);
                iExist++;
            }
        }
    }
    
//display this only if we didn't remove the entities our self, and the trigger should actuallally really trigger
    if(iExist < 1 && fRemove == 0 && fQuantity >= i){
        globalCoop_main_print("coop_multiplayeronly()->Couldn't find any entity specified in uservar1 to 3");
    }//else if(fRemove == 0){
    //globalCoop_main_print("coop_multiplayeronly()->INFO: uservar4 is set to "+i+" required players");
    //}
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////CINEMATIC//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_cinstart()
//starts cinematic sequence
{    
//Exit if allready running a instance
    if( getCvarInt("sv_cinematic") ){
        return;
    }
    letterbox(.01);
    wait(0.1);
    
    if(!cvar_bool_multiplayer){//singleplayer
        waitForplayer();
    //do not run cinematic before player has joined, otherwise it'll chrash!
        globalCoop_level_hideAndNotSolid($player);
        $player.nodamage();//damage from (hurt)triggers
    }
    
    cinematic();
    freezeplayer();
}

void coop_cinend()
//ends cinematic sequence
{
    if( getCvarInt("sv_cinematic") ){
        clearletterbox( .01 );
    }
    
    cueplayer();
    noncinematic();
    releaseplayer();
    
//Singleplayer
    if(!cvar_bool_multiplayer){
        globalCoop_level_showAndSolid($player);
        $player.takedamage();
    }
}

void coop_cinskipnow()
//is used to be called by the game when cinematic is skipped
{
    globalCoop_main_print("coop_cinskipnow() - trying to skip");
    coop_cinend();
    wait(0.05);
    skipthread("");
}

void coop_cinskipable()
//used to trigger a entity given in uservar1 in order to skip the current cinematic sequence
//uservar1=targetname of trigger/entity to activate when cinematic is skipped
{
    entity    eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger))
    {
        globalCoop_main_print("coop_skipthread()->ERROR: this does not work from console!");
        return;
    }
    skipthread("coop_cinskipnow");
}
void coop_cincuecamera()
//grabs camara, and starts filming from there - angle and origin of the entity given in uservar will be copied and the given entity will be removed, a real camera will be spawned in its place 
//uservar1=targetname of camera
//uservar2=fiel of view - range 0 to 110
{
    entity    eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_cincuecamera()->ERROR: this does not work from console!");
        return;
    }
    
    string sString1;
    float    fFov=0;
    sString1    = eTrigger.getStringvar("uservar1");
    fFov        = eTrigger.getFloatVar("uservar2");
    
    entity eFakeCamera;
    eFakeCamera=getEntity(sString1);
    if(!doesEntityExist(eFakeCamera)){
        globalCoop_main_print("coop_cincuecamera()->ERROR: Couldn't find Camera specified in uservar1");
        return;
    }
    
    entity    eCamera;
    vector vAngles,vOrigin;
    vAngles = eFakeCamera.getangles();
    vOrigin = eFakeCamera.getOrigin();
    eCamera = spawn("camera","targetname",eFakeCamera.getRawTargetname());
    eFakeCamera.remove();
    
    wait( coop_float_oneFrameTime );
    eCamera.fov(fFov);
    eCamera.angles(vAngles);
    eCamera.origin(vOrigin);
    cuecamera(eCamera);
}


void coop_cincamfollowpath()
//grabs camara and puts it on the given path, then starts filming from there - if camera does not exist, it will be spwned on the given path
//uservar1=camera targetname
//uservar2=path targetname
//uservar3=fiel of view - range 0 to 110
{
    entity    eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_cincamfollowpath()->ERROR: this does not work from console!");
        return;
    }
    
    string sString1;
    string sString2;
    float fFov;
    
    sString1    = eTrigger.getStringvar("uservar1");
    sString2    = eTrigger.getStringvar("uservar2");
    fFov        = eTrigger.getFloatvar("uservar3");
    
    //wait a moment here, to make sure the camera is spawned properly in the call before this (usually: coop_cincuecamera)
    wait( coop_float_oneFrameTime );
    
    entity    eCamera,ePath;
    ePath=getEntity(sString2);
    if(!doesEntityExist(ePath)){
        globalCoop_main_print("coop_cincamfollowpath()->ERROR: Couldn't find Path (entity) specified in uservar2");
        return;
    }

    eCamera=getEntity(sString1);

    //wait a moment, if the camera is not yet spawned by a other cinematic function
    if(!doesEntityExist(eCamera)){
        wait( coop_float_oneFrameTime );
    //try again
        eCamera=getEntity(sString1);
        
        //if the blody camera does not exist, spawn it        
        if(!doesEntityExist(eCamera)){
            entity    eCamera;
            vector vAngles,vOrigin;
            vAngles = ePath.getangles();
            vOrigin = ePath.getOrigin();
            eCamera = spawn("camera","targetname",""+sString1);
            wait( coop_float_oneFrameTime );
        }
    }
    
    //move camera to path, adapt to path, set field of view, follow path, cut to camera and start filming from there
    eCamera.angles(vAngles);
    eCamera.origin(vOrigin);
    eCamera.fov(fFov);
    eCamera.follow( ePath );
    cuecamera(eCamera);    
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////MUSIC//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_mood()
//changes the current music mood
{
    entity eTrigger, ePlayer;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_mood()->ERROR: this does not work from console!");
        return;
    }
    string sMusicMood;
    sMusicMood = eTrigger.getStringVar("uservar1");
    
    music( sMusicMood , "normal" );
}

void coop_moodlocal()
//changes the current music mood, for the local players only
{
    entity eTrigger, ePlayer;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_moodlocal()->ERROR: this does not work from console!");
        return;
    }
    string sMusicMood;
    sMusicMood = eTrigger.getStringVar("uservar1");    
    
    if(!cvar_bool_multiplayer){
        music( sMusicMood , "normal" );
    }else{
        entity ePlayer;
        float fPlayerId;
        for(fPlayerId=0;fPlayerId<coop_integer_maxPlayers;fPlayerId++){
            ePlayer = getentity("player"+fPlayerId);
            if(globalCoop_check_isEntityTouchingOther(ePlayer,eTrigger,0)){
                ePlayer.music( sMusicMood , "normal" );
                ePlayer.hudprint("touch me baby\n");
            }else{
                ePlayer.hudprint("not touching\n");
            }
        }
    }
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////PLAYER//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_addhud()
//adds hud to player activating the trigger
//uservar1 = hudname
//uservar2 =
//uservar3 =
//uservar4 = all/team/activatior
{
    entity eTrigger, ePlayer;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_addhud()->ERROR: this does not work from console!");
        return;
    }
    
    string sHudname;
    ePlayer = eTrigger.getLastActivatingEntity();
    sHudname = eTrigger.getStringVar("uservar1");
    
    if(sHudname == ""){
        globalCoop_main_print("coop_addhud()->ERROR: No hudname specified in uservar1!");
        return;
    }
    
    string sIndividually;
    sIndividually = getStringVar("uservar4");
    
    if( sIndividually != "all" && sIndividually != "team" ){
        thread globalCoop_huds_Add(ePlayer,sHudname);
    }else{
        if(!cvar_bool_multiplayer){
            thread globalCoop_huds_Add($player,sHudname);
        }else{
            float fPlayerIdInUse; 
            for(fPlayerIdInUse=0;fPlayerIdInUse<coop_integer_maxPlayers;fPlayerIdInUse++){
                ePlayer = getentity("player"+fPlayerIdInUse);
                thread globalCoop_huds_Add(ePlayer,sHudname);
            }
        }
    }
}




void coop_removehud()
//removes hud from player activating the trigger
//uservar1 = hudname
//uservar2 =
//uservar3 =
//uservar4 = all/team/activatior
{
    entity eTrigger,ePlayer;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_removehud()->ERROR: this does not work from console!");
        return;
    }
    
    ePlayer = eTrigger.getLastActivatingEntity();
    
    string sHudname;
    sHudname = getStringVar("uservar1");
    
    if(sHudname == ""){
        globalCoop_main_print("coop_removehud()->ERROR: No hudname specified in uservar1!");
        return;
    }
    
    string sIndividually;
    sIndividually = getStringVar("uservar4");
    
    if( sIndividually != "all" && sIndividually != "team" ){
        if(doesEntityExist(ePlayer)){ePlayer.removehud(sHudname);}
    }else{
        if(!cvar_bool_multiplayer){
            $player.removehud(sHudname);
        }else{
            float fPlayerIdInUse; 
            for(fPlayerIdInUse=0;fPlayerIdInUse<coop_integer_maxPlayers;fPlayerIdInUse++){
                ePlayer = getentity("player"+fPlayerIdInUse);
                if(doesEntityExist(ePlayer)){
                    if(doesEntityExist(ePlayer)){ePlayer.removehud(sHudname);}
                }
            }
        }
    }
}


void coop_addhudtemporary()
//adds hud temporarly to player activating the trigger
//uservar1 = hudname
//uservar2 = time to wait before removal
//uservar3 =
//uservar4 = all/team/activatior
{
    entity eTrigger,ePlayer;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_addhudtemporary()->ERROR: this does not work from console!");
        return;
    }
    
    string sHudname;
    float fRemove=0;
    sHudname = eTrigger.getStringVar("uservar1");
    fRemove = eTrigger.getFloatVar("uservar2");    
    ePlayer = eTrigger.getLastActivatingEntity();
    
    if(sHudname == ""){
        globalCoop_main_print("coop_addhudtemporary()->ERROR: No hudname specified in uservar1!");
        return;
    }
    
    if(fRemove == 0){
        globalCoop_main_print("coop_addhudtemporary()->WARNING: uservar2 not set? Should be time in secounds!");
    }

    
    string sIndividually;
    sIndividually = getStringVar("uservar4");
    
    if( sIndividually != "all" && sIndividually != "team" ){
        thread globalCoop_huds_Add(ePlayer,sHudname);
        
        wait((fRemove + 0.01));
        if(doesEntityExist(ePlayer)){ePlayer.removehud(sHudname);}
    }
    else{
        if(!cvar_bool_multiplayer){
            thread globalCoop_huds_Add($player,sHudname);
        }else{
            float fPlayerIdInUse; 
            for(fPlayerIdInUse=0;fPlayerIdInUse<coop_integer_maxPlayers;fPlayerIdInUse++){
                ePlayer = getentity("player"+fPlayerIdInUse);
                thread globalCoop_huds_Add(ePlayer,sHudname);
            }
        }
        
        wait((fRemove + 0.01));        
        if(!cvar_bool_multiplayer){
            $player.removehud(sHudname);
        }else{
            for(fPlayerIdInUse=0;fPlayerIdInUse<coop_integer_maxPlayers;fPlayerIdInUse++){
                ePlayer = getentity("player"+fPlayerIdInUse);        
                if(doesEntityExist(ePlayer)){
                    ePlayer.removehud(sHudname);
                }
            }
        }
    }
}



////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////MISSION//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_missionobjective()
//marks a entity as a missiobjective on the player radar
//uservar1 = targetname
//uservar2 = targetname
//uservar3 = targetname
//uservar4 = targetname
{
    entity eTrigger,eTarget;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sTargetname;
        float i;
        for(i=1;i<5; i++){
            sTargetname = eTrigger.getStringVar("uservar"+i);
            if(sTargetname != ""){
                eTarget = getEntity(sTargetname);
                if(doesEntityExist(eTarget)){
                    eTarget.missionobjective(1);
                }else{
                    globalCoop_main_print("coop_missionobjective()->WARNING: Entity from uservar"+i+" with targetname $"+sTargetname+" could not be found! ");
                }
            }
        }        
    }
}

void coop_nomissionobjective()
//Unmarks a entity as a missiobjective on the player radar
//uservar1 = targetname
//uservar2 = targetname
//uservar3 = targetname
//uservar4 = targetname
{
    entity eTrigger,eTarget;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sTargetname;
        float i;
        for(i=1;i<5; i++){
            sTargetname = eTrigger.getStringVar("uservar"+i);
            if(sTargetname != ""){
                eTarget = getEntity(sTargetname);
                if(doesEntityExist(eTarget)){
                    eTarget.missionobjective(0);
                }else{
                    globalCoop_main_print("coop_missionobjective()->WARNING: Entity from uservar"+i+" with targetname $"+sTargetname+" could not be found! ");
                }
            }
        }        
    }
}


void coop_map()
//Load a Map, used for level change on missions
//Specify map on uservar1
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        //[b607] chrissstrahl - prevent any issues if the wrong trigger type is used
        if(doesEntityExist(eTrigger)){
            eTrigger.nottriggerable();
        }
        
        string sMap;
        sMap = eTrigger.getStringVar("uservar1");
        if(sMap == ""){
            globalCoop_main_print("coop_map()->ERROR: No mapname specified, specify mapname in uservar1");
            centerprint("^1coop_map()^5->^1ERROR ^3No mapname specified, specify mapname in uservar1\n");
            return;
        }
        //[b607] chrissstrahl - changed to thread to fix a bug, but it didn't work - keeping it anyway
        thread globalCoop_server_loadGivenMapNow(sMap);
    }
}

void coop_accomplished()
//Marks the current Level/Mission to be sucessfull.
//Use this if you want to load the next Map or Display Mission Sucess Screen Instead of Mission Failure if the Time runs out before you the Mission Completed screen is shown/next level is loadad
//EXAMPLE: Objectives are complete, and Level-End Cinematic is running while level time runs out.
{
    thread globalCoop_mission_accomplished();
}

void coop_count()
//counts upwards the given name and triggers the given entity when the limit is hit
//uservar1=nameforthiscounter
//uservar2=NUMBER_limit
//uservar3=targetname
{
    float fLimit,fCurrent;
    entity eTrigger,eTarget;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sName,sEntity;
        
        sName = eTrigger.getStringVar("uservar1");
        if(sName == ""){
            globalCoop_main_print("coop_count()->ERROR: uservar1 was empty, but needs any name");
            return;
        }
        
        fLimit = eTrigger.getFloatVar("uservar2");
        if(fLimit == 0 ){
            globalCoop_main_print("coop_count()->ERROR: uservar2 was empty or 0, but needs 1 or higher");
            return;
        }
        
        sEntity = eTrigger.getStringVar("uservar3");
        if(sEntity == ""){
            globalCoop_main_print("coop_count()->ERROR: uservar3 was empty, but needs targetname of entity to trigger");
            return;
        }
        
        fCurrent = $world.getFloatVar("coop_count"+sName);
        fCurrent++;
        if(fCurrent ==  fLimit){
            eTarget=getEntity(sEntity);
            if(doesEntityExist(eTarget)){
                triggerEntity(eTarget);
                globalCoop_main_print("coop_count()->sucessfully triggred: $"+sEntity);
            }else{
                globalCoop_main_print("coop_count()->ERROR: target entity specified in uservar3 not found");
            }
        }else{
            globalCoop_main_print("coop_count()->"+sName+" count set to: "+fCurrent);
        }
        $world.setFloatVar("coop_count"+sName,fCurrent);
    }
}

void coop_complete()
//End the Level/Mission Sucessfully
//uservar1 allows you to specify a map to load
//If uservar2 is set to noscreen the sucess -screen is not displayed (Multiplayer only)
{
//mark sucessfull right now
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    //OVERWRITE CO-OP DEFAULT SETTINGS
        coop_bool_showMissionSucessHud = 1;//show sucess hud at the end of the mission    
        coop_string_nextMapToCheck=eTrigger.getStringVar("uservar1");
        if(coop_string_nextMapToCheck == ""){
            globalCoop_main_print("coop_complete()->WARNING: No mapname specified in uservar1, reloading same map");
        }
        if(    eTrigger.getStringVar("uservar2") == "noscreen")
        {
            coop_bool_showMissionSucessHud = 0;
        }
    }
    thread coop_endLevel();
}

void coop_fail()
//Fail the Mission
//Specify reason on uservar1
//EXAMPLE: Key=uservar1 Value=You did fail a important mission objective!
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        globalCoop_mission_failWithReason(eTrigger.getStringVar("uservar1"));
    }
}

void coop_savegame()
//Saves the Mission on Singleplayer
//Specify savegame-name on uservar1
{
    if(!cvar_bool_multiplayer){
        entity eTrigger;
        eTrigger=getCurrentEntity();
        
        if(doesEntityExist(eTrigger)){
                    string sSaveName;
            sSaveName =  "^5" + ""+cvar_string_mapname+"^8 "+eTrigger.getStringVar("uservar1")+"^8";
            
            if($player.getHealth() > 0 && getcvarInt("com_canAutoSaveNow") != 0){
                stuffcmd("ui_savegamewithname \""+sSaveName+"\"\n");
            }else{
                globalCoop_main_print("coop_savegame()->INFO: Savegame not allowed right now, discarded");
            }
        }
    }
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////DIALOGS//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_dialogstop()
//Stops playing Dialog, set current to stop current speaker set all to stop alldialogs
//Specify entities in uservar1 to uservar2
//EXAMPLE1: uservar1 current
//EXAMPLE2: uservar1 all
//EXAMPLE3: uservar1 current - uservar2 munro
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eShutUp;
        float fCounter;
        float fTargeted;
        string sString;
        eShutUp=eTrigger.getTargetEntity();
        thread globalCoop_dialog_stop(eShutUp);
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                if(sString == "current"){
                    thread globalCoop_dialog_stop(coop_entity_dialogSpeaker);
                }else if(sString == "all"){
                    thread globalCoop_dialog_stopAll();
                }
                else{
                    eShutUp=getEntity(sString);
                    thread globalCoop_dialog_stop(eShutUp);
                }
            }
        }
    }
}

void coop_dialog()
//Plays a Dialog at the given Entity or the Player closest to the trigger
//uservar1 = NPC targetname without $, set player to play dialog on a player
//uservar2 = Dialog to play, Syntax is: folder/dialog.mp3
//EXAMPLE: train2/tuvok_yourrec.mp3
//DO NOT USE deu/sound/dialog/
//DO NOT USE eng/sound/dialog/
//DO NOT USE localization/dialog/
//uservar3 = MUST BE A NUMBER! Volume of the dialog 1 is default and best to be used
//uservar4 = MUST BE A NUMBER! Minimum Range of full Dialog volume, use 1000 or above to display the head hud
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        float fVolume;
        float fRange;
        float fHeadHud;
        float fTargeted;
        string sString1;
        string sString2;
        entity eActor;
        entity eTargeted;
        sString1    = eTrigger.getStringvar("uservar1");
        sString2    = eTrigger.getStringvar("uservar2");
        fVolume        = eTrigger.getFloatvar("uservar3");
        fRange        = eTrigger.getFloatVar("uservar4");
        eTargeted=eTrigger.getTargetEntity();
        if(doesEntityExist(eTargeted)){
            if(eTargeted.getStringvar("uservar1") == "" && eTargeted.getStringvar("uservar2") == ""){
                fTargeted=1;
                eActor=eTargeted;
            }
        }
        if(sString1 != "" || fTargeted == 1){
            if(!fTargeted){
                if(sString1 == "player"){
                    eActor=globalCoop_return_playerClosestActive(eTrigger);
                }else{
                    eActor=getEntity(sString1);
                }
            }
            if(doesEntityExist(eActor)){
                if(sString2 == ""){
                    globalCoop_main_print("coop_playdialog()->ERROR: uservar2 must contain the Dialog to play, was->EMPTY");
                    return;
                }
//check range setting
                if(fRange >= 1000){fHeadHud = 1;}
                else if(fRange < 64){fRange=64;}
//check dialog volume settings
                if(fVolume < 1){fVolume=1;}
//play the dialog now
                //globalCoop_dialog_play(eActor,sString2,fVolume,fRange,fHeadHud);
                globalCoop_dialog_play(eActor,sString2,5,400,0);
            }else{
                globalCoop_main_print("coop_playdialog()->ERROR: uservar1 must contain NPC targetname without $ or value player\nValue was->"+eTrigger.getStringvar("uservar1"));
            }
        }else{
            globalCoop_main_print("coop_playdialog()->ERROR: uservar1 must contain NPC targetname without $ or value player\nValue was->EMPTY");
        }
    }
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////TEAMMATES//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//removed in [b607]

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////ALLPLAYERS//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_everyone()
//Executes a Command on all players.
//Specify in uservar1 to uservar4
//EXAMPLE: uservar1 ammo
//droptofloor    = Drops all players to the ground
//kill            = Kills every player
//hide            = Hides all players
//show            = Shows all players
//nodamage        = Makes players invinceble
//takedamage    = Makes players take damage as usual again
//putaway        = Puts player weapons away
//disable        = Disable Player Weapons
//enable        = Enable Player Weapons again
//health        = Restores health to maximum
//ammo            = gives some ammo
//armor            = gives some armor to all players
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter,fValid;
        string sString;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                fValid++;
                //globalCoop_main_print("coop_everyone()->ALL PLAYERS: "+sString);
                thread globalCoop_main_globalCommand(sString);
            }
        }
        if(fValid == 0){
            globalCoop_main_print("coop_everyone()->ERROR: All uservars are EMPTY!");
        }        
    }
}


void coop_immobilize()
//Immobilizes ALL PLAYERS, disables moving and fireing weapon
{
    globalCoop_player_imobilizeAll(1);
}

void coop_mobilize()
//Mobilizes ALL PLAYERS again, so they can move and fire again
{
    globalCoop_player_imobilizeAll(0);
}

void coop_weapongive()
//Gives a weapon to all players and makes them "use" the last specified.
//Specify weapons in uservar1 to uservar4
//EXAMPLE: uservar1 burstrifle
//AVIALABLE WEAPONS ARE:
//attrex-rifle
//batleth
//burstrifle
//compressionrifle
//drull-staff
//enterprise
//fieldassaultrifle
//grenadelauncher
//IMod
//phaser
//phaser-STX
//photon
//rom-datapad
//rom-radgun
//rom-disruptor
//sniperrifle
//tetryon
//tricorder
//tricorder-STX
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_weapongive()->executed!");
        float fCounter,fValid;
        string sString;
        string sLast;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);        
            
            if(sString != ""){
                fValid++;
                sLast = sString;
                //globalCoop_main_print("coop_weapongive()->Given: "+sString);
                sLast = "models/weapons/worldmodel-"+sString+".tik";
                thread globalCoop_player_giveAll(sLast,0.5);//give,useafterdelayof
            }
        }
        if(fValid == 0){
            globalCoop_main_print("coop_weapongive()->ERROR: All uservars are EMPTY!");
        }
    }
}


void coop_weapontake()
//TAKES a weapon FROM all players.
//Specify weapons in uservar1 to uservar4
//EXAMPLE: uservar1 burstrifle
//AVIALABLE WEAPONS ARE:
//attrex-rifle
//batleth
//burstrifle
//compressionrifle
//drull-staff
//enterprise
//fieldassaultrifle
//grenadelauncher
//IMod
//phaser
//phaser-STX
//photon
//rom-datapad
//rom-radgun
//sniperrifle
//tetryon
//tricorder
//tricorder-STX
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter,fValid;
        string sString;    
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                fValid++;
                //globalCoop_main_print("coop_weapontake()->TAKEN: "+sString);
                thread globalCoop_player_takeAll("models/weapons/worldmodel-"+sString+".tik");
            }
        }
        if(fValid == 0){
            globalCoop_main_print("coop_weapontake()->ERROR: All uservars are EMPTY!");
        }
    }
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////OBJECTIVES//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

void coop_objective()
//Set a mission Objective text in the Mission Objective Hud
//uservar1 = Item Number, range: 1 to 8
//uservar2 = Objective State, valid: complete,failed,active
//uservar3 = Objective Item Text, specify your Objective text
//uservar4 = German Objective Item Text
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sString1;
        string sString2;
        string sString3;
        string sString4;
        sString1 = eTrigger.getstringvar("uservar1");
        sString2 = eTrigger.getstringvar("uservar2");
        sString3 = eTrigger.getstringvar("uservar3");
        sString4 = eTrigger.getstringvar("uservar4");
        float fObjectiveItem = 0;        
        if(sString1 == "1"){fObjectiveItem=1;}
        if(sString1 == "2"){fObjectiveItem=2;}
        if(sString1 == "3"){fObjectiveItem=3;}
        if(sString1 == "4"){fObjectiveItem=4;}
        if(sString1 == "5"){fObjectiveItem=5;}
        if(sString1 == "6"){fObjectiveItem=6;}
        if(sString1 == "7"){fObjectiveItem=7;}
        if(sString1 == "8"){fObjectiveItem=8;}
        if(fObjectiveItem == 0){
            globalCoop_main_print("coop_objective()->No Objective Item NUMBER specified on uservar1, range is 1 to 8");
            globalCoop_main_print("coop_objective()->ERROR: NOSCRIPT can not create Objective");
            return;
        }
        if(sString2 != "complete" && sString2 != "failed" && sString2 != "active"){
            globalCoop_main_print("coop_objective()->WARNING: Objective state in uservar2 invalid");
            globalCoop_main_print("coop_objective()->INFO: NOSCRIPT using now: active");
            sString2 = "active";
        }
        if(sString3 == "" && sString2 != "complete"){
            globalCoop_main_print("coop_objective()->INFO: WARNING: "+fObjectiveItem+" no Objective-Text specified on uservar3");
        }
        
        if(fObjectiveItem==1){
            coop_string_objectiveItem1=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem1);
            coop_string_objectiveItem1_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem1_deu);}
        if(fObjectiveItem==2){
            coop_string_objectiveItem2=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem2);
            coop_string_objectiveItem2_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem2_deu);}
        if(fObjectiveItem==3){
            coop_string_objectiveItem3=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem3);
            coop_string_objectiveItem3_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem3_deu);}
        if(fObjectiveItem==4){
            coop_string_objectiveItem4=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem4);
            coop_string_objectiveItem4_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem4_deu);}
        if(fObjectiveItem==5){
            coop_string_objectiveItem5=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem5);
            coop_string_objectiveItem5_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem5_deu);}
        if(fObjectiveItem==6){
            coop_string_objectiveItem6=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem6);
            coop_string_objectiveItem6_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem6_deu);}
        if(fObjectiveItem==7){
            coop_string_objectiveItem7=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem7);
            coop_string_objectiveItem7_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem7_deu);}
        if(fObjectiveItem==8){
            coop_string_objectiveItem8=globalCoop_return_string1IfString2IsEmpty(sString3,coop_string_objectiveItem8);
            coop_string_objectiveItem8_deu=globalCoop_return_string1IfString2IsEmpty(sString4,coop_string_objectiveItem8_deu);}

        if(    sString2 != "complete" &&
            sString2 != "failed" &&
            sString2 != "active" )
        {
            sString2 = "active";
        }        
        thread globalCoop_objectives_update(sString2,fObjectiveItem,1);
    }
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////PUZZLES//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////NPC - ARTIFICIAL INTELEGENCE//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_aion()
//Activate NPC AI, Make them think on their own
//uservar1 = Targetname of NPC of which you want to turn on it's AI
//uservar2 = Targetname of NPC of which you want to turn on it's AI
//uservar3 = Targetname of NPC of which you want to turn on it's AI
//uservar4 = Targetname of NPC of which you want to turn on it's AI
//Grabs also Targetentity
//Grabs also entity activating the Trigger
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    
        float fCounter;
        string sString;
        entity eAi;
        eAi = eTrigger.getLastActivatingEntity();
        if(coop_checkExistHasModelPrintWithTargetname(eAi,"coop_aion()->AI_ON: "+eAi.getTargetName())){
            eAi.ai_on();
        }
        eAi = eTrigger.getTargetEntity();
        if(coop_checkExistHasModelPrintWithTargetname(eAi,"coop_aion()->AI_ON: "+eAi.getTargetName())){
            eAi.ai_on();
        }
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eAi=getEntity(sString);
                if(coop_checkExistHasModelPrintWithTargetname(eAi,"coop_aion()->AI_ON: "+eAi.getTargetName())){
                    eAi.ai_on();
                }
            }
        }
    }
}

void coop_aioff()
//Deactivate NPC AI, NPC will stand arround and do nothing
//uservar1 = Targetname of NPC of which you want to turn off it's AI
//uservar2 = Targetname of NPC of which you want to turn off it's AI
//uservar3 = Targetname of NPC of which you want to turn off it's AI
//uservar4 = Targetname of NPC of which you want to turn off it's AI
//Grabs also Targetentity
//Grabs also entity activating the Trigger
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        string sString;
        entity eAi;
        eAi = eTrigger.getLastActivatingEntity();
        if(coop_checkExistHasModelPrintWithTargetname(eAi,"coop_aioff()->AI_OFF: "+eAi.getTargetName())){
            eAi.ai_off();
        }
        eAi = eTrigger.getTargetEntity();
        if(coop_checkExistHasModelPrintWithTargetname(eAi,"coop_aion()->AI_OFF: "+eAi.getTargetName())){
            eAi.ai_off();
        }
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eAi = getEntity(sString);
                if(coop_checkExistHasModelPrintWithTargetname(eAi,"coop_aioff()->AI_OFF: "+eAi.getTargetName())){
                    eAi.ai_off();
                }
            }
        }
    }
}

void coop_animate()
//Makes a AI do a Animation and leave the AI turned off
//Specify targetname in uservar1 and Animatiosn in uservar2 to userver4
//If no targetname is specified the NPC triggering the trigger will be handled
//This repeats animation, to play animation only once you must set idle or stopanimating in a uservar
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eAi;
        float fUseUservar1;
        string sString1;
        string sString2;
        string sString3;
        string sString4;
        string sTargetname;
        sString1=eTrigger.getStringVar("uservar1");
        sString2=eTrigger.getStringVar("uservar2");
        sString3=eTrigger.getStringVar("uservar3");
        sString4=eTrigger.getStringVar("uservar4");
//CHECK ACTIVATOR
        eAi = eTrigger.getLastActivatingEntity();
        if(coop_checkIsNotPlayerHasModel(eAi)){
            sTargetname = eAi.getRawtargetname();
            if(sTargetname != "world"){
                globalCoop_main_print("coop_aianimate()->Triggered by ACTIVATOR: "+sTargetname);
                fUseUservar1=1;
            }
        }
//CHECK TARGET
        else{
            eAi = eTrigger.getTargetEntity();
            if(coop_checkIsNotPlayerHasModel(eAi)){
                fUseUservar1=1;
            }
        }
//CHECK USERVARS
        if(doesEntityExist(eAi) == 0 || fUseUservar1 == 0 ){
//GRAB USERVAR1 ENTITY
            eAi = getEntity(sString1);
//EXIT WHEN MISSING
            if(!doesEntityExist(eAi)){
                globalCoop_main_print("coop_aianimate()->ERROR: Coudn't find the NPC! Needs targetname in uservar1 or a target (Control+K)");
                return;    
            }
        }
        eAi.ai_off();
        
        globalCoop_main_print("coop_aianimate()->ANIMATING ENTITY: "+eAi.getTargetName());
        float fIndexCurrent,fIndexCalled;
        fIndexCurrent = eAi.getFloatVar("coop_animationIndex");
        fIndexCalled = fIndexCurrent;
        fIndexCalled++;
        
        eAi.setFloatvar("coop_animationIndex",fIndexCalled);
        if(fUseUservar1 == 1 && sString1 != ""){
            globalCoop_actor_animateWaitForAnimation(eAi,sString1);
        }
        
        if(sString2 != ""){
            if(eAi.getFloatvar("coop_animationIndex") == fIndexCalled){
                globalCoop_actor_animateWaitForAnimation(eAi,sString2);
            }
        }
        if(sString3 != ""){
            if(eAi.getFloatvar("coop_animationIndex") == fIndexCalled){
                globalCoop_actor_animateWaitForAnimation(eAi,sString3);
            }
        }
        if(sString4 != ""){
            if(eAi.getFloatvar("coop_animationIndex") == fIndexCalled){
                globalCoop_actor_animateWaitForAnimation(eAi,sString4);
            }
        }
        
        return;
        
        
        if(    sString1 != "" && sString1 == "stopanimating" ||
            sString2 != "" && sString2 == "stopanimating" ||
            sString3 != "" && sString3 == "stopanimating" ||
            sString4 != "" && sString4 == "stopanimating"  )
        {
            if(eAi.getFloatvar("coop_animationIndex") == fIndexCalled){
                eAi.stopAnimating();
            }
        }
    }
}


void coop_animateaion()
//Makes a AI do a Animation and tunrs AI ON again
//Specify targetname in uservar1 and Animations in uservar2, uservar3 and userver4
//If no targetname is specified the NPC triggering the trigger will be handled
//This repeats animation, to play animation only once you must set idle or stopanimating in a uservar
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eAi;
        string sString1;
        sString1 = eTrigger.getStringVar("uservar1");
        if(sString1 == ""){
            globalCoop_main_print("coop_aianimate()->ERROR: NO ACTOR targetname specified in uservar1!");
            return;
        }
        eAi = getEntity(sString1);
        if(!doesEntityExist(eAi)){
            globalCoop_main_print("coop_aianimate()->ERROR: Coudn't find the ACTOR specified in uservar1: $"+sString1);
            return;
        }
        
        
        string sString2;
        string sString3;        
        sString1=eTrigger.getStringVar("uservar2");
        sString2=eTrigger.getStringVar("uservar3");
        sString3=eTrigger.getStringVar("uservar4");
        
        string sAnimation;
        float fUservarNum;
        for(fUservarNum = 2;fUservarNum<5;fUservarNum++){
            if(fUservarNum==2){sAnimation = sString1;}
            else if(fUservarNum==3){sAnimation = sString2;}
            else{sAnimation = sString3;}
            
            if(sAnimation != ""){
                if(sAnimation != "stopanimating" || sAnimation != "stop"){//play animation and wait for it to end, before playing the next animation
                    globalCoop_actor_animateWaitForAnimation(eAi,sAnimation);
                }else if(doesEntityExist(eAi)){//halt animation
                    eAi.stopAnimating();
                }
            }
        }
//renable ai again
        if(doesEntityExist(eAi)){
            eAi.ai_on();
        }
    }
}

void coop_hurt()
//Hurt the entity, basicly substracts health and gives pain to the entity
//uservar1 = Entity Targetname
//uservar2 = Entity Targetname
//uservar3 = Entity Targetname
//uservar4 = Ammount of damage
//Grabs also target entity
//To hurt entity entering a trigger please use a trigger_hurt
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        float fHurt;
        string sString;
        entity eHurt;
        fHurt=eTrigger.getFloatVar("uservar4");
        if(fHurt == 0){
            fHurt=5;
        }
        eHurt=eTrigger.getTargetEntity();
        if(coop_checkExistHasModelAndHealth(eHurt)){
            eHurt.hurt(fHurt);
            globalCoop_main_print("coop_hurt()->HURT: "+eHurt.getTargetname());
        }
        while(fCounter<3){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eHurt=getEntity(sString);
                if(coop_checkExistHasModelAndHealth(eHurt)){
                    globalCoop_main_print("coop_hurt()->HURT: "+eHurt.getTargetname());
                    eHurt.hurt(fHurt);
                }
            }
        }
        if(!doesEntityExist(eHurt)){
            globalCoop_main_print("coop_hurt()->WARNING: Coud not hurt entities specified in uservar1 to 3, they do not or nolonger exist!");
        }
    }
}

void coop_heal()
//Heal the entity, basicly adds health to the entity
//uservar1 = Entity Targetname
//uservar2 = Entity Targetname
//uservar3 = Ammount of healing
//uservar4 = Max Health
//Heals also Entity Activating the trigger
//Heals also targetentity
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        float fHeal;
        float fHealMax;
        string sString;
        entity eHeal;
        eHeal=eTrigger.getLastActivatingEntity();
        fHeal=eTrigger.getFloatVar("uservar3");
        fHealMax=eTrigger.getFloatVar("uservar4");
        if(fHeal == 0){
            fHeal=5;
        }
        if(fHealMax == 0){
            fHealMax=200;
        }
        if(coop_checkExistHasModelAndHealth(eHeal)){
            globalCoop_main_print("coop_heal()->HEALING: "+eHeal.getTargetname());
            thread coop_setHealth(eHeal,fHeal,fHealMax);
        }
        eHeal=eTrigger.getTargetEntity();
        if(coop_checkExistHasModelAndHealth(eHeal)){
            globalCoop_main_print("coop_heal()->HEALING: "+eHeal.getTargetname());
            thread coop_setHealth(eHeal,fHeal,fHealMax);
        }
        while(fCounter<3){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eHeal=getEntity(sString);
                if(coop_checkExistHasModelAndHealth(eHeal)){
                    globalCoop_main_print("coop_heal()->HEALING: "+eHeal.getTargetname());
                    thread coop_setHealth(eHeal,fHeal,fHealMax);
                }
            }
        }
    }
}


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////LEVEL OBJECTS SCRIPT_OBJECTS//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/* contents + sets - removes
shootable
targetable
body
solid
usable
setclip
playerclip
monsterclip
cameraclip
weaponclip
corpse
all
*/

void coop_viewmode()
//makes the entity specified in uservars 2 3 and 4 only visible during the viewmode specified in uservar1
//Avialable: tracegas,structuralintegrity,phaseshift,nightvision,torpedostrike,enemydetect,tripwire
//uservar1=viewmodename
//uservar2=targetname
//uservar3=targetname
//uservar4=targetname
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        return;
    }
    
    string sViewmode;
    sViewmode = eTrigger.getstringvar("uservar1");
    if(sViewmode == ""){
        globalCoop_main_print("coop_viewmode()->ERROR: No viewmode set in uservar2!");
        return;
    }
    if( sViewmode != "tracegas" &&
        sViewmode != "structuralintegrity" &&
        sViewmode != "phaseshift" &&
        sViewmode != "nightvision" &&
        sViewmode != "torpedostrike" &&
        sViewmode != "enemydetect" &&
        sViewmode != "tripwire"
    ){
        globalCoop_main_print("Viewmodenames: tracegas,structuralintegrity,phaseshift,nightvision,torpedostrike,enemydetect,tripwire");
        return;
    }
    
    float i;
    entity eViewmode;
    string sEntityTargetname;
    for(i=2;i<5;i++){
        sEntityTargetname = eTrigger.getstringvar("uservar"+i);
        if(sEntityTargetname != ""){
            eViewmode = getEntity(""+sEntityTargetname);
            if(!doesEntityExist(eViewmode)){
                globalCoop_main_print("coop_viewmode()->WARNING: Could not find $"+sEntityTargetname+" specified in uservar"+i+" !");
            }else{
                //globalCoop_main_print("coop_viewmode()->Set Visibility to "+sViewmode+" on $"+sEntityTargetname);
                eViewmode.viewmode(""+sViewmode);                
            }
        }
    }
}

void coop_viewmodeadd()
//Adds viewmodes, so they become availibale when using the tricorder
//Avialable: tracegas,structuralintegrity,phaseshift,nightvision,torpedostrike,enemydetect,tripwire
//uservar1=viewmodename
//uservar2=viewmodename
//uservar3=viewmodename
//uservar4=viewmodename
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sViewmode,sModesAdded;
        sModesAdded = "coop_viewmodeadd()->Viewmodes Added: ";
        float i;
        for( i=1; i < 5; i++){
            sViewmode = eTrigger.getstringvar("uservar"+i);
            if( sViewmode != ""){
                sModesAdded = sModesAdded+""+sViewmode+", ";
                $world.addAvailableViewMode(""+sViewmode);
            }
        }
        if(sModesAdded == "coop_viewmodeadd()->Viewmodes Added: "){
            globalCoop_main_print("coop_viewmodeadd()->ERROR: No viewmodes set in uservars!");
            globalCoop_main_print("Viewmodenames: tracegas,structuralintegrity,phaseshift,nightvision,torpedostrike,enemydetect,tripwire");
            return;
        }
        globalCoop_main_print(sModesAdded);
    }
}

void coop_viewmoderemove()
//Removes viewmodes, so they become are no longer availibale when using the tricorder
//Avialable: tracegas,structuralintegrity,phaseshift,nightvision,torpedostrike,enemydetect,tripwire
//uservar1=viewmodename
//uservar2=viewmodename
//uservar3=viewmodename
//uservar4=viewmodename
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sViewmode,sModesAdded;
        sModesAdded = "coop_viewmoderemove()->Viewmodes Removed: ";
        float i;
        for( i=1; i < 5; i++){
            sViewmode = eTrigger.getstringvar("uservar"+i);
            if( sViewmode != ""){
                sModesAdded = sModesAdded+""+sViewmode+", ";
                $world.removeAvailableViewMode(""+sViewmode);
            }
        }
        if(sModesAdded == "coop_viewmoderemove()->Viewmodes Removed: "){
            globalCoop_main_print("coop_viewmoderemove()->ERROR: No viewmodes set in uservars!");
            globalCoop_main_print("Viewmodenames: tracegas,structuralintegrity,phaseshift,nightvision,torpedostrike,enemydetect,tripwire");
            return;
        }
        globalCoop_main_print(sModesAdded);
    }
}

void coop_viewmodeclear()
//Clears all viewmodes, so they become are no longer availibale when using the tricorder
//no uservar specification required
{
    $world.clearAvailableViewModes();
    $world.addAvailableViewMode("BogusMode");//has to be added for the clear command to work
    globalCoop_main_print("coop_viewmodeclear()->All Viewmodes removed!");
}

void coop_weather()
//this sets the weather on the map rain/snow
//uservar1 = weathertype
//uservar2 = ammount, 0 dissables
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sWeather;
        sWeather = eTrigger.getstringvar("uservar1");
        if(sWeather == ""){
            globalCoop_main_print("coop_weather()->ERROR: No weather-type specified in uservar1, use eigther rain/snow!");
            return;
        }
        $world.weather(sWeather,eTrigger.getfloatvar("uservar2"));
    }
}

void coop_archetype()
//sets the given archetype on the entity (this is the text thingy which is displayed when targeting a object or using tricorder to scann objects)
//uservar1 = targetname of entity to change archetype
//uservar2 = targetname of entity to change archetype
//uservar3 = targetname of entity to change archetype
//uservar4 = archetypename, can also be 'none' to remove archetype
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string sArcheType;
        sArcheType = "$$TriPuz_Default$$";
        if(eTrigger.getstringvar("uservar4") != "none" && eTrigger.getstringvar("uservar4") != "None"){
            sArcheType = eTrigger.getstringvar("uservar4");
        }else{
            sArcheType = "";
            globalCoop_main_print("coop_archetype()->archetype set to 'none', removing archetype");
        }
        
        string sUservar1;
        string sUservar2;
        string sUservar3;
        sUservar1 = eTrigger.getstringvar("uservar1");
        sUservar2 = eTrigger.getstringvar("uservar2");
        sUservar3 = eTrigger.getstringvar("uservar3");
        
        
        float i;
        entity eEntity;
        for(i=1;i<4;i++){
            
            if(i==1){ eEntity = getEntity(sUservar1);}
            else if(i==2){ eEntity = getEntity(sUservar2);}
            else{ eEntity = getEntity(sUservar3);}
            float fRoundsLimit = 10;
            while(doesEntityExist(eEntity) == 1 && fRoundsLimit > 0){
                fRoundsLimit--;
                eEntity.archetype(sArcheType);
                eEntity = getNextEntity(eEntity);
                wait( coop_float_oneFrameTime );
            }
        }
    }
}





void coop_bind()
//Binds a Entity To a Entity
//uservar1 = MASTER/Origin Entity Targetname
//uservar2 = SLAVE Entity to be bound to MASTER
//uservar3 = SLAVE Entity to be bound to MASTER
//uservar4 = SLAVE Entity to be bound to MASTER
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eMaster;
        eMaster = getEntity(eTrigger.getstringvar("uservar1"));    
        thread coop_bindToOrigin(getEntity(eTrigger.getstringvar("uservar2")),eMaster);        
        thread coop_bindToOrigin(getEntity(eTrigger.getstringvar("uservar3")),eMaster);        
        thread coop_bindToOrigin(getEntity(eTrigger.getstringvar("uservar4")),eMaster);        
    }
    else{
        globalCoop_main_print("coop_bind()->ERROR: Could not find entity specified in uservar1!");
    }
}


void coop_unbind()
//Unbinds a Entity from a Entity
//uservar1 = SLAVE Entity to Unbind
//uservar2 = SLAVE Entity to Unbind
//uservar3 = SLAVE Entity to Unbind
//uservar3 = SLAVE Entity to Unbind
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        thread coop_unbindThisEntity(getEntity(eTrigger.getstringvar("uservar1")));
        thread coop_unbindThisEntity(getEntity(eTrigger.getstringvar("uservar2")));
        thread coop_unbindThisEntity(getEntity(eTrigger.getstringvar("uservar3")));
        thread coop_unbindThisEntity(getEntity(eTrigger.getstringvar("uservar4")));
    }
}


void coop_unbindall()
//Unbinds ALL Entities which have been bound to the MASTER
//uservar1 = MASTER Entity to Unbind all entities from
//uservar2 = MASTER Entity to Unbind all entities from
//uservar3 = MASTER Entity to Unbind all entities from
//uservar4 = MASTER Entity to Unbind all entities from
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        thread coop_unbindAllFromOrigin(getEntity(eTrigger.getstringvar("uservar1")));
        thread coop_unbindAllFromOrigin(getEntity(eTrigger.getstringvar("uservar2")));
        thread coop_unbindAllFromOrigin(getEntity(eTrigger.getstringvar("uservar3")));
        thread coop_unbindAllFromOrigin(getEntity(eTrigger.getstringvar("uservar4")));
    }
}

void coop_move()
{
//uservar1 = keyword -> target-entity-targetname/up/down/left/right/west/north/south/east
//uservar2 = keyword -> up/down/left/right/west/north/south/east
//uservar3 = if no target -> travel speed
//uservar4 = travel time
    centerprint("coop_move()->Not Working Yet\n");
}


void coop_updatespawnlocations()
{
//set new Origin to a object
//uservar1 = Spawnlocation set (targetname ipdX_?)
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eTarget;
        string fFloat1;
        float fLocation;
        entity eSpawn;
        entity eLocation;
        fFloat1    = eTrigger.getStringVar("uservar1");
        while(fLocation < 9){
            fLocation++;
            eSpawn        = getEntity("ipd"+fLocation);
            eLocation     = getEntity("ipd"+fLocation+"_"+fFloat1);
            if(doesEntityExist(eSpawn) == 1 && doesEntityExist(eLocation) == 1){
                eSpawn.origin(eLocation.getOrigin());
                eSpawn.angle(vectorGetY(eLocation.getAngles()));
                if(eLocation.getStringVar("uservar1") == "remove"){
                    eLocation.remove();
                }
            }
        }
    }
}

/* void coop_spawneffectname()
//uservar1 = Target Entity
//uservar2 = Effect Name
//uservar3 = If set to group, all entities of the group will be processed, ie: spawn1 spawn2 spawn3 spawn4 and so on
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        string s1;
        string s2;
        string s3;        
        entity eTarget;
        s1 = eTrigger.getStringVar("uservar1");
        s2 = eTrigger.getStringVar("uservar2");
        s3 = eTrigger.getStringVar("uservar3");
        if(s3 == "Group" || s3 == "GROUP"){
            s3 = "group";
        }
        eTarget = getEntity(s1);
        if(doesEntityExist(eTarget)){
            eTarget.spawneffectname(s2);
        }else{
            globalCoop_main_print("coop_spawneffectname()->MISSING ["+s1+"] using targetname for groupname now.");
            s3 = "group";
        }
        if(s3 = "group"){
            float fIndex;
            for(fIndex=0;fIndex<101;fIndex++){
                eTarget = getEntity(s1+fIndex);
                if(doesEntityExist(eTarget)){
                    eTarget.spawneffectname(s2);
                }
            }
        }
    }
} */

void coop_respawn()
//Makes the ai respawn when death
//Needs to be set at a func_spawn entity!
//uservar1 = how many times the ai should respawn 0=Infinity
//SETTINGS:
//KEY=setspawngroupdeaththread
//VALUE=coop_respawn

//KEY=setspawngroupID
//VALUE=ANY_UNIQE_NUMBER_HERE

//KEY=targetname
//VALUE=A_UNIQE_TARGETNAME_HERE

//KEY=spawntargetname
//VALUE=TARGETNAME_OF_THE_func_spawn_ENTITY
{
    entity e;
    e=getCurrentEntity();
    string sModel;
    string sTargetname;
    entity eSpawner;
    if(coop_checkExistHasModelPrintWithTargetname(e,"coop_respawn->Trying to RESPAWN at")){
        sModel = e.getModelName();
        sTargetname = e.getRawtargetname();
        eSpawner = getEntity(sTargetname);
        float fHasModel=1;
        while(fHasModel){
            if(doesEntityExist(eSpawner)){
                if(eSpawner.getModelName() == ""){
                    fHasModel=0;
                }else{
                    eSpawner = getNextEntity(e);
                }
            }else{
                globalCoop_main_print("ERROR: coop_respawn->func_spawn with targetname "+sTargetname+"does not exist!");
                fHasModel=0;
            }
            wait( coop_float_oneFrameTime );
        }
        if(doesEntityExist(eSpawner)){
            float fRespawns;
            fRespawns = eSpawner.getFloatvar("coop_noscript_respawns");
//STOP RESPAWING WHEN LIMIT IS HIT, SPAWN INFINITY IF NO LIMIT IS SET
            if(eSpawner.getFloatvar("uservar1") < 1){
                eSpawner.setFloatvar("uservar1",0);
            }else if(fRespawns == eSpawner.getFloatvar("uservar1")){
                globalCoop_main_print("coop_respawn->Reached Maximum("+eSpawner.getFloatvar("uservar1")+") spawns for: "+sTargetname+", specified in uservar1");
                return;
            }
            fRespawns++;
            eSpawner.setFloatvar("coop_noscript_respawns",fRespawns);
            if(doesEntityExist(eSpawner)){
                triggerEntity(eSpawner);
            }
        }
    }else{
        centerprint("USE: func_spawn, set: KEY setspawngroupdeaththread VALUE coop_respawn & KEY setspawngroupID VALUE INTEGER!\n");
    }
}

void coop_walkto()
//Make the ai walk to the specified locations
//uservar1 = NPC targetname
//uservar2 = Animation Name, walk/run not all NPCs can run, preferably use walk
//uservar3 = Targetname of the location to walk to
//uservar4 = Targetname of the additional location to walk to
//uservar4 = If allowfall is set as value, makes the actor ignore falls when trying to move.
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eAi;
        string sString1;
        string sString2;
        string sString3;
        string sString4;
        sString4=eTrigger.getStringVar("uservar1");
        eAi=getEntity(sString4);
        sString1=eTrigger.getStringVar("uservar2");
        sString2=eTrigger.getStringVar("uservar3");
        sString3=eTrigger.getStringVar("uservar4");
        if(doesEntityExist(eAi)){
            eAi.ai_off();
            if(sString3 == "allowfall"){
                eAi.allowFall(1);
            }
            globalCoop_main_print("coop_aiwalkto()::"+sString4+"->"+sString2+"animation:"+sString1);
            eAi.walkto("$"+sString2,sString1);
            waitFor(eAi);
            if(sString3 != "allowfall" && sString3 != ""){
                globalCoop_main_print("coop_aiwalkto()::"+sString4+"->"+sString3+"animation:"+sString1);
                eAi.walkto("$"+sString3,sString1);
            }
        }else{
            globalCoop_main_print("coop_aiwalkto()->uservar1->No NPC with the given targetname found!");
        }
    }
}

void coop_turntowardsentity()
//Make the ai turn towards a specified entity
//uservar1 = NPC targetname
//uservar2 = Entity Targetname to turn towrads
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eAi;
        entity eObject;
        string sString1;
        string sString2;
        sString1=eTrigger.getStringVar("uservar1");
        sString2=eTrigger.getStringVar("uservar2");
        eAi=getEntity(sString1);
        eObject=getEntity(sString2);
        if(doesEntityExist(eAi)){
            if(doesEntityExist(eObject)){
                eAi.ai_off();
                eAi.turntowardsentity(eObject);
            }
        }else{
            globalCoop_main_print("coop_turntowardsentity()->ERROR: uservar1 or uservar2 invalid entity targetname");
        }
    }
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////LEVEL-INTERAVION//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

void coop_trigger()
//This triggers/fires the given entities, works with doors,triggers,sound_speaker
//Example: Use it if you want to trigger multiple events at once on seperated trigger_relay triggers
//uservar1 = Targetname of Entity to trigger
//uservar2 = Targetname of Entity to trigger
//uservar3 = Targetname of Entity to trigger
//uservar4 = Targetname of Entity to trigger
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_trigger()->ERROR: can not be called by console!");
        return;
    }    
    
    float i;
    entity eTriggerMe;
    string sTargetname;
    for(i=1;i<5;i++){
        sTargetname = eTrigger.getStringVar("uservar"+i);
        if(sTargetname != ""){
            eTriggerMe = getEntity(sTargetname);
            if(doesEntityExist(eTriggerMe)){
                thread coop_triggerEntity(eTriggerMe);
            }else{
                globalCoop_main_print("coop_trigger()->WARNING: entity $"+sTargetname+" specified in uservar"+i+" does not exist!");
            }
        }
    }
}


void coop_triggerable()
//Make trigger able to be activated, like ON/OFF
//uservar1 targetname of trigger to enable
//uservar2 targetname of trigger to enable
//uservar3 targetname of trigger to enable
//uservar4 targetname of trigger to enable
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_triggerable()->ERROR: can not be called by console!");
        return;
    }    
    
    float i;
    entity eTriggerMe;
    string sTargetname;
    for(i=1;i<5;i++){
        sTargetname = eTrigger.getStringVar("uservar"+i);
        if(sTargetname != ""){
            eTriggerMe = getEntity(sTargetname);
            if(doesEntityExist(eTriggerMe)){
                thread coop_triggerableThis(eTriggerMe);
            }else{
                globalCoop_main_print("coop_triggerable()->WARNING: entity $"+sTargetname+" specified in uservar"+i+" does not exist!");
            }
        }
    }
}

void coop_nottriggerable()
//Make trigger UNable to be activated, like ON/OFF set to ->OFF
//uservar1 targetname of trigger to disable
//uservar2 targetname of trigger to disable
//uservar3 targetname of trigger to disable
//uservar4 targetname of trigger to disable
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_nottriggerable()->ERROR: can not be called by console!");
        return;
    }    
    
    float i;
    entity eTriggerMe;
    string sTargetname;
    for(i=1;i<5;i++){
        sTargetname = eTrigger.getStringVar("uservar"+i);
        if(sTargetname != ""){
            eTriggerMe = getEntity(sTargetname);
            if(doesEntityExist(eTriggerMe)){
                thread coop_notTriggerableThis(eTriggerMe);
            }else{
                globalCoop_main_print("coop_nottriggerable()->WARNING: entity $"+sTargetname+" specified in uservar"+i+" does not exist!");
            }
        }
    }
}

void coop_lock()
//Locks doors
//uservar1 targetname of door to Lock
//uservar2 targetname of door to Lock
//uservar3 targetname of door to Lock
//uservar4 targetname of door to Lock
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_lock()->ERROR: can not be called by console!");
        return;
    }    
    
    float i;
    entity eTriggerMe;
    string sTargetname;
    for(i=1;i<5;i++){
        sTargetname = eTrigger.getStringVar("uservar"+i);
        if(sTargetname != ""){
            eTriggerMe = getEntity(sTargetname);
            if(doesEntityExist(eTriggerMe)){
                thread coop_lockThisDoor(eTriggerMe);
            }else{
                globalCoop_main_print("coop_lock()->WARNING: entity $"+sTargetname+" specified in uservar"+i+" does not exist!");
            }
        }
    }
}

void coop_unlock()
//Unlocks doors
//uservar1 targetname of door to Unlock
//uservar2 targetname of door to Unlock
//uservar3 targetname of door to Unlock
//uservar4 targetname of door to Unlock
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_unlock()->ERROR: can not be called by console!");
        return;
    }    
    
    float i;
    entity eTriggerMe;
    string sTargetname;
    for(i=1;i<5;i++){
        sTargetname = eTrigger.getStringVar("uservar"+i);
        if(sTargetname != ""){
            eTriggerMe = getEntity(sTargetname);
            if(doesEntityExist(eTriggerMe)){
                thread coop_unlockThisDoor(eTriggerMe);
            }else{
                globalCoop_main_print("coop_unlock()->WARNING: entity $"+sTargetname+" specified in uservar"+i+" does not exist!");
            }
        }
    }
}

void coop_message()
//Prints a message to all plyers screen center, specify your text in uservar1
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    //PLAY SOUND
            $world.playsound("sound/player/CommunicatorBeep.wav", 3, 3, 800000);
    //SHOW MESSAGE TO ALL PLAYERS
            centerprint(eTrigger.getStringVar("uservar1")+"\n");
    }
}

void coop_kill()
//Kills specified targets
//Kills specified entities in uservar1 to uservar4
//If all uservars are empty the entity activating the trigger will be killed
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eKillMe;
        float fAllEmpty=1;
        float fCounter;
        string sString;    
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eKillMe = getEntity(sString);
                if(doesEntityExist(eKillMe)){
                    fAllEmpty=0;
                    eKillMe.kill();
                }
                else{
                    globalCoop_main_print("coop_kill()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
        if(fAllEmpty){
            eKillMe=eTrigger.getTargetEntity();
            if(doesEntityExist(eKillMe)){
                eKillMe.kill();
            }
        }
    }
}

void coop_removeme()
//removes given entity
//uservar1= delay in secounds
{
    entity eTrigger;
    eTrigger=getCurrentEntity();

    if(doesEntityExist(eTrigger)){
        float fWait;
        fWait = eTrigger.getFloatVar("uservar1");
        wait((fWait + 0.001));
        if(doesEntityExist(eTrigger)){eTrigger.remove();}
    }
}

void coop_remove()
//Removes specified targets
//Removes specified entities in uservar1 to uservar4
//Entities with the value noremove in a uservar will NOT be removed
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eRemove;
        float fCounter;
        string sString;    
        eRemove=eTrigger.getTargetEntity();
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eRemove = getEntity(sString);
                if(doesEntityExist(eRemove)){
                    eRemove.remove();
                }
                else{
                    globalCoop_main_print("coop_remove()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
    }
}

void coop_explode()
//Spawn a explosion
//Remove target entity
//Remove objects set in uservar1 to uservar4
//Entities with the value noremove in a uservar will NOT be removed
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){//TRY TO DELETE THE TARGET ENTITY    
    entity eTarget;
    float fCounter;
    string sString;    
        eTarget=eTrigger.getTargetEntity();
        eTarget.selfdetonate();
        eTarget.remove();
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eTarget = getEntity(sString);
                if(doesEntityExist(eTarget)){
                    eTarget.selfdetonate();
                    float i;
                    string sRemove;
                    for(i=1;i<5;i++){
                        sRemove = eTarget.getStringVar("uservar"+i);
                        if(sRemove == "noremove" ){
                            return;
                        }
                    }
                    eTarget.remove();
                }
                else{
                    globalCoop_main_print("coop_explode()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
    }
}

void coop_hide()
//Makes entities invisible
//Specify targetnames in uservar1 to uservar4
//Grabs also the target entity!
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eHide;
        float fCounter;
        string sString;    
        eHide=eTrigger.getTargetEntity();
        thread globalCoop_level_hide(eHide);
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eHide = getEntity(sString);
                if(doesEntityExist(eHide)){
                    thread globalCoop_level_hide(eHide);
                }
                else{
                    globalCoop_main_print("coop_hide()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
    }
}

void coop_show()
//Makes entities visible again
//Specify targetnames in uservar1 to uservar4
//Grabs also the target entity!
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        string sString;    
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                thread globalCoop_level_show(getEntity(sString));
            }
            else{
                globalCoop_main_print("coop_show()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
            }
        }
    }
}

void coop_solid()
//Makes entities SOLID
//Specify targetnames in uservar1 to uservar4
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eSolid;
        float fCounter;
        string sString;    
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eSolid = getEntity(sString);
                if(doesEntityExist(eSolid)){
                    eSolid.solid();
                }
                else{
                    globalCoop_main_print("coop_solid()->WARNING: entiy $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
    }
}

void coop_notsolid()
//Makes entities SOLID
//Specify targetnames in uservar1 to uservar4
//Grabs also the target entity!
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        entity eSolid;
        float fCounter;
        string sString;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eSolid = getEntity(sString);
                if(doesEntityExist(eSolid)){
                    eSolid.notsolid();
                }
                else{
                    globalCoop_main_print("coop_notsolid()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
    }
}

void coop_hidenotsolid()
//Hide entity and makes then notsolid, collides with no objects
//Specify targetnames in uservar1 to uservar4
//Grabs also the target entity!
{
    entity eTrigger,eHandle;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        string sString;    
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eHandle = getEntity(sString);
                if(doesEntityExist(eHandle)){
                    thread globalCoop_level_hideAndNotSolid(eHandle);
                }
                else{
                    globalCoop_main_print("coop_hidenotsolid()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
    }
}


void coop_showsolid()
//Shows entities and makes them solid, collides with (all) objects again
//Specify targetnames in uservar1 to uservar4
//Grabs also the target entity!
{
    entity eTrigger,eHandle;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        string sString;    
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                eHandle = getEntity(sString);
                if(doesEntityExist(eHandle)){
                    thread globalCoop_level_showAndSolid(eHandle);
                }
                else{
                    globalCoop_main_print("coop_showsolid()->WARNING: entity $"+sString+" specified in uservar"+fCounter+" does not exist");
                }
            }
        }
    }
}

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////FORCEFIELDS//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_forcefieldoff()
//Disable Forcefields (does not remove them)
//Set in uservar1 to uservar4
//Grabs also the target entity!
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        thread coop_disableFF(getEntity(eTrigger.getStringVar("uservar1")));
        thread coop_disableFF(getEntity(eTrigger.getStringVar("uservar2")));
        thread coop_disableFF(getEntity(eTrigger.getStringVar("uservar3")));
        thread coop_disableFF(getEntity(eTrigger.getStringVar("uservar4")));
    }
}


void coop_forcefieldon()
//Enables Forcefields, Makes them Interactive
//Set in uservar1 to uservar4
//Grabs also the target entity!
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        thread coop_enableFF(getEntity(eTrigger.getStringVar("uservar1")));
        thread coop_enableFF(getEntity(eTrigger.getStringVar("uservar2")));
        thread coop_enableFF(getEntity(eTrigger.getStringVar("uservar3")));
        thread coop_enableFF(getEntity(eTrigger.getStringVar("uservar4")));
    }
}
void coop_enableFF(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        e.setFloatvar("coop_doloopsound",1);
        coop_forcefieldEnable(e); //reenabled [b607]
        globalCoop_main_print("coop_forcefieldon()->ENABLED FORCEFIELD: "+e.getTargetname());
    }
    else{
        globalCoop_main_print("coop_forcefieldon()->WARNING: Could NOT find specified entity");
    }
}
void coop_disableFF(entity e)
//not meant to be called by a trigger! This will chrash the game!
{
    if(doesEntityExist(e)){
        coop_forcefieldDisable(e); //reenabled [b607]
        globalCoop_main_print("coop_forcefieldoff()->DISABLED FORCEFIELD: "+e.getTargetname());
    }
    else{
        globalCoop_main_print("coop_disableFF()->WARNING: Could NOT find specified entity");
    }
}

void coop_forcefieldSetOnTouch(entity eOnTouch,string sThread)
//----------------------------------------------------------------------
// Set thread to start if this entity gets Touchd
//----------------------------------------------------------------------
{
//CHECK IF ENTITY EXISTS, DO NOTHING IF NOT
    if(doesEntityExist(eOnTouch)){
        eOnTouch.noTouch();
        globalCoop_main_waitAFrame();
        eOnTouch.onTouch(sThread);
        pause();
    }
}

void coop_forcefieldSetOnDamage(entity eOnDamage,string sThread)
//----------------------------------------------------------------------
// Set thread to start if this entity gets Damaged
//----------------------------------------------------------------------
{
//CHECK IF ENTITY EXISTS, DO NOTHING IF NOT
    if(doesEntityExist(eOnDamage)){
        eOnDamage.noDamage();
        globalCoop_main_waitAFrame();
        eOnDamage.onDamage(sThread);
        pause();
    }
}

void coop_forcefieldEnable( entity eFF )
//----------------------------------------------------------------------
// Make this entity to a interactive forcefield (save type work :P )
//----------------------------------------------------------------------
{
    if(doesEntityExist(eFF)){
        float fWait;
        eFF.setFloatVar("coop_ffIsOffline",-1);        
        do{
            fWait=0;
            if(globalCoop_check_isEntityInsideOfPlayer(eFF,10)){
                fWait=1;
                globalCoop_main_waitAFrame();
            }
        }while(fWait);
        if(doesEntityExist(eFF)){
            if(eFF.getFloatVar("coop_ffIsOffline") != 1){
                eFF.setFloatVar("coop_ffIsOffline",0);
                globalCoop_level_showAndSolid(eFF);
                if(eFF.getFloatvar("coop_doloopsound")){
                    eFF.loopSound("sound/ships/enterprise/ent_forcefield.wav",1,64);
                }
                coop_forcefieldMakeInteractive(eFF);
            }
        }
    }
}

void coop_forcefieldDisable(entity eForceField)
//----------------------------------------------------------------------
// Disable this force Field
//----------------------------------------------------------------------
{
    if(doesEntityExist(eForceField)){
    //Make sure this ff will not be triggerd again
        eForceField.setFloatVar("coop_ffIsOffline",1);
        globalCoop_main_waitAFrame();//wait for onuse/ontouch/ondamage threads
        if(doesEntityExist(eForceField)){
            globalCoop_level_hideAndNotSolid(eForceField);
            eForceField.noTouch();
            eForceField.noDamage();
            eForceField.stoploopsound();
        }
    }
}

void coop_forcefieldMakeInteractive( entity eMakeInteractiveFF )
//----------------------------------------------------------------------
// Make this entity to a interactive forcefield (save type work :P )
//----------------------------------------------------------------------
{
    if(doesEntityExist(eMakeInteractiveFF)){
        if(eMakeInteractiveFF.getFloatVar("coop_ffIsOffline") != 1){
            eMakeInteractiveFF.setFloatVar("coop_ffIsOffline",0);
            thread coop_forcefieldSetOnTouch(eMakeInteractiveFF,"coop_forcefieldOnTouch");
            thread coop_forcefieldSetOnDamage(eMakeInteractiveFF,"coop_forcefieldOnDamage");
        }
    }
}

void coop_forcefieldOnDamage()
//----------------------------------------------------------------------
// On Damage the InterActive FF Calls This Thread
//----------------------------------------------------------------------
{
entity eForceField;

    //Get the Force Field
    eForceField = getCurrentEntity();

//Exit If entity is missing
    if(doesEntityExist(eForceField)){
        eForceField.noDamage();    
        
    //Exit if ff is about to shutdown
        if(eForceField.getFloatVar("coop_ffIsOffline") == 1){
            coop_forcefieldDisable(eForceField);
            return;
        }
        
        globalCoop_level_hide(eForceField);
        globalCoop_main_waitAFrame();
        if(eForceField.getFloatVar("coop_ffIsOffline") != 1){
            globalCoop_level_show(eForceField);
            coop_forcefieldPlaySound( eForceField );
        }
        globalCoop_main_waitZeroDotZero5();
        if(eForceField.getFloatVar("coop_ffIsOffline") != 1){
            thread coop_forcefieldSetOnDamage( eForceField ,"coop_forcefieldOnDamage");
        }
    }
}


void coop_forcefieldOnTouch()
//----------------------------------------------------------------------
// On Touch the InterActive FF Calls This Thread
//----------------------------------------------------------------------
{
    entity eForceField;
    entity ePlayer;
    float fInteract=1;
    float fDamage=5;
    eForceField = getCurrentEntity();
//Check if f exists
    if(doesEntityExist(eForceField)){
        eForceField.noTouch();
//DO NOT CONTINUE IF FF IS SHUT DOWN
        if(eForceField.getFloatVar("coop_ffIsOffline") == 1){
            return;
        }
//GRAB ACTIVATOR
        ePlayer    = eForceField.getLastActivatingEntity();
//CHECK IF IT IS A PLAYER
        if(globalCoop_return_integerPlayerId(ePlayer) > -1){
//IF PLAYER IS ACTIVE
            if(!globalCoop_check_playerSpectator(ePlayer)){
                if(!cvar_bool_multiplayer){
                    fDamage = 0.5;
                }
                ePlayer.hurt(5);
//MAKE PLAYER SEAM TO ACT ON THE EVENT
                ePlayer.jump(20);
            }
//PLAYER IS SPECTATOR
            else{
                fInteract=0;
            }
        }
//BLINK WHEN ACTIVATOR IS NOT A PLAYER OR A ACTIVE PLAYER
        if(fInteract){
            coop_forcefieldPlaySound(eForceField);
            globalCoop_level_hide(eForceField);
        }
        globalCoop_main_waitAFrame();
//SHOW FF AGAIN IF IT IS NOT DISABLED
        if(eForceField.getFloatVar("coop_ffIsOffline") != 1){
            globalCoop_level_show(eForceField);
            wait(.2);
//SET TOUCH THREAD AGAIN; TO MAKE IT RESPONDE AGAIN IF IT IS NOT DISABLED
            if(eForceField.getFloatVar("coop_ffIsOffline") != 1){
                thread coop_forcefieldSetOnTouch(eForceField,"coop_forcefieldOnTouch");
            }
        }
    }
}


void coop_forcefieldPlaySound(entity eForceField)
//----------------------------------------------------------------------
// Force Field Interactions thread
//----------------------------------------------------------------------
{
//Exit if entity is missing
    if(doesEntityExist(eForceField)){
        eForceField.playsound( "sound/ships/enterprise/ent_forcefield_down.wav",50,1.5,256);
    }
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////DYNAMIC LIGHTS//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
void coop_lightstyle()
//Set a style on a dynamic light
//uservar1 = Group name of the light
//uservar2 = Style of the light how to flicker (max 64 letters->a-z)
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        $world.light_lightstyle(eTrigger.getstringvar("uservar1"),eTrigger.getstringvar("uservar2"),0);
    }
}

void coop_lighttoggle()
//Toggle lights ON/OFF
//Set group_name in uservar1 to uservar4
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fCounter;
        string sString;    
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                if($world.getlightintensity(sString) != 0){
                    $world.light_intensity(sString, 0 );
                }else{
                    $world.light_intensity(sString, 1 );
                }
            }
        }
    }
}

void coop_lighttogglefade()
//Toggle lights ON/OFF with fading
//Set group_name in uservar1 to uservar4
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    float fCounter;
    string sString;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                if($world.getlightintensity(sString) != 0){
                    $world.light_fade(sString,0,0.4);
                }else{
                    $world.light_fade(sString,1,0.4);
                }
            }
        }
    }
}

void coop_lighton()
//Turn light ON
//Set group_name in uservar1 to uservar4
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    float fCounter;
    string sString;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                $world.light_intensity(sString,1);
            }
        }
    }
}

void coop_lightoff()
//Turn light OFF
//Set group_name in uservar1 to uservar4
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    float fCounter;
    string sString;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                $world.light_intensity(sString,0);
            }
        }
    }
}

void coop_lightonfade()
//Turn light ON with fading
//Set group_name in uservar1 to uservar4
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    float fCounter;
    string sString;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                $world.light_fade(sString,1,1);
            }
        }
    }
}

void coop_lightofffade()
//Turn light OFF with fading
//Set group_name in uservar1 to uservar4
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
    float fCounter;
    string sString;
        while(fCounter<4){
            fCounter++;
            sString=eTrigger.getStringVar("uservar"+fCounter);
            if(sString != ""){
                $world.light_fade(sString,0,1);
            }
        }
    }
}


void coop_displayeffect()
//use=trigger_once
//displays the specified effect on the Players (inside the area)
//uservar1 = Effect Name Part1 -> TransportOut
//uservar2 = Effect Name Part2 -> Federation
//uservar3 = Area -> touching(the trigger)/inside(the trigger)/outside(the trigger)/all(every player)
{
    entity eTrigger;
    eTrigger = getCurrentEntity();
    
    if(doesEntityExist(eTrigger)){
        
        vector vOrigin;
        vector vMins;
        vector vMaxs;
        string sEffect1;
        string sEffect2;
        string sArea;
        vOrigin         = eTrigger.getOrigin();
        vMins            = eTrigger.getMins();
        vMaxs            = eTrigger.getMaxs();
        sEffect1        = eTrigger.getStringVar("uservar1");
        sEffect2        = eTrigger.getStringVar("uservar2");
        sArea            = eTrigger.getStringVar("uservar3");
        if(sArea != "outside" && sArea != "all" && sArea != "inside" && sArea != "touching"){
            sArea != "touching";
        }
        
        if(sEffect1 == ""){
            globalCoop_main_print("coop_displayeffect()->ERROR: No effectname specified in uservar1");
            return;
        }
        
        globalCoop_main_print("coop_displayeffect()->"+sEffect1+"->"+sEffect2+": "+sArea);
        
    //display the effect on the specific players
        entity ePlayer;
        float fPlayerIdInUse;
        
        float fInOrOutSide;
        float fPlayerIsInside;

        for(fPlayerIdInUse=0;fPlayerIdInUse<coop_integer_maxPlayers;fPlayerIdInUse++){
            fInOrOutSide    =0;
            fPlayerIsInside    =0;
            if(cvar_bool_multiplayer){
                ePlayer = getentity("player"+fPlayerIdInUse);
            }else{
                fPlayerIdInUse = coop_integer_maxPlayers;
                ePlayer = getentity("player");
            }
            
            if(globalCoop_check_existingLivingEntity(ePlayer)){
                if(sArea != "touching"){
                    vector vOriginP;
                    vector vMinsP;
                    vector vMaxsP;                    
                    vOriginP         = ePlayer.getOrigin();
                    vMinsP             = ePlayer.getMins();
                    vMaxsP             = ePlayer.getMaxs();
                    fPlayerIsInside    = globalCoop_check_isBoundingBox2InsideOfBoundingBox1(vOrigin,vMins,vMaxs,vOriginP,vMinsP,vMaxsP,-4);//-10=player inside not touching
                    globalCoop_main_print("coop_displayeffect()->Activator inside trigger: "+fPlayerIsInside);
                }
                else{
                    fPlayerIsInside    = globalCoop_check_isEntityTouchingOther(ePlayer,eTrigger, 0 );//player inside or touching
                    globalCoop_main_print("coop_displayeffect()->Activator touching trigger: "+fPlayerIsInside);
                }
                
                if(sArea == "inside" || sArea == "touching" ){//bugfix->[if] can not handle the original check construct
                    fInOrOutSide = 1;
                }
                
                if(    sArea == "all" || fInOrOutSide == fPlayerIsInside)
                {
                    if(sEffect2 != ""){
                        ePlayer.displayEffect(sEffect1,sEffect2);
                    }else{
                        ePlayer.displayEffect(sEffect1);
                    }
                }
            }
        }    
    }
}


string coop_waitforteamString;
entity coop_waitforteamEntity;

void coop_waitforteam_continue()
{
    
    coop_triggerEntity(coop_waitforteamEntity);
    
    wait(2);
//trigger mission end...
    globalCoop_mission_completed(coop_waitforteamString);
}

void coop_waitforteam()
//sets the level End gathering Area at the place and in the size of the trigger which calles this thread
//uservar1 = Trigger This Entity when all players are inside
//uservar2 = Next map to load
//uservar3 = Don't show Mission sucess hud, on value: noscreen
{
    thread globalCoop_mission_accomplished();//mark done, as the mission is as good as completed
    
    entity eTrigger;
    eTrigger = getCurrentEntity();
    
    if(!doesEntityExist(eTrigger)){
        return;
    }
    
    vector vOrigin;
    //vector vMins;
    vector vMaxs;
    string sNextMap;
    string sShowSucess;
    entity eTriggerMe;
    string sTriggerMe;
    
    vOrigin     = eTrigger.getOrigin();
    //vMins        = eTrigger.getMins();
    vMaxs        = eTrigger.getMaxs();
    sTriggerMe    = eTrigger.getStringVar("uservar1");
    eTriggerMe        = getEntity(sTriggerMe);
    sNextMap        = eTrigger.getStringVar("uservar2");
    sShowSucess        = eTrigger.getStringVar("uservar3");
    
//do not show mi-objective
    if(sShowSucess == "noscreen"){
        coop_bool_showMissionSucessHud=0;
    }else{
        coop_bool_showMissionSucessHud=1;
    }
    
//remove trigger
    globalCoop_level_remove(eTrigger);
    
//wait for all players
    globalCoop_main_print("coop_waitforteam()->INFO: waiting for the players to gather!");
    if(!doesEntityExist(eTriggerMe)){
        globalCoop_main_print("coop_waitforteam()->WARNING: trigger named in uservar1 does NOT exist");
        return;
    }
    coop_waitforteamString = sNextMap;

    thread globalCoop_level_gatheringArea("coop_playerGatherIngArea","coop_waitforteam_continue",100,vMaxs,vOrigin);
}


void coop_requiredentity()
//adds a required ACTOR to a existing real trigger_volume_callvolume
//the trigger will not fire unless all the ACTORS specified by their targetname
//are in the trigger-field or are gone/dead
//uservar1 = targetname of trigger to which the requiredentity actor shall be added
//uservar2 = targetname of ACTOR
//uservar3 = targetname of ACTOR
//uservar4 = targetname of ACTOR
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_requiredentity()->ERROR: Can not be called by console!");
        return;
    }
    
    string sString;
    sString = eTrigger.getStringVar("uservar1");
    if(sString == ""){
        globalCoop_main_print("coop_requiredentity()->ERROR: Uservar1 was empty, needs targetname of trigger to add the requiredentity to!");
        return;    
    }
    entity eCallVollumeTrigger;
    eCallVollumeTrigger = getEntity(sString);
    if(!doesEntityExist(eCallVollumeTrigger)){
        globalCoop_main_print("coop_requiredentity()->ERROR: Could not find trigger $"+sString+" specified in uservar1!");
        return;
    }
    
    float fCounter;
    fCounter=1;
    while(fCounter<4){
        fCounter++;
        sString=eTrigger.getStringVar("uservar"+fCounter);
        if(sString != ""){
            eCallVollumeTrigger.requiredentity(sString);
            globalCoop_main_print("coop_requiredentity()->INFO: added required ACTOR: "+sString);
        }
    }
}

void coop_callvollume()
//used to replace the trigger that calls this function with a real trigger_volume_callvolume.
//specify the ACTOR targetnames in uservar2 to uservar4 that you want
//all to be inside the trigger-field to activate the entity specified in uservar1
//uservar1 = entity targetname to activate when all required ACTORS are inside the trigger-field
//uservar2 = targetname of actor
//uservar3 = targetname of actor
//uservar4 = targetname of actor
{
    float fValid;
    entity eTriggerNew;
    entity eTriggerMe;
    string sTargetname;
    string sTriggerMe;
    entity eTrigger,eTarget;
    string sUservar2;
    string sUservar3;
    string sUservar4;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_callvollume()->ERROR: can not be called by console!");
        return;
    }
    
    sTriggerMe = eTrigger.getStringVar("uservar1");
    if(sTriggerMe != ""){
        eTarget = getEntity(sTriggerMe);
    }
    if(!doesEntityExist(eTarget)){
        globalCoop_main_print("coop_callvollume()->ERROR: target entity in uservar1 is NOT valid!");
        return;
    }

    float i;
    for(i=2;i<5;i++){
        sTargetname = eTrigger.getStringVar("uservar"+i);
        if(sTargetname != ""){
            eTriggerMe = getEntity(sTargetname);
            if(doesEntityExist(eTriggerMe)){
                if(i == 2){sUservar2 = sTargetname;}
                else if(i == 3){sUservar3 = sTargetname;}
                else{sUservar4 = sTargetname;}                
            }else{
                globalCoop_main_print("coop_callvollume()->WARNING: entity $"+sTargetname+" specified in uservar"+i+" does not exist!");
            }
        }
    }
    
//spawn the clone here
    string sTargetnameNew;
    sTargetnameNew = eTrigger.getRawTargetName();
    vector vMins,vMaxs,vOrigin;
    vMins    = eTrigger.getMins();
    vMaxs    = eTrigger.getMaxs();
    vOrigin    = eTrigger.getOrigin();
    eTrigger.remove();
    
    eTriggerNew = spawn("trigger_volume_callvolume","nottriggerable","1");
    globalCoop_main_waitAFrame();
    
    eTriggerNew.requiredentity(sUservar2);
    eTriggerNew.requiredentity(sUservar3);
    eTriggerNew.requiredentity(sUservar4);
    eTriggerNew.thread("coop_callvollume_activate");
    eTriggerNew.targetname(""+sTargetnameNew);
    globalCoop_main_waitAFrame();
    
    eTriggerNew.setStringVar("uservar1",""+sTriggerMe);
    eTriggerNew.origin(vOrigin);
    eTriggerNew.setSize(vMins,vMaxs);
    eTriggerNew.triggerable();
}


void coop_selectionmove()
//Moves a object to the selected destination.
//uservar1 = liftname
//uservar2 = location targetname -> WITHOUT NUMBER
//uservar3 = traveltime from start-location to end-location (entire distance)
//uservar4 = Force to this location number (1=targetname1,2=targetname2,3=targetname3...)

//Uservars for the Move-Object:
//uservar1 = move-start / move-loop SOUND
//uservar2 = move-stop SOUND
{
    entity eTrigger;
    eTrigger=getCurrentEntity();
    if(!doesEntityExist(eTrigger)){
        globalCoop_main_print("coop_selectionmove()->ERROR: This Thread MUST be called by a trigger");
        return;
     }

    entity eUser;
    eUser = eTrigger.getLastActivatingEntity();
    if(!doesEntityExist(eUser)){
        return;
    }
    float fTriggerIdenty;
    string s1;
    string s2;
    float f3;
    float f4;
    s1 = eTrigger.getStringvar("uservar1");
    s2 = eTrigger.getStringvar("uservar2");
    f3 = eTrigger.getFloatvar("uservar3");
    f4 = eTrigger.getFloatvar("uservar4");
    eTrigger.setFloatvar("uservar4",f4);//avoid console spam
    fTriggerIdenty = eTrigger.getFloatVar("coop_noscript_selection_triggerIdentity");
    if(fTriggerIdenty == 0){
        fTriggerIdenty = $world.getFloatVar("coop_noscript_selection_triggerIdentityIndex");
        fTriggerIdenty++;
        $world.setFloatVar("coop_noscript_selection_triggerIdentityIndex",fTriggerIdenty);
        eTrigger.setFloatVar("coop_noscript_selection_triggerIdentity",fTriggerIdenty);
    }
    if(f3 == 0){
        globalCoop_main_print("coop_selectionmove()->WARNING: No traveltime sepecified in uservar3! Using 10 sec");
        f3=10;
    }
    entity eMover;
    if(s1 != ""){eMover = getEntity(s1);}
    
    entity eMoverOrigin;
    if(doesEntityExist(eMover)){
        if(eMover.getStringvar("coop_bindMaster") != ""){
            eMoverOrigin=getEntity((eMover.getStringvar("coop_bindMaster")));
        }else{
            eMoverOrigin=getEntity(s1+"_origin");
            if(doesEntityExist(eMoverOrigin)){
                coop_bindToOrigin(eMover,eMoverOrigin);
            }else{
                eMoverOrigin = eMover;//move the oject instead
                eMover.setStringvar("coop_bindMaster",s1);//make it self to its own master
                globalCoop_main_print("coop_selectionmove()->WARNING: Coudn't bind "+s1+" to "+s1+"_origin, object might move bad/wrong...");
            }
        }
    }else{
        globalCoop_main_print("coop_selectionmove()->ERROR: Object to Move NOT found, specify in uservar1");
return;
    }
/////////////////////////////////
/////////////////////////////////
/////////////////////////////////
    if(!doesEntityExist(eMoverOrigin)){
        globalCoop_main_print("coop_selectionmove()->ERROR: Entity to move or its origin could NOT be found!");
return;
    }
    if(eMoverOrigin.getFloatVar("coop_noscript_selectionDisable")){
        coop_printMessageToPlayer(eUser,"^3Please wait.");
return;
    }
    if(eMoverOrigin.getFloatVar("coop_noscript_selectionTriggerIdendity") != 0){
        if(eMoverOrigin.getFloatVar("coop_noscript_selectionTriggerIdendity") != fTriggerIdenty){
            coop_printMessageToPlayer(eUser,"^2Controls ^3allready^2 in use!");
            return;
        }
    }else{
        eMoverOrigin.setFloatVar("coop_noscript_selectionTriggerIdendity",fTriggerIdenty);
    }
    
//grab travel entity
    entity eMoveTo;
    if(s2 == ""){
        globalCoop_main_print("coop_selectionmove()->ERROR: No travel to target-entity sepecified in uservar2!");
return;
    }
    eMoveTo=getEntity(s2+""+1);
    if(!doesEntityExist(eMoveTo)){
        globalCoop_main_print("coop_selectionmove()->ERROR: Coudn't find any travel-to entity with targetname: "+s2);
return;
    }
    entity eMoveToEnd;
    float fSelectionIndex;
    float fSelectionIndexMax = 1;
    while(doesEntityExist(getEntity(s2+""+fSelectionIndexMax))){
        fSelectionIndexMax++;
        wait( coop_float_oneFrameTime );
    }
    fSelectionIndexMax--;//go one back to grab previouse
    eMoveToEnd = getEntity(s2+""+fSelectionIndexMax);
    if(!doesEntityExist(eMoveToEnd)){
        globalCoop_main_print("coop_selectionmove()->ERROR: REPORT TO HAZARDMODDING CODE->ERR#1");
return;
    }
    float fTravelDistanceTotal;
    fTravelDistanceTotal = vectorLength((eMoveTo.getOrigin()) - (eMoveToEnd.getOrigin()));
/////////////////////////////////
/////////////////////////////////
/////////////////////////////////
    if(!doesEntityExist(eMoverOrigin)){
        globalCoop_main_print("coop_selectionmove()->ERROR: Move-Object or Move-Object-Origin was deleted! #1");
return;
    }
    if(f4 == 0){//uservar4 sets the index the mover must be send to
        fSelectionIndex=eMoverOrigin.getFloatVar("coop_noscript_selectionIndex");
        if(fSelectionIndex < fSelectionIndexMax){
            fSelectionIndex++;
        }else{
            fSelectionIndex=1;
        }
    }else{
        fSelectionIndex=f4;
    }
    eMoverOrigin.setFloatVar("coop_noscript_selectionIndex",fSelectionIndex);
    eMoverOrigin.setFloatVar("coop_noscript_selectionTime",getLevelTime());
//PRINT TO USER
    string sHudprint;
    if(doesEntityExist(eUser)){
        eMoveTo=getEntity(s2+""+fSelectionIndex);
        if(doesEntityExist(eMoveTo)){
            sHudprint=eMoveTo.getStringVar("uservar1");
        }
        if(sHudprint != ""){
            coop_printMessageToPlayer(eUser,sHudprint);
        }else{
            eMoveTo.setStringVar("uservar1","");
            coop_printMessageToPlayer(eUser,"^2Selection:^5 "+fSelectionIndex);
        }
    }
//the selection is still active
    if(eMoverOrigin.getFloatVar("coop_noscript_selectionActive")){
        return;
    }
    eMoverOrigin.setFloatVar("coop_noscript_selectionActive",1);
    eMoverOrigin.setFloatVar("coop_noscript_selectionDisable",0);
    float fWait=1;
    float fTime;
    while(fWait)
    {
        if(doesEntityExist(eMoverOrigin)){
            fTime = eMoverOrigin.getFloatVar("coop_noscript_selectionTime");
            if(getLevelTime() > (fTime + 2)){
                fWait=0;
            }
        }else{
            globalCoop_main_print("coop_selectionmove()->ERROR: Move-Object or Move-Object-Origin was deleted! #2");
            return;
        }
        wait(.1);
    }
//DISABLE SELECTION NOW!
    eMoverOrigin.setFloatVar("coop_noscript_selectionDisable",1);        
//TRY TO BIND TRIGGER
    entity eTrigger;
    entity eDoor;
    eTrigger=getEntity(s1+"_trigger");
    if(doesEntityExist(eTrigger)){
        if(eTrigger.getStringvar("coop_bindMaster") == ""){
            coop_bindToOrigin(eTrigger,eMoverOrigin);
        }
    }
/////////////////////////////////
/////////////////////////////////
/////////////////////////////////
    fSelectionIndex = eMoverOrigin.getFloatVar("coop_noscript_selectionIndex");
    eMoveTo=getEntity(s2+""+fSelectionIndex);
//PRINT TO USER
    if(!doesEntityExist(eMoveTo)){
        globalCoop_main_print("coop_selectionmove()->ERROR: Selection: "+s2+""+fSelectionIndex+" !INVALID ENTITY!");
        coop_printMessageToPlayer(eUser,"ERROR: Selection: "+s2+""+fSelectionIndex+" !INVALID ENTITY!");
    //ALLOW SELECTION AGAIN, ALLOW ALL TRIGGERS AGAIN
        coop_selectionmovereset(eMoverOrigin);
return;
    }
//LOCK and CLOSE DOOR
    eDoor=getEntity(s1+"_door"+eMoverOrigin.getFloatVar("coop_noscript_selectionLastTravel"));
    if(doesEntityExist(eDoor)){
        eDoor.lock();
        eDoor.close();
    }
    float fTravelTime;
    fTravelTime = (f3 / fTravelDistanceTotal);//time/distance
    fTravelTime = (fTravelTime * vectorLength((eMoveTo.getOrigin()) - (eMoverOrigin.getOrigin())));
    string sSound;
    sSound = eMover.getStringVar("uservar1");
    if(sSound != ""){
        eMoverOrigin.loopsound(sSound,1,128);
    }
    eMoverOrigin.moveToPos(eMoveTo.getOrigin());
    eMoverOrigin.time(fTravelTime);
    waitfor(eMoverOrigin);
    eMoverOrigin.stoploopsound();
    sSound = eMover.getStringVar("uservar2");
    if(sSound != ""){
        eMoverOrigin.playsound(sSound,0,1,128);
    }
    eDoor=getEntity(s1+"_door"+fSelectionIndex);
    if(doesEntityExist(eDoor)){
        eDoor.unlock();
        eDoor.open($world);
        eDoor.wait(-1);//make door stay open
    }
    eMoverOrigin.setFloatVar("coop_noscript_selectionLastTravel",fSelectionIndex);
    wait(3);
//ALLOW SELECTION AGAIN, ALLOW ALL TRIGGERS AGAIN
    coop_selectionmovereset(eMoverOrigin);
/////////////////////////////////
/////////////////////////////////
/////////////////////////////////

}


void coop_music()
//sets a soundtrack for the current level
//uservar1 = soundtrack type
//uservar2 = soundtrack path
//uservar3 = soundtrack loop
//uservar4 = soundtrack volume
{
    
}

void coop_groupdeaththread()
{
//[b607] chrissstrahl - this allowes to add a group deaththread to multiple actors
    entity eTrigger;
    entity e;
    entity oldEnt;
    eTrigger=getCurrentEntity();
    if(doesEntityExist(eTrigger)){
        float fValid    = 0;
        string sThreadName;
        float fGroupNumber;
        sThreadName=eTrigger.getStringVar("uservar1");    
        if(sThreadName == ""){
            globalCoop_main_print("coop_groupdeaththread()->ERROR: uservar1 EMPTY! Should contain: script thread name");
        }
        //else{
            //globalCoop_main_print("coop_groupdeaththread()->DEBUG: uservar1 set thread: "+sThreadName);
        //}
        fGroupNumber=eTrigger.getFloatVar("uservar2");    
        if(fGroupNumber == 0){
            fGroupNumber = -1; //make sure we don't mess sométhin üp
            globalCoop_main_print("coop_groupdeaththread()->ERROR: uservar2 EMPTY! Should contain: group ID or NUMBER (can't be 0)");
        }
        //else{
            //globalCoop_main_print("coop_groupdeaththread()->DEBUG: uservar2 set id: "+fGroupNumber);
        //}
        
//handle targeted entity
        e = eTrigger.getTargetEntity();
        if(doesEntityExist(e)){
            fValid++;
            //handle multiple enties with the same targetname
            while(doesEntityExist(e)){
                e.setgroupid(fGroupNumber);
                e.groupDeathThread(sThreadName);
                //oldEnt = e;
                e = getnextentity(e);
                //if(!doesEntityExist(e)){
                    //oldEnt.groupDeathThread(sThreadName);
                //}
            }
            //globalCoop_main_print("coop_groupdeaththread()->DEBUG: using targeted");
        }
        
//handle uservar3-4 values
        float fCounter    = 3;
        string sBaseTargetname;
        while(fCounter<=4){
            sBaseTargetname=eTrigger.getStringVar("uservar"+fCounter);
            
            if(sBaseTargetname != ""){
                e = getEntity(sBaseTargetname);
//handle entities that have just the given basename as full targetname (group1room)
                if(doesEntityExist(e)){
                    fValid++;
                    //handle multiple enties with the same targetname
                    while(doesEntityExist(e)){
                        e.setgroupid(fGroupNumber);
                        e.groupDeathThread(sThreadName);
                        e = getnextentity(e);
                    }
                    //globalCoop_main_print("coop_groupdeaththread()->DEBUG: using (base) uservar"+fCounter);
                }
//handle entities that have the basename and a number attached (group1room0, group1room1, ...)
                float fId = 0;
                while(fId < 2 || doesEntityExist(e) == 1){ //try to handle at least 0 and 1 before we give up
                    e = getEntity(sBaseTargetname + fId);
                    if(doesEntityExist(e)){
                        fValid++;
                        //handle multiple enties with the same targetname
                        while(doesEntityExist(e)){
                            e.setgroupid(fGroupNumber);
                            e.groupDeathThread(sThreadName);
                            e = getnextentity(e);
                        }
                        //globalCoop_main_print("coop_groupdeaththread()->DEBUG: using (base+NUM) uservar"+fCounter);
                    }
                    fId++;
                    e = getEntity(sBaseTargetname + fId);
                }
            }
            fCounter++;
        }
//give proper feedback
        if(fValid == 0){
            globalCoop_main_print("coop_groupdeaththread()->ERROR: No valid targetnames given in uservar3-4");
        }
    }
}

//test threads //test threads //test threads //test threads
//test threads //test threads //test threads //test threads
//test threads //test threads //test threads //test threads
void coop_deaththreadExample(float fGroup){
    $world.playsound("sound/player/CommunicatorBeep.wav", 3, 3, 800000);
    centerprint("All members of Group "+fGroup+" are dead...\n");
}
void coop_deaththreadExample1(){coop_deaththreadExample(1);}
void coop_deaththreadExample2(){coop_deaththreadExample(2);}
void coop_deaththreadExample3(){coop_deaththreadExample(3);} 


---