예제 #1
0
파일: g_trigger.c 프로젝트: basecq/q2dos
void trigger_counter_use(edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->count == 0)
		return;
	
	self->count--;

	if (self->count)
	{
		if (! (self->spawnflags & 1))
		{
			safe_centerprintf(activator, "%i more to go...", self->count);
			gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0);
		}
		return;
	}
	
	if (! (self->spawnflags & 1))
	{
		safe_centerprintf(activator, "Sequence completed!");
		gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0);
	}
	self->activator = activator;
	multi_trigger (self);
}
예제 #2
0
파일: g_lock.c 프로젝트: Kiln707/KMQuake2
void target_lock_use (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t *e;
	int		n;
	char    current[16];
	char	*copy_message;

	memset(current,0,16);

	for (e = self->teammaster; e; e = e->teamchain)
	{
		if (!e->count)
			continue;
		n = e->count - 1;
		current[n] = '0' + e->s.frame;
	}
	if(strcmp(current,self->key_message)==0)
	{
		copy_message  = self->message;
		self->message = NULL;
		G_UseTargets(self,activator);
		self->message = copy_message;
	}
	else
	{
		if(self->message) safe_centerprintf(activator,self->message);
		if(self->pathtarget) {
			e = G_Find(NULL,FOFS(targetname),self->pathtarget);
			if(e) e->use(e,other,activator);
		}
		else {
			BeepBeep(activator);
		}
	}
}
예제 #3
0
파일: g_chase.c 프로젝트: basecq/q2dos
void GetChaseTarget(edict_t *ent)
{
	int i;
	edict_t *other;

	for (i = 1; i <= maxclients->value; i++) {
		other = g_edicts + i;
		if (other->inuse && !other->client->resp.spectator) {
			ent->client->chase_target = other;
			ent->client->update_chase = true;
			UpdateChaseCam(ent);
			return;
		}
	}
	safe_centerprintf(ent, "No other players to chase.");
}
예제 #4
0
파일: p_client.c 프로젝트: ZwS/qudos
/*
=====================
ClientBeginDeathmatch

A client has just connected to the server in 
deathmatch mode, so clear everything out before starting them.
=====================
*/
void ClientBeginDeathmatch (edict_t *ent)
{
#ifdef WITH_ACEBOT
// ACEBOT_ADD
	static char current_map[55];
// ACEBOT_END
#endif
	G_InitEdict (ent);
#ifdef WITH_ACEBOT
// ACEBOT_ADD
	ACEIT_PlayerAdded(ent);
// ACEBOT_END
#endif
	InitClientResp (ent->client);

	// locate ent at a spawn point
	PutClientInServer (ent);

	// send effect
	gi.WriteByte (svc_muzzleflash);
	gi.WriteShort (ent-g_edicts);
	gi.WriteByte (MZ_LOGIN);
	gi.multicast (ent->s.origin, MULTICAST_PVS);
#ifdef WITH_ACEBOT
	safe_bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
	safe_centerprintf(ent,"\nQ2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2\n\nZaero Bots\n\n\n'sv addbot' to add a new bot.\n\n'sv removebot <name>' to remove bot.\n\n\nhttp://qudos.quakedev.com\n\n\nQ2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2 Q2\n\n");
	// If the map changes on us, init and reload the nodes
	if(strcmp(level.mapname,current_map))
	{
		
		ACEND_InitNodes();
		ACEND_LoadNodes();
		if (botauto_respawn->value) {
			ACESP_LoadBots();
		}
		strcpy(current_map,level.mapname);
	}

	safe_bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
// ACEBOT_END
#else
	gi.bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
#endif	

	// make sure all view stuff is valid
	ClientEndServerFrame (ent);
}
예제 #5
0
void crane_control_action(edict_t *control, edict_t *activator, vec3_t point)
{
	float  Z;
	int    dir;
	int    row, column;
	int    content;
	edict_t *beam, *cable, *cargo, *hoist, *hook;
	trace_t tr;
	vec3_t  center, v;
	vec3_t  end, forward, start, pt;
	vec3_t  bonk, mins, maxs;

	if(!(control->spawnflags & 1))
	{
		if(control->message)
			safe_centerprintf(activator,"%s\n",control->message);
		else
			safe_centerprintf(activator,"No power\n");
		return;
	}

	if(control->busy) return;

	// First make sure player (activator) is on the panel side of the
	// control panel
	// Also get center point of panel side
	switch (control->style)
	{
	case 0:
		if(activator->s.origin[0] > control->absmax[0]) return;
		center[0] = control->absmin[0];
		center[1] = (control->absmin[1] + control->absmax[1])/2;
		center[2] = (control->absmin[2] + control->absmax[2])/2;
		break;
	case 1:
		if(activator->s.origin[1] > control->absmax[1]) return;
		center[0] = (control->absmin[0] + control->absmax[0])/2;
		center[1] = control->absmin[1];
		center[2] = (control->absmin[2] + control->absmax[2])/2;
		break;
	case 2:
		if(activator->s.origin[0] < control->absmin[0]) return;
		center[0] = control->absmax[0];
		center[1] = (control->absmin[1] + control->absmax[1])/2;
		center[2] = (control->absmin[2] + control->absmax[2])/2;
		break;
	case 3:
		if(activator->s.origin[1] < control->absmin[1]) return;
		center[0] = (control->absmin[0] + control->absmax[0])/2;
		center[1] = control->absmax[1];
		center[2] = (control->absmin[2] + control->absmax[2])/2;
		break;
	}
	// now check distance from player to panel
	VectorSubtract(activator->s.origin,center,v);
	if(VectorLength(v) > 64) return;

	beam  = control->crane_beam;
	cable = control->crane_cable;
	hoist = control->crane_hoist;
	hook  = control->crane_hook;
	cargo = hook->crane_cargo;
	if(cargo) cargo->gravity = 0.0;    // reset after making it float up,
									   // otherwise things get jammed up
	control->activator = activator;

	// if any part of crane is currently moving, do nothing.
	if(VectorLength(control->velocity) > 0.) return;
	if(VectorLength(beam->velocity)    > 0.) return;
	if(VectorLength(hoist->velocity)   > 0.) return;
	if(VectorLength(hook->velocity)    > 0.) return;

	// now find which row and column of buttons corresponds to "point"
	row = (2*(point[2] - control->absmin[2]))/(control->absmax[2]-control->absmin[2]);
	if(row < 0) row = 0;
	if(row > 1) row = 1;
	switch (control->style)
	{
	case 1:
		column = (4*(point[0]-control->absmin[0]))/(control->absmax[0]-control->absmin[0]);
		break;
	case 2:
		column = (4*(point[1]-control->absmin[1]))/(control->absmax[1]-control->absmin[1]);
		break;
	case 3:
		column = (4*(point[0]-control->absmax[0]))/(control->absmin[0]-control->absmax[0]);
		break;
	default:
		column = (4*(point[1]-control->absmax[1]))/(control->absmin[1]-control->absmax[1]);
		break;
	}
	if(column < 0) column = 0;
	if(column > 3) column = 3;

	// adjust for controller facing beam movement direction
	if( beam->movedir[0] > 0 && (control->style == 0 || control->style == 2)) {
		if(column == 0 || column == 1) {
			column = 1-column;
			row = 1-row;
		}
	}
	if( beam->movedir[1] > 0 && (control->style == 1 || control->style == 3)) {
		if(column == 0 || column == 1) {
			column = 1-column;
			row = 1-row;
		}
	}

	switch(column)
	{
	case 0:
		//==================
		// move hoist
		//==================
		if(row)
		{
			// hoist away
			if(control->style == 0 || control->style == 1)
				control->crane_increment = 1;
			else
				control->crane_increment = -1;
		}
		else
		{
			// hoist toward
			if(control->style == 0 || control->style == 1)
				control->crane_increment = -1;
			else
				control->crane_increment = 1;
		}
		if(hoist->movedir[0] > 0)
		{
			// hoist travels in X
			dir = 0;
			if(control->crane_increment > 0)
			{
				if(Crane_Hook_Bonk(hook,0,1,bonk))
				{
					bonk[0] += hoist->absmax[0] - hook->absmax[0];
					hoist->crane_bonk = min(bonk[0],hoist->pos2[0]);
				}
				else
					hoist->crane_bonk = hoist->pos2[0];
				hoist->crane_bonk += hoist->absmin[0] - hoist->absmax[0];
			}
			else
			{
				if(Crane_Hook_Bonk(hook,0,-1,bonk))
				{
					bonk[0] += hoist->absmin[0] - hook->absmin[0];
					hoist->crane_bonk = max(bonk[0],hoist->pos1[0]);
				}
				else
					hoist->crane_bonk = hoist->pos1[0];
			}
		}
		else
		{
			// travels in Y
			dir = 1;
			if(control->crane_increment > 0)
			{
				if(Crane_Hook_Bonk(hook,1,1,bonk))
				{
					bonk[1] += hoist->absmax[1] - hook->absmax[1];
					hoist->crane_bonk = min(bonk[1],hoist->pos2[1]);
				}
				else
					hoist->crane_bonk = hoist->pos2[1];
				hoist->crane_bonk += hoist->absmin[1] - hoist->absmax[1];

			}
			else
			{
				if(Crane_Hook_Bonk(hook,1,-1,bonk))
				{
					bonk[1] += hoist->absmin[1] - hook->absmin[1];
					hoist->crane_bonk = max(bonk[1],hoist->pos1[1]);
				}
				else
					hoist->crane_bonk = hoist->pos1[1];
			}
		}
		hoist->crane_dir = dir;
		hoist->moveinfo.remaining_distance = control->crane_increment *
			(hoist->crane_bonk - hoist->absmin[dir]);
		if(hoist->moveinfo.remaining_distance <= 0) return;

		hoist->moveinfo.remaining_distance = min(hoist->moveinfo.remaining_distance,STEPSIZE);
		Crane_AdjustSpeed(hoist);
		VectorSet(hoist->moveinfo.dir,
			hoist->movedir[0]*control->crane_increment,
			hoist->movedir[1]*control->crane_increment,
			0);
		hoist->crane_control = control;

		hook->crane_dir  = dir;
		hook->crane_bonk = hoist->crane_bonk + hook->absmin[dir] -
			hoist->absmin[dir];
		hook->crane_control = control;
		memcpy(&hook->moveinfo,&hoist->moveinfo,sizeof(moveinfo_t));

		cable->crane_dir  = dir;
		cable->crane_bonk = hoist->crane_bonk + cable->absmin[dir] -
			hoist->absmin[dir];
		cable->crane_control = control;
		memcpy(&cable->moveinfo,&hoist->moveinfo,sizeof(moveinfo_t));

		if(cargo)
		{
			cargo->movetype   = MOVETYPE_PUSH;
			cargo->crane_dir  = dir;
			cargo->crane_bonk = hoist->crane_bonk + cargo->absmin[dir] -
				hoist->absmin[dir];
			cargo->crane_control = control;
			memcpy(&cargo->moveinfo,&hoist->moveinfo,sizeof(moveinfo_t));
		}
		Crane_Move_Begin(hoist);
		Crane_Move_Begin(hook);
		if(cargo) Crane_Move_Begin(cargo);
		break;
	case 1:
		//==================
		// move beam
		//==================
		// first re-parent associated speaker, if any
		if(beam->speaker && control == beam->crane_onboard_control)
		{
			beam->speaker->owner = control;
			VectorAdd(control->absmin,control->absmax,beam->speaker->s.origin);
			VectorScale(beam->speaker->s.origin,0.5,beam->speaker->s.origin);
			VectorSubtract(beam->speaker->s.origin,control->s.origin,beam->speaker->offset);
			control->noise_index = beam->noise_index;
		}
		if(row)
		{
			// left arrow
			if(control->style == 0 || control->style == 3)
				control->crane_increment =  1;
			else
				control->crane_increment = -1;
		}
		else
		{
			// right arrow
			if(control->style == 0 || control->style == 3)
				control->crane_increment = -1;
			else
				control->crane_increment =  1;
		}
		if(beam->movedir[0] > 0)
		{
			// travels in X
			dir = 0;
			if(control->crane_increment > 0)
			{
				if(Crane_Hook_Bonk(hook,0,1,bonk))
				{
					bonk[0] += beam->absmax[0] - hook->absmax[0];
					beam->crane_bonk = min(bonk[0],beam->pos2[0]);
				}
				else
					beam->crane_bonk = beam->pos2[0];
				beam->crane_bonk += beam->absmin[0] - beam->absmax[0];
			}
			else
			{
				if(Crane_Hook_Bonk(hook,0,-1,bonk))
				{
					bonk[0] += beam->absmin[0] - hook->absmin[0];
					beam->crane_bonk = max(bonk[0],beam->pos1[0]);
				}
				else
					beam->crane_bonk = beam->pos1[0];
			}
		}
		else
		{
			// travels in Y
			dir = 1;
			if(control->crane_increment > 0)
			{
				if(Crane_Hook_Bonk(hook,1,1,bonk))
				{
					bonk[1] += beam->absmax[1] - hook->absmax[1];
					beam->crane_bonk = min(bonk[1],beam->pos2[1]);
				}
				else
					beam->crane_bonk = beam->pos2[1];
				beam->crane_bonk += beam->absmin[1] - beam->absmax[1];
			}
			else
			{
				if(Crane_Hook_Bonk(hook,1,-1,bonk))
				{
					bonk[1] += beam->absmin[1] - hook->absmin[1];
					beam->crane_bonk = max(bonk[1],beam->pos1[1]);
				}
				else
					beam->crane_bonk = beam->pos1[1];
			}
		}
		beam->crane_dir = dir;
		beam->moveinfo.remaining_distance = control->crane_increment *
			(beam->crane_bonk - beam->absmin[dir]);
//		gi.dprintf("remaining distance = %g\n",beam->moveinfo.remaining_distance);
		if(beam->moveinfo.remaining_distance <= 0) return;
		beam->moveinfo.remaining_distance = min(beam->moveinfo.remaining_distance,STEPSIZE);

		Crane_AdjustSpeed(beam);

		VectorSet(beam->moveinfo.dir,
			beam->movedir[0]*control->crane_increment,
			beam->movedir[1]*control->crane_increment,
			0);
		beam->crane_control = control;

		hoist->crane_dir  = dir;
		hoist->crane_bonk = beam->crane_bonk + hoist->absmin[dir] - beam->absmin[dir];
		hoist->crane_control = control;
		memcpy(&hoist->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));

		hook->crane_dir   = dir;
		hook->crane_bonk  = beam->crane_bonk + hook->absmin[dir] - beam->absmin[dir];
		hook->crane_control = control;
		memcpy(&hook->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));

		cable->crane_dir  = dir;
		cable->crane_bonk = beam->crane_bonk + cable->absmin[dir] -
			beam->absmin[dir];
		cable->crane_control = control;
		memcpy(&cable->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));
		
		if(beam->crane_onboard_control)
		{
			beam->crane_onboard_control->crane_dir  = dir;
			beam->crane_onboard_control->crane_bonk = beam->crane_bonk +
				beam->crane_onboard_control->absmin[dir] -
				beam->absmin[dir];
			beam->crane_onboard_control->crane_control = control;
			memcpy(&beam->crane_onboard_control->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));
		}

		if(cargo)
		{
			cargo->movetype   = MOVETYPE_PUSH;
			cargo->crane_dir  = dir;
			cargo->crane_bonk = beam->crane_bonk + cargo->absmin[dir] - beam->absmin[dir];
			cargo->crane_control = control;
			memcpy(&cargo->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));
		}
		Crane_Move_Begin(beam);
		Crane_Move_Begin(hoist);
		Crane_Move_Begin(hook);
		if(beam->crane_onboard_control)
			Crane_Move_Begin(beam->crane_onboard_control);
		if(cargo) Crane_Move_Begin(cargo);
		break;
	case 2:
		//==================
		// hook up/down
		//==================
		hook->crane_dir = dir = 2;
		if(row)
		{
			// hook up
			control->crane_increment = 1;
			if(Crane_Hook_Bonk(hook,2,1,bonk))
				hook->crane_bonk = min(bonk[2],hook->pos2[2]);
			else
				hook->crane_bonk = hook->pos2[2];
			hook->crane_bonk += hook->absmin[2] - hook->absmax[2];
		}
		else
		{
			// hook down
			if(cargo)
			{
				pt[0] = (cargo->absmin[0] + cargo->absmax[0])/2;
				pt[1] = (cargo->absmin[1] + cargo->absmax[1])/2;
				pt[2] = cargo->absmin[2] - 0.125;
				content = gi.pointcontents(pt);
				if(content & MASK_SOLID)
				{
					BeepBeep(activator);
					return;
				}
			}
			control->crane_increment = -1;
			if(Crane_Hook_Bonk(hook,2,-1,bonk))
				hook->crane_bonk = max(bonk[2],hook->pos1[2]);
			else
				hook->crane_bonk = hook->pos1[2];
		}
		hook->moveinfo.remaining_distance = control->crane_increment *
			(hook->crane_bonk - hook->absmin[hook->crane_dir]);
		if(hook->moveinfo.remaining_distance <= 0)
		{
			BeepBeep(activator);
			return;
		}
		hook->moveinfo.remaining_distance = min(hook->moveinfo.remaining_distance,STEPSIZE);
		Crane_AdjustSpeed(hook);
		VectorSet(hook->moveinfo.dir,0.,0.,(float)(control->crane_increment));
		hook->crane_control = control;
		if(cargo)
		{
			cargo->movetype   = MOVETYPE_PUSH;
			cargo->crane_dir  = dir;
			cargo->crane_bonk = hook->crane_bonk + cargo->absmin[dir] - hook->absmin[dir];
			cargo->crane_control = control;
			VectorSubtract(cargo->s.origin,hook->s.origin,cargo->offset);
			memcpy(&cargo->moveinfo,&hook->moveinfo,sizeof(moveinfo_t));
		}
		cable->think = Cable_Think;
		cable->nextthink = level.time + FRAMETIME;

		Crane_Move_Begin(hook);
		if(cargo) Crane_Move_Begin(cargo);
		break;
	case 3:
		//==================
		// hook/unhook
		//==================
		if(row)
		{
			// pickup cargo

			if(hook->crane_cargo)
			{
				// already carrying something
				BeepBeep(activator);
				return;
			}
			VectorAdd(hook->absmin,hook->absmax,start);
			VectorScale(start,0.5,start);
			VectorSet(forward,0.,0.,-1.);
			VectorMA(start, 8192, forward, end);
			VectorSubtract(hook->absmin,start,mins);
			VectorSubtract(hook->absmax,start,maxs);
			// 06/03/00 change: Use 1/3 the bounding box to force a better hit
			VectorScale(mins,0.3333,mins);
			VectorScale(maxs,0.3333,maxs);
			// end 06/03/00 change
			tr=gi.trace(start, mins, maxs, end, hook, MASK_SOLID);
			if((tr.fraction < 1) && (tr.ent) && (tr.ent->classname) &&
				(tr.ent->movetype == MOVETYPE_PUSHABLE) )
			{
				Z = hook->absmin[2] - tr.ent->absmax[2];
				if(Z > MAX_PICKUP_DISTANCE)
				{
					safe_centerprintf(activator,"Too far\n");
					return;
				}
				if(CrateOnTop(NULL,tr.ent))
				{
					BeepBeep(activator);
					gi.dprintf("Too heavy\n");
					return;
				}
				// run a trace from top of cargo up... if first entity hit is NOT
				// the hook, we can't get there from here.
				if( Z > 0 )
				{
					trace_t tr2;

					VectorMA(tr.ent->mins,0.5,tr.ent->size,start);
					start[2] = tr.ent->maxs[2];
					VectorCopy(tr.ent->size,mins);
					VectorScale(mins,-0.5,mins);
					VectorCopy(tr.ent->size,maxs);
					VectorScale(maxs,0.5,maxs);
					mins[2] = maxs[2] = 0;
					mins[0] += 1; mins[1] += 1; maxs[0] -= 1; maxs[1] -= 1;
					VectorCopy(start,end);
					end[2] += Z + 1;
					tr2=gi.trace(start, mins, maxs, end, hook, MASK_SOLID);
					if((tr2.fraction < 1) && tr2.ent && (tr2.ent != hook))
					{
						safe_centerprintf(activator,"Blocked!\n");
						return;
					}
				}
				Z -= CARGO_BUFFER;   // leave a buffer between hook and cargo
				hook->crane_cargo    = cargo = tr.ent;
				cargo->groundentity  = NULL;
				cargo->crane_control = control;
				cargo->crane_hook    = hook;
				cargo->movetype      = MOVETYPE_PUSH;
				cargo->touch         = NULL;
				// Make cargo float up to the hook
				if(Z > 0)
				{
					control->busy      = true;
					cargo->attracted   = true;
					cargo->gravity     = 0.0;
					cargo->velocity[2] = 0.0;
					cargo->think       = Cargo_Float_Up;
					cargo->blocked     = cargo_blocked;
					cargo->goal_frame  = level.framenum;
					cargo->nextthink   = level.time + FRAMETIME;
					gi.linkentity(cargo);
				}
				else
				{
					gi.positioned_sound (start, cargo, CHAN_VOICE,
						gi.soundindex("tank/thud.wav"), 1, 1, 0);
				}
			}
			else
				BeepBeep(activator);
		}
		else
		{
			// drop cargo

			if(hook->crane_cargo)
			{
				hook->crane_cargo->gravity    = 1.0;
				hook->crane_cargo->movetype   = MOVETYPE_PUSHABLE;
				hook->crane_cargo->touch      = box_touch;
				hook->crane_cargo->crane_control = NULL;
				gi.linkentity(hook->crane_cargo);
				box_movestep (hook->crane_cargo, vec3_origin, true);
				hook->crane_cargo = NULL;
			}
			else
				BeepBeep(activator);
		}
	}
}
예제 #6
0
void crane_reset_use (edict_t *self, edict_t *other, edict_t *activator)
{
	float   d1, d2;
	int     dir;
	edict_t *delay;
	edict_t *crane;
	edict_t *control, *beam, *cable, *cargo, *hoist, *hook;
	vec3_t  bonk, v1, v2;
	

	crane = G_Find (NULL, FOFS(targetname), self->target);
	if(!crane)
	{
		gi.dprintf("Cannot find target of crane_reset at %s\n",vtos(self->s.origin));
		return;
	}
	control = crane->crane_control;
	control->activator = activator;

	if(!(control->spawnflags & 1))
	{
		if(control->message)
			safe_centerprintf(activator,"%s\n",control->message);
		else
			safe_centerprintf(activator,"No power\n");
		return;
	}
	
	beam    = control->crane_beam;
	hoist   = control->crane_hoist;
	hook    = control->crane_hook;
	cable   = control->crane_cable;
	cargo   = hook->crane_cargo;
	VectorSubtract(beam->pos1,self->s.origin,v1);
	VectorSubtract(beam->pos2,self->s.origin,v2);
	d1 = VectorLength(v1);
	d2 = VectorLength(v2);

	if(d2 < d1)
		control->crane_increment = 1;
	else
		control->crane_increment = -1;

	if(beam->movedir[0] > 0)
	{
		// travels in X
		dir = 0;
		if(control->crane_increment > 0)
		{
			if(Crane_Hook_Bonk(hook,0,1,bonk))
			{
				bonk[0] += beam->absmax[0] - hook->absmax[0];
				beam->crane_bonk = min(bonk[0],beam->pos2[0]);
			}
			else
				beam->crane_bonk = beam->pos2[0];
			beam->crane_bonk += beam->absmin[0] - beam->absmax[0];
		}
		else
		{
			if(Crane_Hook_Bonk(hook,0,-1,bonk))
			{
				bonk[0] += beam->absmin[0] - hook->absmin[0];
				beam->crane_bonk = max(bonk[0],beam->pos1[0]);
			}
			else
				beam->crane_bonk = beam->pos1[0];
		}
	}
	else
	{
		// travels in Y
		dir = 1;
		if(control->crane_increment > 0)
		{
			if(Crane_Hook_Bonk(hook,1,1,bonk))
			{
				bonk[1] += beam->absmax[1] - hook->absmax[1];
				beam->crane_bonk = min(bonk[1],beam->pos2[1]);
			}
			else
				beam->crane_bonk = beam->pos2[1];
			beam->crane_bonk += beam->absmin[1] - beam->absmax[1];
		}
		else
		{
			if(Crane_Hook_Bonk(hook,1,-1,bonk))
			{
				bonk[1] += beam->absmin[1] - hook->absmin[1];
				beam->crane_bonk = max(bonk[1],beam->pos1[1]);
			}
			else
				beam->crane_bonk = beam->pos1[1];
		}
	}

	if(beam->speaker && beam->crane_onboard_control)
	{
		beam->speaker->owner = beam->crane_onboard_control;
		VectorAdd(beam->crane_onboard_control->absmin,
			      beam->crane_onboard_control->absmax,
				  beam->speaker->s.origin);
		VectorScale(beam->speaker->s.origin,0.5,beam->speaker->s.origin);
		VectorSubtract(beam->speaker->s.origin,
			           beam->crane_onboard_control->s.origin,beam->speaker->offset);
		beam->speaker->owner->noise_index = beam->noise_index;
	}

	beam->crane_dir = dir;
	beam->moveinfo.remaining_distance = control->crane_increment *
		(beam->crane_bonk - beam->absmin[dir]);
	if(beam->moveinfo.remaining_distance <= 0) return;

	Crane_AdjustSpeed(beam);

	VectorSet(beam->moveinfo.dir,
		beam->movedir[0]*control->crane_increment,
		beam->movedir[1]*control->crane_increment,
		0);
	beam->crane_control = control;

	hoist->crane_dir  = dir;
	hoist->crane_bonk = beam->crane_bonk + hoist->absmin[dir] - beam->absmin[dir];
	hoist->crane_control = control;
	memcpy(&hoist->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));

	hook->crane_dir   = dir;
	hook->crane_bonk  = beam->crane_bonk + hook->absmin[dir] - beam->absmin[dir];
	hook->crane_control = control;
	memcpy(&hook->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));

	cable->crane_dir  = dir;
	cable->crane_bonk = beam->crane_bonk + cable->absmin[dir] - beam->absmin[dir];
	cable->crane_control = control;
	memcpy(&cable->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));
		
	if(beam->crane_onboard_control)
	{
		beam->crane_onboard_control->crane_dir  = dir;
		beam->crane_onboard_control->crane_bonk = beam->crane_bonk +
			beam->crane_onboard_control->absmin[dir] -
			beam->absmin[dir];
		beam->crane_onboard_control->crane_control = control;
		memcpy(&beam->crane_onboard_control->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));
	}

	if(cargo)
	{
		cargo->crane_dir  = dir;
		cargo->crane_bonk = beam->crane_bonk + cargo->absmin[dir] - beam->absmin[dir];
		cargo->crane_control = control;
		memcpy(&cargo->moveinfo,&beam->moveinfo,sizeof(moveinfo_t));
	}
	delay = G_Spawn();
	delay->owner     = control;
	delay->think     = crane_reset_go;
	delay->nextthink = level.time + FRAMETIME;
	gi.linkentity(delay);

	self->count--;
	if(!self->count) {
		self->think = G_FreeEdict;
		self->nextthink = level.time + 1;
	}
}
예제 #7
0
파일: g_trigger.c 프로젝트: basecq/q2dos
/*QUAKED trigger_key (.5 .5 .5) (-8 -8 -8) (8 8 8)
A relay trigger that only fires it's targets if player has the proper key.
Use "item" to specify the required key, for example "key_data_cd"
*/
void trigger_key_use (edict_t *self, edict_t *other, edict_t *activator)
{
	int			index;

	if (!self->item)
		return;
	if (!activator->client)
		return;

	index = ITEM_INDEX(self->item);
	if (!activator->client->pers.inventory[index])
	{
		if (level.time < self->touch_debounce_time)
			return;
		self->touch_debounce_time = level.time + 5.0;
		safe_centerprintf (activator, "You need the %s", self->item->pickup_name);
		gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/keytry.wav"), 1, ATTN_NORM, 0);
		return;
	}

	gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/keyuse.wav"), 1, ATTN_NORM, 0);
	if (coop->value)
	{
		int		player;
		edict_t	*ent;

		if (strcmp(self->item->classname, "key_power_cube") == 0)
		{
			int	cube;

			for (cube = 0; cube < 8; cube++)
//				if (activator->client->pers.power_cubes & (1 << cube))
//					break;
			for (player = 1; player <= game.maxclients; player++)
			{
				ent = &g_edicts[player];
				if (!ent->inuse)
					continue;
				if (!ent->client)
					continue;
//				if (ent->client->pers.power_cubes & (1 << cube))
//				{
//					ent->client->pers.inventory[index]--;
//					ent->client->pers.power_cubes &= ~(1 << cube);
//				}
			}
		}
		else
		{
			for (player = 1; player <= game.maxclients; player++)
			{
				ent = &g_edicts[player];
				if (!ent->inuse)
					continue;
				if (!ent->client)
					continue;
				ent->client->pers.inventory[index] = 0;
			}
		}
	}
	else
	{
		activator->client->pers.inventory[index]--;
	}

	G_UseTargets (self, activator);

	self->use = NULL;
}
예제 #8
0
void G_UseTarget (edict_t *ent, edict_t *activator, edict_t *target)
{
	edict_t		*t;

//
// check for a delay
//
	if (ent->delay)
	{
	// create a temp object to fire at a later time
		t = G_Spawn();
		t->classname = "DelayedUse";
		t->nextthink = level.time + ent->delay;
		t->think = Think_Delay_Single;
		t->activator = activator;
		t->target_ent = target;
		if (!activator)
			gi.dprintf ("Think_Delay_Single with no activator\n");
		t->message = ent->message;
		t->target = ent->target;
		t->killtarget = ent->killtarget;
		t->noise_index = ent->noise_index;
		return;
	}
	
	
//
// print the message
//
	if ((ent->message) && !(activator->svflags & SVF_MONSTER))
	{
		safe_centerprintf (activator, "%s", ent->message);
		if (ent->noise_index > 0)
			gi.sound (activator, CHAN_AUTO, ent->noise_index, 1, ATTN_NORM, 0);
		else if (ent->noise_index == 0)
			gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0);
	}

