Gun.s3d

class Gun{
	var mAnimator;
	var mAnimationId;
	
	var mMeshName;
	var mGunMesh;
	var mGunObj;
	var mOldObj;	
	
	var mSingleShot;
	var mShootingDelay;
	var mShootingDelayOrig;
	var mRecoilDepth;
	
	var mBulletMesh;
	var mBulletSpeed;
	var mBulletMaxDistance;
	var mBulletMaxLife;
	var mShootType;
	var mShootAnimationTime;
	var mDelayAnimFactor;
	var mLastShotTime;
	var mIsShooting;
	var mBulletPower;
	
	var mViveController;
	
	var mIsVive;
	
	var mBulletColors;
	var mColorIndex;
	var mIsActionAvailable;
	var mIsPowerEnabled;
	
	var mIsSwitching;
	var mRenderOldObj;
	var mSwitchGunTime;
	
	var mColorShader;
	var mID;
	var mBulletIndex;
	
	var mSoundManager;
	var mShootingSoundIndex;
	
	IsShooting();
	UpdateGun();
	SetRotationMatrix(mat);
	Rotate(angle, x, y, z);
	SetPosition(x,y,z);
	Shoot();
	Draw();
	GetObj();
	CreatePickupPoint(pos, rotation, axis);
	Pickup();
	LinkToController(controller);
	UnlinkController();
	Clone();
	Copy(otherGun, oldObj);
	SetACtionAvailable(isAvailable);
	EnablePower(isPowerEnabled);
	SwitchGunAnimation(oldObj);
	Recreate();
	IsSwitching();
	
	GetPosition();
	
	GetMeshName();
	GetMesh();
	GetShootingDelay();
	GetRecoilDepth();	
	GetBulletMesh();
	GetBulletSpeed();
	GetBulletMaxDistance();
	GetBUlletMaxLife();
	IsSingleShot();
	GetShootType();
	GetDelayAnimFactor();
	GetShootAnimationTime();
	GetAnimator();
	GetAnimationId();
	GetBulletPower();	
	GetBUlletCOlors();
	GetID();
	GetSoundManager();
	GetShootingSoundIndex();
};

function Gun::Gun(ID, meshName, shootingDelay, recoilDepth, bulletMesh, bulletSpeed, bulletMaxDistance, bulletMaxLife, bulletColors, bulletPower, shootType, singleShot, animator, animationId, soundManager, shootingSoundIndex){
	mDelayAnimFactor = 350;
	mSwitchGunTime = 0.15;	
	mColorIndex = 0;	
	mLastShotTime = 0;
	mIsVive = false;
	mISActionAvailable = false;
	mIsPowerEnabled = false;
	mIsSwitching = false;
	mIsShooting = false;	
	mColorShader = CVMShaderProgram("Shaders/SimpleColorShader.glsl");
	mRenderOldObj = false;
	mBulletIndex = 0;		
	
	if(len(meshName) > 1){
		mMeshName = meshName;
		mGunMesh = CvmNewMesh(mMeshName);
		mGunObj= CvmObj(mGunMesh);
		mOldObj = CvmObj(mGunMesh);
		mShootingDelayOrig = shootingDelay;
		mShootingDelay = mShootingDelayOrig;
		mRecoilDepth = recoilDepth;
		mBulletMesh = bulletMesh;
		mBulletSpeed = bulletSpeed;
		mBulletMaxDistance = bulletMaxDistance;
		mBulletMaxLife = bulletMaxLife;
		mShootType = shootType;
		mSingleShot = singleShot;
		mShootAnimationTime = mShootingDelay/mDelayAnimFactor;
		mAnimationId = animationId;
		mAnimator = animator;
		mBulletPower = bulletPower;			
		mBulletColors = valtype(bulletColors[0]) == "A" || valtype(bulletColors[0]) == "V" ? bulletColors : {bulletColors};
		mSoundManager = soundManager;
		mShootingSoundIndex = shootingSoundIndex != Void ? shootingSoundIndex : -1;
		
		mID = ID;
	}
	else{
		mMeshName = "";
		mGunMesh = null;
		mGunObj= null;
		mOldObj = null;
		mShootingDelayOrig = 0;
		mShootingDelay = 0;
		mRecoilDepth = 0;
		mBulletMesh = null;
		mBulletSpeed = 0;
		mBulletMaxDistance = 0;
		mBulletMaxLife = 0;
		mShootType = 0;
		mSingleShot = false;
		mShootAnimationTime = 0;
		mAnimationId = -1;
		mAnimator = null;
		mBulletPower = 0;			
		mBulletColors = [0,0,0];	
		mSoundManager = null;
		shootingSoundIndex = -1;
	}
}


