/***********************************************************************

projectile_landmine.script

***********************************************************************/

#define LM_NONE		0
#define LM_TRAP		1
#define LM_PROX		2

#define BEAM_START_OFFSET	-0.25f

object projectile_landmine : projectile_armable {

	void		preinit();
	void		syncFields();
	void		destroy();

	void		vSetOwner( entity other );

	void		OnTouch( entity other, object traceObject );
	void		OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location );
	float		OnUpdateCrosshairInfo( entity p );
	float		OnActivate( entity p, float distance );
	float		GetActivateCode( entity p, float distance );
	void		OnTriggerTimeChanged();
	void		OnStick( entity collisionEnt, vector collisionNormal, string surfaceType, string joint );
	boolean		vGetIsSelfArm();
	void		vSetSpotTime( float time );
	void		vOnTargetDestroyed();

	void		vOnContextDisarm( entity p );
	void		vMakeSticky(  entity collisionEnt, vector collisionNormal, string surfaceType, boolean _allowTripmine, string joint );

	void		CheckTrapAgainst( entity triggerer );

	void		OnModeChanged();
	
	void		BotOnExplode();

	float		vGetPliersProgressBarValue( float action );

	void		Idle();
	void		CheckTrigger();
	void		CheckDetonate();

	void		DoRadiusDamage();

	void		OnDisarmed( entity p );
	void		OnArmed( entity p );
	void		OnSelfArmed( entity p );

	float		EnemyCount();
	float		EnemyInFrontCount();
	void		ArmEffects();
	void		UpdateFlag();
	void		ShowIcon();
	void		HideIcon();
	
	void		Trigger( boolean newState );

	float		OnCollide( object traceObject, vector velocity, float bodyId );

	boolean		vRepairDroneIgnoreHidden();

	void		vApplyEmpDamage( entity attacker, float time, float weaponTime );

	void		DisarmFizzleThread();
	void		KillDisarmFizzleThread();
	
	void		SetupWorldIcon();
	boolean		worldIconSet;

	float		disarmProficiency;

	float		range;
	float		armDelay;
	float		mode;

	float		damageFilterIndex;

	float		commandMapIcon;

	float		lastSpotTime;

	float		beamRange;
	float		beamLength;
	float		beamHandle;

	float		activateTime;
	float		triggerTime;

	entity		owner;
	entity		vGetOwner() { return owner; }

	float		showBeam;

	float		creationTime;
	float		vGetMineCreationTime() { return creationTime; }
	
	boolean		allowTripmine;

	boolean		playTriggerEffect;

	float		detonateDelay;
	
	float		disableProficiency;

	float		selfArmDelay;
	boolean		selfArmIsArming;
}

void projectile_landmine::syncFields() {
	syncBroadcast( "beamLength" );
	syncBroadcast( "activateTime" );
	syncBroadcast( "triggerTime" );
	syncBroadcast( "mode" );
	syncBroadcast( "owner" );
	syncBroadcast( "selfArmIsArming" );
	syncCallback( "mode", "OnModeChanged" );
	syncCallback( "triggerTime", "OnTriggerTimeChanged" );
}

void projectile_landmine::preinit() {
	mode			= LM_NONE;

	range			= getFloatKey( "range" );

	ScheduleFizzle( getFloatKeyWithDefault( "fizzle_time", 30 ) );

	disarmProficiency	= GetProficiency( getKey( "prof_disarm" ) );

	beamRange			= GetGlobalFloat( "tripmine_beam_range" );
	beamHandle			= -1;

	commandMapIcon		= -1;

	damageFilterIndex	= GetTargetFilter( getKey( "ti_target_filter" ) );

	creationTime		= sys.getTime();

	playTriggerEffect	= true;

	detonateDelay		= getFloatKey( "prox_detonate_delay" );
	selfArmDelay		= getFloatKey( "self_arm_delay" );

	disableProficiency	= GetProficiency( getKey( "prof_disable" ) );

	disableKnockback();
}