//
// kill killtargets
//
	if (ent->killtarget)
	{
		t = NULL;
		while ((t = G_Find (t, FOFS(targetname), ent->killtarget)))
		{
			// Lazarus: remove killtargeted monsters from total_monsters
			if(t->svflags & SVF_MONSTER) {
				if(!t->dmgteam || strcmp(t->dmgteam,"player"))
					if(!(t->monsterinfo.aiflags & AI_GOOD_GUY))
						level.total_monsters--;
			}
			G_FreeEdict (t);
			if (!ent->inuse)
			{
				gi.dprintf("entity was removed while using killtargets\n");
				return;
			}
		}
	}

//
// fire target
//
	if (target)
	{
		// doors fire area portals in a specific way
		if (!Q_strcasecmp(target->classname, "func_areaportal") &&
			(!Q_strcasecmp(ent->classname, "func_door") || !Q_strcasecmp(ent->classname, "func_door_rotating") 
			|| !Q_strcasecmp(ent->classname,"func_door_rot_dh")))
			return;

		if (target == ent)
		{
			gi.dprintf ("WARNING: Entity used itself.\n");
		}
		else
		{
			if (target->use)
				target->use (target, ent, activator);
		}
		if (!ent->inuse)
		{
			gi.dprintf("entity was removed while using target\n");
			return;
		}
	}
}
예제 #9
0
/*
==============================
G_UseTargets

the global "activator" should be set to the entity that initiated the firing.

If self.delay is set, a DelayedUse entity will be created that will actually
do the SUB_UseTargets after that many seconds have passed.

Centerprints any self.message to the activator.

Search for (string)targetname in all entities that
match (string)self.target and call their .use function

==============================
*/
void G_UseTargets (edict_t *ent, edict_t *activator)
{
	edict_t		*t;

//
// check for a delay
//
	if (ent->delay)
	{
	// create a temp object to fire at a later time
		t = G_Spawn();
		t->classname = "DelayedUse";
		t->nextthink = level.time + ent->delay;
		t->think = Think_Delay;
		t->activator = activator;
		if (!activator)
			gi.dprintf ("Think_Delay with no activator\n");
		t->message = ent->message;
		t->target = ent->target;
		t->killtarget = ent->killtarget;
		t->noise_index = ent->noise_index;
		return;
	}
	
	
//
// print the message
//
	if ((ent->message) && !(activator->svflags & SVF_MONSTER))
	{
//		Lazarus - change so that noise_index < 0 means no sound
		safe_centerprintf (activator, "%s", ent->message);
		if (ent->noise_index > 0)
			gi.sound (activator, CHAN_AUTO, ent->noise_index, 1, ATTN_NORM, 0);
		else if (ent->noise_index == 0)
			gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0);
	}

