/*
===============================================================================

 constructible_objective
	base class for objectives that get constructed

===============================================================================
*/


object constructible_objective {
	void			preinit();
	void			destroy();
	void			syncFields();

	boolean			CheckActionCode_Base( entity p, float actionCode );
	boolean			vCheckActionCode( entity p, float actionCode ) {
		return CheckActionCode_Base( p, actionCode );
	}

	void			vSetOwner( entity o ) { ; }

	void			vConstruct( entity p );
	void			OnConstructionStarted() {}
	void			OnConstructionFinished( entity p ) {}
	void			OnConstructionFizzled();

	void			vCreateMission();
	void			vFreeMission();
	void			vCompleteMission();

	float			OnActivate( entity p, float distance );
	float			GetActivateCode( entity p, float distance );
	boolean			HasConstructContext( entity other );

	void			OnDisabledChanged();
	void			OnIsPrimaryObjectiveChanged();

	void			OnCounterChanged();

	void			UpdateObjectiveProgress();
	void			UpdateObjectiveProgress_Base();
	void			SetObjectiveIndicator();
	void			ClearObjectiveIndicator();
	float			CalcObjectiveProgress();
	void			UpdateObjectiveThread();
	void			SetObjectiveReminderTime( float time );

	float			vGetPliersProgressBarValue( float action );
	float			OnUpdateCrosshairInfo( entity p );

	void			FinishObjective_Base();
	void			StartObjective_Base();
	void			vFinishObjective() { FinishObjective_Base(); }
	void			vStartObjective() { StartObjective_Base(); }

	void			vMakePrimaryObjective( boolean value );

	void			KillFizzleThread();
	void			CreateFizzleThread( float delay );
	void			FizzleThread( float delay );

	entity			GetConstructionStage() { return $null_entity; }
	void			OnConstructing() { }
	
	void			ShowAndEnableClip();
	void			HideAndDisableClip();

	boolean			vIsPrimaryObjective();
	boolean			IsPrimaryConstruction();

	string			vGetObjectiveString() { return "constructObjective"; }

	boolean			isPrimaryObjective;

	float			totalCount;
	float			constructionCount;
	float			counter;
	float			fizzleTime;

	boolean			fizzleThreadActive;
	float			fizzleEndTime;

	float			constructProficiency;

	boolean			constructed;
	entity			constructor;
	float			lastConstructTime;
	float			lastWarningUpdate;

	float			objectiveIndex;
	handle			progressMessage;
	boolean			forceShowProgress;
	float			nextProgressMessageTime;

	boolean			disabled;

	float			useMeToolTip1;
	float			useMeToolTip2;

	float			nextObjectiveReminderTime;
	handle			objectName;
	handle			constructedMessage;
	task			missionTask;
	
	float			dmgIndex;

	boolean			fizzling;
}

void constructible_objective::syncFields() {
	sync( "counter" );

	syncBroadcast( "fizzling" );
	syncBroadcast( "disabled" );
	syncCallback( "counter", "OnCounterChanged" );
	syncCallback( "disabled", "OnDisabledChanged" );
}

void constructible_objective::OnDisabledChanged() {
	if ( disabled ) {
		vFinishObjective();
	} else {
		vStartObjective();
	}
}

void constructible_objective::OnIsPrimaryObjectiveChanged() {
	ClearObjectiveIndicator();

	if ( isPrimaryObjective ) {
		SetObjectiveIndicator();
	}
}

void constructible_objective::OnCounterChanged() {
	OnConstructing();
}

void constructible_objective::SetObjectiveReminderTime( float time ) {
	if ( time > nextObjectiveReminderTime ) {
		nextObjectiveReminderTime = time;
	}
}

void constructible_objective::UpdateObjectiveProgress() {
	UpdateObjectiveProgress_Base();
}

void constructible_objective::UpdateObjectiveThread() {
	waitUntil( objManager.gameState == GS_GAMEON );

	objManager.PlaySound( getKey( "snd_intro_strogg" ), stroggTeam );
	objManager.PlaySound( getKey( "snd_intro_gdf" ), gdfTeam );

	SetObjectiveReminderTime( sys.getTime() + OBJECTIVEMESSAGE_WAIT_TIME );

	while ( true ) {
		UpdateObjectiveProgress();

		if ( !sys.isClient() ) {
			if ( sys.getTime() >= nextObjectiveReminderTime ) {
				if ( objManager.gameState == GS_GAMEON ) {
					objManager.PlaySound( getKey( "snd_reminder_strogg" ), stroggTeam );
					objManager.PlaySound( getKey( "snd_reminder_gdf" ), gdfTeam );
				}

				SetObjectiveReminderTime( sys.getTime() + OBJECTIVEMESSAGE_WAIT_TIME );
			}
		}

		sys.waitFrame();
	}
}

void constructible_objective::SetObjectiveIndicator() {
	UpdateObjectiveProgress();

	thread UpdateObjectiveThread();

	if ( sys.doClientSideStuff() ) {
		sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.active", 1.f );
		sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.stage1", 0.f );
		sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.stage2", 0.f );
	}
}

void constructible_objective::ClearObjectiveIndicator() {
	sys.killThread( "UpdateObjectiveThread_" + getName() );

	if ( sys.doClientSideStuff() ) {
		sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.active", 0 );
	}
}

