turret

[malyczolg]

hi , why turrent not planted ?
what model I have precache ?

		#include maps\mp\_utility;

main()
{
    level thread waitforconnect();
}

waitforconnect()
{
    for(;;)
    {
        level waittill("connecting",player);
        player thread waitforspawn();
    }
}


waitforspawn()
{
    self endon("disconnect");
    for(;;)
    {
        self waittill("spawned_player");
        self thread plantmg();
    }
}
    

plantmg()
{
    self endon("killed_player");
    self endon("disconnect");
    self endon("spawned_player");
    while(isalive(self))
    {
        while(self meleebuttonpressed())
            wait 0.05;
        while(!(self meleebuttonpressed()))
            wait 0.05;
        {
            if(getcvarint("scr_enablesentrys")==1)
            {
                forward=maps\mp\_utility::vectorScale(anglestoforward(self getplayerangles()),2000);
                plantloc=bullettrace(self geteye(),self geteye()+forward,false,undefined);
                if(distance(vectornormalize(plantloc["normal"]),(0,0,1))<sin(level.maxplantangle)&&self.sentrycount<=level.maxplayersentries)
                {
                    self.sentrycount++;
                    model=spawn("script_model",plantloc["position"]);
                    model.angles=vectortoangles(anglestoup(vectortoangles(plantloc["normal"])));
                    turrorg=model.origin+maps\mp\_utility::vectorScale(vectornormalize(plantloc["normal"]),level.turrsupportheight);
                    model2=spawn("script_model",turrorg);
                    model setmodel(level.turrsupportmodel);
                    model2 setmodel(level.turrmodel);
                    model2.angles=self getplayerangles();
                    model.setcandamage=true;
                    model2.setcandamage=true;
                    model solid();
                    model2 solid();
                    model setcontents (1);
                    model2 setcontents (1);
                    model.shareshealth=model2;
                    model2.damagefeedback=true;
                    model2.issentry=true;
                    model.damagefeedback=true;
                    model2.planter=self;
                    model2.health=200;
                    model2 thread cleanupafterdestroyed(self,model);
                    model2 thread monitorzombies(self,model);
                    model2 thread timer(self,model);
                    model2 thread cleanupdisconnect(self,model);

                }
                else if(self.sentrycount>level.maxplayersentries)
                    self iprintlnbold("Too much sentries");
                else 
                    self iprintlnbold("Cant plant there");
            }
        }
    }
}


cleanupafterdestroyed(planter,othermodel)
{
    self endon("end_mg_destroyed");
    planter endon("disconnect");
    self waittill("destroyed_by",attacker);
    self notify("end_mg");
    self notify("end_mg_timer");
    self notify("end_mg_disconnect");
    planter.sentrycount--;
    othermodel delete();
    self delete();
}
    

timer(planter,othermodel)
{
    self endon("end_mg_timer");
    planter endon("disconnect");
    wait level.sentrytime;
    self notify("end_mg_destroyed");
    self notify("end_mg");
    self notify("end_mg_disconnect");
    planter.sentrycount--;
    self delete();
    othermodel delete();    
}

cleanupdisconnect(planter,othermodel)
{
    self endon("end_mg_disconnect");
    planter waittill("disconnect");
    self notify("end_mg_destroyed");
    self notify("end_mg_timer");
    self notify("end_mg");
    othermodel delete();
    self delete();
}
        
    

monitorzombies(planter,othermodel)
{
    self endon("end_mg");
    planter endon("disconnect");

    for(;;)
    {
        if(planter.pers["team"]=="allies")
            badteam="axis";
        else if(planter.pers["team"]=="axis")
            badteam="allies";
        else
        {
            
            othermodel delete();
            self delete();
            planter.sentrycount--;
            self notify("end_mg");
            return;
        }
        players=getentarray("player","classname");
        enemyplayers=[];
        for(i=0;i<players.size;i++)
        {
            if(level.dmstyle)
            {
                if(isalive(players[i])&&players[i]!=planter)
                    enemyplayers[enemyplayers.size]=players[i];
            }
            else if(players[i].pers["team"]==badteam&&isalive(players[i]))
                enemyplayers[enemyplayers.size]=players[i];
        }
        enemies=self sortplayerarray(enemyplayers);
        aimplayer=undefined;
        for(i=0;i<enemies.size;i++)
        {
            vec=enemies[i].origin-self.origin;
            barrel=maps\mp\_utility::vectorscale(vectornormalize(vec),level.turrbarrelheight);
            barrel=barrel+maps\mp\_utility::vectorscale(vectornormalize(vec),level.turrbarrellength);
            start=self.origin+barrel+maps\mp\_utility::vectorscale(vectornormalize(vec),level.turrbarrellength);

            trace1=bullettrace(start,enemies[i] geteyepos(),true,self);
            trace2=bullettrace(start,maps\mp\_utility::vectorscale(enemies[i] geteyepos()+enemies[i].origin,0.5),true,self);
            if(goodtrace(trace1,enemyplayers)||goodtrace(trace2,enemyplayers)&&!isdefined(aimplayer))
            {
                aimplayer=enemies[i];
                break;
            }
        }
        if(isdefined(aimplayer))
        {
            barrel=maps\mp\_utility::vectorscale(vectornormalize(anglestoup(self.angles)),level.turrbarrelheight);
            vector=aimplayer geteye()-(self.origin+barrel);
            angles=vectortoangles(vectornormalize(vector));
            currvector=anglestoforward(self.angles);
            turn=distancesquared(vectornormalize(vector),vectornormalize(currvector));

            time=turn/level.turrspeed;
            if(time<level.shotwait)
                time=level.shotwait;
            self rotateto(angles,time);
            wait level.shotwait;
            if(time<2*level.shotwait)
                self firebullet(planter);
        }
        else
            wait level.shotwait;

    }
}

