invisible and objective

[ORDI]

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

[Tally]

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.

[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).

[Tally]

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?

[ORDI]

it isn't a headicon.

		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:

		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();
//    }
//} 
	

[Tally]

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.