void constructible_objective::UpdateObjectiveProgress_Base() {
	if ( sys.doClientSideStuff() ) {
		sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.stage1", CalcObjectiveProgress() );
	}
}

float constructible_objective::CalcObjectiveProgress() {
	return counter / constructionCount;
}

void constructible_objective::FinishObjective_Base() {
	if ( !sys.isClient() ) {
		disabled = true;
	}

	HideAndDisableClip();
}

void constructible_objective::StartObjective_Base() {
	if ( !sys.isClient() ) {
		disabled = false;
	}

	ShowAndEnableClip();
}

void constructible_objective::vMakePrimaryObjective( boolean value ) {
	isPrimaryObjective = value;
	OnIsPrimaryObjectiveChanged();
}

void constructible_objective::preinit() {
	counter					= 0;

	objectiveIndex			= getFloatKeyWithDefault( "objective_index", -1 );

	forceShowProgress		= getIntKey( "force_show_progress" );

	useMeToolTip1			= GetToolTip( getKey( "tt_intro_use_me_1" ) );
	useMeToolTip2			= GetToolTip( getKey( "tt_intro_use_me_2" ) );

	constructionCount		= gameRules.GetFloatKeyWithSuffix( self, "construct_count", 100.f );
	totalCount				= constructionCount;
	fizzleTime				= getFloatKeyWithDefault( "fizzle_time", 60.f );
	progressMessage			= sys.localizeString( getKeyWithDefault( "progress_message", "maps/generic/obj_construct" ) );

	constructProficiency	= GetProficiency( getKey( "prof_construct" ) );
	objectName				= sys.localizeString( getKey( "object_name" ) );
	
	string temp = getKey( "constructed_message" );
	if ( temp != "" ) {
		constructedMessage	= sys.localizeString( temp );
	} else {
		constructedMessage	= invalid_handle;
	}

	nextProgressMessageTime	= 0;
	
	dmgIndex				= GetDamage( getKey( "dmg_kill" ) );
}

void constructible_objective::destroy() {
	if ( isPrimaryObjective ) {
		ClearObjectiveIndicator();
	}
	vFreeMission();
}

boolean constructible_objective::CheckActionCode_Base( entity p, float actionCode ) {
	if ( objManager.gameState != GS_GAMEON ) {
		return false;
	}
	
	if ( getEntityAllegiance( p ) != TA_FRIEND ) {
		return false;
	}

	if ( actionCode == AC_CONSTRUCT ) {
		return true;
	}

	return false;
}

void constructible_objective::vConstruct( entity p ) {
	float time = sys.getTime();
	entity oldConstructor = constructor;
	if ( constructor == $null_entity || lastConstructTime < time - 2 ) {
		constructor = p;
		if ( lastConstructTime < time - 10 ) {
			oldConstructor = $null_entity;
		}
	}

	if ( p == constructor && ( forceShowProgress || objectiveIndex >= 0 ) ) {
		if ( sys.getTime() > nextProgressMessageTime ) {
			objManager.PushCPrintString( p.getUserName() );
			objManager.CPrintEvent( progressMessage, $null );
			nextProgressMessageTime = sys.getTime() + 5.f;
		}

		if ( constructor != oldConstructor ) {
			objManager.PlaySound( getKey( "snd_constructing_strogg" ), stroggTeam );
			objManager.PlaySound( getKey( "snd_constructing_gdf" ), gdfTeam );

			SetObjectiveReminderTime( sys.getTime() + ( OBJECTIVEMESSAGE_WAIT_TIME * 0.5f ) );
		}
	}

	lastConstructTime = time;

	team_base team = p.getGameTeam();

	if ( counter >= constructionCount ) {
		counter = 0;
	}

	if ( counter == 0 ) {
		OnConstructionStarted();
	}

	float count = 1;
	if ( team.HasConstructionBonus( p ) ) {
		count = count * 1.25f;
	}
	counter = counter + count;

	if ( !sys.isClient() ) {
		if ( constructProficiency != -1 ) {
			p.giveProficiency( constructProficiency, count / totalCount, missionTask, "construction" );
		}

		if ( counter >= constructionCount ) {
			OnConstructionFinished( p );
		} else {
			CreateFizzleThread( fizzleTime );
		}
	}

	OnConstructing();
}

void constructible_objective::KillFizzleThread() {
	fizzling = false;
	fizzleEndTime = 0;
	sys.killThread( "FizzleThread_" + getName() );
	fizzleThreadActive = false;
}

void constructible_objective::CreateFizzleThread( float delay ) {
	KillFizzleThread();

	fizzleEndTime = sys.getTime() + delay;
	if ( !fizzleThreadActive ) {
		thread FizzleThread( delay );
	}
}

void constructible_objective::OnConstructionFizzled() {
	counter = 0;
}

void constructible_objective::FizzleThread( float delay ) {
	fizzling = false;
	sys.threadName( "FizzleThread_" + getName() );
	
	fizzleThreadActive = true;
	while ( sys.getTime() < fizzleEndTime ) {
		sys.wait( fizzleEndTime - sys.getTime() );
	}
	fizzleThreadActive = false;
	if ( fizzleEndTime != 0 ) {
		OnConstructionFizzled();
	}
}

