public void CreatingEnergizer()
{
GhostPack gp = new GhostPack();
Energizer e = new Energizer(gp);
Assert.AreEqual(e.ToString(), new Energizer(new GhostPack()).ToString());
}
public static void Main(string[] args)
{
Energizer energizer = new Energizer();
energizer.Play();
Application.Run(energizer.form);
}
public void EnerGizerPointsPropReadTest()
{
GhostPack gp = new GhostPack();
Energizer e = new Energizer(gp);
Assert.AreEqual(e.Points, 500);
}
public void EnergizerConstructorTest()
{
int expectedPoints = 100;
Energizer e = new Energizer();
int actual = e.Points;
Assert.AreEqual(expectedPoints, actual);
}
public void MemberPropertyTestGet()
{
Energizer expected = new Energizer();
Path path = new Path(1, 1, expected);
ICollidable actual = path.Member;
Assert.AreEqual(expected, actual);
}
public void TestGameStateParse_EnergizerPosition()
{
GameState game1 = GetGameState();
GhostPack ghosts = new GhostPack();
Energizer energizer = new Energizer(ghosts);
Tile path = new Path(1, 3, energizer);
Assert.AreEqual(game1.Maze[1, 3].Member().ToString(), path.Member().ToString());
}
public void EnergizerGetterTest()
{
Energizer e = new Energizer();
e.Points = 400;
int expected = 400;
int actual = e.Points;
Assert.AreEqual(expected, actual);
}
public void EnergizerSetterTest_ValidInput()
{
Energizer e = new Energizer();
e.Points = 500;
int expected = 500;
int actual = e.Points;
Assert.AreEqual(expected, actual);
}
public void MemberPropertyTestSet()
{
Energizer e = new Energizer();
Path path = new Path(1, 1, e);
Pellet expected = new Pellet();
path.Member = expected;
ICollidable actual = path.Member;
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Bitmap bitmap = new Bitmap(@"C:\Users\aless\Downloads\141104497-d2a191db-e894-4f72-93a8-92590d692313.jpg");
//IContentAwarable contentAwarable = new MySeamCarving(bitmap, 10, ReduceType.ByWidth);
//IContentAwarable contentAwarable = new RavingContent(bitmap, ReduceType.ByWidth);
IContentAwarable contentAwarable = new Energizer(bitmap, ReduceType.ByWidth);
bitmap = contentAwarable.Reduce(100);
bitmap.Save(@"C:\Users\aless\Downloads\monna1.jpg");
}
public void TestCollide()
{
myEnergizer = new Energizer(myGameState.GhostSquad);
myEnergizer.Collision += myGameState.Score.incrementScore;
myEnergizer.Collide();
Assert.AreEqual(100, myGameState.Score.Score);
myEnergizer.Collide();
Assert.AreEqual(200, myGameState.Score.Score);
foreach (Ghost ghost in myGameState.GhostSquad)
{
Assert.AreEqual(GhostState.Scared, ghost.CurrentState);
}
}
private void OnCollisionStay(Collision collision)
{
// If the enemy collide with the player
if (collision.gameObject.CompareTag("Player"))
{
Energizer energizer = collision.gameObject.GetComponentInChildren <Energizer>();
if (energizer != null)
{
// Enemy steal energy to the player
energizer.GiveEnergy(energyAbsorbPerSecond * Time.deltaTime);
}
}
}
public void CollisionEventRaisedTest()
{
Boolean actual = false;
Boolean expected = true;
Energizer e = new Energizer();
e.CollisionEvent += (x) =>
{
x.Points += 100;
actual = true;
};
e.Collide();
Assert.AreEqual(expected, actual);
}
private void OnTriggerEnter(Collider other)
{
var energizer = other.GetComponent <Energizer>();
// If the collider is the player (player has Energizer component)
if (energizer != null)
{
energy = energizer;
// Stop current coroutines (maybe it's decreasing intensity...)
StopAllCoroutines();
// Start Increasing Intensity
StartCoroutine(IncreaseIntensity());
}
}
public Tile(Game game, int column, int row, Texture2D colorMap)
{
// Data extraction
rawData = new Color[1];
extractRegion = new Rectangle(column, row, 1, 1);
colorMap.GetData <Color>(0, extractRegion, rawData, 0, 1);
// Tile property initialization
Index = row * 28 + column;
Line = row;
IsWall = false;
IsEmpty = false;
HasPacdot = false;
HasEnergizer = false;
Reset();
// Calculate position
Position = new Vector2(column * 8, row * 8);
Center = new Vector2(Position.X + 4.0f, Position.Y + 4.0f);
Bounds = new Rectangle((int)Position.X, (int)Position.Y, 8, 8);
// Collectibles
Pacdot = new Pacdot(game, this);
Energizer = new Energizer(game, this);
// Developer mode only
if (IsWall)
{
DevColor = Color.DarkRed;
}
else
{
DevColor = Color.Green;
}
}
// 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;
}
}
}
public EnergizerPickupEventArgs(Energizer energizer, int totalCollected)
{
TotalCollected = totalCollected;
Energizer = energizer;
}
// Use to process your families.
protected override void onProcess(int familiesUpdateCount)
{
if (!levelInit)
{
// Pause all game system during initialisation
foreach (FSystem system in SystemHolder.pausableSystems)
{
if (system == this)
{
continue;
}
system.Pause = true;
}
foreach (GameObject go in _mapSpawnerGO)
{
Factory factory = go.GetComponent <Factory>();
Tilemap tilemap = go.GetComponent <Tilemap>();
//factory.reloadProgress += Time.deltaTime;
if (factory.reloadProgress >= factory.reloadTime)
{
foreach (var pos in tilemap.cellBounds.allPositionsWithin)
{
Vector3Int localPos = new Vector3Int(pos.x, pos.y, pos.z);
if (tilemap.HasTile(localPos))
{
Vector3 worldPos = tilemap.CellToWorld(localPos);
//Instantiate and bind to FYFY a new instance of antibodies drift (factory prefab)
GameObject mySpawn = Object.Instantiate <GameObject>(factory.prefab, worldPos, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
GameObjectManager.bind(mySpawn);
}
}
factory.reloadProgress = 0f;
}
}
foreach (GameObject go in _playerGO)
{
Player player = go.GetComponent <Player>();
foreach (GameObject buyableGO in player.levelBuyablePrefabs)
{
Buyable buyable = buyableGO.GetComponent <Buyable>();
//Create a new visual
GameObject myUI = Object.Instantiate <GameObject>(player.unitUIVisual, player.unitContainer.transform);
GameObjectManager.bind(myUI);
//Add height to container (each new element is 100px height here)
RectTransform rt = player.unitContainer.GetComponent <RectTransform>();
rt.sizeDelta = new Vector2(rt.sizeDelta.x, rt.sizeDelta.y + 100);
SpriteRenderer sr = buyableGO.GetComponentInChildren <SpriteRenderer>();
Info info = buyableGO.GetComponent <Info>();
//Update UI image and text
UIUnit ui = myUI.GetComponent <UIUnit>();
ui.image.sprite = sr.sprite;
ui.image.color = sr.color;
ui.text.text = info.myName.Replace("\\n", "\n");;
if (buyable != null)
{
ui.text.text += "\nCost : " + buyable.energyPrice.ToString("F0") + " energy";
}
ui.prefab = buyableGO;
}
}
levelInit = true;
// Resume systems
foreach (FSystem system in SystemHolder.pausableSystems)
{
system.Pause = false;
}
}
else
{
foreach (GameObject go in _playerGO)
{
Health playerHealth = go.GetComponent <Health>();
Energy playerEnergy = go.GetComponent <Energy>();
//Update health
if (playerHealth != null && !gamePaused)
{
bool init = false;
if (playerHealth.maxHealthPoints == 0)
{
init = true;
}
playerHealth.healthPoints = 0;
foreach (GameObject cellGO in _cellsGO)
{
Health cellHealth = cellGO.GetComponent <Health>();
if (init)
{
playerHealth.maxHealthPoints += cellHealth.maxHealthPoints;
}
playerHealth.healthPoints += cellHealth.healthPoints;
}
}
//Update energy
if (playerEnergy != null && !gamePaused)
{
foreach (GameObject energizerGO in _energizerGO)
{
Energizer energizer = energizerGO.GetComponent <Energizer>();
energizer.reloadProgress += Time.deltaTime;
if (energizer.reloadProgress >= energizer.reloadTime)
{
playerEnergy.energyPoints += energizer.recoverPoints;
energizer.reloadProgress = 0f;
}
}
//Cap at max
if (playerEnergy.energyPoints > playerEnergy.maxEnergyPoints)
{
playerEnergy.energyPoints = playerEnergy.maxEnergyPoints;
}
if (playerEnergy.energyPoints < 0)
{
playerEnergy.energyPoints = 0f;
}
}
}
//Check cell spawn position of cell is dead
foreach (GameObject go in _mapSpawnerGO)
{
Tilemap tilemap = go.GetComponent <Tilemap>();
//Remove cell tile position when cell is dead
foreach (var pos in tilemap.cellBounds.allPositionsWithin)
{
Vector3Int localPos = new Vector3Int(pos.x, pos.y, pos.z);
if (tilemap.HasTile(localPos))
{
bool cellFound = false;
Vector3 worldPos = tilemap.CellToWorld(localPos);
Collider2D[] colliders = Physics2D.OverlapCircleAll(worldPos, 1f, LayerMask.GetMask("Ignore Raycast"));
foreach (Collider2D collider in colliders)
{
GameObject collidedGO = collider.gameObject;
if (_cellsGO.contains(collidedGO.GetInstanceID()))
{
//There is a cell at position
cellFound = true;
break;
}
}
if (!cellFound)
{
tilemap.SetTile(localPos, null);
}
}
}
}
//Spawn waves
if (!gamePaused)
{
foreach (GameObject go in _levelSpawnerGO)
{
FactoryLevel factory = go.GetComponent <FactoryLevel>();
factory.reloadProgress += Time.deltaTime;
if (factory.reloadProgress >= factory.reloadTime)
{
if (factory.currentWave < factory.waves.Count)
{
Wave wave = factory.waves[factory.currentWave];
List <Vector3> spawnArea = TilemapUtils.getAllWorldPosition(factory.spawnArea);
List <Vector3> targetArea = TilemapUtils.getAllWorldPosition(factory.spawnTargetArea);
//Spawn each group of entity
foreach (Group g in wave.groups)
{
int i = 0;
while (i < g.nbSpawn)
{
Vector3 position = Vector3.zero;
if (spawnArea.Count > 0)
{
position = spawnArea[Random.Range(0, spawnArea.Count)];
}
GameObject mySpawn = Object.Instantiate <GameObject>(g.prefab, position, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
GameObjectManager.bind(mySpawn);
//Init first target move
Vector3 target = Vector3.zero;
if (targetArea.Count > 0)
{
target = targetArea[Random.Range(0, targetArea.Count)];
}
Move mv = mySpawn.GetComponent <Move>();
if (mv != null)
{
mv.targetPosition = target;
mv.targetObject = null;
mv.newTargetPosition = true;
mv.forcedTarget = true;
}
i++;
}
}
factory.reloadTime = wave.timeBeforeNext;
factory.reloadProgress = 0f;
factory.currentWave += 1;
}
}
//Destroy level wave factory if last wave was released (for victory condition)
if (factory.currentWave >= factory.waves.Count)
{
if (factory.waveIndicator != null)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Wave : " + factory.currentWave + " / " + factory.waves.Count);
sb.AppendLine("Final Wave");
factory.waveIndicator.text = sb.ToString();
}
GameObjectManager.removeComponent <FactoryLevel>(go);
//GameObjectManager.unbind(go);
//Object.Destroy(go);
}
else
{
if (factory.waveIndicator != null)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Wave : " + factory.currentWave + " / " + factory.waves.Count);
float time = factory.reloadTime - factory.reloadProgress;
sb.AppendLine("Time remain : " + time.ToString("F0"));
factory.waveIndicator.text = sb.ToString();
}
}
}
}
//Check level status
if (_attackersGO.Count == 0)
{
levelStatus = "Victory";
}
else
{
int nbHealth = 0;
int nbHealthZero = 0;
foreach (GameObject go in _playerGO)
{
Health playerHealth = go.GetComponent <Health>();
if (playerHealth != null)
{
nbHealth += 1;
if (playerHealth.healthPoints == 0)
{
nbHealthZero += 1;
}
}
}
if (nbHealthZero == nbHealth)
{
levelStatus = "Defeat";
}
}
}
GameObject playerGO = _playerGO.First();
if (playerGO != null)
{
Player player = playerGO.GetComponent <Player>();
string title, descr;
switch (levelStatus)
{
case "Victory":
title = "Victoire !";
descr = "Vous avez réussi à vous protéger de la menace pathogène.";
endGame(player, title, descr);
break;
case "Defeat":
title = "Défaite.";
descr = "La menace pathogène s'est trop répandue et est maintenant hors de contrôle.";
endGame(player, title, descr);
break;
case "Pending":
default:
break;
}
}
}
public void EnergizerSetterTest_InvalidInput()
{
Energizer e = new Energizer();
e.Points = -1;
}