void projectile_landmine::destroy() {
	HideIcon();

	if ( beamHandle != -1 ) {
		freeBeam( beamHandle );
		beamHandle = -1;
	}
	
	if ( owner != $null_entity ) {
		owner.binRemove( self );
	}

	KillDisarmFizzleThread();
	sys.killThread( "OnSelfArmed_" + getName() );
}

void projectile_landmine::Idle() {
	while ( true ) {
		sys.waitFrame();

		UpdateFlag();

		CheckTrigger();
		CheckDetonate();
	}
}

void projectile_landmine::OnModeChanged() {
	if ( mode != LM_NONE ) {
		stuck = true;
		freeze( 1.f );
		clearContacts();
		putToRest();
	}
}

void projectile_landmine::SetupWorldIcon() {
	if ( mode == LM_PROX && !worldIconSet ) {
		if ( g_drawMineIcons.getBoolValue() && g_allowMineIcons.getBoolValue() ) {
			float size = g_mineIconSize.getFloatValue();
			float cutoff = getFloatKeyWithDefault( "world_icon_cutoff_dist", 512 );

			setIconEnabled( true );
			setIconMaterial( "mtr_worldicon" );
			setIconSize( size, size );
			setIconColorMode( EI_TEAM );
			setIconPosition( EI_CENTER );
			setIconCutoff( cutoff );
			setIconAlphaScale( g_mineIconAlphaScale.getFloatValue() );
			worldIconSet = true;
		}
	}
}

void projectile_landmine::OnTriggerTimeChanged() {
	if ( triggerTime != 0 ) {
		if ( mode == LM_PROX ) {
			// slow beep
			if( playTriggerEffect ) {
				startSound( "snd_trigger", SND_WEAPON_ARM );
				playEffect( "fx_trigger", "", false );
				playTriggerEffect = false;

				player lPlayer = sys.getLocalViewPlayer();
				if ( lPlayer != $null_entity ) {
					vector dir = lPlayer.getWorldOrigin() - getWorldOrigin();
					if ( sys.vecLength( dir ) < range * 1.3 ) {
						lPlayer.vMineWarning( self );
					}
				}
			}
		 } else {
			// 
		 }
	} else {
		// stop beeping sound
	}
}

void projectile_landmine::Trigger( boolean newState ) {
	if ( newState ) {
		triggerTime = sys.getTime();
	} else {
		triggerTime = 0;
	}
	
	OnTriggerTimeChanged();
}
	
void projectile_landmine::ShowIcon() {
	player lPlayer;
	object team;

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

	if( commandMapIcon == -1 ) {
		team = getGameTeam();

		commandMapIcon = sys.allocCMIcon( self, getFloatKey( "icon_sort_cm" ) );
		string mat = "mtr_icon_friendly";
		if ( lPlayer.getGameTeam() != team ) {
			mat = "mtr_icon_enemy";
		}
		sys.setCMIconMaterial( commandMapIcon, GetMaterial( getKey( mat ) ) );
		sys.setCMIconSize( commandMapIcon, 10.f );
		sys.setCMIconFlag( commandMapIcon, CMF_ALWAYSKNOWN );
	}
}

void projectile_landmine::HideIcon() {
	if( commandMapIcon != -1 ) {
		sys.freeCMIcon( self, commandMapIcon );
		commandMapIcon = -1;
	}
}