float constructible_objective::vGetPliersProgressBarValue( float action ) {
	return counter / constructionCount;
}

float constructible_objective::OnUpdateCrosshairInfo( entity p ) {
	if ( !sys.doClientSideStuff() ) {
		return 1.f;
	}

	float allegiance = getEntityAllegiance( p );
	float distance = chGetDistance();
	float range = InchesToMetres( distance );

	chSetNumLines( 0 );

	vector color = GetAllegianceColor( allegiance );

	if ( p != $null_entity ) {
		if ( p.isLocalPlayer() && objectiveIndex != -1 ) {
			p.sendToolTip( GetToolTip( getKey( "tt_intro_info" ) ) );
		}

		// see if theres a valid action to perform
		float code = GetActivateCode( p, distance );
		if ( code != AK_NONE && p.vHasActionItem( code ) ) {
			float index = chAddLine();
			chSetLineMaterial( index, p.vGetActionIcon( code ) );
			chSetLineType( index, CI_IMAGE );
			chSetLineSize( index, 64, 64 );
			chSetLineColor( index, g_colorWhite, 0.9f );

			if ( p.isLocalPlayer() ) {
				if ( !p.isToolTipPlaying() ) {
					if ( sys.getTime() - p.getCrosshairStartTime() > 1.f ) {
						if ( p.getCurrentWeapon() != p.vGetActionItem( code ) ) {
							p.sendToolTip( useMeToolTip1 );
						} else {
							p.sendToolTip( useMeToolTip2 );
						}
					}
				}
			}
		} else if ( code == AK_INWARMUP ) {
			if ( p.isLocalPlayer() && distance < DISTANCE_FOR_ACTION ) {
				team_base team = p.getGameTeam();
				if ( team != $null_entity ) {
					p.sendToolTip( GetToolTip( getKey( "tt_noobjective" ) ) );
				}
			}
		}
	}

	index = chAddLine();
	chSetLineTextIndex( index, objectName );
	chSetLineColor( index, color, 1.f );
	chSetLineType( index, CI_TEXT );
	chSetLineSize( index, 0, 0 );
	if ( ( range <= 25.f ) && ( range >= 5.f ) ) {
		index = chAddLine();
		chSetLineText( index, G_BuildRangeStr( range ) );
		chSetLineColor( index, color, 1.f );
		chSetLineType( index, CI_TEXT );
		chSetLineSize( index, 0, 0 );
	}

	return 1.f;
}

float constructible_objective::OnActivate( entity p, float distance ) {
	float code = GetActivateCode( p, distance );
	if ( code == AK_NONE ) {
		return 0.f;
	}

	p.vSelectActionItem( code );
	return 1.f;
}

float constructible_objective::GetActivateCode( entity p, float distance ) {
	if ( objManager.gameState != GS_GAMEON ) {
		return AK_INWARMUP;
	}

	if ( p.getViewingEntity() != p ) {
		return AK_NONE;
	}

	if ( p.getHealth() <= 0 ) {
		return AK_NONE;
	}

	if ( distance > DISTANCE_FOR_ACTION ) {
		return AK_NONE;
	}

	float allegiance = getEntityAllegiance( p );
	if ( allegiance == TA_FRIEND ) {
		return AK_CONSTRUCT;
	}

	return AK_NONE;
}

boolean constructible_objective::HasConstructContext( entity other ) {
	float allegiance = getEntityAllegiance( other );
	if ( allegiance != TA_FRIEND ) {
		return false;
	}

	return true;
}

void constructible_objective::vCreateMission() {
	vFreeMission();
	missionTask = taskManager.allocEntityTask( GetPlayerTask( getKey( "task_construct" ) ), self );
}

void constructible_objective::vFreeMission() {
	if ( missionTask != $null ) {
		missionTask.free();
		missionTask = $null;
	}
}

void constructible_objective::vCompleteMission() {
	if ( missionTask != $null ) {
		missionTask.complete();
		missionTask.free();
		missionTask = $null;
	}
}

void constructible_objective::ShowAndEnableClip() {
	show();
	if ( hasForceDisableClip() ) {
		forceEnableClip();

		if ( !sys.isClient() ) {
			// destroy touching entities
			float count = self.entitiesInBounds( getAbsMins(), getAbsMaxs(), MASK_SHOT_RENDERMODEL | MASK_SHOT_BOUNDINGBOX, 1 );

			float index;
			for ( index = 0; index < count; index++ ) {
				entity other = self.getBoundsCacheEntity( index );
				if ( other == self ) {
					continue;
				}
				if ( other != $null_entity ) {
					float entTouch = other.touches( self, true );

					if ( entTouch == 0.0f && inCollection( "bounds_check" ) ) {
						if ( G_ContainsBounds( getAbsMins(), getAbsMaxs(), other.getAbsMins(), other.getAbsMaxs(), 2 ) ) {
							entTouch = 1;
						}
					}

					if ( entTouch ) {
						projectile_landmine mine = other;
						if ( mine != $null_entity ) {
							mine.vSetOwner( $null_entity );
						} else {
							if ( dmgIndex != -1 ) {
								other.applyDamage( $null_entity, self, vec3_down, dmgIndex, 1.0f, $null_entity );
							}
						}
					}
				}
			}
		}
	}
}

