/// <summary>
/// Called when a sequence's time is finished without success.
/// </summary>
public void OnSequenceEnded()
{
if (_currentEnemy == null && _currentHeart == null)
{
return;
}
if (_currentHeart != null)
{
_currentHeart.SetState(CHeart.STATE_DEATH);
_currentHeart = null;
}
else
{
if (_currentEnemy.GetState() == CEnemy.STATE_ATTACK)
{
return;
}
_currentEnemy.SetState(CEnemy.STATE_ATTACK);
}
_ui.SetSequence(new List <Runes>());
_elapsedTimeNoEnemy = 0;
_ui.SetClockValue(0);
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
_mercenary.SetState(CMercenary.STATE_ANGRY);
}
public void SpawnEnemy()
{
float randSpawn = Random.value;
if (randSpawn < .02f)
{
GameObject heart = Instantiate(CLevelManager.Inst._heart, transform);
_currentHeart = heart.GetComponent <CHeart>();
heart.transform.position = _enemySpawnPonint.position;
}
else
{
float maxProbab = 0;
int maxProbIndex = 0;
float highestProb = 0;
List <EnemyData> enemies = CLevelManager.Inst._enemies;
for (int i = 0; i < enemies.Count; i++)
{
if (enemies[i].IsValidEnemy(CSequenceManager.Inst.GetCurrentRuneCount()))
{
maxProbab += enemies[i].spawnProbability;
if (highestProb < enemies[i].spawnProbability)
{
highestProb = enemies[i].spawnProbability;
maxProbIndex = i;
}
}
}
float rand = Random.value;
int spawnIndex = -1;
float spawnProb = 1;
for (int i = 0; i < enemies.Count; i++)
{
float prob = enemies[i].spawnProbability / maxProbab;
if (rand <= prob && spawnProb > prob)
{
spawnIndex = i;
spawnProb = prob;
}
}
if (spawnIndex < 0)
{
CreateEnemy(maxProbIndex);
}
else
{
CreateEnemy(spawnIndex);
}
if (_currentEnemy == null)
{
return;
}
}
CSequenceData data = CSequenceManager.Inst.RequestSequence(_laneIndex);
data.ui = _ui;
_ui.SetSequence(data.sequence);
_mercenary.SetState(CMercenary.STATE_REQUEST);
}
private void Update()
{
if (GameData.IsPause)
{
return;
}
if (_currentEnemy == null && _currentHeart == null)
{
_elapsedTimeNoEnemy += Time.deltaTime;
if (_elapsedTimeNoEnemy > _timeToWaitBetweenEnemies)
{
_elapsedTimeNoEnemy = 0;
_ui.SetClockValue(0);
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
SpawnEnemy();
return;
}
}
else
{
if (_currentEnemy != null && _currentEnemy.IsDead())
{
_currentEnemy = null;
_elapsedTimeNoEnemy = 0;
_ui.SetClockValue(0);
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
}
if (_currentHeart != null && _currentHeart.IsDead())
{
_currentHeart = null;
_elapsedTimeNoEnemy = 0;
_ui.SetClockValue(0);
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
}
}
}
override protected void init()
{
base.init();
_heart = CHeart.CreateBuilder();
}
public static System.Object getDataModel(ProtoTypeEnum type)
{
if (dataModel.ContainsKey(type))
{
return(dataModel[type]);
}
else
{
switch (type)
{
case ProtoTypeEnum.CLogin: {
return(CLogin.CreateBuilder());
}
case ProtoTypeEnum.SUserData: {
return(SUserData.CreateBuilder());
}
case ProtoTypeEnum.CEnterRoom: {
return(CEnterRoom.CreateBuilder());
}
case ProtoTypeEnum.COutRoom: {
return(COutRoom.CreateBuilder());
}
case ProtoTypeEnum.SOutRoom: {
return(SOutRoom.CreateBuilder());
}
case ProtoTypeEnum.SFishChapter: {
return(SFishChapter.CreateBuilder());
}
case ProtoTypeEnum.CHangUpRoom: {
return(CHangUpRoom.CreateBuilder());
}
case ProtoTypeEnum.SError: {
return(SError.CreateBuilder());
}
case ProtoTypeEnum.SSingleUpdate: {
return(SSingleUpdate.CreateBuilder());
}
case ProtoTypeEnum.CTest: {
return(CTest.CreateBuilder());
}
case ProtoTypeEnum.STest: {
return(STest.CreateBuilder());
}
case ProtoTypeEnum.CHeart: {
return(CHeart.CreateBuilder());
}
}
return(null);
}
}
public static System.Object getDataModel(ProtoTypeEnum type, byte[] bytes)
{
switch (type)
{
case ProtoTypeEnum.CLogin: {
CLogin.Builder model;
if (dataModel.ContainsKey(type))
{
model = (CLogin.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = CLogin.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.SUserData: {
SUserData.Builder model;
if (dataModel.ContainsKey(type))
{
model = (SUserData.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = SUserData.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.CEnterRoom: {
CEnterRoom.Builder model;
if (dataModel.ContainsKey(type))
{
model = (CEnterRoom.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = CEnterRoom.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.COutRoom: {
COutRoom.Builder model;
if (dataModel.ContainsKey(type))
{
model = (COutRoom.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = COutRoom.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.SOutRoom: {
SOutRoom.Builder model;
if (dataModel.ContainsKey(type))
{
model = (SOutRoom.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = SOutRoom.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.SFishChapter: {
SFishChapter.Builder model;
if (dataModel.ContainsKey(type))
{
model = (SFishChapter.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = SFishChapter.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.CHangUpRoom: {
CHangUpRoom.Builder model;
if (dataModel.ContainsKey(type))
{
model = (CHangUpRoom.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = CHangUpRoom.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.SError: {
SError.Builder model;
if (dataModel.ContainsKey(type))
{
model = (SError.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = SError.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.SSingleUpdate: {
SSingleUpdate.Builder model;
if (dataModel.ContainsKey(type))
{
model = (SSingleUpdate.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = SSingleUpdate.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.CTest: {
CTest.Builder model;
if (dataModel.ContainsKey(type))
{
model = (CTest.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = CTest.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.STest: {
STest.Builder model;
if (dataModel.ContainsKey(type))
{
model = (STest.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = STest.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
case ProtoTypeEnum.CHeart: {
CHeart.Builder model;
if (dataModel.ContainsKey(type))
{
model = (CHeart.Builder)dataModel[type];
model.Clear();
model.MergeFrom(bytes);
}
else
{
model = CHeart.ParseFrom(bytes).ToBuilder();
dataModel.Add(type, model);
}
return(model);
}
}
return(null);
}