void projectile_landmine::UpdateFlag() {
	entity localPlayer = sys.getLocalPlayer();
	if( localPlayer == $null_entity ) {
		return;
	}

	float oldShowBeam;
	boolean isFriend = getEntityAllegiance( localPlayer ) == TA_FRIEND;

	oldShowBeam = showBeam;

	if ( armTime == 0 ) {
		showBeam = false;
		show();
		HideIcon();
	} else {
		showBeam = true;
		show();
		
		if ( isFriend || ( sys.getTime() - lastSpotTime ) < 1.f ) {
			ShowIcon();
		} else {
			HideIcon();
		}

		setSkin( "" );
		
		SetupWorldIcon();
	}

	if( oldShowBeam != showBeam ) {
		if ( mode == LM_PROX ) {
			if( showBeam ) {
				startSound( "snd_beep", SND_WEAPON_SIG );
			} else {
				stopSound( SND_WEAPON_SIG );
			}
		}
	}

	if ( showBeam ) {
		if ( mode == LM_TRAP ) {
			if ( beamHandle == -1 ) {
				beamHandle = allocBeam( getKey( "mtr_beam" ) );
			}

			vector beamDir		= getWorldAxis( 2 );
			vector beamStartPos = getWorldOrigin() + ( beamDir * BEAM_START_OFFSET );
			
			vector beamColor;
			if ( isFriend ) {
				beamColor = g_colorGreen;
			} else {
				beamColor = g_colorRed;
			}

			updateBeam( beamHandle, beamStartPos, beamStartPos + ( beamDir * beamLength ), beamColor, 1.f, .5f );
		}
	} else {
		if ( beamHandle != -1 ) {
			freeBeam( beamHandle );
			beamHandle = -1;
		}
	}
}

void projectile_landmine::ArmEffects() {
	if ( mode == LM_NONE ) {
		return;
	}

	SetupContents();
	startSound( "snd_armed", SND_WEAPON_ARM );

	if ( mode == LM_TRAP ) {
		if ( !sys.isClient() ) {
			setCanCollideWithTeam( 0.f );

			vector beamDir		= getWorldAxis( 2 );
			vector beamStartPos = getWorldOrigin() + ( beamDir * BEAM_START_OFFSET );

			float fraction = sys.tracePoint( beamStartPos, beamStartPos + ( beamDir * beamRange ), CONTENTS_SOLID | CONTENTS_RENDERMODEL, self );

			// don't allow trip mine if the trace hit an entity
			// as we can't determine the actual beam length.
			if ( fraction == 1.f || sys.getTraceEntity() != sys.getEntity( "worldspawn" ) ) {
				mode = LM_PROX;
			} else {
				beamLength = fraction * beamRange;
			}
			
			activateTime = sys.getTime() + 2.f;
			setCanCollideWithTeam( 1.f );
		}
	}
	
	SetupWorldIcon();
}

float projectile_landmine::EnemyCount() {
	entitiesInRadius( g_vectorZero, range, -1, 0 );
	filterEntitiesByFilter( damageFilterIndex, 1 );
	
	float aliveCount = 0;
	float count = filterEntitiesByDisguiseAllegiance( TA_FLAG_ENEMY, 1 );
	float index;
	for ( index = 0; index < count; index++ ) {
		entity e = getBoundsCacheEntity( index );
		if ( e.getHealth() <= 0 ) {
			continue;
		}
		
		// don't have empty vehicles set off mines
		vehicle_base v = e;
		if ( v != $null_entity ) {
			if ( v.isEmpty() ) {
				continue;
			}
		}
		
		aliveCount++;
	}
	
	return aliveCount;
}

float projectile_landmine::EnemyInFrontCount() {
	entitiesInRadius( g_vectorZero, range, -1, 0 );
	filterEntitiesByFilter( damageFilterIndex, 1 );
	
	float aliveCount = 0;
	float count = filterEntitiesByDisguiseAllegiance( TA_FLAG_ENEMY, 1 );
	float index;
	for ( index = 0; index < count; index++ ) {
		entity e = getBoundsCacheEntity( index );
		if ( e.getHealth() <= 0 ) {
			continue;
		}
		
		// don't have empty vehicles set off mines
		vehicle_base v = e;
		if ( v != $null_entity ) {
			if ( v.isEmpty() ) {
				continue;
			}
		}

		// check if in front
		vector myForwards = getWorldAxis( 2 );
		vector myPos = getWorldOrigin() - myForwards * 2;
		vector delta = sys.vecNormalize( e.getWorldOrigin() - myPos );
		if ( myForwards * delta <= 0.0f ) {
			continue;
		}

		aliveCount++;
	}
	
	return aliveCount;
}