void constructible_objective::HideAndDisableClip() {
	hide();
	if ( !hasForceDisableClip() ) {
		forceDisableClip();

		if ( !sys.isClient() ) {
			entity next;
			entity current;
			for ( current = getNextTeamEntity(); current != $null_entity; current = next ) {
				next = current.getNextTeamEntity();
				current.vOnBindMasterDestroyed();
			}
		}
	}
}

boolean constructible_objective::vIsPrimaryObjective() {
	if ( objectiveIndex == -1 ) {
		return false;
	}

	if ( !isPrimaryObjective ) {
		return false;
	}

	return true;
}

boolean constructible_objective::IsPrimaryConstruction() {
	if ( objectiveIndex >= 0 ) {
		return true;
	}

	return false;
}

/*
===============================================================================

 constructible_materials
	the script object attached to the construct materials

===============================================================================
*/

#define		CSTATE_BLANK						0
#define		CSTATE_PROGRESS						1
#define		CSTATE_COMPLETE						2

object constructible_materials : constructible_objective {
	void			preinit();
	void			init();
	void			syncFields();
	void			destroy();

	boolean			vCheckActionCode( entity p, float actionCode );

	void			OnConstructionStarted();
	void			OnConstructionFinished( entity p );
	void			OnConstructionFizzled();
	
	void			UpdateObjectiveProgress();

	void			SetupConstruction();

	void			OnStateChanged();
	void			SetConstructionState( float newState );
	void			AfterConstructed();
	void			vSetConstructionState( float newState ) { SetConstructionState( newState ); }

	void			vFinishObjective();
	void			vStartObjective();

	void			OnStartNewState();
	void			OnFinishCurrentState( entity other );

	entity			GetConstructionStage();

	void			OnConstructing();

	string			vGetQuickChatString( entity p );

	void			vOnContextConstruct( entity p );
	void			vOnContextDefend( entity p );
	entity			vGetSpectateEntity();
	boolean			vIsObjectiveComplete();

	float			startConstructed;

	float			state;
	float			oldState;

	// todo nick; make a seperate multi-staged constructible
	entity			firstStage;
	entity			secondStage;
	entity			intermediateStage;
	entity			removeEnt;
	entity			constructedEnt;
	boolean			multipleStages;
	float			constructDelay;

	flashpoint_obj	flashpoint;

	boolean			firstCompletedVO;
}

void constructible_materials::syncFields() {
	syncBroadcast( "removeEnt" );
	syncBroadcast( "firstStage" );
	syncBroadcast( "secondStage" );
	syncBroadcast( "intermediateStage" );
	syncBroadcast( "constructedEnt" );

	syncBroadcast( "state" );
	syncCallback( "state", "OnStateChanged" );
}

void constructible_materials::destroy() {
	if ( flashpoint != $null ) {
		delete flashpoint;
	}
}

void constructible_materials::vFinishObjective() {
	FinishObjective_Base();

	HideAndDisableClip();
}

void constructible_materials::vStartObjective() {
	StartObjective_Base();
	SetConstructionState( state );
}

void constructible_materials::preinit() {
	setGameTeam( sys.getTeam( getKey( "team" ) ) );

	multipleStages = getIntKey( "multiple_stages" );
	if ( multipleStages ) {
		totalCount = totalCount * 2;
	}

	constructDelay = 0;
	state = -1;
}

void constructible_materials::SetupConstruction() {
	if ( sys.isClient() ) {
		OnStateChanged();
		return;
	}

	firstStage = getEntityKey( "construction" );
	if ( firstStage == $null_entity ) {
		sys.error( "No construction found on " + self.getName() );
	}
	firstStage.setGameTeam( getGameTeam() );
	firstStage.vSetOwner( self );

	removeEnt = getEntityKey( "construction_remove" );
	if ( removeEnt != $null_entity ) {
		removeEnt.setGameTeam( getGameTeam() );
	}

	if( multipleStages ) {
		intermediateStage = getEntityKey( "construction_intermediate" );
		intermediateStage.vSetOwner( self );

		secondStage = getEntityKey( "construction_second" );
		if( secondStage == $null_entity ) {
			sys.error( "No construction_second found on " + self.getName());
		}
		secondStage.vSetOwner( self );

		secondStage.setGameTeam( getGameTeam() );
	}

	constructedEnt = getEntityKey( "constructed" );
	if ( constructedEnt != $null_entity ) {
		constructedEnt.setGameTeam( getGameTeam() );
		constructedEnt.vSetOwner( self );
	}

	float newState;

	startConstructed = getFloatKey( "start_constructed" );
	if( !startConstructed ) {
		newState = CSTATE_NONE;
	} else {
		if( multipleStages ) {
			newState = CSTATE_FIRST_SECOND;
		} else {
			newState = CSTATE_FIRST;
		}
	}

	SetConstructionState( newState );
}

void constructible_materials::init() {
	SetupConstruction();
}

boolean constructible_materials::vCheckActionCode( entity p, float actionCode ) {
	if ( !CheckActionCode_Base( p, actionCode ) ) {
		return false;
	}

	if ( sys.getTime() < constructDelay ) {
		return false;
	}

	if( multipleStages ) {
		return state != CSTATE_FIRST_SECOND;
	}
	return state != CSTATE_FIRST;
}

