invisible and objective

hello

i would like to know how to hide the objective shader of the zombie gametype when a player is invisible?
i tried some things but it didn't work.
i often checked objpoints.gsc but i didn't find :/
someone can help me?

ORDI
xfire: ordi37zk

What is "the objective shader" in zombie games? Is it a waypoint? If you expect people to help you, don't assume they know what you are talking about.

the star icon above of the hunters and only the zombies can see it in the cod2 game and in a zom server (zombie gametype by paulus).

Quote:

---

Originally Posted by ORDI

the star icon above of the hunters and only the zombies can see it in the cod2 game and in a zom server (zombie gametype by paulus).

---

Is it a headicon? Can you post the code?

it isn't a headicon.

PHP Code:

---

makeobjmarker()
{
    level.showoncompass = GetCvarInt("scr_zom_showoncompass");
    level.showasobjpoint = GetCvarInt("scr_zom_showasobjpoint");

    if (level.showasobjpoint)
    {
        temp = [];
        temp[0]=self.origin[0];
        temp[1]=self.origin[1];
        temp[2]=self.origin[2]+70;

        maps\mp\gametypes\_objpoints::addTeamObjpoint(temp, self.clientid, "axis", "objective");
    }
    
    if (level.showoncompass)
    {
        objnum = GetNextObjNum();
        if (!(objnum==-1))
        {
            self.objnum = objnum;
            objective_add(objnum, "current", self.origin, "objective");
            objective_icon(objnum,"objective");
            objective_team(objnum,"axis");
            objective_position(objnum, self.origin);
            lastobjpos = self.origin;
            newobjpos = self.origin;
        }
    }

    if (level.showasobjpoint || level.showoncompass)
    {
        self thread DeleteOnEvent("killed_player");
        self thread DeleteOnEvent("disconnect");
        self thread updateobjmarker();
    }
}

updateobjmarker()
{
    self endon("StopOnCompass");
    

    level.positiontime = GetCvarInt("scr_zom_positiontime");
    
    if (level.positiontime<0 || level.positiontime>20)
        level.positiontime=0.000001;

    if (level.positiontime==0)
        level.positiontime=0.000001;
        
    for(;;)
    {
        wait level.positiontime;
    
        if (level.showasobjpoint)
        {
            /*temp = [];
            temp[0]=self.origin[0];
            temp[1]=self.origin[1];
            temp[2]=self.origin[2]+70;
            maps\mp\gametypes\_objpoints::addTeamObjpoint(temp, self.clientid, "axis", "objective");
            */
            for(i = 0; i < level.objpoints_axis.array.size; i++)
            {
                if (level.objpoints_axis.array[i].name==self.clientid)
                {
                    
                    level.objpoints_axis.array[i].x=self.origin[0];
                    level.objpoints_axis.array[i].y=self.origin[1];
                    level.objpoints_axis.array[i].z=self.origin[2]+70;
                }
            }

            //maps\mp\gametypes\_objpoints::updatePlayerObjpoints();
            updateAllPlayerObjpoints("axis");
        }
        
        if (level.showoncompass)
        {
            objective_position(self.objnum, self.origin);
        }
    }
}

GetNextObjNum()
{
    for (i=0;i<15;i++)
    {
        if (level.objused[i] == true)
            continue;
        
        level.objused[i] = true;
        return ( i );
    }
    return -1;
}

DeleteOnEvent(event)
{
    self waittill(event);

    self notify("StopOnCompass");
    if (isdefined (self.objnum))
    {
        objective_delete(self.objnum);
        level.objused[(self.objnum)] = false;
        self.objnum = undefined;
    }

    if(level.showasobjpoint==1)
    {
        for(i = 0; i < level.objpoints_axis.array.size; i++)
        {
            if (level.objpoints_axis.array[i].name==self.clientid)
            {
                level.objpoints_axis.array[i].name=undefined;

                clearHudObjPoints("axis");
                cleanObjPointsArray();
                updateAllPlayerObjpoints("axis");
            }
        }
    }
}

cleanObjPointsArray()
{
// Rebuild objpoints array minus named
    cleanpoints = [];
    for(i = 0; i < level.objpoints_axis.array.size; i++)
    {
        objpoint = level.objpoints_axis.array[i];
    
        if(isdefined(objpoint.name))
            cleanpoints[cleanpoints.size] = objpoint;
    }
    //return cleanpoints;
    level.objpoints_axis.array=cleanpoints;

}