function Gun::SetRotationMatrix(mat){
	mGunObj.SetRotationMatrix(mat);
}

function Gun::Rotate(angle,x,y,z){
	mGunObj.Rotate(angle,x,y,z);
}

function Gun::SetPosition(x,y,z){
	if(valtype(x) == "A" || valtype(x) == "V"){
		mGunObj.SetPosition(x);		
	}
	else
		mGunObj.SetPosition(x,y,z);
}

function Gun::Shoot(){
	var ret = {};
	if(GetTime() - mLastShotTime > mShootingDelay){
		mIsShooting = true;
		mLastShotTime = GetTime();
		mAnimator.CreateGenericTransition(mAnimationId, 0, {mRecoilDepth,0}, mShootAnimationTime, 2);
		
		var bulletsArray = {};
		if(mShootType == 0){			
			var bulletObj = CvmObj(mBulletMesh);
			var startPoint = mGunObj.GetPosition();
			bulletObj.SetRotationMatrix(mGunObj.GetRotationMatrix());
			
			var center = mGunObj.LocalToWorld([0, 0, 0]);
			var tip = mGunObj.LocalToWorld([0, 0, -1]);
			mAnimator.CreateTransition(bulletObj, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj);	
		}
		else if(mShootType == 1){		
			var startPoint = mGunObj.GetPosition();
			var bulletObj = CvmObj(mBulletMesh);
			var bulletObj1 = CvmObj(mBulletMesh);
			var bulletObj2 = CvmObj(mBulletMesh);
			var bulletObj3 = CvmObj(mBulletMesh);
			var bulletObj4 = CvmObj(mBulletMesh);
			var bulletObj5 = CvmObj(mBulletMesh);
			var bulletObj6 = CvmObj(mBulletMesh);	
			var bulletObj7 = CvmObj(mBulletMesh);	
			var bulletObj8 = CvmObj(mBulletMesh);				
			
			bulletObj.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj1.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj2.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj3.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj4.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj5.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj6.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj7.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj8.SetRotationMatrix(mGunObj.GetRotationMatrix());
			
			var center = mGunObj.LocalToWorld([0, 0, 0]);
			var tip = mGunObj.LocalToWorld([0, 0, -1]);		
			mAnimator.CreateTransition(bulletObj, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj);	
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([0.02, 0, -1]);	
			mAnimator.CreateTransition(bulletObj1, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj1);
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([-0.02, 0, -1]);	
			mAnimator.CreateTransition(bulletObj2, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);	
			aadd(bulletsArray, bulletObj2);				
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([0, 0.02, -1]);	
			mAnimator.CreateTransition(bulletObj3, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj3);		
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([0, -0.02, -1]);	
			mAnimator.CreateTransition(bulletObj4, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj4);
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([-0.02, -0.015, -1]);	
			mAnimator.CreateTransition(bulletObj5, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj5);
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([0.02, 0.015, -1]);	
			mAnimator.CreateTransition(bulletObj6, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj6);
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([0.015, -0.02, -1]);	
			mAnimator.CreateTransition(bulletObj7, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj7);
			
			center = mGunObj.LocalToWorld([0, 0, 0]);
			tip = mGunObj.LocalToWorld([-0.015, 0.02, -1]);	
			mAnimator.CreateTransition(bulletObj8, startPoint, startPoint+(tip-center)*mBulletMaxDistance, mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj8);		
		}
		else if(mShootType == 2){		
			var startPoint = mGunObj.GetPosition();
			var bulletObj = CvmObj(mBulletMesh);
			var bulletObj1 = CvmObj(mBulletMesh);
			var bulletObj2 = CvmObj(mBulletMesh);			
			
			bulletObj.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj1.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj1.Rotate(55,0,0,1);
			bulletObj2.SetRotationMatrix(mGunObj.GetRotationMatrix());
			bulletObj2.Rotate(-55,0,0,1);
			
			var center = mGunObj.LocalToWorld([0, 0, 0]);
			var tip = mGunObj.LocalToWorld([0, 0, -1]);		
			mAnimator.CreateTransition(bulletObj, startPoint - [0, 0.16*SCALE_FACTOR,0], startPoint+(tip-center)*mBulletMaxDistance - [0, 0.16*SCALE_FACTOR,0], mBulletSpeed ,false, 0);			
			mAnimator.CreateTransition(bulletObj1, startPoint - [0.08*SCALE_FACTOR,0,0], startPoint+(tip-center)*mBulletMaxDistance - [0.08*SCALE_FACTOR,0,0], mBulletSpeed ,false, 0);	
			mAnimator.CreateTransition(bulletObj2, startPoint + [0.08*SCALE_FACTOR,0,0], startPoint+(tip-center)*mBulletMaxDistance+ [0.08*SCALE_FACTOR,0,0], mBulletSpeed ,false, 0);
			aadd(bulletsArray, bulletObj);
			aadd(bulletsArray, bulletObj1);
			aadd(bulletsArray, bulletObj2);
		}
		
		for(var i = 0; i < len(bulletsArray); i++){
			aadd(ret, Bullet(bulletsArray[i], GetTime(), mBulletMaxLife, false, mBulletPower, mBulletColors[mColorIndex], (mID+" "+str(mBulletIndex++))));
			mColorIndex = (mColorIndex+1)%(len(mBulletColors));
		}	
	}
	
	if(len(ret) > 0 && mShootingSOundIndex > 0)
		mSoundManager.PlaySOund(mShootingSOundIndex, true, 1);
		
	return ret;
}