void projectile_landmine::CheckTrigger() {
	if ( triggerTime != 0 || armTime == 0 ) {
		return;
	}

	if ( mode == LM_PROX ) {
		if ( EnemyInFrontCount() == 0 ) {
			return;
		}
	} else if ( mode == LM_TRAP ) {
		if ( activateTime > sys.getTime() ) {
			return;
		}
	}

	Trigger( true );
}

void projectile_landmine::CheckDetonate() {
	if ( triggerTime == 0 ) {
		return;
	}
	
	if ( mode == LM_PROX ) {
		if ( ( sys.getTime() - triggerTime  ) < detonateDelay ) {
			return;
		}

		Explode( $null_entity, $null_entity );

		Trigger( false );

		return;
	}

	if ( mode == LM_TRAP ) {
		vector beamDir		= getWorldAxis( 2 );
		vector beamStartPos = getWorldOrigin() + ( beamDir * BEAM_START_OFFSET );

		setCanCollideWithTeam( 0.f );
		float count = entitiesInBounds( beamStartPos, beamStartPos + ( beamDir * beamLength ), CONTENTS_MONSTER | CONTENTS_VEHICLECLIP | CONTENTS_BODY | CONTENTS_SLIDEMOVER, 1.f );
		setCanCollideWithTeam( 1.f );
		
		float i;
		for ( i = 0; i < count; i++ ) {
			CheckTrapAgainst( getBoundsCacheEntity( i ) );
		}
	}
}

void projectile_landmine::CheckTrapAgainst( entity triggerer ) {
	boolean trigger = false;
	player p = triggerer;
	vehicle_base vehicle = triggerer;

	if ( p == $null_entity && vehicle == $null_entity ) {
		return;
	}

	float allegiance = getEntityAllegiance( triggerer );
	float disguiseAllegiance = allegiance;

	if ( triggerer != $null_entity ) {
		if ( triggerer.vTriggerTripmine() ) {
			player disguised = triggerer.getDisguiseClient();
			if ( disguised != $null_entity ) {
				disguiseAllegiance = getEntityAllegiance( disguised );
			}
		}
	}
	
	if ( allegiance == TA_ENEMY && disguiseAllegiance == TA_ENEMY ) {
		Explode( $null_entity, $null_entity );

		Trigger( false );
	}
}	

void projectile_landmine::OnArmed( entity p ) {
	stopSound( SND_ITEM );

	if ( !sys.isClient() ) {
		selfArmIsArming = false;
	}

	ProjectileArmable_OnArmed( p );
	ArmEffects();

	CancelFizzle();

	if ( !sys.isClient() ) {
		if ( mode == LM_NONE ) {
			sys.warning( "projectile_landmine::Arm No Mode Set\n" );
			mode = LM_PROX;
		}

		player myPlayer = owner;
		if ( myPlayer != $null_entity ) {
			myPlayer.binAdd( self );
			myPlayer.setPlayerMineArmed( true, self, true ); //mal: let the bots know this mine has been armed, and is dangerous.
		}
	}
}

void projectile_landmine::OnSelfArmed( entity p ) {
	selfArmIsArming = true;
	sys.assert( selfArmDelay - 2.f > 0 );

	sys.wait( 2.f );
	startSound( "snd_arm_auto", SND_ITEM );
	sys.wait( selfArmDelay - 2.f );

	if ( armTime == 0.0f ) {
		doPostArmSwitch = false;
		OnArmed( p );
	}
}