clearHudObjPoints(team)
{
    players = getentarray("player", "classname");
    for(i = 0; i < players.size; i++)
    {
        player = players[i];
        
        if(isDefined(player.pers["team"]) && player.pers["team"] == team) // && player.sessionstate == "playing"
            player maps\mp\gametypes\_objpoints::clearPlayerObjpoints();
    }
}

updateAllPlayerObjpoints(team)
{
    players = getentarray("player", "classname");
    for(i = 0; i < players.size; i++)
    {
        player = players[i];
        
        if(isDefined(player.pers["team"]) && player.pers["team"] == team) // && player.sessionstate == "playing"
            player maps\mp\gametypes\_objpoints::updatePlayerObjpoints();
    }
} 


---

in the zombie gametype

and the script _objpoints which is in iw_07:

PHP Code:

---

init()
{
    precacheShader("objpoint_default");

    level.objpoints_allies = spawnstruct();
    level.objpoints_allies.array = [];
    level.objpoints_axis = spawnstruct();
    level.objpoints_axis.array = [];
    level.objpoints_allplayers = spawnstruct();
    level.objpoints_allplayers.array = [];
    level.objpoints_allplayers.hudelems = [];
    
    if(level.splitscreen)
        level.objpoint_scale = 14;
    else
        level.objpoint_scale = 7;
    
    level thread onPlayerConnect();
}

onPlayerConnect()
{
    for(;;)
    {
        level waittill("connecting", player);
        
        player.objpoints = [];

        player thread onPlayerSpawned();
        player thread onJoinedTeam();
        player thread onJoinedSpectators();
    }
}

onJoinedTeam()
{
    self endon("disconnect");
    
    for(;;)
    {
        self waittill("joined_team");
        self thread clearPlayerObjpoints();
    }
}

onJoinedSpectators()
{
    self endon("disconnect");
    
    for(;;)
    {
        self waittill("joined_spectators");
        self thread clearPlayerObjpoints();
    }
}

onPlayerSpawned()
{
    self endon("disconnect");
    
    for(;;)
    {
        self waittill("spawned_player");

        self thread updatePlayerObjpoints();        
        self thread onPlayerKilled();
    }
}

onPlayerKilled()
{
    self endon("disconnect");

    for(;;)
    {
        self waittill("killed_player");
        
        self thread clearPlayerObjpoints();
    }
}

addObjpoint(origin, name, material)
{
    thread addTeamObjpoint(origin, name, "all", material);
}

addTeamObjpoint(origin, name, team, material)
{
    assert(team == "allies" || team == "axis" || team == "all");
    if(team == "allies")
    {
        assert(isdefined(level.objpoints_allies));
        objpoints = level.objpoints_allies;
    }
    else if(team == "axis")
    {
        assert(isdefined(level.objpoints_axis));
        objpoints = level.objpoints_axis;
    }
    else
    {
        assert(isdefined(level.objpoints_allplayers));
        objpoints = level.objpoints_allplayers;
    }

    // Rebuild objpoints array minus named
    cleanpoints = [];
    for(i = 0; i < objpoints.array.size; i++)
    {
        objpoint = objpoints.array[i];
    
        if(isdefined(objpoint.name) && objpoint.name != name)
            cleanpoints[cleanpoints.size] = objpoint;
    }
    objpoints.array = cleanpoints;
    
    newpoint = spawnstruct();
    newpoint.name = name;
    newpoint.x = origin[0];
    newpoint.y = origin[1];
    newpoint.z = origin[2];
    newpoint.archived = false;

    if(isdefined(material))
        newpoint.material = material;
    else
        newpoint.material = "objpoint_default";

    objpoints.array[objpoints.array.size] = newpoint;

    //update objpoints for team specified
    
    if (team == "all")
    {
        clearGlobalObjpoints();
        
        for(j = 0; j < objpoints.array.size; j++)
        {
            objpoint = objpoints.array[j];
            
            newobjpoint = newHudElem();
            newobjpoint.name = objpoint.name;
            newobjpoint.x = objpoint.x;
            newobjpoint.y = objpoint.y;
            newobjpoint.z = objpoint.z;
            newobjpoint.alpha = .61;
            newobjpoint.archived = objpoint.archived;
            newobjpoint setShader(objpoint.material, level.objpoint_scale, level.objpoint_scale);
            newobjpoint setwaypoint(true);
            
            level.objpoints_allplayers.hudelems[level.objpoints_allplayers.hudelems.size] = newobjpoint;
        }
    }
    else
    {
        players = getentarray("player", "classname");
        for(i = 0; i < players.size; i++)
        {
            player = players[i];
            
            if(isDefined(player.pers["team"]) && player.pers["team"] == team && player.sessionstate == "playing")
            {
                player clearPlayerObjpoints();
    
                for(j = 0; j < objpoints.array.size; j++)
                {
                    objpoint = objpoints.array[j];
                    
                    newobjpoint = newClientHudElem(player);
                    newobjpoint.name = objpoint.name;
                    newobjpoint.x = objpoint.x;
                    newobjpoint.y = objpoint.y;
                    newobjpoint.z = objpoint.z;
                    newobjpoint.alpha = .61;
                    newobjpoint.archived = objpoint.archived;
                    newobjpoint setShader(objpoint.material, level.objpoint_scale, level.objpoint_scale);
                    newobjpoint setwaypoint(true);
                    
                    player.objpoints[player.objpoints.size] = newobjpoint;
                }
            }
        }
    }
}

