ObjectFile.cpp #1

// ObjectFile.cpp: implementation of the CObjectFile class.
//
//////////////////////////////////////////////////////////////////////

#include "p4objects.h"

LINK_ENTITY_TO_CLASS( object_file, CObjectFile)
#define MAX_REVS 150

void CObjectFile::Spawn()
{
	Precache( );
			
	SET_MODEL( ENT(pev), "models/file/w_file.mdl" );

	UTIL_SetOrigin( pev, pev->origin );
	target = (Vector)pev->origin;  //by default, we're already where we want to be.

	UTIL_SetSize( pev, Vector(-5, -15, 38), Vector( 5, 15, 86) );  //collision box!

	level = 0;

	pev->movetype = MOVETYPE_FLY;
//			pev->sequence = LookupActivity (ACT_IDLE);
//			pev->frame = 0;
//			pev->framerate = 1;
	pev->solid = SOLID_BBOX; 

	SetThink( Think );
	SetTouch( Touch );

	pev->nextthink = gpGlobals->time + 0.5;
}

void CObjectFile::Precache()
{
	PRECACHE_MODEL("models/file/w_file.mdl");
}

void CObjectFile :: Think( void )
{
	if (!IsInWorld())
	{
		parent->disown( this );
		UTIL_Remove( this );
		return;
	}

	if (UTIL_VecUpdate( &(pev->origin), target )) {
		pev->nextthink = gpGlobals->time + 0.05;
		UTIL_SetSize( pev, Vector(-5, -15, 38), Vector( 5, 15, 86) );  //collision box!
	}
	else pev->nextthink = gpGlobals->time + 0.5;
}

void CObjectFile :: Touch( CBaseEntity* Thing )
{ 
	CBasePlayer *pl;
	CBaseEntity *be = CBaseEntity::Instance(Thing->pev->owner);

	if (Thing->IsPlayer()) pl = (CBasePlayer*) Thing;
	else if (be->IsPlayer()) pl = (CBasePlayer*) be;
	else return;
	if (pl->m_flNextP4Time > gpGlobals->time) return;
	pl->m_flNextP4Time = gpGlobals->time + 0.5;

	if (Thing->IsExpand()) {
		Expand( pl );
		return;
	}

	if (Thing->IsLong()) {
		Long( pl );
		return;
	}
	pl->m_flNextP4Time = gpGlobals->time + 0.2;
	UTIL_PrintHud(pl, path.Text());
}

void CObjectFile::Long( CBasePlayer* pl )
{
	ClientFileUser ui;
	ui.logflag = TRUE;
	ClientApi client;
	Error e;
	StrBuf msg = StrBuf();

	client.Init( &e );
	if (e.GetSeverity()) {
		e.Fmt(&msg);
		UTIL_FatalHud(pl, msg.Text());
		pl->m_flNextP4Time = gpGlobals->time + 20.0; //20 second delay on connect error
		return;
	}
	
	char* args[1];
	args[0] = path.Text();

	client.SetArgv(1, args);
	client.Run( "filelog", &ui );

	client.Final( &e );
	if (e.GetSeverity()) {
		e.Fmt(&msg);
		UTIL_WarningHud(pl, msg.Text());
	}

	UTIL_PrintHud( pl, ui.filelog.Text());
}