void constructible_materials::OnConstructionStarted() {
	OnStartNewState();
	
	if ( !sys.isClient() ) {
		objManager.setBotActionStateForEvent( ACTION_STATE_START_BUILD, self ); //mal: let the bots know someone is building the obj!
	}
}

void constructible_materials::OnConstructionFinished( entity p ) { //mal: the map script will handle this particular case.
	OnFinishCurrentState( p );
	counter = constructionCount;
}

void constructible_materials::OnConstructionFizzled() {
	float fizzleDuration = g_objectiveDecayTime.getFloatValue();
	
	// fizzle over time
	while ( counter > 0 ) {
		fizzling = true;
		float fizzleAmount = constructionCount * ( sys.getFrameTime() / fizzleDuration );
		counter = counter - fizzleAmount;
		sys.waitFrame();
	}
	fizzling = false;
	
	counter = 0;

	float newState;
	if ( state == CSTATE_FIRST_PROGRESS ) {
		newState = CSTATE_NONE;
		
		if ( !sys.isClient() ) {
			objManager.setBotActionStateForEvent( ACTION_STATE_BUILD_FIZZLED, self ); //mal: its fizzled - update the bots.
		}
		
	} else if ( state == CSTATE_FIRST_SECOND_PROGRESS ) {
		newState = CSTATE_FIRST;
	} else {
		sys.warning( "constructible_materials::FizzleThread Invalid State" );
		return;
	}

	// we've fallen back a stage
	SetConstructionState( newState );
}

void constructible_materials::OnStartNewState() {
	float newState;

	if ( state == CSTATE_NONE ) {
		newState = CSTATE_FIRST_PROGRESS;
	} else if ( state == CSTATE_FIRST ) {
		newState = CSTATE_FIRST_SECOND_PROGRESS;
	} else {
		sys.warning( "constructible_materials::OnStartNewState Invalid State " + state );
		return;
	}

	SetConstructionState( newState );
}

void constructible_materials::UpdateObjectiveProgress() {
	if ( sys.doClientSideStuff() ) {
		sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.multiStage", multipleStages );
		sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.decaying", fizzling );
		
		if( state == CSTATE_FIRST_SECOND_PROGRESS ) {
			sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.stage1", 1 );
			sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.stage2", CalcObjectiveProgress() );
			return;
		}

		if ( state == CSTATE_FIRST ) {
			sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.stage1", 1 );
			sys.setGUIFloat( GUI_GLOBALS_HANDLE, "constructObjective.stage2", 0 );
			return;
		}

		UpdateObjectiveProgress_Base();
	}
}

void constructible_materials::OnFinishCurrentState( entity other ) {
	boolean finished = true;

	float newState;

	if ( state == CSTATE_FIRST_PROGRESS ) {
		newState = CSTATE_FIRST;
		if ( multipleStages ) {
			finished = false;
		}
	} else if ( state == CSTATE_FIRST_SECOND_PROGRESS ) {
		newState = CSTATE_FIRST_SECOND;
	} else {
		sys.warning( "constructible_materials::OnFinishCurrentState Invalid State" );
		return;
	}
	
	if ( finished ) {
		player p = other;
		if ( p != $null_entity ) {
			team_base team = p.getGameTeam();
			string statName = team.getName();

			if ( IsPrimaryConstruction() ) {
				statName = statName + "_primary";
			} else {
				statName = statName + "_secondary";
			}
			statName = statName + "_objective_constructed";

			sys.increaseStatInt( sys.allocStatInt( statName ), p.getEntityNumber(), 1 );

			sys.increaseStatInt( sys.allocStatInt( "total_objectives_completed" ), p.getEntityNumber(), 1 );
		}
	}

	SetConstructionState( newState );

	constructDelay = sys.getTime() + 0.5f;

	KillFizzleThread();
}

void constructible_materials::OnStateChanged() {
	SetConstructionState( state );
}