void projectile_landmine::OnDisarmed( entity p ) {
	ProjectileArmable_OnDisarmed( p );
	
	if ( getEntityAllegiance( p ) == TA_ENEMY ) {
		p.giveProficiency( disarmProficiency, 1.f, $null, "disarmed mine" );
	}

	if ( !sys.isClient() ) {
		player myPlayer = owner;
		if ( myPlayer != $null_entity ) {
			myPlayer.binRemove( self );
			myPlayer.setPlayerMineArmed( false, self, false ); //mal: thats one less mine for the bots to worry about.
		}
	}

	thread DisarmFizzleThread();
}

void projectile_landmine::OnTouch( entity other, object traceObject ) {
}

void projectile_landmine::vSetSpotTime( float time ) {
	lastSpotTime = time;
}

void projectile_landmine::vOnContextDisarm( entity p ) {
	InitDisarmTask();
}

float projectile_landmine::vGetPliersProgressBarValue( float action ) {
	if ( action == AC_ARM ) {
		if ( armTime != 0 ) {
			return 1.f;
		}
		return countCurrent / targetCount;
	}
	
	if ( action == AC_DISARM ) {
		if ( disarmTime != 0 ) {
			return 1.f;
		}
		return countCurrent / targetCount;
	}
	
	return 0.f;
}

boolean projectile_landmine::vRepairDroneIgnoreHidden() {
	return true;
}

void projectile_landmine::vApplyEmpDamage( entity attacker, float time, float weaponTime ) {
	if ( armTime != 0 ) {		
		if ( disableProficiency != -1 ) {
			attacker.giveProficiency( disableProficiency, 1.f, $null, "emp on mine" );
		}		
	}

	OnDisarmed( $null_entity );
}

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

	float allegiance = getEntityAllegiance( p );

	vector color = GetAllegianceColor( allegiance );
	float distance = chGetDistance();
	float range = InchesToMetres( distance );
	float health = getHealth();

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

			CheckContextToolTip( allegiance, code, p );
		}
	}
	
	index = chAddLine();
	if ( selfArmIsArming ) {
		if ( mode == LM_TRAP ) {
			chSetLineTextIndex( index, g_locStr_SelfArmingTripmine );
		} else {
			chSetLineTextIndex( index, g_locStr_SelfArmingProxymine );
		}
	} else if ( armTime == 0 ) {
		if ( mode == LM_TRAP ) {
			chSetLineTextIndex( index, g_locStr_UnarmedTripmine );
		} else {
			chSetLineTextIndex( index, g_locStr_UnarmedProxymine );
		}
	} else {
		if ( mode == LM_TRAP ) {
			chSetLineTextIndex( index, g_locStr_Tripmine );
		} else /* if ( mode == LM_PROX ) */ {
			chSetLineTextIndex( index, g_locStr_Proxmine );
		}
	}
	chSetLineColor( index, color, 1.f );
	chSetLineType( index, CI_TEXT );
	chSetLineSize( index, 0, 0 );

	if( range <= 100 ) {
		index = chAddLine();

		chSetLineText( index, G_BuildRangeStr( range ) );
		chSetLineColor( index, color, 1.f );
		chSetLineType( index, CI_TEXT );
		chSetLineSize( index, 0, 0 );
	}

	return 1.f;
}

void projectile_landmine::OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location ) {
	if ( owner == sys.getLocalPlayer() ) {
		sys.setGUIString( GUI_GLOBALS_HANDLE, "gameHud.bumpNotifyIcon", "mines" );
	}

	Explode( $null_entity, $null_entity );
}

void projectile_landmine::DoRadiusDamage() {
	if ( mode == LM_TRAP ) {
		splashDamageIndex = GetDamage( getKey( "dmg_splash_damage_trap" ) );
	} else if ( mode == LM_PROX ) {
		splashDamageIndex = GetDamage( getKey( "dmg_splash_damage_prox" ) );
	}

	if ( splashDamageIndex != -1 && !sys.isClient() ) {
		float power = 1.f;
		if ( armTime == 0 ) {
			power = 0.25f;
		}
		sys.applyRadiusDamage( getWorldOrigin(), self, owner, radiusDamageIgnoreEntity, self, splashDamageIndex, power, 1.f );
	}
}

