protected override void onProcess(int currentFrame)
{
foreach (GameObject virus in _virus)
{
Triggered2D t2D = virus.GetComponent <Triggered2D>();
VirusProperties virusProperties = virus.GetComponent <Virus>()._properties;
foreach (GameObject other in t2D.Targets)
{
bool dead = other.GetComponent <Death>() != null;
bool infected = other.GetComponent <Infected>() != null;
bool tagIsValid = (other.tag == "StructureCell" || other.tag == "BCell" || other.tag == "TCell" || other.tag == "Macrophage" || other.tag == "Bactery");
if (!dead && !infected && tagIsValid && Random.value < virusProperties._infectionChance)
{
// Infecter la cible
GameObjectManager.addComponent <Infected>(other, new { _virusProperties = virusProperties });
// Détruire le virus
GameObjectManager.unbind(virus);
Object.Destroy(virus);
break;
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D> ();
foreach (GameObject target in t2d.Targets)
{
if (target.GetComponent <Obstacle> () == null)
{
int weight = 1;
if (target.tag == "special_coin")
{
weight = 2;
}
GameObjectManager.unbind(target);
Object.Destroy(target);
go.GetComponent <Dinosaure>().score += 1 * weight;
go.GetComponent <Dinosaure>().energy += 5 * weight;
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
//On récupére les élements qui entrent en collision avec nous
Triggered2D t2d = go.GetComponent <Triggered2D>();
foreach (GameObject target in t2d.Targets)
{
//Si l'élement est un élement controlé par un joueur
if (target.GetComponent <Controllable> () != null)
{
Debug.Log(go.GetComponent <Endlevel> ().currentLevel);
//Une fois la on incremente le niveau actuelle pour aller au niveau prochain
go.GetComponent <Endlevel> ().currentLevel += 1;
//string next = string.Concat("Niveau" + go.GetComponent<Endlevel> ().currentLevel);
//Debug.Log(go.GetComponent<Endlevel> ().currentLevel);
if (go.GetComponent <Endlevel> ().currentLevel == -1)
{
Application.Quit();
}
SceneManager.LoadScene(go.GetComponent <Endlevel> ().currentLevel);
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
//Debug.Log (go);
Triggered2D t2d = go.GetComponent <Triggered2D> ();
//on récupére les éléments qui rentrent en collision avec lui
foreach (GameObject target in t2d.Targets)
{
//si l'élément est un vrai élément et c'est pas les murs
if (target != null && !target.GetComponent <Wall>())
{
Debug.Log(target);
if (target.gameObject.transform.parent)
{
//on le détruit
GameObjectManager.destroyGameObject(target.gameObject.transform.parent.gameObject);
}
else
{
GameObjectManager.destroyGameObject(target);
}
//GameObjectManager.destroyGameObject (target);
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
//Récupérer les élements qui rentrent en collision
Triggered2D t2d = go.GetComponent <Triggered2D> ();
//Vérifier que le target peut être agglutinés
if (go.GetComponent <Agglutinué> () != null)
{
Debug.Log(go + " aggl");
continue;
}
foreach (GameObject target in t2d.Targets)
{
//On lui rajoute le leucocyte IsInfacble et Isinfecte comme component
Leucocyte leucocyte = target.GetComponent <Leucocyte> ();
IsInfectable isInfectable = target.GetComponent <IsInfectable> ();
IsInfecte infecte = target.GetComponent <IsInfecte> ();
if ((isInfectable != null || leucocyte != null) && infecte == null)
{
target.AddComponent <IsInfecte>();
//On lui change l'image pour représenter qu'il est infecté
SpriteRenderer spriteRenderer;
spriteRenderer = target.GetComponent <SpriteRenderer>();
Sprite s = (Sprite)Resources.Load(spriteRenderer.sprite.name + "_infected", typeof(Sprite));
Debug.Log(s);
spriteRenderer.sprite = s;
Infecteur virus = go.GetComponent <Infecteur>();
virus.hasInfect = true;
Debug.Log(target + " : est infecté !");
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
//Récupérer les élements qui peuvent être en collision
Triggered2D t2d = go.GetComponent <Triggered2D> ();
foreach (GameObject target in t2d.Targets)
{
Leucocyte leucocyte = go.GetComponent <Leucocyte> ();
HP hp1 = target.GetComponent <HP>();
Absorbeur absorbe = target.GetComponent <Absorbeur> ();
//Si l'élément n'est pas mort et que c'est un leucocyte et qu'il n'est pas un absorbeur
if (hp1 != null && leucocyte != null && absorbe == null)
{
//on lui rajoute endommager
Endommage endommage = go.GetComponent <Endommage> ();
Debug.Log(hp1.hp);
hp1.hp -= endommage.hpLost;
/*if (hp1.hp <= 0)
* GameObjectManager.destroyGameObject (target);
*/
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2D = go.GetComponent <Triggered2D>();
foreach (GameObject target in t2D.Targets)
{
if (target.GetComponents <Move> () != null)
{
//Si l'élement peut secreter et qu'ils secretent Toxines et Bactéries
if (target.GetComponent <Secreter> () != null && target.GetComponent <Secreter>().type.Equals("Toxines") && go.GetComponent <Specialisation> ().type.Equals("Bacterie"))
{
target.GetComponent <Move> ().coefv = 0.8f;
}
else
{
//si l'élement secrete un virus alors on ralentie
if (target.GetComponent <Infecteur> () != null && go.GetComponent <Specialisation>().type.Equals("Virus"))
{
target.GetComponent <Move> ().coefv = 0.8f;
}
}
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
//pour chaque élément absorbeur détecté
foreach (GameObject go in _controllableGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D> ();
// Comme absorber diminue le HP on le récupére dans le fils de l'élément
HP hp1 = go.gameObject.GetComponentInChildren <HP> ();
//On récupére tous les élements en collision
foreach (GameObject target in t2d.Targets)
{
//on vérifie que l'élément a côté n'a pas été déja absorbé
IsAbsorbe isAbsorbe = target.GetComponent <IsAbsorbe> ();
Absorbeur absorbeur = go.GetComponent <Absorbeur> ();
// s'il est en train d'être absorbé
if (isAbsorbe != null)
{
continue;
}
// si l'élement n'est pas encore été absorbé, si c'est une toxine
if (target.gameObject.CompareTag("toxine"))
{
//on lui rajoute le compononent "isAbsorbe"
target.AddComponent <IsAbsorbe>();
Debug.Log("Absorbe : toxine " + go);
//on diminue le hp
hp1.hp -= absorbeur.hpLost;
}
// si l'élement n'est pas encore été absorbé, si c'est une dechet
else if (target.gameObject.CompareTag("dechet"))
{
Debug.Log("Absorbe : dechet " + go);
target.AddComponent <IsAbsorbe>();
hp1.hp -= absorbeur.hpLost;
}
// si l'élement n'est pas encore été absorbé, si c'est une bacterie
else if (target.gameObject.CompareTag("bacterie"))
{
Debug.Log("Absorbe");
target.AddComponent <IsAbsorbe>();
//target.gameObject.transform.GetChild(0).gameObject.AddComponent<IsAbsorbe>();
hp1.hp -= absorbeur.hpLost;
}
// si l'élement n'est pas encore été absorbé, si c'est un virus et qu'il n'est pas agglutiné
else if (target.gameObject.CompareTag("virus") && target.GetComponent <Agglutinué>() != null)
{
Debug.Log("Absorbe");
target.AddComponent <IsAbsorbe>();
target.gameObject.transform.GetChild(0).gameObject.AddComponent <IsAbsorbe>();
hp1.hp -= absorbeur.hpLost;
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D>();
foreach (GameObject target in t2d.Targets)
{
GameObjectManager.unbind(target);
Object.Destroy(target);
}
}
}
protected override void onProcess(int currentFrame)
{
// Si deux virus agglutinés se croisent il ne faut pas retraiter celui qui a été mis en fils
HashSet <GameObject> alreadySeen = new HashSet <GameObject>();
foreach (GameObject stuckVirus_go in f_stuckVirus)
{
if (alreadySeen.Contains(stuckVirus_go))
{
continue;
}
alreadySeen.Add(stuckVirus_go);
// parcours des agent en contact avec ce virus
Triggered2D t2d = stuckVirus_go.GetComponent <Triggered2D>();
foreach (GameObject target in t2d.Targets)
{
// On ne traite que les virus et les virus agglutinés
if ((target.tag != "StuckVirus" && target.tag != "Virus") || alreadySeen.Contains(target))
{
continue;
}
alreadySeen.Add(target);
// positionner cet agent à proximité du virus maître
target.transform.position = new Vector3(stuckVirus_go.transform.position.x + Random.Range(-0.1f, 0.1f), stuckVirus_go.transform.position.y + Random.Range(-0.1f, 0.1f), stuckVirus_go.transform.position.z);
// mettre cet agent comme fils du virus maître
GameObjectManager.setGameObjectParent(target, stuckVirus_go, true);
// désactiver cet agent
GameObjectManager.setGameObjectTag(target, "Untagged");
GameObjectManager.setGameObjectLayer(target, LayerMask.NameToLayer("Default"));
GameObjectManager.removeComponent <Target>(target);
GameObjectManager.removeComponent <Speed>(target);
GameObjectManager.removeComponent <TriggerSensitive2D>(target);
GameObjectManager.removeComponent <PolygonCollider2D>(target);
GameObjectManager.removeComponent <Rigidbody2D>(target);
if (target.tag == "Virus")
{
GameObjectManager.removeComponent <Virus>(target);
}
else
{
// si le virus était déjà un stuckVirus, associer ses enfants au nouveau maître
foreach (Transform child in target.transform)
{
GameObjectManager.setGameObjectParent(child.gameObject, stuckVirus_go, true);
}
}
break;
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in canApoptose)
{
Triggered2D t2d = go.GetComponent <Triggered2D>();
foreach (GameObject target in t2d.Targets)
{
if (target.GetComponent <Infection>() != null)
{
GameObjectManager.unbind(target);
Object.Destroy(target);
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2D = go.GetComponent <Triggered2D> ();
//pour chaque élément rentré en collision avec lui
foreach (GameObject target in t2D.Targets)
{
//Si l'élement est infecté et pas encore agglutiné on lui rajoute un component agglutiné
if (target.GetComponent <Infecteur>() != null && target.GetComponent <Agglutinué> () == null)
{
target.AddComponent <Agglutinué> ();
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
//Parcours des GO dans la famille
foreach (GameObject go in _triggeredGO)
{
//Récupération des composants du GO courant
Triggered2D t2d = go.GetComponent <Triggered2D>();
//Parcours des GO actuellement en collision
foreach (GameObject target in t2d.Targets)
{
//Désabonnement de la cible pour qu'elle ne soit plus gérée par FYFY
GameObjectManager.unbind(target);
//Destruction du GO
Object.Destroy(target);
}
}
}
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2D = go.GetComponent <Triggered2D>();
Eater eat = go.GetComponent <Eater>();
foreach (GameObject target in t2D.Targets)
{
if (target.CompareTag(eat.eatableTag))
{
GameObjectManager.unbind(target);
Object.Destroy(target);
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Transform tr = go.GetComponent <Transform>();
Triggered2D t2d = go.GetComponent <Triggered2D>();
Predator predator = go.GetComponent <Predator>();
Block block = go.GetComponent <Block>();
block.timeSinceLastEffect += Time.deltaTime;
bool effectApplied = false;
//Debug.Log(go.name + " " + t2d.Targets.Length);
foreach (GameObject target in t2d.Targets)
{
if (_preysGO.contains(target.GetInstanceID()))
{
Prey prey = target.GetComponent <Prey>();
if (predator.myPreys.Contains(prey.myType))
{
//TODO slow the target
Move mv = target.GetComponent <Move>();
Transform collidedTr = target.GetComponent <Transform>();
float dist = Vector3.Distance(collidedTr.position, tr.position);
if (block.timeSinceLastEffect >= block.effectFreq)
{
//float f = (float) 0.5f * (1/dist);
float f = 0.5f;
mv.speedModifiers.Add(new SpeedModifier(f, false, 2f));
effectApplied = true;
}
}
}
}
if (effectApplied)
{
block.timeSinceLastEffect = 0f;
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in canInfect)
{
Triggered2D t2d = go.GetComponent <Triggered2D>();
foreach (GameObject target in t2d.Targets)
{
if (target.GetComponent <Infectionable>() != null)
{
GameObjectManager.addComponent <Infection>(target);
target.GetComponent <SpriteRenderer>().sprite = target.GetComponent <Infectionable>().prefab;
GameObjectManager.unbind(go);
Object.Destroy(go);
}
}
}
}
protected override void onProcess(int currentFrame)
{
foreach (GameObject toxin in _toxins)
{
Triggered2D t2D = toxin.GetComponent <Triggered2D>();
float damages = toxin.GetComponent <Toxin>()._damages;
foreach (GameObject other in t2D.Targets)
{
if ((other.tag == "StructureCell" || other.tag == "BCell" || other.tag == "TCell") && other.GetComponent <Death>() == null)
{
GameObjectManager.addComponent <Damage>(other, new { damages = damages });
GameObjectManager.addComponent <Death>(toxin);
break;
}
}
}
}
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in triggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D>();
foreach (GameObject target in t2d.Targets)
{
target.GetComponent <Health>().hp -= go.GetComponent <Damage>().dmg;
if (target.GetComponent <Health>().hp <= 0)
{
GameObjectManager.unbind(target);
Object.Destroy(target);
}
target.transform.position += go.transform.up.normalized * 0.6f;
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in tiggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D>();
Absorption abs = go.GetComponent <Absorption>();
foreach (GameObject target in t2d.Targets)
{
if (target.GetComponent <CanInfect>() == null)
{
abs.nbrAbsorption++;
GameObjectManager.unbind(target);
Object.Destroy(target);
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D> ();
Debug.Log("go : " + go);
//on récupére les élements qui rentrent en collision
foreach (GameObject target in t2d.Targets)
{
Debug.Log("target : " + target);
//Si l'élement qui rentre en collision avec est infecté
IsInfecte isInfecte = target.GetComponent <IsInfecte> ();
if (isInfecte != null)
{
Debug.Log(target + " : IsApoptose !");
//On lui rajoute un component isApoptose
target.AddComponent <IsApoptose>();
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D>();
Absorbance ab = go.GetComponent <Absorbance>();
foreach (GameObject target in t2d.Targets)
{
Death d = target.GetComponent <Death>();
if (d != null && d.number != 0 && d.prefab != null)
{
GameObject newGO = Object.Instantiate(d.prefab, target.transform.position, Quaternion.identity);
GameObjectManager.bind(newGO);
}
GameObjectManager.unbind(target);
Object.Destroy(target);
ab.numberAbsorbed++;
}
}
}
protected override void onProcess(int currentFrame)
{
foreach (GameObject tcell in _tcells)
{
Triggered2D t2d = tcell.GetComponent <Triggered2D>();
foreach (GameObject other in t2d.Targets)
{
// si la cellule touchée est en train de mourrir, on ne fait rien
if (other.GetComponent <Death>() != null)
{
continue;
}
// vérifier si la cellule est infectée
Infected infected = other.GetComponent <Infected>();
if (infected != null)
{
// on la tue en faisant un max de dégâts
infected._virusNumberToCreate = 0; // ne pas générer de virus
GameObjectManager.addComponent <Damage>(other, new { damages = float.PositiveInfinity });
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
// gestion des collisions avec le sol et les structures
foreach (GameObject go in _incollision)
{
InCollision2D col = go.GetComponent <InCollision2D> ();
Move mo = go.GetComponent <Move> ();
foreach (GameObject target in col.Targets)
{
// ground collision
// quand le projectile ne bouge plus -> nouveau projectile créé donc ne plus toucher à la vitesse
if (target != null && target.tag.Equals("Ground") && mo.inMovement == true)
{
mo.groundContact = true;
mo.vitesse.y = 0f;
}
//mo.inMovement == true pour éviter modification de vitesse quand on remet un nouveau projectile
if (target.tag.Equals("wood_struct") && mo.inMovement == true && !mo.idStructure.Contains(target.GetInstanceID()))
{
DataProjectile dP = go.GetComponent <DataProjectile> ();
Rigidbody2D rB = target.GetComponent <Rigidbody2D> ();
mo.vitesse.x = (mo.vitesse.x * (dP.masse - rB.mass)) / (dP.masse + rB.mass);
mo.vitesse.y = (mo.vitesse.y * (dP.masse - rB.mass)) / (dP.masse + rB.mass);
mo.idStructure.Add(target.GetInstanceID());
}
if (target != null && target.tag.Equals("reward"))
{
Collect co = target.GetComponent <Collect> ();
total.score_total += co.reward;
GameObjectManager.unbind(target);
GameObject.Destroy(target);
}
}
}
// détection des récompenses et des obstacles
foreach (GameObject go in _triggered2D)
{
Triggered2D tr = go.GetComponent <Triggered2D> ();
Move mo = go.GetComponent <Move> ();
foreach (GameObject target in tr.Targets)
{
if (target.tag.Equals("reward"))
{
Collect co = target.GetComponent <Collect> ();
total.score_total += co.reward;
GameObjectManager.unbind(target);
GameObject.Destroy(target);
}
if (target.tag.Equals("broken_stone") && mo.inMovement == true && mo.stone_touched == false)
{
mo.vitesse.x = 0;
GameObjectManager.unbind(target);
GameObject.Destroy(target);
mo.stone_touched = true;
}
if (target.tag.Equals("stone_struct") && mo.inMovement == true && mo.stone_touched == false)
{
mo.vitesse.x = 0;
target.GetComponent <SpriteRenderer> ().sprite = Resources.Load("brokenS", typeof(Sprite)) as Sprite;
target.tag = "broken_stone";
mo.stone_touched = true;
}
if (target.tag.Equals("obstacle"))
{
mo.vitesse.x = 0;
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D>();
Predator predator = go.GetComponent <Predator>();
Eat eat = go.GetComponent <Eat>();
eat.timeSinceLastEffect += Time.deltaTime;
bool effectApplied = false;
foreach (GameObject target in t2d.Targets)
{
if (_preysGO.contains(target.GetInstanceID()))
{
Prey prey = target.GetComponent <Prey>();
if (predator.myPreys.Contains(prey.myType))
{
//"eat" the target
Transform collidedTr = target.GetComponent <Transform>();
Health collidedH = target.GetComponent <Health>();
if (eat.timeSinceLastEffect >= eat.effectFreq)
{
collidedH.healthPoints -= eat.damage;
if (collidedH.healthPoints <= 0)
{
Vector3 pos = target.transform.position;
if (eat.infectOnKill)
{
//Debug.Log(pos);
prey.myType = eat.newPreyTag;
GameObjectManager.addComponent <Infected>(target, new { myParasit = go });
GameObjectManager.addComponent <Factory>(target, new { reloadTime = eat.timerFactory, prefab = eat.prefab });
collidedH.healthPoints = collidedH.maxHealthPoints;
Energizer collidedE = target.GetComponent <Energizer>();
Energizer e = go.GetComponent <Energizer>();
if (collidedE != null)
{
if (e != null)
{
collidedE.recoverPoints = e.recoverPoints;
collidedE.reloadTime = e.reloadTime;
}
else
{
GameObjectManager.removeComponent(collidedE);
}
}
else
{
if (e != null)
{
GameObjectManager.addComponent <Energizer>(target, new { recoverPoints = e.recoverPoints, reloadTime = e.reloadTime });
}
}
if (eat.applyColor)
{
Renderer r = target.GetComponentInChildren <Renderer>();
if (r != null)
{
if (r is SpriteRenderer)
{
((SpriteRenderer)r).color = eat.color;
}
else
{
r.material.color = eat.color;
}
}
}
}
else
{
GameObjectManager.unbind(target);
Object.Destroy(target);
}
Move mv = go.GetComponent <Move>();
if (mv != null)
{
mv.targetObject = null;
}
/* Previous functionnality of duplication on kill * /
* GameObject myDuplicate = Object.Instantiate<GameObject>(eat.prefab, pos, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
*
* //WARNING: should not do that but looks like that even if instance come frome a prefab, it is instanciated with a Triggered2D...
* //If this line is commented, FYFY will generate an error
* Object.Destroy(myDuplicate.GetComponent<Triggered2D>());
*
* GameObjectManager.bind(myDuplicate);
*
* Move mv = myDuplicate.GetComponent<Move>();
* if (mv != null) {
* Vector2 posTarget = new Vector2(Random.Range(pos.x - 1f, pos.x + 1f), Random.Range(pos.y -1f, pos.y -1f));
*
* mv.targetPosition = posTarget;
* mv.forcedTarget = true;
* mv.newTargetPosition = true;
* }
* /* */
}
effectApplied = true;
}
}
}
}
if (effectApplied)
{
eat.timeSinceLastEffect = 0f;
}
}
}
protected override void onProcess(int currentFrame)
{
// gestion des zones de reconnaissances
foreach (GameObject recognitionZone_go in f_recognitionZones)
{
Triggered2D rzTriggered = recognitionZone_go.GetComponent <Triggered2D>();
BCell bCell = recognitionZone_go.GetComponentInParent <BCell>();
// parcours des objets dans la zone de détection
foreach (GameObject other in rzTriggered.Targets)
{
if (other.tag == "Bactery")
{
// progression de la détection
bCell._bacteryRecognitionProgress += Time.deltaTime;
updateTypeBar(bCell, BCell.TYPE.BACTERIAL, bCell._bacteryRecognitionProgress, bCell._bacteryRecognitionTime);
if (bCell._bacteryRecognitionProgress >= bCell._bacteryRecognitionTime)
{
// transformation de la BCell en BCell bactérien
specializeBCell(bCell, BCell.TYPE.BACTERIAL);
}
}
else if (other.tag == "Virus")
{
// progression de la détection
bCell._virusRecognitionProgress += Time.deltaTime;
updateTypeBar(bCell, BCell.TYPE.VIRAL, bCell._virusRecognitionProgress, bCell._virusRecognitionTime);
if (bCell._virusRecognitionProgress >= bCell._virusRecognitionTime)
{
// transformation de la BCell en BCell viral
specializeBCell(bCell, BCell.TYPE.VIRAL);
}
}
}
}
// gestion des zones d'action
foreach (GameObject actionZone_go in f_actionZones)
{
Triggered2D azTriggered = actionZone_go.GetComponent <Triggered2D>();
BCell bCell = actionZone_go.GetComponentInParent <BCell>();
// parcours des objets dans la zone d'action
foreach (GameObject other in azTriggered.Targets)
{
if (bCell._type == BCell.TYPE.BACTERIAL && other.tag == "Bactery")
{
// Si c'est une bactérie, la ralentir
Speed speedC = other.GetComponent <Speed>();
speedC._speed = speedC._stuckSpeed;
}
else if (bCell._type == BCell.TYPE.VIRAL && other.tag == "Virus")
{
// Si c'est un virus, l'agglutiner
Speed speedC = other.GetComponent <Speed>();
speedC._speed = speedC._stuckSpeed;
GameObjectManager.removeComponent <Virus>(other);
GameObjectManager.setGameObjectTag(other, "StuckVirus");
GameObjectManager.setGameObjectLayer(other, LayerMask.NameToLayer("StuckVirus"));
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _controllGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D> ();
TempsContact tc = go.GetComponent <TempsContact> ();
foreach (GameObject target in t2d.Targets)
{
// Trouver une solution plus efficace que les tags.
// il faut aussi rajouter les virus infectées et les bactéries.
//or target.gameObject.Equals("Virus") !! Faut voir si annelisse a fait virus.
if (target.gameObject.GetComponent <Secreter>() != null && target.gameObject.GetComponent <Secreter>().type.Equals("Toxines"))
{
if (tc.temp == 0)
{
GameObjectManager.removeComponent <TempsContact>(go);
Specialisation spe = go.gameObject.transform.parent.gameObject.GetComponent <Specialisation> ();
spe.type = "Bacterie";
//GameObjectManager.addComponent (go.gameObject.transform.parent.gameObject, typeof(Specialisation), new { type = "Bacterie"});
//GameObjectManager.addComponent (go.gameObject.transform.parent.gameObject, typeof(Secreter), new { type = "Anticorps"});
// TODO: reduire le temps de reload de secreter!!!!
GameObjectManager.addComponent(go.gameObject.transform.parent.gameObject, typeof(Secreter), new { type = "Anticorps", reloadTime = 0.4f });
SpriteRenderer sprit;
sprit = go.gameObject.transform.parent.GetComponent <SpriteRenderer> ();
Sprite s = (Sprite)Resources.Load("lymphocyteBBacterie", typeof(Sprite));
sprit.sprite = s;
}
else
{
tc.temp--;
}
}
if (target.gameObject.GetComponent <Infecteur> ())
{
Debug.Log("virus spé");
if (tc.temp == 0)
{
GameObjectManager.removeComponent <TempsContact>(go);
Specialisation spe = go.gameObject.transform.parent.gameObject.GetComponent <Specialisation> ();
spe.type = "Virus";
//GameObjectManager.addComponent (go.gameObject.transform.parent.gameObject, typeof(Specialisation), new { type = "Virus"});
GameObjectManager.addComponent(go.gameObject.transform.parent.gameObject, typeof(Secreter), new { type = "Anticorps", reloadTime = 0.4f });
//Secreter secr =go.gameObject.transform.parent.gameObject.GetComponent<Secreter> ();
// TODO: reduire le temps de reload de secreter !!!!
SpriteRenderer sprit;
sprit = go.gameObject.transform.parent.GetComponent <SpriteRenderer> ();
Sprite s = (Sprite)Resources.Load("lymphocyteBVirale", typeof(Sprite));
sprit.sprite = s;
}
else
{
tc.temp--;
}
}
}
}
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
foreach (GameObject go in _triggeredGO)
{
Triggered2D t2d = go.GetComponent <Triggered2D> ();
foreach (GameObject target in t2d.Targets)
{
//While level is not finished we handle
if (!target.GetComponent <Dinosaure>().levelDone)
{
//Check if the obstacle is fatal, then die
if (go.GetComponent <Obstacle>().fatal)
{
//target.GetComponent<Transform>().Rotate(new Vector3 (5,0,0));
//Dino is dead
target.GetComponent <Dinosaure>().isDead = true;
//Make it fall
target.GetComponent <Rigidbody2D> ().bodyType = RigidbodyType2D.Dynamic;
//Remove the trigger
target.GetComponent <CapsuleCollider2D>().isTrigger = false;
//Stop the animation
target.GetComponent <Animator> ().enabled = true;
target.GetComponent <Animator> ().SetBool("died", true);
//Stop scrolling
env.GetComponent <ScrollingBG>().GetComponent <Rigidbody2D>().velocity = new Vector2(0, 0);
//Remove wind (or there can be collision between windGO and bird)
foreach (GameObject obstacleGO in _obstaclesGO)
{
if (obstacleGO.GetComponent <Obstacle>().type == obstacleType.Wind)
{
GameObjectManager.unbind(obstacleGO);
Object.Destroy(obstacleGO);
}
}
//Display Loser Panel
lostPanel.SetActive(true);
}
//If it's not check the type of obstacle
else
{
switch (go.GetComponent <Obstacle>().type)
{
case obstacleType.Wind:
target.GetComponent <Velocity>().speed -= go.GetComponent <Obstacle>().slowRatio;
break;
case obstacleType.Level:
target.GetComponent <Animator> ().enabled = false;
target.GetComponent <Dinosaure>().levelDone = true;
//target.GetComponent<Rigidbody2D>().mass= 1;
//target.GetComponent<Rigidbody2D>().drag= 1;
env.GetComponent <ScrollingBG>().GetComponent <Rigidbody2D>().velocity = new Vector2(0, 0);
int score = target.GetComponent <Dinosaure>().score;
if (env.GetComponent <Level>().bestScore < score)
{
env.GetComponent <Level>().bestScore = score;
}
wonPanel.SetActive(true);
//NextLevel()
break;
case obstacleType.LimitUp:
//if(limitUpInstanceId == 0)
// limitUpInstanceId = go.GetInstanceID();
//target.GetComponent<Dinosaure>().reachedUp=true;
break;
default:
break;
}
}
}
}
}
}