void constructible_materials::SetConstructionState( float newState ) {
	if ( newState == CSTATE_DESTROY ) { // special notification state that is CSTATE_NONE, to distinguish between this and a fizzle
		// Gordon: doing the extra check here, because constructions may be put directly into the none state when they spawn
		if ( oldState != CSTATE_NONE ) {
			objManager.OnDestructionComplete( self );
		}
		newState = CSTATE_NONE;
	}

	if ( newState == CSTATE_NONE ) {
		firstStage.vSetState( CSTATE_NONE );

		if ( !disabled ) {
			ShowAndEnableClip();
		}

		if ( multipleStages ) {
			secondStage.vSetState( CSTATE_NONE );
			if ( intermediateStage != $null_entity ) {
				intermediateStage.vSetState( CSTATE_NONE );
			}
		}

		if ( constructedEnt != $null_entity ) {
			constructedEnt.vSetState( CSTATE_NONE );
		}
		if ( removeEnt != $null_entity ) {
			removeEnt.vSetState( CSTATE_COMPLETE );
		}

	} else if ( newState == CSTATE_FIRST_PROGRESS ) {
		firstStage.vSetState( CSTATE_PROGRESS );

		if ( !disabled ) {
			ShowAndEnableClip();
		}

		if ( multipleStages ) {
			secondStage.vSetState( CSTATE_NONE );
			if ( intermediateStage != $null_entity ) {
				intermediateStage.vSetState( CSTATE_PROGRESS );
			}
		}

		if ( constructedEnt != $null_entity ) {
			constructedEnt.vSetState( CSTATE_NONE );
		}
		if ( removeEnt != $null_entity ) {
			removeEnt.vSetState( CSTATE_COMPLETE );
		}
	} else if ( newState == CSTATE_FIRST ) {
		firstStage.vSetState( CSTATE_COMPLETE );

		if ( multipleStages ) {
			secondStage.vSetState( CSTATE_NONE );

			if ( intermediateStage != $null_entity ) {
				intermediateStage.vSetState( CSTATE_COMPLETE );
			}

			if ( !disabled ) {
				ShowAndEnableClip();
			}
			if ( constructedEnt != $null_entity ) {
				constructedEnt.vSetState( CSTATE_NONE );
			}
			if ( removeEnt != $null_entity ) {
				removeEnt.vSetState( CSTATE_COMPLETE );
			}


			if ( !firstCompletedVO ) {
				objManager.PlaySound( getKey( "snd_firststage_strogg" ), stroggTeam );
				objManager.PlaySound( getKey( "snd_firststage_gdf" ), gdfTeam );
				firstCompletedVO = true;
			}
		} else {
			AfterConstructed();
		}


	} else if( newState == CSTATE_FIRST_SECOND_PROGRESS ) {
		if( !multipleStages ) {
			sys.warning( "constructible_materials::SetConstructionState Not Multistage!" );
			return;
		}

		secondStage.vSetState( CSTATE_PROGRESS );

		if ( !disabled ) {
			ShowAndEnableClip();
		}

		if ( intermediateStage != $null_entity ) {
			intermediateStage.vSetState( CSTATE_COMPLETE );
		}

		if ( constructedEnt != $null_entity ) {
			constructedEnt.vSetState( CSTATE_NONE );
		}
		if ( removeEnt != $null_entity ) {
			removeEnt.vSetState( CSTATE_COMPLETE );
		}
	} else if( newState == CSTATE_FIRST_SECOND ) {
		if( !multipleStages ) {
			sys.warning( "constructible_materials::SetConstructionState Not Multistage!" );
			return;
		}

		if ( intermediateStage != $null_entity ) {
			intermediateStage.vSetState( CSTATE_NONE );
		}

		firstStage.vSetState( CSTATE_NONE );
		secondStage.vSetState( CSTATE_COMPLETE );

		AfterConstructed();
	}

	state		= newState;
	oldState	= newState;
}

void constructible_materials::AfterConstructed() {
	if ( objectiveIndex >= 0 ) {
		if ( getGameTeam() == stroggTeam ) {
			G_PlayObjectiveCompletedRoll( GDF );
		} else if ( getGameTeam() == gdfTeam ) {
			G_PlayObjectiveCompletedRoll( STROGG );
		}

		objManager.CompleteObjective( objectiveIndex, constructor );
	} else {
		if ( constructedMessage != invalid_handle ) {
			objManager.PushCPrintString( constructor.getUserName() );
			objManager.CPrintEvent( constructedMessage, $null );
		}
	}

	objManager.OnConstructionComplete( self );

	if ( constructedEnt != $null_entity ) {
		firstStage.vSetState( CSTATE_NONE );
		if ( multipleStages ) {
			secondStage.vSetState( CSTATE_NONE );
		}

		constructedEnt.vSetState( CSTATE_COMPLETE );
	}

	if( removeEnt != $null_entity ) {
		removeEnt.vSetState( CSTATE_NONE );
	}

	HideAndDisableClip();

	objManager.PlaySound( getKey( "snd_finished_strogg" ), stroggTeam );
	objManager.PlaySound( getKey( "snd_finished_gdf" ), gdfTeam );
}

entity constructible_materials::GetConstructionStage() {
	if ( state == CSTATE_FIRST_PROGRESS ) {
		if ( multipleStages ) {
			return intermediateStage;
		}
		return firstStage;
	} else if ( state == CSTATE_FIRST_SECOND_PROGRESS ) {
		return secondStage;
	}
	return $null_entity;
}

void constructible_materials::OnConstructing() {
	entity stage = GetConstructionStage();
	if ( stage == $null_entity ) {
		return;
	}

	player p = sys.getLocalPlayer();
	if ( p == $null_entity ) {
		return;
	}

	if ( sys.getTime() - lastWarningUpdate < 1.0f ) {
		return;
	}
	lastWarningUpdate = sys.getTime();

	sys.assert( stage.hasForceDisableClip() );

	stage.forceEnableClip();
	if ( !p.touches( stage, 0.0f ) ) {
		stage.forceDisableClip();
		return;
	}

	float contents = p.getEntityContents();
	stage.forceDisableClip();

	if ( contents == 0.0f ) {
		return;
	}

	if ( !p.isToolTipPlaying() ) {
		p.sendToolTip( GetToolTip( getKey( "tt_warning" ) ) );
	}
}

