// Start is called before the first frame update
void Start()
{
enemy = GetComponent <EnemyTarget>();
navMesh = GetComponentInParent <NavMeshAgent>();
navMesh.speed = enemy.startSpeed;
}
void SearchTarget()
{
GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");
GameObject nearestEnemy = null;
shortestDistance = Mathf.Infinity;
foreach (GameObject enemy in enemies)
{
float distanceToEnemy = Vector3.Distance(transform.position, enemy.transform.position);
if (distanceToEnemy < shortestDistance)
{
shortestDistance = distanceToEnemy;
nearestEnemy = enemy;
targetEnemy = nearestEnemy.GetComponent <EnemyTarget>();
}
}
if (nearestEnemy != null && shortestDistance <= range)
{
target = nearestEnemy.transform;
}
else
{
target = null;
}
}
void HandeleLookToEnemyRotation(float d)
{
if (lookToEnemy)
{
Vector3 targetDir = lockonTransform.position - this.transformCache.position;
targetDir.Normalize();
if (targetDir == Vector3.zero)
{
targetDir = this.transformCache.forward;
}
Quaternion targetRot = Quaternion.LookRotation(targetDir);
targetRot.x = 0;
targetRot.z = 0;
if (targetRot.eulerAngles.y + 5f > transformCache.rotation.eulerAngles.y && transformCache.rotation.eulerAngles.y > targetRot.eulerAngles.y - 5f)
{
lockonTarget = null;
lockonTransform = null;
lockon = false;
lookToEnemy = false;
return;
}
transformCache.rotation = Quaternion.Slerp(transformCache.rotation, targetRot, d * 20);
lookAngle = transformCache.rotation.eulerAngles.y;
}
}
public void SeesEnemy(HumanoidModel enemy, Vector3 location)
{
/*
* first remove the nearest enemy marker that is in range
* if seeing enemy for the first time
*/
EnemyTarget target = null;
viewableEnemies.TryGetValue(enemy, out target);
if (target == null)
{
foreach (CommunicatableEnemyMarker marker in hiddenEnemies)
{
if (Vector3.Distance(location, marker.GetEnemyMarker().GetLocation()) < hiddenEnemyRadius)
{
marker.Invalidate();
HumanoidTargeterCommunication.Communicate(
new CommunicationPackage(
GetDeepCopyOfHiddenEnemies(),
this
)
);
RemoveHiddenEnemy(marker);
break;
}
}
}
// next add viewable enemy
viewableEnemies[enemy] = new EnemyTarget(enemy, location);
}
public void Configure(SpawnConfig config, EnemyTarget target, Wave wave, PrecalculatedPath path)
{
// just for reference
currentConfig = config;
currentWave = wave;
color = config.color;
spriteRenderer.sprite = sprites.GetSprite(currentConfig.kind);
switch (currentConfig.color)
{
case ColorType.Red:
spriteRenderer.color = Color.red;
gameObject.layer = LayerMask.NameToLayer("EnemyRed");
break;
case ColorType.Green:
spriteRenderer.color = Color.green;
gameObject.layer = LayerMask.NameToLayer("EnemyGreen");
break;
case ColorType.Blue:
spriteRenderer.color = Color.blue;
gameObject.layer = LayerMask.NameToLayer("EnemyBlue");
break;
}
health = currentConfig.health;
spinner.speed = currentConfig.spinSpeed;
pathFollower.speed = currentConfig.walkSpeed;
pathFollower.target = target;
pathFollower.UpdatePath(path.path, path.calculatedAt);
}
public CommunicatableEnemyTarget(
EnemyTarget t
)
{
target = t;
isValid = true;
}
void Explode()
{
// Show effect
GameObject explosion = Instantiate(explosionEffect, transform.position, transform.rotation);
Collider[] colliders = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in colliders)
{
Rigidbody rb = nearbyObject.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(force, transform.position, radius, upforce, ForceMode.Impulse);
}
EnemyTarget nearbyTarget = nearbyObject.transform.root.gameObject.GetComponent <EnemyTarget>();
if (nearbyTarget != null)
{
float proximity = (transform.position - nearbyTarget.transform.position).magnitude;
int explosiveEffect = 1 - (int)(proximity / radius);
nearbyTarget.TakeDamage(explosiveEffect * 7);
}
}
// Remove grenade
Destroy(gameObject);
Destroy(explosion, 2.5f);
}
public void Shoot()
{
currentAmmo--;
Debug.Log("currentammo:" + currentAmmo);
muzzleFlash.Play();
RaycastHit hit;
if (Physics.Raycast(fpsCam.transform.position, fpsCam.transform.forward, out hit, range))
{
EnemyTarget enemyTarget = hit.transform.GetComponent <EnemyTarget>(); // convert this to abstract class
if (enemyTarget != null)
{
enemyTarget.KillDamage(fireDamage);
}
if (hit.rigidbody != null)
{
hit.rigidbody.AddForce(-hit.normal * rifleImpactForce);
}
GameObject impactGameObject = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal));
Destroy(impactGameObject, 1.4f);
GameObject bulletObject = Instantiate(bulletTex[UnityEngine.Random.Range(0, 2)], hit.point, Quaternion.FromToRotation(Vector3.up, hit.normal));
bulletObject.transform.parent = hit.transform; // we made bullets the children of the object they hit, so there will be no floating bullet texture on dynamic objects.
Destroy(bulletObject, 2f);
}
}
/// <summary>
/// Attackings coroutine that is called every 1 sec.
/// </summary>
/// <returns></returns>
private IEnumerator Attacking()
{
while (true)
{
Animator.SetTrigger("Smash Attack");
EnemyTarget.SetDamage(_damage);
yield return(new WaitForSeconds(1));
}
}
void FixedUpdate()
{
EnemyTarget enemyTarget = GetComponent <EnemyTarget>();
if (enemyTarget)
{
//Attach progress bar
if (!progressBar)
{
GameObject go = Instantiate(PrefabManager.instance.progressBarType, transform.position, Quaternion.identity);
go.transform.Translate(new Vector3(0.3f, +0.5f));
progressBar = go.GetComponent <HealthBar>();
}
//Detect if any enemy in range
GameObject[] enemies = EnemiesInRange();
if (enemies.Length > 0)
{
enemyTowerProgress += enemies.Length / 5f;
progressBar.SetHealthRatio(enemyTowerProgress / 100f);
if (enemyTowerProgress >= 100f)
{
if (towerController == null)
{
tower = FindObjectOfType <TowerSpawner>().InitTower(transform);
towerController = tower.GetComponentInChildren <TowerController>();
towerType = tower.GetComponentInChildren <TowerType>();
isOccupied = true;
towerController.UpdateOwnerToEnemy();
}
else if (towerController.owner != TowerOwner.ENEMY)
{
towerController.UpdateOwnerToEnemy();
}
else if (towerController.owner == TowerOwner.ENEMY)
{
towerController.UpgradeTower();
}
Destroy(progressBar.gameObject);
progressBar = null;
enemyTowerProgress = 0f;
}
}
}
else
{
enemyTowerProgress = 0f;
if (progressBar)
{
Destroy(progressBar.gameObject);
progressBar = null;
}
}
}
void hitDamage(Transform enemy)
{
EnemyTarget e = enemy.GetComponent <EnemyTarget>();
if (e != null)
{
e.TakeDamage(damage);
}
//Destroy(enemy.gameObject);
}
bool CheckForBackStab(Action slot)
{
//If the weapon has no back stab ability, skip
if (!slot.canBackStab)
{
return(false);
}
EnemyStates backStabTarget = null;
Vector3 origin = transform.position;
origin.y += 1;
Vector3 raycastDir = transform.forward;
RaycastHit hit;
if (Physics.Raycast(origin, raycastDir, out hit, 1, ignoreLayers))
{
backStabTarget = hit.transform.GetComponentInParent <EnemyStates>();
}
if (backStabTarget == null)
{
return(false);
}
//Direction towards the player
Vector3 direction = transform.position - backStabTarget.transform.position;
direction.Normalize();
direction.y = 0;
float angle = Vector3.Angle(backStabTarget.transform.forward, direction);
Debug.Log("Backstab angle: " + angle);
if (angle > 150)
{
//Get target position
Vector3 targetPos = direction * backStabOffset;
targetPos += backStabTarget.transform.position;
transform.position = targetPos;
backStabTarget.transform.rotation = transform.rotation;
backStabTarget.IsGettingBackStabbed(slot, inventoryManager.GetCurrentWeapon(slot.mirror));
onEmpty = false;
canMove = false;
canAttack = false;
inAction = true;
animator.SetBool(StaticStrings.animParam_Mirror, slot.mirror);
animator.CrossFade(StaticStrings.animParam_ParryAttack, 0.2f);
lockOnTarget = null;
return(true);
}
return(false);
}
private void MarkTileAsTarget()
{
TileScript[] tiles = FindObjectsOfType <TileScript>();
int index = (int)Random.Range(0, tiles.Length);
GameObject tile = tiles[index].gameObject;
tile.AddComponent <EnemyTarget>();
tile.GetComponent <SpriteRenderer>().color = new Color(222f / 255f, 71f / 255f, 224f / 255f);
tileTarget = tile.GetComponent <EnemyTarget>();
}
bool CheckForBackstab(Action slot)
{
if (!slot.canBackstab)
{
return(false);
}
EnemyStates backstabTarget = null;
Vector3 origin = transform.position;
origin.y += 1;
Vector3 rayDir = transform.forward;
RaycastHit hit;
if (Physics.Raycast(origin, rayDir, out hit, 3, ignoreLayers))
{
backstabTarget = hit.transform.GetComponentInParent <EnemyStates>();
}
if (backstabTarget == null)
{
return(false);
}
Vector3 dir = transform.position - backstabTarget.transform.position;
dir.Normalize();
dir.y = 0;
float angle = Vector3.Angle(backstabTarget.transform.forward, dir);
if (angle > 150)
{
Vector3 targetPos = dir * backstabOffset;
targetPos += backstabTarget.transform.position;
transform.position = targetPos;
backstabTarget.transform.rotation = transform.rotation;
backstabTarget.IsGettingBackstabbed(slot, inventoryManager.GetCurrentWeapon(slot.mirror));
onEmpty = false;
canAttack = false;
canMove = false;
inAction = true;
anim.SetBool(StaticStrings.mirror, slot.mirror);
anim.CrossFade(StaticStrings.parry_attack, 0.2f);
lockonTarget = null;
return(true);
}
return(false);
}
void SpawnMiniBoss()
{
EnemyTarget playerTarget = GameObject.FindGameObjectWithTag("Player").GetComponent <EnemyTarget>();
GameObject newEnemy = CreateSimpleEnemy(PrefabManager.instance.enemy_tower_builder, playerTarget);
newEnemy.transform.localScale = new Vector3(2, 2, 1);
newEnemy.GetComponent <SimpleEnemyController>().maxHp = powerRuleForMiniBossMaxHp.retrieveValueForLevel(GameManager.instance.wave);
newEnemy.GetComponent <SimpleEnemyController>().coinDrop = (int)powerRuleForMiniBossCoinDrop.retrieveValueForLevel(GameManager.instance.wave);
newEnemy.GetComponent <EnemyController>().baseCoolDownTime = newEnemy.GetComponent <EnemyController>().baseCoolDownTime / 2f;
newEnemy.GetComponent <EnemyController>().baseForce = powerRuleForMiniBossForce.retrieveValueForLevel(GameManager.instance.wave);
newEnemy.GetComponent <EnemyController>().Speed = powerRuleForMiniBossSpeed.retrieveValueForLevel(GameManager.instance.wave);
}
void OnCollisionEnter(Collision collision)
{
ContactPoint contact = collision.contacts[0];
Instantiate(impactEffect, contact.point, Quaternion.LookRotation(contact.normal));
if (collision.gameObject.tag == "Enemy")
{
EnemyTarget target = collision.transform.gameObject.GetComponent <EnemyTarget>();
target.ApplyDamage(damage);
}
Destroy(gameObject);
}
void Update()
{
//Press Space Key To Lock On
if (Input.GetKeyDown(KeyCode.Q) && !lockedOn)
{
if (nearByEnemies.Count >= 1)
{
lockedOn = true;
image.enabled = true;
//Lock On To First Enemy In List By Default
lockedEnemy = 0;
target = nearByEnemies[lockedEnemy];
}
}
//Turn Off Lock On When Space Is Pressed Or No More Enemies Are In The List
else if ((Input.GetKeyDown(KeyCode.Q) && lockedOn) || nearByEnemies.Count == 0)
{
lockedOn = false;
image.enabled = false;
lockedEnemy = 0;
target = null;
}
if (Input.GetKeyDown(KeyCode.E))
{
if (lockedEnemy == nearByEnemies.Count - 1)
{
//If End Of List Has Been Reached, Start Over
lockedEnemy = 0;
target = nearByEnemies[lockedEnemy];
}
else
{
//Move To Next Enemy In List
lockedEnemy++;
target = nearByEnemies[lockedEnemy];
}
}
if (lockedOn && PauseMenu.GameIsPaused == false)
{
target = nearByEnemies[lockedEnemy];
//Determine Crosshair Location Based On The Current Target
gameObject.transform.position = cam.WorldToScreenPoint(target.transform.position);
//Rotate Crosshair
gameObject.transform.Rotate(new Vector3(0, 0, -1));
}
}
public Transform CreateAvoidanceTarget(Vector3 heading)
{
if (enemyTarget)
{
enemyTarget.transform.position = GetRotatedHeading(heading);
}
else
{
enemyTarget = Instantiate(targetPrefab, GetRotatedHeading(heading), Quaternion.identity) as EnemyTarget;
enemyTarget.targetEnemy = enemy;
}
return enemyTarget.transform;
}
public static void FlankLeftVisibleEnemy(EnemyTarget enemy)
{
AttackableObject <EnemyTarget> info = instance.targetsForAttack.Find(m => {
return(m.GetObject() == enemy);
});
if (info == null)
{
Debug.LogError("No enemy target found!");
}
else
{
info.AddLeftFlanker();
}
}
public static void NoLongerSuppressVisibleEnemy(EnemyTarget enemy)
{
AttackableObject <EnemyTarget> info = instance.targetsForAttack.Find(m => {
return(m.GetObject() == enemy);
});
if (info == null)
{
Debug.LogError("No enemy target found!");
}
else
{
info.RemoveSuppressor();
}
}
public void Initialization()
{
AgentAI = GetComponent <NavMeshAgent>();
RIGI.isKinematic = true;
RIGI = GetComponent <Rigidbody>();
anim = GetComponentInChildren <Animator>();
ETarget = GetComponent <EnemyTarget>();
ETarget.Init(this);
InitRagDoll();
EparryIsON = false;
IgnoreLayers = ~(1 << 9);
EnemyPos = this.transform.position;
}
public EnemyTarget GetEnemy(Vector3 from)
{
EnemyTarget r = null;
float minDis = float.MaxValue;
for (int i = 0; i < enemyTargets.Count; i++)
{
float tDis = Vector3.Distance(from, enemyTargets[i].GetTarget().position);
if (tDis < minDis)
{
minDis = tDis;
r = enemyTargets[i];
}
}
return(r);
}
public static int GetSuppressorsOnVisibleEnemy(
EnemyTarget target
)
{
AttackableObject <EnemyTarget> info = instance.targetsForAttack.Find(m => {
return(m.GetObject() == target);
});
if (info == null)
{
Debug.LogError("No enemy target found!");
return(0);
}
else
{
return(info.GetCoveringFireAttackers());
}
}
/// <summary>
/// Checks line of sight to a target object or the "Player" based on a raycast to the target object. This raycast will not hit trigger colliders;
/// </summary>
/// <param name="actor"></param>
/// <returns></returns>
private void LookForActor(GameObject actor)
{
//TODO set up field of view
RaycastHit hit;
Vector3 direction = actor.transform.position - this.transform.position;
Ray sightLine = new Ray(this.transform.position, direction);
//make sure if the player isn't seen, the flag is not true
targetInSight = false;
if (Physics.Raycast(sightLine, out hit))
{
//Raycasts to the player to check line of sight
if (hit.collider.gameObject.transform.tag == "Player")
{
targetInSight = true;
lastPlayerPos = actor.transform;
enemyTarget = EnemyTarget.Player;
}
//Raycasts to the player to check line of sight
if (hit.collider.gameObject.transform.tag == "Survivor")
{
targetInSight = true;
lastPlayerPos = actor.transform;
enemyTarget = EnemyTarget.Survivor;
}
}
if (Physics.Raycast(sightLine, out hit, maxSightDistance, buildLayer, QueryTriggerInteraction.Collide))
{
//If the player can not be seen and a wall is in the way, target that wall
enemyTarget = EnemyTarget.Structure;
targetInSight = true;
targetwall = hit.collider.gameObject.GetComponent <BaseWall>();
hasAttackPosition = true;
}
if (!targetInSight)
{
enemyTarget = EnemyTarget.None;
}
}
private GameObject CreateSimpleEnemy(GameObject enemyPrefab, EnemyTarget enemyTarget)
{
GameObject newEnemy = Instantiate(enemyPrefab);
newEnemy.GetComponent <EnemyController>().Target = enemyTarget;
float randX = Random.Range(-horzExtent * 0.8f, +horzExtent * 0.8f);
float randY = Random.Range(vertExtent, vertExtent + vertExtent / 10);
newEnemy.transform.position = new Vector3(randX, randY, 0);
newEnemy.GetComponent <SimpleEnemyController>().healthBarType = PrefabManager.instance.healthBarType.GetComponent <HealthBar>();
newEnemy.GetComponent <SimpleEnemyController>().maxHp = powerRuleForEnemyMaxHp.retrieveValueForLevel(GameManager.instance.wave);
newEnemy.GetComponent <SimpleEnemyController>().coinDrop = (int)powerRuleForEnemyCoinDrop.retrieveValueForLevel(GameManager.instance.wave);
newEnemy.GetComponent <EnemyController>().baseForce = powerRuleForEnemyForce.retrieveValueForLevel(GameManager.instance.wave);
newEnemy.GetComponent <EnemyController>().Speed = powerRuleForEnemySpeed.retrieveValueForLevel(GameManager.instance.wave);
return(newEnemy);
}
void Start()
{
health = 10000000;
anim = GetComponentInChildren <Animator>();
enemyTarget = GetComponent <EnemyTarget>();
enemyTarget.Init(this);
rigid = GetComponent <Rigidbody>();
a_hook = anim.GetComponent <AnimatorHook>();
if (a_hook == null)
{
a_hook = anim.gameObject.AddComponent <AnimatorHook>();
}
a_hook.Init(null, this);
InitRagdoll();
parryIsOn = false;
}
private static void BitchThatWasMyKill()
{
var enemies = GameObjects.Enemy.Where(e => e.IsValidTarget(Shotgun.Range) && e != null);
//Menu
var UseShotgun = Config["killsteal"]["ks.shotgun"].GetValue <MenuBool>().Enabled;
var UseTrap = Config["killsteal"]["ks.trap"].GetValue <MenuBool>().Enabled;
var UseDash = Config["killsteal"]["ks.dash"].GetValue <MenuBool>().Enabled;
foreach (var EnemyTarget in enemies)
{
if (EnemyTarget.IsValid && EnemyTarget != null)
{
//Prediction
var ShotgunPred = Shotgun.GetPrediction(EnemyTarget).Hitchance >= HitChance.High;
var TrapPred = Trap.GetPrediction(EnemyTarget).Hitchance >= HitChance.High;
var DashPred = Dash.GetPrediction(EnemyTarget).Hitchance >= HitChance.High;
//Damages
double DashDmg = DashDamage(EnemyTarget);
double AADamage = ObjectManager.Player.GetAutoAttackDamage(EnemyTarget);
double ShotgunDmg = ShotgunDamage(EnemyTarget);
double TrapDmg = TrapDamage(EnemyTarget);
if (!Mounted() && EnemyTarget.Health < ShotgunDmg && UseShotgun && EnemyTarget.IsValidTarget(Shotgun.Range) && ShotgunPred)
{
Shotgun.Cast(EnemyTarget);
}
if (Mounted())
{
if (EnemyTarget.Health < TrapDmg && UseTrap && EnemyTarget.IsValidTarget(Trap.Range) && TrapPred)
{
Trap.Cast(EnemyTarget);
}
if (EnemyTarget.Health < TrapDmg && UseDash && EnemyTarget.IsValidTarget(Dash.Range) && DashPred)
{
Dash.Cast(EnemyTarget);
}
}
}
}
}
public void Init()
{
health = 100;
anim = GetComponentInChildren <Animator>();
enTarget = GetComponent <EnemyTarget>();
enTarget.Init(this);
rigid = GetComponent <Rigidbody>();
agent = GetComponent <NavMeshAgent>();
rigid.isKinematic = true;
a_hook = anim.GetComponent <AnimtorHook>();
if (a_hook == null)
{
a_hook = anim.gameObject.AddComponent <AnimtorHook>();
}
a_hook.Init(null, this);
InitRagDoll();
//dataRecolected = GameObject.Find("DataRecolected").GetComponent<DataRecolected>();
ignoreLayers = ~(1 << 9);
}
void StartSpawn()
{
spawnCount = powerRuleForEnemyNumbers.retrieveValueForLevel(GameManager.instance.wave);
towerBuilderSpawnCount = powerRuleForEnemyBuilderNumbers.retrieveValueForLevel(GameManager.instance.wave);
currentCount = spawnCount + towerBuilderSpawnCount;
isMiniBossSpawned = false;
MarkTileAsTarget();
EnemyTarget playerTarget = GameObject.FindGameObjectWithTag("Player").GetComponent <EnemyTarget>();
for (int i = 0; i < spawnCount; i++)
{
CreateSimpleEnemy(PrefabManager.instance.enemy, playerTarget);
}
for (int i = 0; i < towerBuilderSpawnCount; i++)
{
CreateSimpleEnemy(PrefabManager.instance.enemy_tower_builder, tileTarget);
}
}
protected EnemyIntent GenerateIntent()
{
if (GameManager.instance.turn % 2 == 0)
{
// Attack
Direction direction = GenEnemyTargetDirection();
Vector2 start = (Vector2)transform.position;
Vector2 location = start + DirectionToCoordinates(direction);
EnemyTarget enemyTarget = Instantiate(enemyTargetPrefab, location, Quaternion.identity);
return(new AttackLocation(location));
}
else
{
// Move
Direction direction;
if (Mathf.Abs(target.position.x - transform.position.x) < float.Epsilon)
{
direction = target.position.y > transform.position.y ? Direction.U : Direction.D;
}
else
{
direction = target.position.x > transform.position.x ? Direction.R : Direction.L;
}
Vector2 start = (Vector2)transform.position;
Vector2 location = start + DirectionToCoordinates(direction);
EnemyMove enemyMove = Instantiate(enemyMovePrefab, transform.position, Quaternion.identity);
SpriteRenderer spriteRenderer = enemyMove.GetComponent <SpriteRenderer>();
spriteRenderer.sprite = GetSpriteFromDirection(direction);
return(new MoveToLocation(location));
}
}
protected IEnumerator RestartOrbitRoutine(EnemyTarget enemy, float duration)
{
this.OrbitEnabled = false;
float halfDuration = duration / 2.0f;
iTween.EaseType goEase = iTween.EaseType.easeOutQuad;
iTween.EaseType backEase = iTween.EaseType.linear;
this.gameObject.MoveTo( enemy.transform.position ).Time( halfDuration ).EaseType(goEase).Execute();
// note: use local coordinates here to return to the target
// this only works if the projectiles are children of the target!!!
this.gameObject.MoveTo( target.transform.InverseTransformPoint( target.transform.position ) ).IsLocal(true).Time ( halfDuration ).EaseType(backEase).Delay( halfDuration ).Execute();
yield return new WaitForSeconds( halfDuration );
if( enemy != null )
{
SoundManager.use.PlaySFX( SoundManager.use.enemyHit );
enemy.OnAttacked();
GameObject.Destroy( enemy.gameObject );
}
yield return new WaitForSeconds( halfDuration );
iTween.Stop( this.gameObject );
transform.position = GetOrbitStartPosition();
OrbitEnabled = true;
}
public void Attack(EnemyTarget target, float duration)
{
LugusCoroutines.use.StartRoutine( RestartOrbitRoutine(target, duration) );
}
public EnemyMarker(EnemyTarget target, HumanoidTargeter founder)
: this(target.GetEnemy(), target.GetLocation(), founder)
{
}
void Start()
{
m_target = GameObject.Find("EnemyTarget").GetComponent<EnemyTarget>();
m_enemyMan = GameObject.Find("EnemyManager").GetComponent<EnemyManager>();
m_gameKB = GameObject.Find("GameKeyboard").GetComponent<GameKeyboard>();
m_gameKB.lockKeyboard(false);
}
