public override void PerformSetup(Context context, IState previousState)
{
base.PerformSetup(context, previousState);
// Generate Calamity
EnemyDefinition calamityType = HackUtil.GetRandomCalamityClass();
_calamity = ClassUtil.CreateCharacter(
calamityType.Id,
(uint)Guid.NewGuid().GetHashCode(),
calamityType.NameGenerator.GetName(),
calamityType.CharacterClass,
30u);
// Generate Potential Party Members
uint partyId = (uint)NewPartyGuid.GetHashCode();
for (int i = 0; i < 5; i++)
{
uint id = (uint)(i + 1);
PlayerClassDefinition randomClass = HackUtil.GetRandomPlayerClass();
string randomName = randomClass.NameGenerator.GetName();
PlayerCharacter playerCharacter = ClassUtil.CreatePlayerCharacter(id, partyId, randomName, randomClass.PlayerClass);
_generatedCharacters.Add(playerCharacter);
}
// Generate (Unequipped) Starting Equipment
int weaponCount = RANDOM.Next(3);
for (int i = 0; i < weaponCount; i++)
{
if (HackUtil.GetRandomWeapon() is var newWeapon)
{
_generatedInventory.Add(newWeapon.Item);
}
}
int armorCount = RANDOM.Next(3);
for (int i = 0; i < armorCount; i++)
{
if (HackUtil.GetRandomArmor() is var newArmor)
{
_generatedInventory.Add(newArmor.Item);
}
}
int itemCount = RANDOM.Next(5);
for (int i = 0; i < itemCount; i++)
{
if (HackUtil.GetRandomItem() is var newItem)
{
_generatedInventory.Add(newItem.Item);
}
}
}
public void InstantiateEnemy(EnemyDefinition enemyDefinition)
{
var enemyController = collisionInstantiator.Execute <EnemyController>(enemyDefinition);
var rectTransform = enemyController.GetComponent <RectTransform>();
rectTransform.SetParent(EnemiesContainer);
rectTransform.ScaleOne();
enemyController.Init(mapEnemyViewModel.Execute(enemyController.Id, enemyDefinition));
}
public Enemy(EnemyDefinition definition, int level, EnemySettings settings, Lane lane, float entryPoint = 0, GameObject parent = null) : base(definition.name, settings.speed, definition.width, definition.laneHeightPadding, settings.health, definition.Value(level), lane)
{
color = settings.color;
enter = Enter(entryPoint * lane.width);
if (parent != null)
{
container.transform.SetParent(parent.transform);
}
}
public EnemyViewModel Execute(string id, EnemyDefinition enemyDefinition)
{
var pathDefinition = configuration.AllPaths.FirstOrDefault(p => p.Name.Equals(enemyDefinition.PathName));
var gunDefinition = configuration.AllGuns.FirstOrDefault(g => g.Name.Equals(enemyDefinition.GunName));
return(new EnemyViewModel(id, enemyDefinition.name,
Mathf.Max(1, enemyDefinition.Speed),
Mathf.Max(1, enemyDefinition.ScorePoints),
Mathf.Max(1, enemyDefinition.Health),
pathDefinition,
gunDefinition));
}
private void DrawEnemy(EnemyDefinition enemyDefinition)
{
var serializedObject = new SerializedObject(enemyDefinition);
EditorGUILayout.PropertyField(serializedObject.FindProperty("Name"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("Health"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("GunName"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("Speed"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("Prefab"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("PathName"), true);
EditorGUILayout.PropertyField(serializedObject.FindProperty("ScorePoints"), true);
serializedObject.ApplyModifiedProperties();
}
//temporarily returning weapon list. Need to fix when implementing other drop types
public WeaponDefinition[] generateLoot(string enemyId)
{
//check the enemy id matches a key in the enemy definitions
if (!enemyDefinitions.definitions.ContainsKey(enemyId))
{
throw new System.Exception("Missing enemy id.");
}
//retrieve the enemy details
EnemyDefinition definition = enemyDefinitions.definitions[enemyId];
//create an array to store the loot drops
WeaponDefinition[] generatedDefinitions = new WeaponDefinition[definition.lootDrops];
for (int i = 0; i < definition.lootDrops; i++)
{
//randomly select the loot drop type such as weapon, armour, resource etc.
string dropType = ((WeightedString)WeightedValueSelector.selectValue(definition.lootDropTypes)).value;
switch (dropType)
{
case "WEAPON":
//using the selected loot drop type, randomly select the inner group of loot items such as assault_rifles
WeaponLootDefinition weaponLootDefinition = ((WeaponLootDefinition)WeightedValueSelector.selectValue(definition.weaponWeights));
//randomly select the rarity type of the loot drop
RarityObject.Rarity rarity = ((WeightedRarityObject)WeightedValueSelector.selectValue(weaponLootDefinition.rarityWeights)).value;
//using the randomly selected information retrieve a weapon definition and add to loot list
generatedDefinitions[i] = WeaponUtil.getWeapon(weaponLootDefinition.name, rarity);
break;
case "ARMOUR":
break;
case "INTEL":
break;
case "RESOURCE":
break;
case "NONE":
break;
}
}
//return the list of awarded loot types
return(generatedDefinitions);
}
void NewEnemy(string enemyName, Weapon enemyWeapon,
float enemyExpValue, float enemyChangeValue,
int enemyHealth, int enemySpeed, int enemyDefense,
int enemyLevel, bool bBoss = false)
{
EnemyDefinition enemy;
if (null == enemyWeapon)
{
return;
}
enemy = new EnemyDefinition(enemyName, enemyWeapon,
enemyExpValue, enemyChangeValue,
enemyHealth, enemySpeed, enemyDefense,
enemyLevel);
if (true == bBoss)
{
if (null == bosses)
{
bosses = new Dictionary <int, Dictionary <string, EnemyDefinition> >();
}
if (false == bosses.ContainsKey(enemyLevel))
{
bosses[enemyLevel] = new Dictionary <string, EnemyDefinition>();
}
bosses[enemyLevel].Add(enemy.name, enemy);
}
else
{
if (null == enemies)
{
enemies = new Dictionary <int, Dictionary <string, EnemyDefinition> >();
}
if (false == enemies.ContainsKey(enemyLevel))
{
enemies[enemyLevel] = new Dictionary <string, EnemyDefinition>();
}
enemies[enemyLevel].Add(enemy.name, enemy);
}
}
public void ApplyPreset(EnemyDefinition enemy)
{
full_name.RuntimeValue = enemy.full_name;
short_name.RuntimeValue = enemy.short_name;
color = enemy.color;
level.RuntimeValue = enemy.level;
health.RuntimeValue = health.RuntimeMax = enemy.health;
energy.RuntimeValue = energy.RuntimeMax = enemy.energy;
experience.RuntimeValue = experience.RuntimeMax = enemy.experience;
strength.RuntimeValue = enemy.strength;
will.RuntimeValue = enemy.will;
stamina.RuntimeValue += enemy.stamina;
perception.RuntimeValue = enemy.perception;
}
public void Init(EnemyDefinition def)
{
stats.def = def;
stats.currHp = def.maxHp;
state = EnemyState.ACTIVE;
// gameObject.layer = LayerMask.NameToLayer("Default");
//set sprite TODO Set animator or sumthin
sr.sprite = SpriteLibrary.I.GetEnemySprite(def.type);
//Set collider
GetComponent <BoxCollider2D>().size = sr.sprite.bounds.size;
//Set AI
switch (def.type)
{
case EnemyType.WALKER:
ai = new BuildingDiverAI();
break;
case EnemyType.ROVER:
ai = new StraightDownAI();
break;
case EnemyType.BIKE:
ai = new BuildingDiverAI();
break;
case EnemyType.PLANE:
ai = new StraightDownAI();
break;
default:
break;
}
ai.UpdateGoalPos(transform.position);
}
public GameObject GetNewInstanceOfEnemy(EnemyTypesEnum aType)
{
EnemyDefinition aEnemy = null;
for (int i = 0; i < Enemies.Length; i++)
{
if (Enemies[i].Type == aType)
{
aEnemy = Enemies[i];
break;
}
}
GameObject aEnemyInstance = Instantiate(aEnemy.EnemyPrefab) as GameObject;
EnemyMovement aEnemyMovement = aEnemyInstance.GetComponent <EnemyMovement>();
aEnemyMovement.OnEnemyInvasionEvent += new EnemyMovement.EnemyInvasionHandler(onEnemyInvasion);
aEnemyInstance.GetComponent <Enemy>().SetUIController(mGuiUpdater);
return(aEnemyInstance);
}
public void Initialize(JsonArray enemy_table)
{
var assembly = typeof(EnemyFactory).GetTypeInfo().Assembly;
foreach (var enemy_template in enemy_table)
{
var enemy_template_object = (JsonObject)enemy_template.GetObject();
EnemyDefinition definition = new EnemyDefinition();
definition.MovementType = assembly.DefinedTypes.Where(t =>
t.Name == enemy_template_object.GetNamedString("Movement")
).Single().AsType();
definition.Speed = (float)enemy_template_object.GetNamedNumber("Speed");
if (definition.MovementType == null)
{
MessageBox.Show("Unable to find type " + enemy_template_object.GetNamedString("Movement"), "Invalid type in enemies.json", new String[] { "Ok" });
}
_TemplateList.Add(definition);
}
}
public void ShowEnemyLevels(EnemyDefinition definition, Vector3 position)
{
HideEnemyLevels();
int count = definition.levels.Count;
Add(_enemyLevels = new Layout("HeroLevels", 4, count + 1, 0.25f, 0.1f, count + 1, container));
_enemyLevels.SetPosition(position + (Vector3.right * _enemyLevels.width * 0.5f) + (Vector3.back * _enemyLevels.height * 0.5f));
_enemyLevels.Add(new List <Button>(
Button.GetButtons(count,
(int index) => new Button("Level " + index, 4, 1, container, "Item", fontSize: 20,
Enter: (Button button) => button.SetColor(button.selected ? button.color : Color.green),
Stay: (Button button) =>
{
if (Input.GetMouseButtonDown(0))
{
_selectedEnemy = definition;
_selectedLevel = index;
ShowEnemyEditor();
HideEnemyLevels();
}
},
Exit: (Button button) => button.SetColor(button.selected ? button.color : Color.white))))
{
new Button("Add Enemy Level", 4, 1, container, "AddEnemyLevel", fontSize: 20,
Enter: ( Button button ) => button.SetColor(Color.green),
Stay: ( Button button ) =>
{
if (Input.GetMouseButtonDown(0))
{
definition.AddLevel();
ShowEnemyLevels(definition, position);
}
},
Exit: ( Button button ) => button.SetColor(Color.white))
}, true);
}
public void RefreshEnemyDefinition()
{
if (this.IsNormalNavi)
{
this.EnemyDefinition = EnemyDefinition.GetEnemyDefinition(this.ID, this.X, this.Y, this.Rank, this.HP, this.Chip5.ID, this.Chip4.ID, this.Chip3.ID, this.NameKey);
}
else
{
this.EnemyDefinition = EnemyDefinition.GetEnemyDefinition(this.ID, this.X, this.Y, this.Rank);
}
if (this.EnemyDefinition != null)
{
this.chips = this.EnemyDefinition.Chips;
if (this.IsNormalNavi)
{
foreach (var c in this.chips)
{
c.CodeNumber = null;
}
}
this.hp = this.EnemyDefinition.HP;
this.name = this.EnemyDefinition.Name;
this.nameKey = this.EnemyDefinition.NameKey;
this.OnPropertyChanged(nameof(this.Chip1));
this.OnPropertyChanged(nameof(this.Chip2));
this.OnPropertyChanged(nameof(this.Chip3));
this.OnPropertyChanged(nameof(this.Chip4));
this.OnPropertyChanged(nameof(this.Chip5));
this.OnPropertyChanged(nameof(this.HP));
this.OnPropertyChanged(nameof(this.Name));
this.OnPropertyChanged(nameof(this.NameKey));
}
}
void AddEnemy()
{
// Generate random enemy position
Room randomRoom = rooms[Random.Range(0, rooms.Count)];
Position randomRoomTilePosition = new Position(randomRoom.position.x + 1 + Random.Range(0, (randomRoom.size.width - 2)),
randomRoom.position.y + 1 + Random.Range(0, randomRoom.size.height - 2));
// Fetch an EnemyDefinition form the database
EnemyDefinition enemyDefinition = enemyDefinitionDatabase.FetchEnemyDefinitionByID(0);
// Create a new enemy gameobject
GameObject enemyClone = (GameObject)Instantiate(slime, new Vector3(0, 0, -1), transform.rotation);
enemyClone.transform.parent = transform;
// give it the correct data
Enemy enemy = enemyClone.GetComponent <Enemy> ();
enemy.definition = enemyDefinition;
enemy.position = randomRoomTilePosition;
enemy.health = enemy.definition.maxHealth; // Give an enemy it's max health at the start
enemies.Add(enemyClone);
}
void NewEnemy(string enemyName, Weapon enemyWeapon,
float enemyExpValue, float enemyChangeValue,
int enemyHealth, int enemySpeed, int enemyDefense,
int enemyLevel, bool bBoss=false)
{
EnemyDefinition enemy;
if(null == enemyWeapon)
return;
enemy = new EnemyDefinition(enemyName, enemyWeapon,
enemyExpValue, enemyChangeValue,
enemyHealth, enemySpeed, enemyDefense,
enemyLevel);
if(true == bBoss)
{
if(null == bosses)
bosses = new Dictionary<int, Dictionary<string, EnemyDefinition>>();
if(false == bosses.ContainsKey(enemyLevel))
bosses[enemyLevel] = new Dictionary<string, EnemyDefinition>();
bosses[enemyLevel].Add(enemy.name, enemy);
}
else
{
if(null == enemies)
enemies = new Dictionary<int, Dictionary<string, EnemyDefinition>>();
if(false == enemies.ContainsKey(enemyLevel))
enemies[enemyLevel] = new Dictionary<string, EnemyDefinition>();
enemies[enemyLevel].Add(enemy.name, enemy);
}
}
public void ShowWaveEventButtons()
{
HideWaveEventButtons();
List <List <Button> > waveEventButtons = new List <List <Button> >();
for (int i = 0; _editor.stage.lanes > i; i++)
{
waveEventButtons.Add(new List <Button>());
Layout layout = new Layout("WaveEvent" + i.ToString() + "Layout", waveEventButtons[i].Count, 1, 0.25f, 0.1f, 1, container, false);
layout.SetLocalPosition(_editor.stage.LaneBy(i).start + (Vector3.left * layout.width * 0.5f));
waveEventLayouts.Add(layout);
Add(layout);
}
for (int i = 0; selectedWaveDefinition.waveEvents.Count > i; i++)
{
int index = i;
int laneIndex = selectedWaveDefinition.waveEvents[index].lane;
WaveEventDefinition waveEvent = selectedWaveDefinition.waveEvents[index];
Lane lane = _editor.stage.LaneBy(laneIndex);
if (waveEventButtons.Count > laneIndex)
{
float width = 1;
float height = 1;
Color color = Color.white;
string name = index.ToString();
switch ((WaveEvent.Type)waveEvent.type)
{
case WaveEvent.Type.SpawnEnemy:
EnemyDefinition enemyDefinition = Definitions.Enemy((Definitions.Enemies)waveEvent.subType);
EnemyLevel enemyLevel = enemyDefinition.levels[waveEvent.level];
width = enemyDefinition.width;
height = lane.height - enemyDefinition.laneHeightPadding;
name = enemyDefinition.name;
color = enemyLevel.color;
break;
case WaveEvent.Type.SpawnItem:
break;
}
Button button = new Button(name, width, height, container, "WaveEvent" + index.ToString(),
fontSize: 20,
Enter: (Button butt) => butt.SetColor(Color.green),
Stay: (Button butt) =>
{
if (Input.GetMouseButtonUp(0))
{
for (int j = 0; waveEventButtons[laneIndex].Count > j; j++)
{
waveEventButtons[laneIndex][j].Hide();
}
butt.Select();
_selectedWaveEvent = waveEvent;
ShowWaveEventEditor(butt, index);
}
if (Input.GetMouseButtonDown(1))
{
selectedWaveDefinition.Remove(waveEvent);
ShowWaveEventButtons();
}
},
Exit: (Button butt) =>
{
if (_editor.timelineEditor.heldWave == null && heldWaveEvent == null && Input.GetMouseButton(0))
{
heldWaveEvent = new HeldEvent(butt.rect.position, width, height, color, waveEvent, laneIndex);
heldWaveEvent.SetText(name);
}
butt.SetColor(color);
},
Close: (Button butt) =>
{
if (Input.GetMouseButtonDown(0) && butt.selected && _waveTypes == null && _enemyLevels == null && _enemyTypes == null && _itemTypes == null && (waveEventEditor == null || !waveEventEditor.containsMouse))
{
HideWaveEventEditor();
butt.Deselect();
for (int j = 0; waveEventButtons[selectedWaveDefinition.waveEvents[index].lane].Count > j; j++)
{
waveEventButtons[selectedWaveDefinition.waveEvents[index].lane][j].Show();
}
}
});
button.SetColor(color);
waveEventButtons[laneIndex].Add(button);
waveEventLayouts[laneIndex].Add(button);
button.SetLocalPosition(new Vector3(waveEvent.entryPoint * lane.width, 1, 0));
}
}
}
public void Init(EnemyDefinition def)
{
stats.def = def;
stats.currHp = def.maxHp;
state = EnemyState.ACTIVE;
// gameObject.layer = LayerMask.NameToLayer("Default");
//set sprite TODO Set animator or sumthin
sr.sprite = SpriteLibrary.I.GetEnemySprite(def.type);
//Set collider
GetComponent<BoxCollider2D>().size = sr.sprite.bounds.size;
//Set AI
switch (def.type) {
case EnemyType.WALKER:
ai = new BuildingDiverAI();
break;
case EnemyType.ROVER:
ai = new StraightDownAI();
break;
case EnemyType.BIKE:
ai = new BuildingDiverAI();
break;
case EnemyType.PLANE:
ai = new StraightDownAI();
break;
default:
break;
}
ai.UpdateGoalPos(transform.position);
}
private static void InitializeGameData()
{
var totalDataToLoad = (double)(LoadingWindowViewModel.Settings.EnemyCount + LoadingWindowViewModel.Settings.ChipCount + LoadingWindowViewModel.Settings.AddOnCount + LoadingWindowViewModel.Settings.InteriorCount + LoadingWindowViewModel.Settings.BackgroundCount);
var dataLoaded = 0;
// Prints multiple NullReferenceExceptions as EnemyBase in ShanghaiEXE has undefined ids caught in the game code
Constants.BaseEnemyDefinitions = new Dictionary <int, EnemyDefinition>();
for (int enemyID = 0; enemyID < LoadingWindowViewModel.Settings.EnemyCount; enemyID++)
{
Constants.BaseEnemyDefinitions[enemyID] = EnemyDefinition.GetEnemyDefinition(enemyID, 0, 0, 1);
dataLoaded++;
Constants.ConstantsLoadProgressEventUpdated?.Invoke(null, new ConstantsLoadProgressEventUpdatedEventArgs("Data: Enemy: ", dataLoaded / totalDataToLoad));
}
Constants.ChipDefinitions = new Dictionary <int, ChipDefinition>();
for (int chipID = 0; chipID < LoadingWindowViewModel.Settings.ChipCount; chipID++)
{
var chipDefinition = ChipDefinition.GetChipDefinition(chipID);
if (chipDefinition != null)
{
Constants.ChipDefinitions[chipID] = chipDefinition;
}
dataLoaded++;
Constants.ConstantsLoadProgressEventUpdated?.Invoke(null, new ConstantsLoadProgressEventUpdatedEventArgs("Data: Chip: ", dataLoaded / totalDataToLoad));
}
Constants.AddOnDefinitions = new Dictionary <int, AddOnDefinition>();
for (int addOnID = 0; addOnID < LoadingWindowViewModel.Settings.AddOnCount; addOnID++)
{
var addOnDefiniton = AddOnDefinition.GetAddOnDefinition(addOnID);
if (addOnDefiniton != null)
{
Constants.AddOnDefinitions[addOnID] = addOnDefiniton;
}
dataLoaded++;
Constants.ConstantsLoadProgressEventUpdated?.Invoke(null, new ConstantsLoadProgressEventUpdatedEventArgs("Data: AddOn: ", dataLoaded / totalDataToLoad));
}
Constants.InteriorDefinitions = new Dictionary <int, string>();
for (int interiorID = 0; interiorID < LoadingWindowViewModel.Settings.InteriorCount; interiorID++)
{
var interiorKey = $"Interior.Item{interiorID + 1}";
if (Constants.TranslationService.CanTranslate(interiorKey))
{
Constants.InteriorDefinitions[interiorID] = Constants.TranslationService.Translate(interiorKey).Text;
}
dataLoaded++;
Constants.ConstantsLoadProgressEventUpdated?.Invoke(null, new ConstantsLoadProgressEventUpdatedEventArgs("Data: Interior: ", dataLoaded / totalDataToLoad));
}
Constants.BackgroundDefinitions = new Dictionary <int, BackgroundDefinition>();
for (int i = 0; i < LoadingWindowViewModel.Settings.BackgroundCount; i++)
{
Constants.BackgroundDefinitions[i] = new BackgroundDefinition(BackgroundBase.BackMake(i));
dataLoaded++;
Constants.ConstantsLoadProgressEventUpdated?.Invoke(null, new ConstantsLoadProgressEventUpdatedEventArgs("Data: Background: ", dataLoaded / totalDataToLoad));
}
CharacterInfo.LoadCharacterInfo(out FloatingCharacters, out NoShadowCharacters);
var keyItemDoc = new XmlDocument();
keyItemDoc.Load($"data/data/KeyItems.xml");
var keyItemDefintions = Constants.LoadKeyItems(keyItemDoc);
Constants.KeyItemDefinitions = new ObservableConcurrentDictionary <int, KeyItemDefinition>();
foreach (var kvp in keyItemDefintions)
{
Constants.KeyItemDefinitions.Add(kvp.Key, kvp.Value);
}
var mailDoc = new XmlDocument();
mailDoc.Load($"data/data/Mail.xml");
var mailDefinitions = Constants.LoadMail(mailDoc);
Constants.MailDefinitions = new ObservableConcurrentDictionary <int, MailDefinition>();
foreach (var kvp in mailDefinitions)
{
Constants.MailDefinitions.Add(kvp.Key, kvp.Value);
}
}
public SpawnEnemyEvent(EnemyDefinition enemyDefinition, WaveEventDefinition waveEventDefinition) : base(waveEventDefinition)
{
this.enemyDefinition = enemyDefinition;
}