function Gun::IsShooting(){
	return mIsShooting;
}

function Gun::UpdateGun(){	
	if(mIsSwitching){
		mOldObj.SetPosition(mGunObj.GetPosition());
		mOldObj.SetRotationMatrix(mGunObj.GetRotationMatrix());
		if(mOldObj.GetScale() == [0,0,0]){
			if(mGunObj.GetScale() == [0,0,0]){
				mRenderOldObj = false;
				mAnimator.CreateScalingTransition(mGunObj, [0,0,0], [1,1,1], mSwitchGunTime, false);			
			}
			else if(mGunObj.GetScale() == [1,1,1]){
				mIsSwitching = false;
			}
		}
	}	
	
	if(mIsVive){
		mGunObj.SetRotationMatrix(mViveController.GetRotationMatrix());
		mGunObj.SetPosition(mViveController.GetPosition());	
	}
	
	if(KeyPressed("q")){
		mShootingDelay = mShootingDelayOrig/10;
		mShootAnimationTime = mShootingDelay/mDelayAnimFactor;
	}
	else{
		mShootingDelay = mShootingDelayOrig;	
		mShootAnimationTime = mShootingDelay/mDelayAnimFactor;
	}
	
	if(mIsShooting){
		var translateValue = mAnimator.GetCurrentStateInTransition(mAnimationId,6);
		if(translateValue != Void){
			var center = mGunObj.LocalToWorld([0, 0, 0]);
			var tip = mGunObj.LocalToWorld([0, 0, 1]);
			mGunObj.Translate((tip-center)*translateValue);		
		}
		else{
			mIsShooting = false;
		}			
	}
}

function Gun::Draw(){
	var objToDraw = mRenderOldObj ? mOldObj : mGunObj;
	if(mIsActionAvailable || mIsPowerEnabled){
		var scale = objToDraw.GetScale();
		var color = [0,0,1];
		if(mIsPowerEnabled)
			color = [1,0,0];
		
		if(mIsActionAvailable)
			color = [1,1,0];
			
		glCullFace (GL_FRONT);		 	
		objToDraw.SetScale(scale + [0.02, 0.02, 0.02]);
		
		mColorShader.Start();
			mColorShader.SetParameter("alpha", 1.0);
			mColorShader.SetParameter("outlinecolor", [1,1,0]);
			mColorShader.SetParameter("outline", 0);
			objToDraw.Draw();
		mColorShader.Stop();
		
		glCullFace (GL_BACK);  	
		objToDraw.SetScale(scale);
	}
	
	objToDraw.Draw();
}

function Gun::GetObj(){
	return mGunObj;
}

function Gun::CreatePickupPoint(pos, rotation, axis){
	if(rotation != Void && axis != Void){
		mGunObj.Rotate(rotation, axis.x, axis.y, axis.z);
	}
	mGunObj.SetPosition(pos);
	mAnimator.CreateRotatingTransition(mGunObj, 0, 360, [0,1,0], 2, true, false);
}

