public void ApplyBounus(ObjectController target)
{
switch (bounus_type)
{
case BounusType.Stats:
switch (stats_bounus.value_type)
{
case SetStatsField.ValueType.Raw:
target.AddMaxStats(stats_bounus.stats_type, stats_bounus.value);
break;
case SetStatsField.ValueType.Percentage:
if ((int)STATSTYPE.DEFENSE <= (int)stats_bounus.stats_type && (int)stats_bounus.stats_type <= (int)STATSTYPE.HASTE)
{
target.AddMaxStats(stats_bounus.stats_type, (float)System.Math.Round(stats_bounus.value, 1));
}
else
{
target.AddMaxStats(stats_bounus.stats_type, (float)System.Math.Round(stats_bounus.value * target.MaxStats.Get(stats_bounus.stats_type), 0));
}
break;
}
break;
case BounusType.Passive:
if (target.GetPassive(passive_bounus.GetType()) != null)
{
return;
}
CachedPassive = (PassiveSkill)passive_bounus.Instantiate();
CachedPassive.InitSkill(target);
target.Passives.Add(CachedPassive);
break;
}
}
virtual public void ApplyDebuff(ObjectController applyer, ObjectController target)
{
this.target = target;
this.applyer = applyer;
gameObject.transform.SetParent(target.Debuffs_T());
gameObject.transform.localPosition = Vector3.zero;
}
private void OnTriggerStay(Collider other)
{
if (other.CompareTag("ColorSwap"))
{
if (Input.GetKey(KeyCode.A) && controller.isControlled)
{
ColorChanger changer = other.GetComponent <ColorChanger>();
changer?.SwapColors(colorMgr); // Check if the changer exists and swap colors
if (colorMgr.GetCurrentColor() == ObjectColor.YELLOW)
{
Instantiate(yellowSmoke, controller.transform.position, controller.transform.rotation);
Destroy(GameObject.Find("Rework Yellow Smoke(Clone)"), 2f);
}
else if (colorMgr.GetCurrentColor() == ObjectColor.MAGENTA)
{
Instantiate(magentaSmoke, controller.transform.position, controller.transform.rotation);
Destroy(GameObject.Find("Rework Magenta Smoke(Clone)"), 2f);
}
}
}
if (other.CompareTag("ControllableHeavy"))
{
ObjectController obj = other.GetComponent <ObjectController>();
if (obj.colorMgr.GetCurrentColor() == colorMgr.GetCurrentColor()) // If the player has the same color than the object
{
if (Input.GetKey(KeyCode.E) && controller.isControlled && canPos && !canDepos)
{
StartCoroutine("PosObject");
AudioSource.PlayClipAtPoint(Pos, transform.position, volume);
Instantiate(smoke, obj.transform.position, obj.transform.rotation);
Destroy(GameObject.Find("Rework Smoke(Clone)"), 2f);
controller.ControlObject(obj, true, controller);
}
}
}
else if (other.CompareTag("ControllableLightweight"))
{
ObjectController obj = other.GetComponent <ObjectController>();
if (obj.colorMgr.GetCurrentColor() == colorMgr.GetCurrentColor()) // If the player has the same color than the object
{
if (Input.GetKey(KeyCode.E) && controller.isControlled && canPos && !canDepos)
{
StartCoroutine("PosObject");
AudioSource.PlayClipAtPoint(Pos, transform.position, volume);
Instantiate(smoke, obj.transform.position, obj.transform.rotation);
Destroy(GameObject.Find("Rework Smoke(Clone)"), 2f);
controller.ControlObject(obj, true, controller);
}
}
}
else
{
return;
}
}
public void OnTriggerEnter(Collider collider)
{
if (collider.CompareTag("ControllableLightweight"))
{
ObjectController obj = collider.GetComponent <ObjectController>();
if (obj.colorMgr.GetCurrentColor() == colorMgr.GetCurrentColor())
{
pressurePlateValue++;
diodeColor1.GetComponent <MeshRenderer>().material.SetColor("_Color", Color.green);
lightOnPlateCount += 1;
pressurePlate.transform.position = transform.position + new Vector3(0, loweringValue1, 0);
if (pressurePlateValue == 2)
{
diodeColor.GetComponent <MeshRenderer>().material.SetColor("_Color", Color.green);
diodeColor1.GetComponent <MeshRenderer>().material.SetColor("_Color", Color.green);
ActivatePressurePlate();
//Sound
if (!b_HasActivated)
{
AudioSource.PlayClipAtPoint(PlateActivation, transform.position, volume);
b_HasActivated = true;
}
}
//Dialogue
if (!b_dialogueHappenned)
{
ThisObjectDialogueTrigger();
}
}
}
}
void Start()
{
oc = GameObject.Find("Object Controller").GetComponent <ObjectController>();
uic = GameObject.Find("UI Controller").GetComponent <UIController>();
// lc = GameObject.Find("Laser Controller").GetComponent<LaserController>();
playerGo = GameObject.Find("Player");
//Look for RT Struct files on a separate thread
Thread t = new Thread(() => {
FindLoadableFiles();
});
t.Start();
threads.Add(t);
// print(GameObject.Find("Wall").GetComponent<MeshRenderer>().material.shader.name);
// Transform top = bed.transform.parent.parent;
// Bounds bounds = new Bounds(top.position,Vector3.zero);
// bounds.Encapsulate(bed.GetComponent<MeshRenderer>().bounds);
// print("Bed: " + bounds);
// return;
// for (int i = 0; i < preloadModels; i++) {
// string s = "";
// LoadModel(pathToData + preloadModelName);
// }
}
public override void Run()
{
Guard.ObjectIsInstanceOfType(Owner, typeof(ISelection), "Owner");
Guard.ObjectIsInstanceOfType(Owner, typeof(IObjectAware), "Owner");
var selection = (ISelection)Owner;
var objectAware = (IObjectAware)Owner;
ObjectController objectController = (ObjectController)this.Owner;
Guid selectedId = Guid.Empty;
var parameters = new ActionParameters(objectAware.ObjectName, selectedId, ViewShowType.Show)
{
{ "WorkingMode", _workMode }
};
var controllerName = objectAware.ObjectName;
BaseController filterController =
objectController.Context.ControllerFinder.FindController <BaseController>("BaseControllerList");
if (filterController != null)
{
Guid?projectId = filterController.GetSelectedFilterProjectId();
Guid?memberId = filterController.GetSelectedMemberId();
Guid?iterationId = filterController.GetSelectedIterationId();
parameters.Add("ProjectId", projectId);
parameters.Add("MemberId", memberId);
parameters.Add("IterationId", iterationId);
}
App.Instance.Invoke(controllerName, "Detail", parameters);
}
public void ControlObject(ObjectController objToControl, bool controlObject, PlayerController player)
{
if (player == null || objToControl == null)
{
return;
}
if (controlObject)
{
objToControl.Player = player;
player.GetComponent <SkinnedMeshRenderer>().enabled = false;
objToControl.SetIsControlled(true);
player.SetIsControlled(false);
player.GetComponent <BoxCollider>().enabled = false;
controller.enabled = false;
player.transform.parent = objToControl.transform;
player.GetComponent <Rigidbody>().isKinematic = true;
StopPlayFootstepSound();
}
else
{
player.GetComponent <SkinnedMeshRenderer>().enabled = true;
objToControl.SetIsControlled(false);
player.SetIsControlled(true);
player.transform.parent = null;
player.transform.position = objToControl.PlayerLeavePoint.position;
player.GetComponent <BoxCollider>().enabled = true;
player.transform.localScale = new Vector3(1, 1, 1);
controller.enabled = true;
player.GetComponent <Rigidbody>().isKinematic = false;
objToControl.Player = null;
}
}
private IEnumerator WaitForButton_Up()
{
while (true)
{
var raycastHit = ShootLaserFromTargetPosition
(transform.position, transform.forward, maxRayDistance);
if (OVRInput.GetUp(button))
{
lineRenderer.enabled = false;
if (raycastHit.collider != null)
{
ObjectController objController = raycastHit.collider.gameObject.transform
.GetComponentInParent <ObjectController>();
StopListening();
if (objController != null)
{
objectSelectedSubject.OnNext(objController);
}
else
{
StartListening();
}
}
else
{
StartListening();
}
}
yield return(new WaitForEndOfFrame());
}
}
private void SetValue()
{
Variable var = ObjectController.Get().GetObject <Variable>(ObjectCategories.Variable, Name);
var.Value = Value;
Debug.Log("Value Set: " + var.Name + " Value: " + var.Value.ToString());
}
private bool isDestroyed; // prevents to restroy object few times
void OnTriggerEnter(Collider other)
{
if (isDestroyed) return; // if objest was destroy return
if (other.tag == "Background" || gameObject.tag == other.tag || other.tag == "PickUp") return;
if (tag == "PlayerBullet" && other.tag == "Player" || tag == "EnemyBullet" && other.tag == "Enemy")
return;
if( tag == "PlayerBullet" && other.tag == "Droid") return; //if player shot have collision with Droid
if (destroyEffects.Length > 0) // if ther is some destroyeffects attached
{
int randIndex = Random.Range(0, destroyEffects.Length); // choose random index in array
GameObject randEffect = destroyEffects[randIndex]; // choose GameObject with randIndex from array
GameObject newEffect = Instantiate(randEffect, transform.position, transform.rotation) as GameObject;
newEffect.transform.SetParent(GameMaster.instance.hierarchyGuard);
}
ObjectController controller = other.GetComponent<ObjectController>(); // get reference to object controller
if (controller) // if there is a script attached to other
{
controller.TakeDamage(damage, transform.position);
if (disableControl)
controller.StartCoroutine("DisableShotAndMove", howLong);
}
StartCoroutine(Destroy());
}
private void ToggleBool()
{
Variable var = ObjectController.Get().GetObject <Variable>(ObjectCategories.Variable, Name);
var.Value = TypeConversion.Convert(typeof(bool), Value.ToString());
Debug.Log("Bool Toggled: " + var.Name + " Value: " + var.Value.ToString());
}
public override void ApplyDebuff(ObjectController applyer, ObjectController target)
{
base.ApplyDebuff(applyer, target);
target.Stunned = true;
//target.MountainlizeRigibody();
target.ActiveVFXParticle(VFX);
}
public override bool Shot(bool controllShot)
{
if (timeToShot > timeBetweenBullets && Time.timeScale != 0) // if player press button, time to next shot left, pause is off
{
timeToShot = 0f;
ShotEffects();
gunLine.enabled = true; // enable the line renderer
gunLine.SetPosition(0, transform.position); // set it's first position to be the end of the gun;
shootRay.origin = transform.position;
shootRay.direction = transform.forward;
if (Physics.Raycast(shootRay, out shootHit, range, shootableMask))
{
ObjectController controller = shootHit.transform.GetComponent <ObjectController>();
if (controller)
{
controller.TakeDamage(damage, shootHit.point);
}
Instantiate(destroyEffect, shootHit.point, destroyEffect.transform.rotation);
gunLine.SetPosition(1, shootHit.point); // set the second position of the line renderer to the point the raycast hit
}
else
{
gunLine.SetPosition(1, shootRay.origin + shootRay.direction * range); // set the second position of the line renderer to the fullest extent of the gun's range
}
return(true); // weapon can shot
}
return(false); // weapon can't shot because time to shot do not paas
}
public override bool Update()
{
if (!isWalking)
{
//npc = gm.getNPC(npcNome);
//NPC_Controller = (ObjectController) npc.GetComponent(typeof(ObjectController));
NPC_Controller = gm.getNPC(npcNome);
if (spawn != "")
{
destiny_position = gm.getSpawnPoint(spawn).transform.position;
}
destiny_position.z = destiny_position.y;
NPC_Controller.addWayPoint(destiny_position);
}
if (wait)
{
isWalking = true;
gm.lockplayer();
if (NPC_Controller.hasStoredWayPoint(destiny_position))
{
return(false);
}
else
{
gm.unlockplayer();
isWalking = false;
return(true);
}
}
else
{
return(true);
}
}
public void LoseLife(int amount, ObjectController attacker)
{
if (_loseLifeOnCoolDownCoroutine == null)
{
_loseLifeOnCoolDownCoroutine = StartCoroutine(LoseLifeOnCoolDown(amount, attacker));
}
}
public void Grab() //Should only be called if isHoldingSomething is false
{
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, pickupRange))
{
GameObject gameObj = hit.collider.gameObject;
if (gameObj.GetComponent <ObjectController>() != null) //Checks for the tag, Object, in hit
//Debug.Log ("Something is there to grab");
{
currentlyEquippedItem = gameObj.GetComponent <ObjectController>();
Destroy(gameObj.GetComponent <Rigidbody>());
SetItemPosAndRot(gameObj);
isHoldingObject = true;
}
}
/* PSEUDO-CODE:
*
* if ( !isHoldingObject && can pick up object ) {
* pick up object;
* isHoldingObject = true;
* }
*/
}
void ApplyBattlFuryPassive(ObjectController target)
{
if (!Spining && UnityEngine.Random.value < (TriggerChance / 100))
{
ActiveBattleFury();
}
}
void DealBFSpingDMG(ObjectController target)
{
float RawDamage;
bool Crit;
if (UnityEngine.Random.value < (OC.GetCurrStats(STATSTYPE.CRIT_CHANCE) / 100))
{
RawDamage = OC.CurrDamage * (Sping_DamageScale / 100) * (OC.CurrCritChance / 100);
Crit = true;
}
else
{
RawDamage = OC.CurrDamage * (Sping_DamageScale / 100);
Crit = false;
}
DirectDamage SpingDmg = new DirectDamage(RawDamage, target.CurrDefense, OC.CurrPenetration, Crit, OC, typeof(BattleFury));
//OC.ON_HEALTH_UPDATE += OC.HealHP;
//OC.ON_HEALTH_UPDATE(new Value(OC.GetCurrLPH(), 1));
//OC.ON_HEALTH_UPDATE -= OC.HealHP;
target.ActiveOneShotVFXParticle(HitVFX);
target.ON_DMG_TAKEN += target.DeductHealth;
target.ON_DMG_TAKEN(SpingDmg);
target.ON_DMG_TAKEN -= target.DeductHealth;
if (!target.HasDebuff(typeof(BleedDebuff)))
{
ApplyBleedDebuff(target);
}
}
void DealMeleeAttackDMG(ObjectController target)
{
DirectDamage dmg = AutoAttackDamageDeal(target.GetCurrStats(STATSTYPE.DEFENSE));
OC.ON_HEALTH_GAIN += OC.HealHP;
OC.ON_HEALTH_GAIN(new HealHP(dmg.Amount * (OC.GetCurrStats(STATSTYPE.LPH) / 100), dmg.Crit, OC, typeof(MeleeAttackCollider)));
OC.ON_HEALTH_GAIN -= OC.HealHP;
target.ON_DMG_TAKEN += target.DeductHealth;
target.ON_DMG_TAKEN(dmg);
target.ON_DMG_TAKEN -= target.DeductHealth;
if (HitVFX != null)
{
target.ActiveOneShotVFXParticle(HitVFX);
}
if (DamageSFXList.Count > 0)
{
AudioSource.PlayClipAtPoint(DamageSFXList[UnityEngine.Random.Range(0, DamageSFXList.Count)], target.transform.position, GameManager.SFX_Volume);
}
else if (HitSFX != null)
{
AudioSource.PlayClipAtPoint(HitSFX, target.transform.position, GameManager.SFX_Volume);
}
}
/// <summary>
/// Flips the bool state of keep high score in
/// runningGame GameData. Also update visual toggle
/// indicator in UI
/// </summary>
public void EnableSaveHighScore()
{
Helper findObj = new Helper();
ObjectController obj = findObj.FindObjectControllerInScene();
if (obj is null)
{
return;
} //return if fault
// flip state of keep high score
if (obj.runningGame.keepHighScore)
{
obj.runningGame.keepHighScore = false;
}
else
{
obj.runningGame.keepHighScore = true;
}
GameObject toggleObj = GameObject.Find("ToggleHS");
if (!(toggleObj is null))
{
Toggle toggle = toggleObj.GetComponent <Toggle>();
toggle.isOn = obj.runningGame.keepHighScore;
}
}
GameObject FindUnfinishedBuilding()
{
float distance = Mathf.Infinity;
float curDistance = 0.0f;
GameObject closest = null;
GameObject buildings = GameObject.Find("Buildings");
ObjectController bCont = null;
if (buildings.transform.childCount <= 0)
{
//print("No " + location);
return(null);
}
// NEED TO COMPARE DISTANCE "Vector3.Distance" and determine closest stockpile
for (int i = 0; i < buildings.transform.childCount; i++)
{
bCont = buildings.transform.GetChild(i).GetComponent <ObjectController>();
curDistance = Vector3.Distance(transform.position, buildings.transform.GetChild(i).position);
if (curDistance < distance && (bCont.NeedStone() || bCont.NeedWood()))
{
// MUST DO SOMETHING HERE TO MAKE IT HAPPEN
distance = curDistance;
closest = buildings.transform.GetChild(i).gameObject;
}
}
return(closest);
}
void OnTriggerEnter(Collider other)
{
if (other.gameObject.tag == "Block" || other.gameObject.tag == "Enemy" || other.gameObject.tag == "Player")
{
if (pc.catchObject != null)
{
return;
}
if (other.gameObject.GetComponent <PlayerController>() != null)
{
_otherPc = other.gameObject.GetComponent <PlayerController>();
if (_otherPc.Stan || _otherPc.Recovery)
{
_otherPc = null;
return;
}
}
if (other.gameObject.GetComponent <ObjectController>() != null)
{
_oc = other.gameObject.GetComponent <ObjectController>();
_oc.EmissionEnable();
}
pc.catchObject = other.gameObject;
}
else if (other.gameObject.tag == "Wall" && pc.throwObject != null)
{
pc.SafetyLock = false;
Debug.Log("wallに触れた");
}
}
private Vector2 GetToPlayerAngle()
{
Vector3 playerPosition = ObjectController.GetPlayer().transform.position;
Vector2 toPlayerVector = playerPosition - transform.position;
return(toPlayerVector);
}
private void IncrementValue()
{
Variable var = ObjectController.Get().GetObject <Variable>(ObjectCategories.Variable, Name);
var.Value = (float)var.Value + Value;
Debug.Log("Value Incremented: " + var.Name + " Value: " + var.Value.ToString());
}
public DotDamage(float RawDamage, bool Crit, ObjectController Source, System.Type Type)
{
this.Amount = DotDamageCalculation(RawDamage);
this.Crit = Crit;
this.Source = Source;
this.Type = Type;
}
void FixedUpdate()
{
if (wakeable.awake)
{
Vector2 toPlayerAngle = GetToPlayerAngle();
RaycastHit2D raycast = Physics2D.Raycast(transform.position, GetToPlayerAngle(), toPlayerAngle.magnitude, defaultLayerMask);
if (!raycast || raycast.normal.y >= -0.01f)
{
bool playerToLeft = ObjectController.GetPlayer().transform.position.x < transform.position.x;
if (playerToLeft)
{
body.AddForce(new Vector2(-runForce, 0));
}
else
{
body.AddForce(new Vector2(runForce, 0));
}
if (Mathf.Abs(transform.position.x - previousPositionX) < 0.001f && grounded)
{
body.AddForce(new Vector2(0, jumpForce));
grounded = false;
}
previousPositionX = transform.position.x;
}
}
body.velocity = new Vector2(body.velocity.x * horizontalDamping, body.velocity.y);
}
private void Awake()
{
if (instance == null)
{
instance = this;
m_manager = FindObjectOfType <GameManager>();
objectStack = new Stack <GameObject> [objectKind];
isSummoned = false;
for (int i = 0; i < objectKind; i++)
{
objectStack[i] = new Stack <GameObject>();
for (int j = 0; j < objectNum[i]; j++)
{
GameObject obj = Instantiate(objectList[i]);
obj.transform.SetParent(transform);
obj.SetActive(false);
objectStack[i].Push(obj);
}
}
}
else if (instance != this)
{
Destroy(gameObject);
}
}
public override void InitSkill(ObjectController OC, int lvl)
{
base.InitSkill(OC, lvl);
Vigorlvl VL = null;
switch (this.lvl)
{
case 0:
return;
case 1:
VL = GetComponent <Vigor1>();
break;
case 2:
VL = GetComponent <Vigor2>();
break;
case 3:
VL = GetComponent <Vigor3>();
break;
case 4:
VL = GetComponent <Vigor4>();
break;
case 5:
VL = GetComponent <Vigor5>();
break;
}
Damge_INC_Percentage = VL.Damge_INC_Percentage;
GenerateDescription();
}
public override void InitSkill(ObjectController OC, int lvl)
{
base.InitSkill(OC, lvl);
Retaliationlvl RL = null;
switch (this.lvl)
{
case 0:
return;
case 1:
RL = GetComponent <Retaliation1>();
break;
case 2:
RL = GetComponent <Retaliation2>();
break;
case 3:
RL = GetComponent <Retaliation3>();
break;
case 4:
RL = GetComponent <Retaliation4>();
break;
case 5:
RL = GetComponent <Retaliation5>();
break;
}
TriggerChance = RL.TriggerChance;
Reflected_DMG_Percentage = RL.Reflected_DMG_Percentage;
GenerateDescription();
}
public override void InitSkill(ObjectController OC, int lvl)
{
base.InitSkill(OC, lvl);
Cripplelvl CL = null;
switch (this.lvl)
{
case 0:
return;
case 1:
CL = GetComponent <Cripple1>();
break;
case 2:
CL = GetComponent <Cripple2>();
break;
case 3:
CL = GetComponent <Cripple3>();
break;
case 4:
CL = GetComponent <Cripple4>();
break;
case 5:
CL = GetComponent <Cripple5>();
break;
}
TriggerChance = CL.TriggerChance;
DMG_DEC_Percentage = CL.DMG_DEC_Percentage;
GenerateDescription();
}
void FixedUpdate()
{
if(charController.velocity.magnitude < 0.1f)
detachableInteractionXforms.enabled = true;
Ray _ray = new Ray(cameraTransform.position, cameraTransform.forward);
cursorOver = getSelectedObject(_ray);
interactibleObject = null;
SelectedItem = null;
if(cursorOver)
{
EquippableItem item = cursorOver.gameObject.GetComponent<EquippableItem>();
interactibleObject = cursorOver.gameObject.GetComponent<ObjectController>();
if (item)
{
SelectedItem = item;
cursorRenderer.material = selectedCursorMaterial;
cursorParticles.Emit(1);
}
else if (interactibleObject)
{
cursorRenderer.material = selectedCursorMaterial;
////// popup for action? I.e. switch, door...
}
else
{
SelectedItem = null;
}
}
if (playerLightScript)
playerLightTransform.rotation = Quaternion.LookRotation(_ray.direction);
}
public override void Enter(ObjectController obj)
{
base.Enter(obj);
}
public override void Exit(ObjectController obj)
{
base.Execute(obj);
}
void Awake()
{
controllerScript = (ObjectController)target;
}
void OnEnable()
{
animationFrames = GetComponent<AnimationFrames>();
controller = transform.parent.GetComponent<ObjectController>();
currentState = null;
}
private void Awake()
{
//Capture a reference to the script that is being edited
controllerScript = (ObjectController) target;
}
public override void Enter(ObjectController obj)
{
base.Enter(obj);
obj.transform.parent = PlayManager.Instance.Temp.Explosion.transform;
}
void Awake()
{
controller = (ObjectController) target;
}
