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::updatePlayerObjpoint s();
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::updatePlayerObjpoint s();
}
} 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.hudele ms));
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.