void CObjectFile::Expand( CBasePlayer* pl )
{
	if (level == 1) return;
	StrBuf hudmsg = StrBuf();
	hudmsg.Append("Displaying history of ");
	hudmsg.Append(path.Text());
	hudmsg.Append("...");
	UTIL_PrintHud( pl, hudmsg.Text());
	//killKids(this);

	newLevel(1);
	parent->killKids(this);

	FileLogCache* cache = new FileLogCache(path);
	/* create an entity for each one - don't set up "from" pointers yet*/
	if (cache->main == NULL) return;
	FileHead* hwork = cache->main;
	FileRev* rwork = hwork->head;
	CObjectRev* orev;
	int xcoord;
	int ycoord;
	short revsmade = 1;
	while (rwork != NULL)
	{
		if (revsmade > MAXRESULTS) break;
		orev = GetClassPtr( (CObjectRev *) NULL);
		revsmade++;
		orev->type = rwork->type;
		revs.Append(orev);
		rwork->ent = orev;
		orev->revobj = rwork;
		xcoord = cache->changes->GetPos(rwork->change);
		orev->pev->classname = MAKE_STRING("object_rev");
		orev->Spawn();
		orev->pev->origin = pev->origin + Vector(-xcoord, 0, 0);
		orev->target = target - Vector(0,0,100);
		orev->target.x -= xcoord*15;
		orev->filerev = hwork->file;
		orev->filerev.Append("#");
		orev->filerev.Append(&(rwork->rev));
		orev->parent = this;
		orev->pev->nextthink = gpGlobals->time;
		rwork = rwork->next;
	}
	hwork = cache->from;
	ycoord = 0;
	while (hwork != NULL)
	{
		ycoord++;
		rwork = hwork->head;
		while (rwork != NULL)
		{
			if (revsmade > MAXRESULTS) break;
			orev = GetClassPtr( (CObjectRev *) NULL);
			revsmade++;
			orev->type = rwork->type;
			revs.Append(orev);
			rwork->ent = orev;
			orev->revobj = rwork;
			xcoord = cache->changes->GetPos(rwork->change);
			orev->pev->classname = MAKE_STRING("object_rev");
			orev->Spawn();
			orev->pev->origin = pev->origin + Vector(-xcoord, ycoord, 0);
			orev->target = target - Vector(0,0,100);
			orev->target.x -= xcoord*15;
			orev->target.y += ycoord*20;
			orev->filerev = hwork->file;
			orev->filerev.Append("#");
			orev->filerev.Append(&(rwork->rev));
			orev->parent = this;
			orev->pev->nextthink = gpGlobals->time;
			rwork = rwork->next;
		}
		hwork = hwork->next;
	}
	hwork = cache->into;
	ycoord = 0;
	while (hwork != NULL)
	{
		ycoord++;
		rwork = hwork->head;
		while (rwork != NULL)
		{
			if (revsmade > MAXRESULTS) break;
			orev = GetClassPtr( (CObjectRev *) NULL);
			revsmade++;
			orev->type = rwork->type;
			revs.Append(orev);
			rwork->ent = orev;
			orev->revobj = rwork;
			xcoord = cache->changes->GetPos(rwork->change);
			orev->pev->classname = MAKE_STRING("object_rev");
			orev->Spawn();
			orev->pev->origin = pev->origin + Vector(-xcoord, -ycoord, 0);
			orev->target = target - Vector(0,0,95);
			orev->target.x -= xcoord*15;
			orev->target.y -= ycoord*20;
			orev->filerev = hwork->file;
			orev->filerev.Append("#");
			orev->filerev.Append(&(rwork->rev));
			orev->parent = this;
			orev->pev->nextthink = gpGlobals->time;
			rwork = rwork->next;
		}
		hwork = hwork->next;
	}
	/* now that they've all been spawned we can run around setting up pointers */
	ListNode* scan = revs.head;
	CObjectRev* obj;
	while (scan != NULL)
	{
		obj = (CObjectRev*) scan->ent;
		if (obj == NULL) break;
		if (obj->revobj->next != NULL)
			obj->next = obj->revobj->next->ent;
		if (obj->revobj->from != NULL)
		{
			obj->from = obj->revobj->from->ent;
			switch (obj->revobj->fromtype)
			{
			default:
			case TYPE_MERGE:
				obj->red = 0;
				obj->green = 0;
				obj->blue = 255;
				obj->bright = 255;
				break;
			case TYPE_BRANCH:
				obj->red = 255;
				obj->green = 255;
				obj->blue = 0;
				obj->bright = 255;
				break;
			case TYPE_DIRTY:
				obj->red = 255;
				obj->green = 0;
				obj->blue = 0;
				obj->bright = 255;
				break;
			case TYPE_COPY:
				obj->red = 0;
				obj->green = 255;
				obj->blue = 0;
				obj->bright = 255;
				break;
			case TYPE_IGNORE:
				obj->red = 255;
				obj->green = 0;
				obj->blue = 255;
				obj->bright = 182;
				break;
			}
		}
		scan = scan->next;
	}
	delete cache;

	if (revsmade > MAXRESULTS) UTIL_WarningHud(pl, "Output truncated!\n");
}

void CObjectFile :: newLevel( short newlev )
{
	if (newlev > 0)
	{
		Vector parvec = parent->targvec();
		target.x = parvec.x;
		target.y = parvec.y;
	}
	target.z += (newlev - level)*100;
	level = newlev;
	parent->newLevel(level+1);
}

void CObjectFile :: disown ( CBaseEntity *Target ) //this does the OPPOSITE of killKids!!!
{
	revs.EKill(Target);
}

void CObjectFile :: killKids( CBaseEntity *Caller )
{
	bool callerFlag = false;
	CBaseEntity* kid = revs.EPop();
	while (kid != NULL)
	{
		if (kid == Caller) 
		{
			callerFlag = TRUE;
			kid = revs.EPop();
			continue;
		}
		kid -> killKids(this);
		UTIL_Remove(kid);
		kid = revs.EPop();
	}
	if (callerFlag) revs.Append(Caller);
}

CObjectFile::CObjectFile()
{

}

/*
CObjectFile::~CObjectFile()
{

}
*/