//
// kill killtargets
//
	if (ent->killtarget)
	{
		t = NULL;
		while ((t = G_Find (t, FOFS(targetname), ent->killtarget)))
		{
			// Lazarus: remove LIVE killtargeted monsters from total_monsters
			if((t->svflags & SVF_MONSTER) && (t->deadflag == DEAD_NO))
			{
				if(!t->dmgteam || strcmp(t->dmgteam,"player"))
					if(!(t->monsterinfo.aiflags & AI_GOOD_GUY))
						level.total_monsters--;
			}
			// and decrement secret count if target_secret is removed
			else if(!Q_strcasecmp(t->classname,"target_secret"))
				level.total_secrets--;
			// same deal with target_goal, but also turn off CD music if applicable
			else if(!Q_strcasecmp(t->classname,"target_goal"))
			{
				level.total_goals--;
				if (level.found_goals >= level.total_goals)
				gi.configstring (CS_CDTRACK, "0");
			}
			G_FreeEdict (t);
			if (!ent->inuse)
			{
				gi.dprintf("entity was removed while using killtargets\n");
				return;
			}
		}
	}

//
// fire targets
//
	if (ent->target)
	{
		t = NULL;
		while ((t = G_Find (t, FOFS(targetname), ent->target)))
		{
			// doors fire area portals in a specific way
			if (!Q_strcasecmp(t->classname, "func_areaportal") &&
				(!Q_strcasecmp(ent->classname, "func_door") || !Q_strcasecmp(ent->classname, "func_door_rotating") 
				/*DWH*/ || !Q_strcasecmp(ent->classname,"func_door_rot_dh")))
				continue;

			if (t == ent)
			{
				gi.dprintf ("WARNING: Entity used itself.\n");
			}
			else
			{
				if (t->use)
					t->use (t, ent, activator);
			}
			if (!ent->inuse)
			{
				gi.dprintf("entity was removed while using targets\n");
				return;
			}
		}
	}
}
예제 #10
0
파일: g_items.c 프로젝트: basecq/q2dos
void Weapon_Sandbag_Fire (edict_t *ent)