string constructible_materials::vGetQuickChatString( entity p ) {
	if ( getEntityAllegiance( p ) == TA_FRIEND ) {
		return getKey( "contextmenu_quickchat_friendly" );
	}
	return getKey( "contextmenu_quickchat_enemy" );
}

void constructible_materials::vOnContextConstruct( entity p ) {
	player local = sys.getLocalViewPlayer();
	if ( local == $null_entity || p == $null_entity ) {
		return;
	}

	if ( flashpoint != $null ) {
		delete flashpoint;
	}

	flashpoint = new flashpoint_obj;
	flashpoint.SetOwner( self );
	flashpoint.SetMaterial( getKey( "mtr_icon_flash" ) );
}

void constructible_materials::vOnContextDefend( entity p ) {
	player local = sys.getLocalViewPlayer();
	if ( local == $null_entity || p == $null_entity ) {
		return;
	}

	if ( objectiveIndex == -1 ) {
		return;
	}

	if ( flashpoint != $null ) {
		delete flashpoint;
	}

	flashpoint = new flashpoint_obj;
	flashpoint.SetOwner( self );
	flashpoint.SetMaterial( getKey( "mtr_icon_flash_destroy" ) );
}

entity constructible_materials::vGetSpectateEntity() {
	float time = sys.getTime();
	if ( lastConstructTime >= time - 0.5f ) {
		return constructor;
	}
	return $null_entity;
}

boolean constructible_materials::vIsObjectiveComplete() {
	if ( multipleStages ) {
		if ( state == CSTATE_FIRST_SECOND ) {
			return true;
		}
	} else {
		if ( state == CSTATE_FIRST ) {
			return true;
		}
	}
	
	return false;
}

/*
================================================

 constructible_base

 This entity simply gets hidden, shown
 and its skin changed

================================================
*/

object constructible_base {
	float		state;
	string		constructionSkin;
	float		maxHealth;

	float		dmgIndex;

	void		preinit() {
		state = -1;
		constructionSkin = getKeyWithDefault( "skin_construct", "deployEffect" );
	}

	void		init() {
		maxHealth = getMaxHealth();

		dmgIndex = GetDamage( getKey( "dmg_kill" ) );
	}

	void		SetState_Base( float newState );
	void		vSetState( float newState ) {
		SetState_Base( newState );
	}

	void		OnStateChanged() {
		vSetState( state );
	}

	string		vGetQuickChatString( entity p );
}

void constructible_base::SetState_Base( float newState ) {
	if ( state == newState ) {
		return;
	}

	setHealth( maxHealth );

	if ( newState == CSTATE_NONE ) {
	
		hide();
		forceDisableClip();
		
		if ( !sys.isClient() ) {
			entity next;
			entity current;
			for ( current = getNextTeamEntity(); current != $null_entity; current = next ) {
				next = current.getNextTeamEntity();
				current.vOnBindMasterDestroyed();
			}
	}

	} else if ( newState == CSTATE_PROGRESS ) {

		show();
		forceDisableClip();
		setSkin( constructionSkin );

	} else if ( newState == CSTATE_COMPLETE ) {

		show();
		setSkin( "" );
		if ( hasForceDisableClip() ) {
			forceEnableClip();

			if ( !sys.isClient() ) {
				// destroy touching entities
				float count = self.entitiesInBounds( getAbsMins(), getAbsMaxs(), MASK_SHOT_RENDERMODEL | MASK_SHOT_BOUNDINGBOX, 1 );

				float index;
				for ( index = 0; index < count; index++ ) {
					entity other = self.getBoundsCacheEntity( index );
					if ( other == self ) {
						continue;
					}
					if ( other != $null_entity ) {
						float entTouch = other.touches( self, true );

						if ( entTouch == 0.0f && inCollection( "bounds_check" ) ) {
							if ( G_ContainsBounds( getAbsMins(), getAbsMaxs(), other.getAbsMins(), other.getAbsMaxs(), 2 ) ) {
								entTouch = 1;
							}
						}

						if ( entTouch ) {
							projectile_landmine mine = other;
							if ( mine != $null_entity ) {
								mine.vSetOwner( $null_entity );
							} else {
								if ( dmgIndex != -1 ) {
									other.applyDamage( $null_entity, self, vec3_down, dmgIndex, 1.0f, $null_entity );
								}
							}
						}
					}
				}
			}
		}
	}

	state		= newState;
}

string constructible_base::vGetQuickChatString( entity p ) {
	if ( getEntityAllegiance( p ) == TA_FRIEND ) {
		return getKey( "contextmenu_quickchat_friendly" );
	}
	return getKey( "contextmenu_quickchat_enemy" );
}

/*
================================================

 constructible_tower

================================================
*/

object constructible_tower : constructible_base {
	void		preinit();
	void		init();
	void		destroy();

	void		vSetState( float newState );

	void		OnKilled( entity inflictor, entity attacker, float damage, vector dir, float location );

	float		OnUpdateCrosshairInfo( entity p );
	float		OnActivate( entity p, float distance );
	float		GetActivateCode( entity p, float distance );
	void		UpdateItemStates();

	void		vSetOwner( entity o );

	void		vCreateMission();
	void		vFreeMission();
	void		vCompleteMission();

	void		vOnContextDestroy( entity p );

	entity		gun;
	entity		ladder;

	handle		objectName;