void projectile_landmine::vSetOwner( entity other ) {
	owner = other;
	
	if ( owner == $null_entity ) {
		Fizzle();
	}
}

void projectile_landmine::vMakeSticky(  entity collisionEnt, vector collisionNormal, string surfaceType, boolean _allowTripmine, string joint ) {
	allowTripmine = _allowTripmine;
	OnStick( collisionEnt, collisionNormal, surfaceType, joint );
}

boolean projectile_landmine::vGetIsSelfArm() {
	if ( owner != $null_entity ) {
		team_base team = owner.getGameTeam();
		if ( team != $null ) {
			if ( team.HasSelfArmingMines( owner ) ) {
				return true;
			}
		}
	}
	
	return false;
}

void projectile_landmine::OnStick( entity collisionEnt, vector collisionNormal, string surfaceType, string joint ) {
	ProjectileMissile_OnStick( collisionEnt, collisionNormal, surfaceType, joint );

	if ( !sys.isClient() ) {
		if ( allowTripmine ) {
			mode = LM_TRAP;
		} else {
			mode = LM_PROX;
		}

		if ( vGetIsSelfArm() ) {
			thread OnSelfArmed( owner );
		}
		
		setClipOriented( true );
	}
}

float projectile_landmine::OnActivate( entity p, float distance ) {
	float allegiance = getEntityAllegiance( p );
	team_base team = p.getGameTeam();

	float code = GetActivateCode( p, distance );
	if ( code == AK_NONE ) {
		return 0.0f;
	}
	
	p.vSelectActionItem( code );
	return 1.f;
}

float projectile_landmine::GetActivateCode( entity p, float distance ) {
	if ( p.getViewingEntity() != p || distance > DISTANCE_FOR_ACTION ) {
		return AK_NONE;
	}

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

	if ( !stuck ) {
		return AK_NONE;
	}

	float allegiance = getEntityAllegiance( p );

	if ( allegiance == TA_ENEMY ) {
		if ( armTime == 0 ) {
			return AK_NONE;
		}

		return AK_ARM;
	} else if ( p == owner ) {
		return AK_ARM;
	}

	if ( armTime == 0 ) {
		return AK_ARM;
	}

	return AK_NONE;
}


// NOTE: If this returns true, all momentum on the object will be cleared, otherwise, it will bounce
float projectile_landmine::OnCollide( object traceObject, vector velocity, float bodyId ) {
	float shaderFlags;
	entity collisionEnt;

	if ( stuck ) {
		return true;
	}

	shaderFlags = traceObject.getTraceSurfaceFlags();
	if ( shaderFlags & SURF_NOIMPACT || shaderFlags & SURF_NOPLANT ) {
		return false;
	}

	collisionEnt = traceObject.getTraceEntity();
	if ( collisionEnt.vDisablePlantCharge() ) {
		return false;
	}
	
	// push the view out of the surface a bit
	vector normal = traceObject.getTraceNormal();
	
	// align to the surface normal
	alignToAxis( normal, Z_AXIS );
	
	// move to surface
	setWorldOrigin( traceObject.getTracePoint() );

	if ( !sys.isClient() ) {
		OnStick( collisionEnt, normal, traceObject.getTraceSurfaceType(), traceObject.getTraceJoint() );
	}
	
	return true;
}

void projectile_landmine::DisarmFizzleThread() {
	playEffect( "fx_disarm", "", false );
	sys.wait( startSound( "snd_disarmed", SND_WEAPON_DISARM ) );
	Fizzle();
}

void projectile_landmine::KillDisarmFizzleThread() {
	sys.killThread( "DisarmFizzleThread_" + getName() );
}

void projectile_landmine::BotOnExplode() { //mal: this mine has exploded, let its owner know.
	player p = owner;
	if ( p != $null_entity ) {
		p.setPlayerMineState( self, true, false );
	}
}

void projectile_landmine::vOnTargetDestroyed() {
	Fizzle();
}