{
	edict_t	*sandbag;

    
	ent->client->ps.gunframe++;

	if (ent->client->resp.team_on->index == 0)
	{
		if (allied_sandbags >= sandbaglimit->value)
		{
			safe_centerprintf(ent, "Your team is at the sandbag limit!\n");
			return;
		}
	}
	else if (ent->client->resp.team_on->index == 1)
	{
		if (axis_sandbags >= sandbaglimit->value)
		{
			safe_centerprintf(ent, "Your team is at the sandbag limit!\n");
			return;
		}
	}

	if (VectorCompare (ent->client->sandbag_pos , vec3_origin))
	{
		safe_centerprintf(ent, "There's no space for sandbags there!\n");
		return;
	}

	ent->client->pers.inventory[ITEM_INDEX(FindItem("Sandbags"))]--;





	sandbag = G_Spawn();

	VectorCopy (ent->client->sandbag_preview->mins, sandbag->mins);
	VectorCopy (ent->client->sandbag_preview->maxs, sandbag->maxs);
	VectorCopy (ent->client->sandbag_preview->s.angles, sandbag->s.angles);

	sandbag->classnameb = SANDBAGS;

	sandbag->movetype = MOVETYPE_TOSS;
	sandbag->solid = SOLID_BBOX;
	sandbag->s.modelindex = gi.modelindex ("models/objects/sandbag/tris.md2");
	sandbag->think = sandbag_think;
	sandbag->nextthink = level.time +.1;
//	ent->s.frame = rand() % 16;
//	ent->s.frame = 1;

	sandbag->mass = 300;

	sandbag->touch = sandbag_touch;

	sandbag->health = 2000;
	sandbag->takedamage      = DAMAGE_YES;
	sandbag->die = sandbag_die;
		sandbag->s.skinnum = 0;


		sandbag->s.frame = 0;
//		VectorSet (sandbag->mins, -19, -9, -10);
//		VectorSet (sandbag->maxs, 19, 9, 8);

	VectorCopy (ent->client->sandbag_pos, sandbag->s.origin);
	
	sandbag->clipmask = MASK_SHOT;


	sandbag->spawnflags = 1;
	if (ent->client->resp.team_on)
		sandbag->obj_owner = ent->client->resp.team_on->index;

	if (ent->client->resp.team_on->index == 0)
		allied_sandbags++;
	else if (ent->client->resp.team_on->index == 1)
		axis_sandbags++;

	sandbag->obj_time = level.time;


	gi.linkentity (sandbag);






	if (ent->client->pers.inventory[ITEM_INDEX(FindItem("Sandbags"))] ==0)
	{
		ent->client->weaponstate=WEAPON_LOWER;
		ent->client->ps.gunframe = 20;
		Use_Weapon (ent, FindItem("fists"));
		return;
	}

	G_FreeEdict (ent->client->sandbag_preview);
	ent->client->sandbag_preview = NULL;
}
예제 #11
0
void camera_on(edict_t *ent)
{
    gclient_t *cl;
    edict_t   *faker;
    edict_t   *monster;
    edict_t   *camera;
    int       i;
    vec3_t    forward, left, up;

    if (!ent->client)
    {
        return;
    }
    if (!ent->client->spycam)
    {
        return;
    }

    // "viewer" can control camera aim (2nd player to come along and use
    // camera cannot)
    camera = ent->client->spycam;
    if (camera->monsterinfo.aiflags & AI_ACTOR)
    {
        camera->flags |= FL_ROBOT;
    }
    if (!camera->viewer)
    {
        camera->viewer = ent;
    }

    // save current viewangles and restore them with camera_off
    VectorCopy(ent->client->v_angle, ent->client->org_viewangles);

    // copy over all important player data to fake player
    ent->client->camplayer = G_Spawn();
    faker          = ent->client->camplayer;
    faker->s.frame = ent->s.frame;
    VectorCopy(ent->s.origin, faker->s.origin);
    VectorCopy(ent->velocity, faker->velocity);
    VectorCopy(ent->s.angles, faker->s.angles);
    faker->s            = ent->s;
    faker->takedamage   = DAMAGE_AIM;
    faker->movetype     = MOVETYPE_WALK;
    faker->groundentity = ent->groundentity;
    faker->viewheight   = ent->viewheight;
    faker->inuse        = true;
    faker->classname    = "camplayer";
    faker->mass         = ent->mass;
    faker->solid        = SOLID_BBOX;
    faker->deadflag     = DEAD_NO;
    faker->clipmask     = MASK_PLAYERSOLID;
    faker->health       = ent->health;
    faker->light_level  = ent->light_level;
    faker->think        = faker_animate;
    faker->nextthink    = level.time + FRAMETIME;
    VectorCopy(ent->mins, faker->mins);
    VectorCopy(ent->maxs, faker->maxs);
    // create a client so you can pick up items/be shot/etc while in camera
    cl = (gclient_t *)malloc(sizeof(gclient_t));
    memset(cl, 0, sizeof(gclient_t));
    ent->client->camplayer->client     = cl;
    ent->client->camplayer->target_ent = ent;
    gi.linkentity(faker);

    AngleVectors(camera->s.angles, forward, left, up);

    VectorMA(camera->s.origin, camera->move_origin[0], forward, ent->s.origin);
    VectorMA(ent->s.origin, -camera->move_origin[1], left, ent->s.origin);
    VectorMA(ent->s.origin, camera->move_origin[2], up, ent->s.origin);

    ent->movetype = MOVETYPE_NOCLIP;
    ent->clipmask = 0;
    ent->solid    = SOLID_NOT;
    VectorClear(ent->velocity);
    ent->client->ps.gunindex        = 0;
    ent->client->ps.pmove.pm_flags |= PMF_NO_PREDICTION;
#ifdef KMQUAKE2_ENGINE_MOD
    // Knightmare- Camera effect and letterboxing
    if (ent->client->monitor->spawnflags & 64)
    {
        ent->client->ps.rdflags |= RDF_CAMERAEFFECT;
    }
    if (ent->client->monitor->spawnflags & 128)
    {
        ent->client->ps.rdflags |= RDF_LETTERBOX;
    }
#endif
    ent->svflags |= SVF_NOCLIENT;

    // check to see if we're the enemy of any monster. If so, make the
    // faker the enemy
    for (i = maxclients->value + 1, monster = g_edicts + i; i < globals.num_edicts; i++, monster++)
    {
        if (!monster->inuse)
        {
            continue;
        }
        if (!(monster->svflags & SVF_MONSTER))
        {
            continue;
        }
        if (monster->enemy == ent)
        {
            monster->enemy = faker;
            FoundTarget(monster);
        }
    }

    if (ent->client->spycam->viewmessage)
    {
        safe_centerprintf(ent, ent->client->spycam->viewmessage);
    }
}
예제 #12
0
파일: g_arty.c 프로젝트: basecq/q2dos
/*
=================
Cmd_Arty_f
CCH: new function to call in airstrikes
=================
*/
void Cmd_Arty_f (edict_t *ent)
{
/*	vec3_t	start;
	vec3_t	forward;
	vec3_t	end;
	vec3_t world_up;

	edict_t *airstrike;//faf
	trace_t	tr;*/

	//int randnum;	
	vec3_t v;
	edict_t *check;
	int e;

	edict_t *t;
	vec3_t  vdist;
	float tdist;

	int i;

	if (!ent->client)
		return;

	if (!IsValidPlayer(ent))
		return;

	if (ent->deadflag)
		return;

	if (!ent->client->resp.team_on)
		return;

	for (i=0 ; i<game.maxentities ; i++)
	{
		vec3_t neworg;

		t = &g_edicts[i];

		if (!t->inuse)
			continue;
		if (!t->classnameb)
			continue;
		if (t->classnameb != TNT)
			continue;

		VectorCopy (ent->s.origin, neworg);
		neworg[2]+= ent->viewheight;

		VectorSubtract (t->s.origin, neworg, vdist);

		tdist = VectorLength (vdist);
		
		if (tdist > 40) 
			continue;

		if (infront (ent, t))
		{
			t->think = G_FreeEdict;
			t->nextthink = level.time + 2;
			t->s.sound = 0;
			t->s.effects = 0;
			safe_centerprintf (ent, "You defused the TNT!\n");
		}
	}

	Spawn_Chute_Special (ent);

	//faf:  turret stuff
	if (!ent->client->turret &&
		!ent->client->grenade)
	{
		if	(CheckForTurret(ent))
		{
			Use_Weapon (ent, FindItem("Fists"));
			CheckForTurret(ent);
			return;
		}
	}
	else
	{
		turret_off(ent);
		return;
	}
	if (ent->client &&
		ent->client->pers.weapon &&
		ent->client->pers.weapon->classnameb == WEAPON_ARISAKA)
	{
		if (ent->client->weaponstate == WEAPON_READY &&
			ent->client->ps.gunframe < 99 &&
			!ent->client->aim)
		{
			ent->client->ps.gunframe = 99;
			Weapon_Bayonet_Fire1 (ent);
			return;
		}
		return;
	}

	if (ent->client &&
		ent->client->pers.weapon &&
		ent->client->pers.weapon->classnameb == WEAPON_CARCANO)
	{
		if (ent->client->weaponstate == WEAPON_READY &&
			ent->client->ps.gunframe < 104 &&
			!ent->client->aim)
		{
			ent->client->ps.gunframe = 104;
			Weapon_Bayonet_Fire1 (ent);
			return;
		}
		return;
	}

	if (ent->client &&
		ent->client->pers.weapon &&
		ent->client->pers.weapon->classnameb == WEAPON_ENFIELD)
	{
		if (ent->client->weaponstate == WEAPON_READY &&
			ent->client->ps.gunframe < 107 //&&
			)//!ent->client->aim)
		{
			ent->client->aim = false;
			ent->client->ps.gunframe = 107;
			Weapon_Bayonet_Fire1 (ent);
			return;
		}
		return;
	}

	if (ent->client &&
		ent->client->pers.weapon &&
		ent->client->pers.weapon->classnameb == WEAPON_SVT)
	{
		if (ent->client->weaponstate == WEAPON_READY &&
			ent->client->ps.gunframe < 89 &&
			!ent->client->aim)
		{
			ent->client->ps.gunframe = 89;
			Weapon_Bayonet_Fire1 (ent);
			return;
		}
		return;
	}

	if (ent->client->airstrike)
	{
		safe_cprintf(ent, PRINT_HIGH, "Airstrike cancelled sir!\n");

		G_FreeEdict(ent->client->airstrike);
		ent->client->airstrike = NULL;
		return;
	}
	else if ((ent->client->pers.weapon &&
		ent->client->pers.weapon->classnameb) &&
		ent->client->pers.weapon->classnameb == WEAPON_BINOCULARS)
	{
		if (ent->client->aim)
			safe_cprintf(ent, PRINT_HIGH, "Press fire to call an airstrike!\n");
		else
			safe_cprintf(ent, PRINT_HIGH, "Aim and then press fire to call an airstrike!\n");
	}

//	if (ent->client->resp.mos != OFFICER) {
//		safe_cprintf(ent, PRINT_HIGH, "You're not an officer, soldier!\n");
//		return;
//	}

	if (ent->deadflag || ent->client->limbo_mode ) {
		safe_cprintf(ent, PRINT_HIGH, "You are dead!\n");
		return;
	}

	//faf:  moving this up so you dont have to look through binocs to cancel arty
	// make sure artillary hasn't already been called

	check = g_edicts+1;
	for (e = 1; e < globals.num_edicts; e++, check++)
	{
		if (!check->inuse)
			continue;
		if (check->health < 1)
			continue;
		if (strcmp(check->classname, "misc_civilian"))
			continue;

		VectorSubtract (ent->s.origin, check->s.origin, v);

		if (VectorLength (v)< 100)
		{
			//gi.dprintf(DEVELOPER_MSG_GAME, "CIV FOUND\n");
			if (check->master == ent)
			{
				check->master = NULL;
				//gi.dprintf(DEVELOPER_MSG_GAME, "STAY\n");
				gi.sound (ent, CHAN_AUTO, gi.soundindex("misc/trigger1.wav"), .5, ATTN_STATIC, 0);
				check->goalentity = NULL;
				check->movetarget = NULL;
				check->enemy = NULL;
				check->monsterinfo.currentmove = &civilian_move_stand;
			}
			else
			{
				if (check->master && check->obj_owner == ent->client->resp.team_on->index)
					return; // can't steal civilian from teammate

				gi.sound (ent, CHAN_AUTO, gi.soundindex("misc/trigger1.wav"), .5, ATTN_STATIC, 0);

				check->master = ent;
				//gi.dprintf(DEVELOPER_MSG_GAME, "FOLLOW\n");
				if (check->obj_owner != ent->client->resp.team_on->index)
				{	
					level.obj_team = ent->client->resp.team_on->index;
					check->obj_owner = ent->client->resp.team_on->index;
					check->wait =level.time;
					//if (!check->wait) check->wait =level.time;
				}
			}
			check->obj_owner = ent->client->resp.team_on->index; 
		}
	}
}