	constructible_materials		materials;
	
	task		missionTask;

	float		dmgIndexDestroy;

	flashpoint_obj flashpoint;
}

void constructible_tower::OnKilled( entity inflictor, entity attacker, float damage, vector dir, float location ) {
	if ( !sys.isClient() ) {
		// destroy touching entities
		float count = self.entitiesInBounds( getAbsMins(), getAbsMaxs(), MASK_SHOT_RENDERMODEL | MASK_SHOT_BOUNDINGBOX, 1 );
		float entityCache = saveCachedEntities();
		float index;
		for ( index = 0; index < count; index++ ) {
			entity  other = self.getSavedCacheEntity( entityCache, index );
			if ( other == self ) {
				continue;
			}
			if ( other != $null_entity ) {
				if ( dmgIndexDestroy != -1 ) {
					other.applyDamage( inflictor, attacker, vec3_down, dmgIndexDestroy, 1.0f, $null_entity );
				}
			}
		}
		freeSavedCache( entityCache );
	}

	materials.SetConstructionState( CSTATE_DESTROY );
}

void constructible_tower::preinit() {
	objectName			= sys.localizeString( getKey( "object_name" ) );
}

void constructible_tower::vCreateMission() {
	vFreeMission();
	missionTask = taskManager.allocEntityTask( GetPlayerTask( getKey( "task_destroy" ) ), self );
}

void constructible_tower::vFreeMission() {
	if ( missionTask != $null ) {
		missionTask.free();
		missionTask = $null;
	}
}

void constructible_tower::vCompleteMission() {
	if ( missionTask != $null ) {
		missionTask.complete();
		missionTask.free();
		missionTask = $null;
	}
}

void constructible_tower::init() {
	gun = getEntityKey( "gun_entity" );
	ladder = getEntityKey( "ladder_entity" );

	dmgIndex = GetDamage( getKey( "dmg_kill" ) );
	dmgIndexDestroy = GetDamage( getKey( "dmg_kill_destroy" ) );

	if ( state != -1 ) {
		UpdateItemStates();
	}
}

void constructible_tower::destroy() {
	if ( flashpoint != $null ) {
		delete flashpoint;
	}
}

void constructible_tower::vSetState( float newState ) {
	SetState_Base( newState );
	UpdateItemStates();
}

void constructible_tower::UpdateItemStates() {
	if ( gun != $null_entity ) {
		if ( state == CSTATE_COMPLETE ) {
			gun.vSetConstructed( true );
		} else {
			gun.vSetConstructed( false );
		}
	}

	if ( ladder != $null_entity ) {
		if ( state == CSTATE_COMPLETE ) {
			ladder.forceEnableClip();
		} else {
			ladder.forceDisableClip();
		}
	}

	if ( state == CSTATE_COMPLETE ) {
		setTakesDamage( true );
	} else {
		setTakesDamage( false );
	}
}

void constructible_tower::vSetOwner( entity o ) {
	materials = o;
}

float constructible_tower::OnUpdateCrosshairInfo( entity p ) {
	if ( !sys.doClientSideStuff() ) {
		return 1.f;
	}

	float allegiance = getEntityAllegiance( p );
	float distance = chGetDistance();
	vector color = GetAllegianceColor( allegiance );

	chSetNumLines( 0 );

	if ( p != $null_entity ) {
		// see if theres a valid action to perform
		float code = GetActivateCode( p, distance );
		if ( code != AK_NONE && p.vHasActionItem( code ) ) {
			float index = chAddLine();
			chSetLineMaterial( index, p.vGetActionIcon( code ) );
			chSetLineType( index, CI_IMAGE );
			chSetLineSize( index, 64, 64 );
			chSetLineColor( index, g_colorWhite, 0.9f );
		}
	}

	index = chAddLine();
	chSetLineTextIndex( index, objectName );
	chSetLineColor( index, color, 1.f );
	chSetLineType( index, CI_TEXT );
	chSetLineSize( index, 0, 0 );

	return 1.f;
}

float constructible_tower::OnActivate( entity p, float distance ) {
	float code = GetActivateCode( p, distance );
	if ( code == AK_NONE ) {
		return 0.f;
	}

	p.vSelectActionItem( code );
	return 1.f;
}

float constructible_tower::GetActivateCode( entity p, float distance ) {
	if ( p.getViewingEntity() != p ) {
		return AK_NONE;
	}

	if ( p.getHealth() <= 0 ) {
		return AK_NONE;
	}

	if ( distance > DISTANCE_FOR_ACTION ) {
		return AK_NONE;
	}

	float allegiance = getEntityAllegiance( p );
	if ( allegiance == TA_ENEMY ) {
		if ( p.vHasActionItem( AK_PLANT ) ) {
			return AK_PLANT;
		}
	}

	return AK_NONE;
}

void constructible_tower::vOnContextDestroy( entity p ) {
	player local = sys.getLocalViewPlayer();
	if ( local == $null_entity || p == $null_entity ) {
		return;
	}

	if ( flashpoint != $null ) {
		delete flashpoint;
	}

	flashpoint = new flashpoint_obj;
	flashpoint.SetOwner( self );
	flashpoint.SetMaterial( getKey( "mtr_icon_flash_destroy" ) );
}