function Gun::Pickup(){
	mAnimator.RemoveTransitionByObject(mGunObj, 1);
}

function Gun::LinkToController(controller){
	mIsVive = true;
	mAnimationId += controller.GetIndex();
	mViveController = controller;
}

function Gun::UnlinkController(){
	mIsVive = false;
}

function Gun::IsSingleShot(){
	return mSingleShot;
}

function Gun::Clone(){
	return Gun(mMeshName, mShootingDelay, mRecoilDepth, mBulletMesh, mBulletSpeed, mBulletMaxDistance, mBulletMaxLife, mBulletColors, mBulletPower, mShootType, mSingleShot, mAnimator, mAnimationId+1);
}

function Gun::Copy(otherGun, oldObj){
	mMeshName = otherGun.GetMeshName();
	mGunMesh = otherGun.GetMesh();
	mGunObj= CvmObj(mGunMesh);
	mOldObj = oldObj == Void ? CvmObj(mGunMesh) : oldObj;
	mShootingDelayOrig = otherGun.GetShootingDelay();
	mShootingDelay = otherGun.GetShootingDelay();
	mRecoilDepth = otherGun.GetRecoilDepth();
	
	mBulletMesh = otherGun.GetBulletMesh();
	mBulletSpeed = otherGun.GetBulletSpeed();
	mBulletMaxDistance = otherGun.GetBulletMaxDistance();
	mBulletMaxLife = otherGun.GetBUlletMaxLife();
	mShootType = otherGun.GetShootType();
	mSingleShot = otherGun.IsSIngleShot();
	mDelayAnimFactor = otherGun.GetDelayAnimFactor();
	mShootAnimationTime = otherGun.GetShootAnimationTime();
	mAnimator = otherGun.GetAnimator();
	mAnimationId = otherGun.GetAnimationId()+1;
	mLastShotTime = 0;
	mBulletPower = otherGun.GetBulletPower();	
	mBulletColors = otherGun.GetBUlletCOlors();
	mID = otherGun.GetID();
	mColorIndex = 0;	
	mIsShooting = false;
	mSoundManager = otherGun.GetSoundManager();
	mShootingSoundIndex = otherGun.GetShootingSoundIndex();
}

function Gun::GetID(){
	return mID;
}

function Gun::GetMeshName(){
	return mMeshName;
}

function Gun::GetMesh(){
	return mGunMesh;
}

function Gun::GetShootingDelay(){
	return mShootingDelayOrig;
}

function Gun::GetRecoilDepth(){
	return mRecoilDepth;
}

function Gun::GetBulletMesh(){
	return mBulletMesh;
}

function Gun::GetBulletSpeed(){
	return mBulletSpeed;
}

function Gun::GetBulletMaxDistance(){
	return mBulletMaxDistance;
}

function Gun::GetBUlletMaxLife(){
	return mBulletMaxLife;
}

function Gun::GetShootType(){
	return mShootType;
}

function Gun::GetDelayAnimFactor(){
	return mDelayAnimFactor;
}

function Gun::GetShootAnimationTime(){
	return mShootAnimationTime;
}

function Gun::GetAnimator(){
	return mAnimator;
}

function Gun::GetAnimationId(){
	return mAnimationId;
}

function Gun::GetBulletPower(){
	return mBulletPower;
}

function Gun::GetBUlletCOlors(){
	return mBulletColors;
}

function Gun::SetACtionAvailable(isAvailable){
	mISActionAvailable = isAvailable;
}

function Gun::EnablePower(isPowerEnabled){
	mIsPowerEnabled = isPowerEnabled;
}

function Gun::SwitchGunAnimation(oldObj){
	mIsSwitching = true;
	mRenderOldObj = true;
	mOldObj.SetPosition(mGunObj.GetPosition());
	mOldObj.SetRotationMatrix(mGunObj.GetRotationMatrix());
	mGunObj.SetScale([0,0,0]);
	mAnimator.CreateScalingTransition(mOldObj, [1,1,1], [0,0,0], mSwitchGunTime, false);
}

function Gun::IsSwitching(){
	return mIsSwitching;
}

function Gun::GetPosition(){
	return mGunObj.GetPosition();
}

function Gun::GetSoundManager(){
	return mSoundManager;
}

function Gun::GetShootingSoundIndex(){
	return mShootingSoundIndex;
}