goodtrace(trace,players)
{
    if(trace["fraction"]==1)
        return true;
    else if(!isdefined(trace["entity"]))
        return false;
    else if(isinarray(trace["entity"],players))
        return true;
    else
        return false;
}

firebullet(attacker)
{
    fw=maps\mp\_utility::vectorScale(anglestoforward(getsentryspreadangles(self.angles)),10000);
    barrel=maps\mp\_utility::vectorscale(vectornormalize(anglestoup(self.angles)),level.turrbarrelheight);
    barrel=barrel+maps\mp\_utility::vectorscale(vectornormalize(anglestoforward(self.angles)),level.turrbarrellength);
    trace=bullettrace(self.origin+barrel,self.origin+barrel+fw,true,self);
    self playsound(level.turrfiresound);
    fxpoint=self.origin+barrel+maps\mp\_utility::vectorscale(vectornormalize(anglestoforward(self.angles)),level.turrbarrellength);
    playfx(level.turrmuzzflash,fxpoint);
    if(isplayer(trace["entity"]))
    {
        vDir=vectornormalize(trace["position"]-self.origin);
        trace["entity"] maps\mp\gametypes\_callbacksetup::CodeCallback_PlayerDamage(attacker, attacker, level.turrdamage, 0, "MOD_RIFLE_BULLET", level.turrweapname, trace["position"], vDir, "none", 0);
    }
    else if(canbedamaged(trace["entity"]))
        finishobjectdamage(attacker,level.turrdamage);
    else if(!isdefined(trace["entity"])&&trace["fraction"]<1&&trace["normal"]!=(0,0,0))
        placebullethole(trace,false,self.origin);

}

getsentryspreadangles(oldangles)
{
    spread=3;
    if(randomint(2))
        minx=-1;
    else
        minx=1;
    if(randomint(2))
        miny=-1;
    else
        miny=1;
    spready=randomfloat(spread);
    oldangles=(oldangles[0]+spready*minx,oldangles[1]+randomfloat(spread)*miny,oldangles[2]);
    if(oldangles[1]>180)
        oldangles=(oldangles[0],oldangles[1]-360,oldangles[2]);
    if(oldangles[1]<-180)
        oldangles=(oldangles[0],oldangles[1]+360,oldangles[2]);
    if(oldangles[0]>90)
        oldangles=(oldangles[0]-spready*2,oldangles[1],oldangles[2]);
    if(oldangles[0]<-90)
        oldangles=(oldangles[0]+spready*2,oldangles[1],oldangles[2]);
    return oldangles;
}



sortplayerarray(ppl)
{
    for(i=0;i<ppl.size;i++)
    {
        disttoself=distancesquared(self.origin,ppl[i].origin)+400;
        vectoplayer=(ppl[i] geteye())-self.origin;
        timetoreach=distancesquared(vectornormalize(anglestoforward(self.angles)),vectornormalize(vectoplayer))+0.25;
        ppl[i].sortonthis=disttoself*timetoreach;
    }
    sorted=[];
    for(i=0;i<ppl.size;i++)
    {
        sortonthis[i]=33554432;
        for(j=0;j<ppl.size;j++)
        {
            if(ppl[j].sortonthis<sortonthis[i]&&!isinarray(ppl[j],sorted))
            {
                sorthonthis[i]=ppl[j].sorthonthis;
                sorted[i]=ppl[j];
            }
        }
    }
    return sorted;
}

    placebullethole(trace,startpoint)
    {
            fx=trace["surfacetype"];
            if(isdefined(level.effects[fx]))
                    effect=level.effects[fx];
            else
                    effect=level.effects["default"];
     
            normal=vectornormalize(trace["normal"]);
            playfx(effect,trace["position"],normal);
    }

finishobjectdamage(attacker,damage)
{
    if(isdefined(self.health))
    {
        self.health-=int(damage);
        if(self.health<0)
            self notify("destroyed_by",attacker);
    }
    else
        self notify("destroyed_by",attacker);
    if(isdefined(attacker))
        attacker thread maps\mp\gametypes\_damagefeedback::updateDamageFeedback();
}

canbedamaged(entity)
{
    if(isdefined(entity))
    {
        if(isdefined(entity.setcandamage))
        {
            if(entity.setcandamage)
                return true;
            else
                return false;
        }
        else
            return false;
    }
    else
        return false;
}

isInArray(array, element)
{
    if(!isDefined(array) || !array.size) return false;

    i = 0;
    while(i < array.size)
    {
        if(array[i] == element) return true;
        i++;
    }
    return false;
}

isOutside(origin)
{
    if(!isDefined(origin)) return false;

    trace = bulletTrace(origin, origin+ (0,0,6000), false, false);

    if(distance(origin, trace["position"]) >= 1000) return true;
    else return false;
}

geteyepos()
{
    if(isdefined(self.eyemarker))
    {
        if(distancesquared(self.eyemarker.origin,self.origin)>0)
            return self.eyemarker.origin;
        else
            return self geteye();
    }
    else
    {
        return self geteye();
    }
}