private EnemyModel initEnemy(EnemyModel enemy)
{
EnemyModel newEnemy = Instantiate(enemy);
for (int i = 0; i < enemy.weaponModels.Length; i++)
{
WeaponModel newWeaponModel = Instantiate(enemy.weaponModels[i]);
if (newWeaponModel.GetType().Equals(typeof(MeleeWeaponModel)))
{
newWeaponModel.attackDemage = randomValue(1, 10);
}
else
{
newWeaponModel.attackDemage = randomValue(2, 20);
}
newEnemy.weaponModels[i] = newWeaponModel;
}
newEnemy.runningSpeed = randomValue(2, 15);
newEnemy.walkSpeed = randomValue(2, (int)newEnemy.runningSpeed);
newEnemy.energy = randomValue(10, 30);
newEnemy.health = randomValue(2, 8);
return(newEnemy);
}
IEnumerator Generate(EnemyData enemy)
{
while (active)
{
Vector2 position = SetNewEnemyPosition(enemy);
Quaternion rotation = SetNewEnemyRotation(enemy, position);
EnemyController newController = Instantiate(enemy.prefab, position, rotation, transform).GetComponent <EnemyController>();
if (newController)
{
newController.SetScreenLimits(leftScreenLimit, rightScreenLimit, upperScreenLimit, lowerScreenLimit);
newController.SetProyectileContainer(proyectileContainer);
currentEnemies.Add(newController);
EnemyModel newModel = newController.gameObject.GetComponent <EnemyModel>();
newModel.Initialize(collisionDamage, enemy.itemGenerationPercentage);
EnemyView newView = newController.gameObject.GetComponent <EnemyView>();
newView.InitializeDamageColor(damageColor, damageColorDuration);
newView.InitializeExplosion(explosionPrefab, explosionContainer);
}
float waitTime = Random.Range(enemy.minWaitTime, enemy.maxWaitTime);
yield return(new WaitForSeconds(waitTime));
}
}
private int SortByScore(EnemyModel e1, EnemyModel e2)
{
double resultE1 = System.Math.Abs(e1.getRating() - getScore());
double resultE2 = System.Math.Abs(e2.getRating() - getScore());
return((int)resultE1.CompareTo(resultE2));
}
private void initPopulation(EnemyModel enemy)
{
for (int i = 0; i < population.Length; i++)
{
newPopulation.Add(initEnemy(enemy));
}
}
public void Setup(EnemyModel model, GunModel gunModel)
{
enemyModel = model;
enemyModel.setConfig(enemyConfig);
this.gunModel = gunModel;
}
public PieceMover Instantiate(PieceMover prefab, EnemyModel enemyModel)
{
return(Instantiate(prefab,
GetSquarePosition(enemyModel.CurrentSquare.Value),
enemyModel.CurrentRotation.Value,
transform));
}
private void CreateRandomBombs()
{
int chance = 80 - GameInfo.Round; //Initial 1 in 80 chance which increases with round.
if (chance < 10) //Chance limit of 10.
{
chance = 10;
}
if (!GetRandomChance(chance)) //Check if we should create a bomb or not. Return if not.
{
return;
}
var enemyModels = GetEnemyModels(); //Check that we have some enemy models to attach the bomb to.
if (enemyModels.Count() == 0)
{
return;
}
EnemyModel enemy = enemyModels[random.Next(enemyModels.Count())]; //Select a random Enemy to assign the bomb to.
//Create a bomb and set the X and Y to that of the chosen enemy model.
EnemyBombModel enemyBomb = new EnemyBombModel();
enemyBomb.X = enemy.X + enemy.Width / 2;
enemyBomb.Y = enemy.Y;
enemyBomb.Height = 40;
enemyBomb.Width = 30;
GameModels.Add(enemyBomb);
}
public override void Construct(CharacterModel model, bool isLoad = false)
{
heroControllers = FindObjectsOfType <HeroController>().ToList();
var heroModels = heroControllers.Select(controller => controller.HeroModel).ToList();
enemyModel = model as EnemyModel;
if (enemyModel == null)
{
Debug.Log("Enemy Model could not resolve in EnemyController");
return;
}
if (!isLoad)
{
enemyModel.Construct(heroModels);
enemyModel.CurrentHealth = enemyModel.Health;
}
characterGraphicsController.Construct(enemyModel.Sprite);
healthBarController.Construct(enemyModel.name);
PublisherSubscriber.Publish(new ProgressBarData
{
Id = enemyModel.name,
BarType = ProgressBarType.HealthProgression,
TotalAmount = enemyModel.Health,
CurrentAmount = enemyModel.CurrentHealth
});
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
EnemyModel enemyModel = (EnemyModel)target;
if (enemyModel.drops.Count != enemyModel.randomDropPercentatges.Count)
{
EditorGUILayout.HelpBox("Los drops y Random Percentatges deben tener el mismo numero de elementos.", MessageType.Error, true);
}
EditorUtility.SetDirty(enemyModel);
foreach (GameObject item in enemyModel.drops)
{
if (item == null)
{
EditorGUILayout.HelpBox("No puedes tener objetos vacios", MessageType.Error, true);
}
}
foreach (int item in enemyModel.randomDropPercentatges)
{
if (item <= 0 || item > 100)
{
EditorGUILayout.HelpBox("No puedes tener numeros por debajo de 0 o más grandes de 100", MessageType.Error, true);
}
}
}
public static GameObject Create(CreateParams params_)
{
if (!_enable)
{
return(null);
}
switch (params_.data.Type)
{
case DataTypes.BULLET:
return(Create <BulletController>(new BulletModel(params_.data as BulletData), params_).gameObject);
case DataTypes.ENEMY:
EnemyData data = params_.data as EnemyData;
EnemyModel enemy = new EnemyModel(data);
enemy.InitMoveParams(10f, 1.0f);
return(Create <EnemyController>(enemy, params_).gameObject);
case DataTypes.HERO:
return(Create <HeroController>(new HeroModel((params_.data as HeroData)), params_).gameObject);
default:
return(null);
}
}
public WarpPipeEnemyModel(BlockSpriteFactory blockSpriteFactory, Vector2 coordinates, Vector2 velocity, EnemyModelFactory enemyModelFactory, string enemyType, int numOfEnemies, CollisionGrid collisionGrid)
: base(blockSpriteFactory)
{
//Constructor for warppipe that hides enemies
//Initialize Texture first
Texture = BlockSpriteFactory.GetBlockSprite("pipetop");
CurrentState = new WarpPipeEntityStandardState(this);
CurrentState.Enter(null);
//Define the characteristics of a pipe block here
Position = coordinates;
CurrentFrame = 0;
Columns = 1;
Rows = 1;
LayerDepth = 1;
Scale = new Vector2(10, 10);
Width = Texture.Width / Columns;
Height = Texture.Height / Rows;
Velocity = velocity;
//Enemies
EnemyModelFactory = enemyModelFactory;
EnemyType = enemyType;
CollisionGrid = collisionGrid;
EnemyModel = enemyModelFactory.GetEnemyModel(enemyType, coordinates, Velocity);
EnemyModel.IsVisible = false;
NumOfEnemies = numOfEnemies;
}
void Awake()
{
levelController = LevelController.instance;
Model = new EnemyModel(3, 2.5f, 1, 5f);
Model.PositionX = 10f;
SetRandomPosition();
}
public void OnEnemyDeath(EnemyModel model)
{
Debug.Log("On Enemy Death Hit");
switch (model.enemyType)
{
case EnemyType.Small:
SmallCounter++;
break;
case EnemyType.Medium:
MediumCounter++;
break;
case EnemyType.Large:
LargeCounter++;
break;
case EnemyType.Boss:
BossCounter++;
break;
default:
Debug.LogError($"Error processing enemy type ---- {model.enemyType}");
break;
}
}
// Start is called before the first frame update
void Awake()
{
dado1 = GameObject.FindWithTag("Dado1");
dado1.GetComponent <Renderer>().enabled = false;
enemy = GetComponent <EnemyModel>();
player = GameController.player;
storyView = GameController.storyView;
enemyView = GameObject.Find("EnemyText").GetComponent <EnemyView>();
enemyView.gameObject.SetActive(false);
//Subscrição eventos do controller
onCombatStart += enemy.Enemy;
onEnemyPower += enemy.AttackPower;
onPlayerPower += player.AttackPower;
onPlayerLife += player.Life;
onEnemyLife += enemy.Life;
onPlayerDamage += player.LifeUpdate;
onEnemyDamage += enemy.Damage;
onDiceRoll += dado.rolar;
EnemyModel.OnEnemyInfoChange += enemyView.CombatStart;
onEnemyAppear += storyView.CombatStart;
onEnemyAttack += storyView.CombatEnemyAttack;
onPlayerAttack += storyView.CombatPlayerAttack;
onCombatPower += storyView.CombatForce;
onEnemyDeath += storyView.CombatSuccess;
onPlayerDeath += storyView.CombatFailed;
onEnemyError += enemyView.CombatSuccess;
}
public CreatureModel ToCreature()
{
CreatureModel model;
switch (this.CreatureType)
{
case CreatureTypeEnum.player:
model = new PlayerModel();
break;
case CreatureTypeEnum.enemy:
model = new EnemyModel();
break;
default:
model = new CreatureModel();
model.CreatureType = CreatureTypeEnum.npc;
break;
}
model.Id = Id;
model.Name = Name;
model.Initiative = 0;
model.HP = HP;
model.AC = AC;
model.MaxHP = MaxHP;
model.InitiativeBonus = InitiativeBonus;
model.ImagePath = ImagePath;
model.PositionX = 0;
model.PositionY = 0;
return(model);
}
public void Setup(EnemyModel model)
{
base.Setup();
Status.Setup(model);
ai_ = GetAI(model.AiId);
enemy_model = model;
}
/// <summary>
/// Gets enemy object.
/// </summary>
/// <param name="enemy">
/// Model of enemy to get.
/// </param>
public async Task <EnemyModel> Get(EnemyModel enemy)
{
var enemyProt = new EnemyProt
{
EnemyType = enemy.Name
};
//get an enemy with a given type
enemyProt = await _protDataAccess.Get(enemyProt);
var result = new EnemyModel
{
Damage = enemyProt.Damage,
Defence = enemyProt.Defence,
MaxHp = enemyProt.MaxHP,
Hp = enemyProt.MaxHP,
Name = enemyProt.EnemyType,
Gold = enemyProt.Gold,
Level = enemyProt.Level,
//fills only types, pulling whole objects is not yet necessary
EquippedArmour = new ArmourModel {
Type = enemyProt.ArmourType
},
EquippedWeapon = new WeaponModel {
Type = enemyProt.WeaponType
}
};
return(result);
}
public void Execute(Entity entity, EnemyModel component)
{
component.weaponResource = weaponResource;
if (entity.hasCircleMissileSpawner)
entity.circleMissileSpawner.resource = weaponResource;
if (entity.hasCircleMissileRotatedSpawner)
entity.circleMissileRotatedSpawner.resource = weaponResource;
if (entity.hasDispersionMissileSpawner)
entity.dispersionMissileSpawner.resource = weaponResource;
if (entity.hasHomeMissileSpawner)
entity.homeMissileSpawner.resource = weaponResource;
if (entity.hasMultipleMissileSpawner)
entity.multipleMissileSpawner.resource = weaponResource;
if (entity.hasMissileSpawner)
entity.missileSpawner.resource = weaponResource;
if (entity.hasTargetMissileSpawner)
entity.targetMissileSpawner.resource = weaponResource;
if (entity.hasLaserSpawner)
{
entity.laserSpawner.resource = weaponResource;
if (entity.laserSpawner.laser != null)
entity.laserSpawner.laser.isDestroyEntity = true;
entity.laserSpawner.laser = null;
}
}
private void LoadEnemyParams(List <string> enemyNames)
{
GlobalVariables.EnemyParams = new List <EnemyModel>();
foreach (string enemyName in enemyNames)
{
using (UnityWebRequest request = UnityWebRequest.Get("http://127.0.0.1:8000/enemy-download?name=" + enemyName))
{
request.SendWebRequest();
while (!request.isDone)
{
new WaitForSeconds(0.1f);
}
if (request.isNetworkError || request.isHttpError)
{
Debug.Log("http://127.0.0.1:8000/enemy-download?name=" + enemyName);
Debug.Log(request.error);
}
else
{
string responseBody = request.downloadHandler.text;
EnemyModel model = JsonUtility.FromJson <EnemyModel>(responseBody);
GlobalVariables.EnemyParams.Add(model);
}
}
}
}
private void CreateEnemyView(EnemyModel enemyModel)
{
EnemyView enemyView = new EnemyView(enemyModel);
LayoutRoot.Children.Add(enemyView);
_enemyViewList.Add(enemyView);
}
public EnemyView CreateEnemyView(EnemyModel enemyModel)
{
EnemyView enemyView = Object.Instantiate(_enemyPrefab);
Controller.Link(enemyModel, enemyView);
return(enemyView);
}
private void ShootUpOrDown(EnemyModel enemy)
{
float y = 0;
// Shoot up
if (_playerModel.Position.Y <= enemy.Position.Y)
{
y -= EnemyBulletDistance;
}
// Shoot down
if (_playerModel.Position.Y >= enemy.Position.Y)
{
y += EnemyBulletDistance;
}
if (!enemy.IsDead && !enemy.IsBoss && enemy.ShootCooldown >= 2000)
{
_bulletListModel.Bullets.Add(new BulletModel(new Vector2(enemy.Position.X + 25, enemy.Position.Y), 0, true, true, false, Color.Yellow, enemy.Damage, new Vector2(0, y)));
enemy.ShootCooldown = 0f;
}
if (!enemy.IsDead && enemy.IsBoss && enemy.ShootCooldown >= 1000)
{
_bulletListModel.Bullets.Add(new BulletModel(new Vector2(enemy.Position.X + 25, enemy.Position.Y), 0, true, true, true, Color.Yellow, enemy.Damage, new Vector2(0, y * 2)));
enemy.ShootCooldown = 0f;
}
}
//未行動の敵を取得する
private void GetBeforeMoveEnemy()
{
EnemyModel beforeActionEnemy = enemyContainer.GetComponentsInChildren <EnemyModel>().FirstOrDefault(
enemy => enemy.isMoved == false);
//未行動の敵が存在するので処理へ
if (beforeActionEnemy != null)
{
Debug.Log("選択した敵 : " + beforeActionEnemy.enemy.name);
//アクティブな敵を設定
mainMap.activeEnemyName = beforeActionEnemy.enemy.name;
mainMap.activeEnemyid = beforeActionEnemy.enemyId;
//フェーズ変更
enemyAIPhase = EnemyAIPhase.MOVE_CURSOR;
Debug.Log("enemyAIPhase : " + enemyAIPhase);
}
else
{
Debug.Log("敵が全員行動済み");
//既に未行動の敵が存在しなければ終了
enemyAIPhase = EnemyAIPhase.END;
Debug.Log("enemyAIPhase : " + enemyAIPhase);
}
}
public EnemyController(EnemyModel enemyModel, EnemyView enemyPrefab)
{
XPos = Random.Range(40, -40);
ZPos = Random.Range(40, -40);
EnemyModel = enemyModel;
EnemyView = GameObject.Instantiate <EnemyView>(enemyPrefab, new Vector3(XPos, 0f, ZPos), Quaternion.identity);
}
public void Setup(EnemyModel model)
{
max_hp_ = model.Hp;
hp_ = model.Hp;
base_attack_ = model.Power;
base_defence_ = model.Defense;
}
private void Awake( )
{
_model = new EnemyModel(1);
_view = GetComponent <EnemyView> ( );
SetBaseModelView(_model, _view);
}
private void Start()
{
//MVC linking
model = GetComponent <EnemyModel>();
view = GetComponent <EnemyView>();
if (model.isBoss)
{
bossHealthScript = GameObject.Find("HealthBarStorage").GetComponent <BossHealthUI>();
}
//Setup melee
if (model.meleeEnabled == true)
{
melee = gameObject.GetComponent <MeleeWeapon>();
melee.AttackDamage = model.meleeAttackDamage;
melee.attackRange = model.meleeAttackRange;
}
//Setup ranged
if (model.rangedEnabled == true)
{
ranged = gameObject.GetComponent <RangedWeapon>();
ranged.damage = model.rangedAttackDamage;
ranged.speed = model.rangedAttackProjectileSpeed;
}
//Increase the enemy counter
GameObject.Find("CounterCanvas").GetComponentInChildren <EnemyCounter>().increaseCount();
}
public void SetParameters(EnemyModel parameters)
{
_maxHealth = parameters.MaxHealth;
_moveSpeed = parameters.MoveSpeed;
Reward = parameters.Reward;
Flying = parameters.Flying;
}
public void SetData(EnemyModel component)
{
this.component = component;
executor = new EnemyModelCmpActionExecutor(component);
createEnemy();
createDummy();
createHud();
}
void addRotationIfNeeded(EnemyModel component, Entity e)
{
if (component.randomRotation > 0)
{
float randomAngle = Random.Range(-component.randomRotation, component.randomRotation);
e.AddRotate(randomAngle, randomAngle);
}
}
void Start()
{
config = GetComponent <EnemyPrefabConfig> ();
model = config.enemyModel;
view = config.enemyView;
model.SetMaxHealth(config.maxHealth);
}
public void ReplaceEnemyModel(EnemyModel newValue)
{
var index = GameComponentsLookup.EnemyModel;
var component = CreateComponent <EnemyModelComponent>(index);
component.value = newValue;
ReplaceComponent(index, component);
}
public static void Rivive(EnemyModel e)
{
float x = (Random.value * b.size.x + b.min.x) * 0.95f;
float y = (Random.value * b.size.y + b.min.y) * 0.95f;
e.transform.position = new Vector3(x, y, 0);
e.health = e.maxHealth;
}
string getDefaultResource(EnemyModel model)
{
if (model.weapon == WeaponTypes.Home)
return ResourceWithColliders.MissileEnemyHoming;
if (model.weapon == WeaponTypes.Laser)
return Resource.Laser;
return ResourceWithColliders.MissileEnemy;
}
public void Execute(Entity entity, EnemyModel component)
{
component.angle = angle;
if (entity.hasDispersionMissileSpawner)
entity.dispersionMissileSpawner.angle = angle;
if (entity.hasCircleMissileRotatedSpawner)
entity.circleMissileRotatedSpawner.angle = angle;
if (entity.hasLaserSpawner)
entity.laserSpawner.angle = angle;
}
public void Execute(Entity entity, EnemyModel component)
{
component.amount = amount;
if (entity.hasCircleMissileSpawner)
entity.circleMissileSpawner.amount = amount;
if (entity.hasCircleMissileRotatedSpawner)
entity.circleMissileRotatedSpawner.amount = amount;
if (entity.hasMultipleMissileSpawner)
entity.multipleMissileSpawner.amount = amount;
}
public EnemyLeftPanelHud(Transform content, EventService eventService, EnemyModelCmpActionExecutor executor, Entity entity, EnemyModel component)
{
go = content.gameObject;
this.content = content;
this.eventService = eventService;
this.executor = executor;
this.entity = entity;
weaponExecutor = new EnemyWeaponActionExecutor(entity, component);
weaponExecutor.Execute(getActionBasedOnType(executor.getWeapon()));
setData();
}
public void Execute(Entity entity, EnemyModel component)
{
component.velocity = velocity;
if (entity.hasCircleMissileSpawner)
entity.circleMissileSpawner.velocity = velocity;
if (entity.hasCircleMissileRotatedSpawner)
entity.circleMissileRotatedSpawner.velocity = velocity;
if (entity.hasDispersionMissileSpawner)
entity.dispersionMissileSpawner.velocity = velocity;
if (entity.hasHomeMissileSpawner)
entity.homeMissileSpawner.velocity = velocity;
if (entity.hasTargetMissileSpawner)
entity.targetMissileSpawner.velocity = velocity;
if (entity.hasLaserSpawner)
entity.laserSpawner.maxHeight = velocity;
}
void setDefaultParameters(EnemyModel model)
{
model.amount = 5;
model.time = 0.5f;
model.spawnDelay = 2.0f;
model.weaponResource = getDefaultResource(model);
model.velocity = 2.0f;
model.angle = 10;
model.angleOffset = 20;
model.waves = 5;
model.startVelocity = new Vector2(0.0f, -2.0f);
model.followDelay = 1.0f;
model.selfDestructionDelay = 3.0f;
model.timeDelay = 2.0f;
model.delay = 2.0f;
model.randomPositionOffsetX = 0.2f;
}
void Start()
{
canvas = GameObject.Find("Canvas").GetComponent<Canvas>() ;
enemyModel = GetComponent<EnemyModel>();
healthPanel = Instantiate(healthPrefab) as GameObject;
healthPanel.transform.SetParent(canvas.transform, false);
enemyModel.HealthPanel = healthPanel;
enemyName = healthPanel.GetComponentInChildren<Text>();
enemyName.text = enemyModel.Name;
healthSlider = healthPanel.GetComponentInChildren<Slider>();
healthSlider.enabled = false;
healthSlider.gameObject.SetActive(false);
enemyName.enabled = false;
}
public void Execute(Entity entity, EnemyModel component)
{
component.spawnDelay = spawnDelay;
if (entity.hasCircleMissileSpawner)
entity.circleMissileSpawner.spawnDelay = spawnDelay;
if (entity.hasCircleMissileRotatedSpawner)
entity.circleMissileRotatedSpawner.spawnDelay = spawnDelay;
if (entity.hasDispersionMissileSpawner)
entity.dispersionMissileSpawner.spawnDelay = spawnDelay;
if (entity.hasHomeMissileSpawner)
entity.homeMissileSpawner.spawnDelay = spawnDelay;
if (entity.hasMultipleMissileSpawner)
entity.multipleMissileSpawner.spawnDelay = spawnDelay;
if (entity.hasMissileSpawner)
entity.missileSpawner.spawnDelay = spawnDelay;
if (entity.hasTargetMissileSpawner)
entity.targetMissileSpawner.spawnDelay = spawnDelay;
}
public virtual void Execute(Entity entity, EnemyModel component)
{
if (entity.hasCircleMissileSpawner)
entity.RemoveCircleMissileSpawner();
if (entity.hasCircleMissileRotatedSpawner)
entity.RemoveCircleMissileRotatedSpawner();
if (entity.hasDispersionMissileSpawner)
entity.RemoveDispersionMissileSpawner();
if (entity.hasHomeMissileSpawner)
entity.RemoveHomeMissileSpawner();
if (entity.hasLaserSpawner)
entity.RemoveLaserSpawner();
if (entity.hasMultipleMissileSpawner)
entity.RemoveMultipleMissileSpawner();
if (entity.hasMissileSpawner)
entity.RemoveMissileSpawner();
if (entity.hasTargetMissileSpawner)
entity.RemoveTargetMissileSpawner();
}
public void provide(Entity e, int damage, EnemyModel component)
{
damage = (int)(damage * getDamageFactor());
switch (component.weapon)
{
case WeaponTypes.Circle:
e.AddCircleMissileSpawner(component.amount, damage, component.time, component.spawnDelay, component.weaponResource,
component.velocity * getMissileSpeedFactor(), CollisionTypes.Enemy);
break;
case WeaponTypes.CircleRotated:
e.AddCircleMissileRotatedSpawner(component.amount, damage, component.waves, component.angle, component.angleOffset,
component.time, component.spawnDelay, component.weaponResource, component.velocity * getMissileSpeedFactor(), CollisionTypes.Enemy);
break;
case WeaponTypes.Dispersion:
e.AddDispersionMissileSpawner(component.time, damage, component.spawnDelay, component.angle, component.weaponResource,
component.velocity * getMissileSpeedFactor(), CollisionTypes.Enemy);
break;
case WeaponTypes.Home:
e.AddHomeMissileSpawner(component.time, component.spawnDelay, damage, component.weaponResource, component.velocity * getMissileSpeedFactor(),
component.startVelocity, component.followDelay, component.selfDestructionDelay, CollisionTypes.Enemy);
break;
case WeaponTypes.Laser:
e.AddLaserSpawner(0.0f, component.velocity, component.velocity, component.angle, Vector2.up, CollisionTypes.Enemy, damage, component.weaponResource, null);
break;
case WeaponTypes.Multiple:
e.AddMultipleMissileSpawner(component.amount, damage, 0, component.timeDelay, component.delay, component.time,
component.spawnDelay, component.weaponResource, component.randomPositionOffsetX, component.startVelocity * getMissileSpeedFactor(), CollisionTypes.Enemy);
break;
case WeaponTypes.Single:
e.AddMissileSpawner(component.time, damage, component.spawnDelay, component.weaponResource, component.startVelocity * getMissileSpeedFactor(), CollisionTypes.Enemy);
break;
case WeaponTypes.Target:
e.AddTargetMissileSpawner(component.time, damage, component.spawnDelay, component.weaponResource, component.velocity * getMissileSpeedFactor(),
CollisionTypes.Enemy, CollisionTypes.Player);
break;
}
}
public void Execute(EnemyModel model)
{
model.randomRotation = randomRotation;
}
public void Execute(Entity entity, EnemyModel component)
{
component.followDelay = followDelay;
if (entity.hasHomeMissileSpawner)
entity.homeMissileSpawner.followDelay = followDelay;
}
public void Execute(Entity entity, EnemyModel component)
{
component.timeDelay = timeDelay;
if (entity.hasMultipleMissileSpawner)
entity.multipleMissileSpawner.timeDelay = timeDelay;
}
public EnemyAddedEventArgs(EnemyModel enemyModel)
{
this.EnemyModel = enemyModel;
}
public override void Execute(Entity entity, EnemyModel model)
{
base.Execute(entity, model);
entity.AddLaserSpawner(0.0f, model.velocity, model.velocity, model.angle, Vector2.up, CollisionTypes.Enemy, 0, model.weaponResource, null);
}
private EnemyModel CreateEnemyModel()
{
EnemyModel enemyModel = new EnemyModel();
enemyModel.Front = new Point(0, -1);
enemyModel.Mass = .2f;
enemyModel.Scale = Mathematics.Lerp(.4d, .8d, _rnd.NextDouble());
enemyModel.MaxSpeed = (float)Mathematics.Lerp(_enemyMaxSpeedLowRange, _enemyMaxSpeedHighRange, _rnd.NextDouble());
enemyModel.MaxForce = (float)Mathematics.Lerp(_enemyMaxForceLowRange, _enemyMaxForceHighRange, _rnd.NextDouble());
int quadrant = _rnd.Next(1, 5);
switch (quadrant)
{
case 1:
enemyModel.Position = new Point(_rnd.NextDouble() * Width, -_enemyCreationBufferWidth);
break;
case 2:
enemyModel.Position = new Point(Width + _enemyCreationBufferWidth, _rnd.NextDouble() * Height);
break;
case 3:
enemyModel.Position = new Point(_rnd.NextDouble() * Width, Width + _enemyCreationBufferWidth);
break;
default:
enemyModel.Position = new Point(-_enemyCreationBufferWidth, _rnd.NextDouble() * Height);
break;
}
enemyModel.Initialize();
return enemyModel;
}
Entity createEnemyFromComponent(EnemySpawnModel model, EnemyModel component)
{
Entity e = enemyCreator.createStandardEnemy(model, component.resource);
e.AddFaceDirection(component.faceDirection);
addCameraShakeIfNeeded(component, e);
addRotationIfNeeded(component, e);
addPathIfNeeded(e, model.posY, model.path);
weaponProvider.provide(e, model.damage, component);
return e;
}
public override void Execute(Entity entity, EnemyModel model)
{
base.Execute(entity, model);
entity.AddTargetMissileSpawner(model.time, 0, model.spawnDelay, model.weaponResource, model.velocity, CollisionTypes.Enemy, CollisionTypes.Player);
}
public EnemyView(EnemyModel enemyModel)
{
InitializeComponent();
_enemyModel = enemyModel;
_enemyModel.Origin = new Point(this.Width / 2, this.Height / 2);
}
public EnemyFactory()
{
_model = new EnemyModel();
}
public override void ParseResult()
{
Component = JsonConvert.DeserializeObject<EnemyModel>(result);
}
public override void Execute(Entity entity, EnemyModel model)
{
base.Execute(entity, model);
entity.AddCircleMissileRotatedSpawner(model.amount, 0, model.waves, model.angle, model.angleOffset, model.time, model.spawnDelay, model.weaponResource, model.velocity, CollisionTypes.Enemy);
}
private void CreateEnemy(EnemyModel model, GameObject[] prefabs)
{
var randomNumber = UnityEngine.Random.Range(0, prefabs.Length);
var enemyPresenter = enemyPresenterFactory.Create(prefabs[randomNumber], model);
enemyPresenter.transform.position = new Vector3(UnityEngine.Random.Range(-spawnPosition.x, spawnPosition.x), spawnPosition.y, spawnPosition.z);
}
void addCameraShakeIfNeeded(EnemyModel component, Entity e)
{
if (component.shakeCamera > 0)
e.AddCameraShakeOnDeath(component.shakeCamera);
}
public void Execute(Entity entity, EnemyModel component)
{
component.waves = waves;
if (entity.hasCircleMissileRotatedSpawner)
entity.circleMissileRotatedSpawner.waves = waves;
}
public UpdateEnemy(EnemyModel component)
{
urlData.Add("ships");
urlData.Add("update");
postData.Add("data", JsonConvert.SerializeObject(component, Formatting.None, new JsonConverter[] { new Vector2Converter() }));
}
Entity createEnemyByTypeFromComponent(EnemyModel component, int type, float posX, float posY, int health, int path, int grid, int damage, float velocityLimit)
{
Entity e = enemyCreator.createStandardEnemy(type, damage, posX, posY, health, velocityLimit, component.resource);
e.AddFaceDirection(component.faceDirection);
addCameraShakeIfNeeded(component, e);
addRotationIfNeeded(component, e);
addPathIfNeeded(e, posY, path);
weaponProvider.provide(e, damage, component);
return e;
}