removeObjpoints()
{
    thread removeTeamObjpoints("all");
}

removeTeamObjpoints(team)
{
    assert(team == "allies" || team == "axis" || team == "all");
    if(team == "allies")
    {
        assert(isdefined(level.objpoints_allies));
        level.objpoints_allies.array = [];
    }
    else if(team == "axis")
    {
        assert(isdefined(level.objpoints_axis));
        level.objpoints_axis.array = [];
    }
    else
    {
        assert(isdefined(level.objpoints_allplayers));
        assert(isdefined(level.objpoints_allplayers.hudelems));
        level.objpoints_allplayers.array = [];
        for (i=0;i<level.objpoints_allplayers.hudelems.size;i++)
            level.objpoints_allplayers.hudelems[i] destroy();
        level.objpoints_allplayers.hudelems = [];
        return;
    }

    //clear objpoints for team specified
    players = getentarray("player", "classname");
    for(i = 0; i < players.size; i++)
    {
        player = players[i];
        
        if(isDefined(player.pers["team"]) && player.pers["team"] == team && player.sessionstate == "playing")
            player clearPlayerObjpoints();
    }
}

updatePlayerObjpoints()
{
    if(isDefined(self.pers["team"]) && self.pers["team"] != "spectator" && self.sessionstate == "playing")
    {
        assert(self.pers["team"] == "allies" || self.pers["team"] == "axis");
        if(self.pers["team"] == "allies")
        {
            assert(isdefined(level.objpoints_allies));
            objpoints = level.objpoints_allies;
        }
        else
        {
            assert(isdefined(level.objpoints_axis));
            objpoints = level.objpoints_axis;
        }
        
        self clearPlayerObjpoints();
        
        for(i = 0; i < objpoints.array.size; i++)
        {
            objpoint = objpoints.array[i];
            
            newobjpoint = newClientHudElem(self);
            newobjpoint.name = objpoint.name;
            newobjpoint.x = objpoint.x;
            newobjpoint.y = objpoint.y;
            newobjpoint.z = objpoint.z;
            newobjpoint.alpha = .61;
            newobjpoint.archived = objpoint.archived;
            newobjpoint setShader(objpoint.material, level.objpoint_scale, level.objpoint_scale);
            newobjpoint setwaypoint(true);
            
            self.objpoints[self.objpoints.size] = newobjpoint;
        }
    }
}

clearPlayerObjpoints()
{
    for(i = 0; i < self.objpoints.size; i++)
        self.objpoints[i] destroy();
    
    self.objpoints = [];
}

clearGlobalObjpoints()
{
    for(i = 0; i < level.objpoints_allplayers.hudelems.size; i++)
        level.objpoints_allplayers.hudelems[i] destroy();
    
    level.objpoints_allplayers.hudelems = [];
}

//removePlayerObjpoint(name)
//{
//    for(i = 0; i < self.objpoints.size; i++)
//    {
//        objpoint = self.objpoints[i];
//        
//        if(isdefined(objpoint.name) && objpoint.name == name)
//            objpoint destroy();
//    }
//} 


---

Okay, it's a waypoint. So, delete it when the player is invisible; then re-create it again when they aren't invisible.

Failing that, find the waypoint (using the waypoint shader array) and set the alpha to 0 when the player is invisible; then set it to 1 when they aren't.