public override void CopyValues(ScrObjLibraryEntry other) { base.CopyValues(other); EnemyEntry ee = (EnemyEntry)other; // General enemyModelN = ee.enemyModelN; enemyModelS = ee.enemyModelS; maxhp = ee.maxhp; speed = ee.speed; // AI values waitStates = new List <StateController.WaitStates>(); for (int i = 0; i < ee.waitStates.Count; i++) { waitStates.Add(ee.waitStates[i]); } waitTimeLimits = new RangedFloat(ee.waitTimeLimits.minValue, ee.waitTimeLimits.maxValue); chaseTimeLimit = ee.chaseTimeLimit; fleeDistance = ee.fleeDistance; fleeTimeLimit = ee.fleeTimeLimit; // Attacking meleeRange = ee.meleeRange; attackRate = ee.attackRate; attacks = ee.attacks; meleeTimeStartup = ee.meleeTimeStartup; meleeTimeAnimation = ee.meleeTimeAnimation; // Reward exp = ee.exp; money = ee.money; //Add some kind of loot table }
void InstansiateEnemy() { GUI.FocusControl(null); if (enemyLibrary.ContainsID(enemyUuid)) { Debug.Log("uuid already exists!"); return; } EnemyEntry ee = Editor.CreateInstance <EnemyEntry>(); ee.name = enemyUuid; ee.uuid = enemyUuid; ee.entryName = enemyUuid; ee.repColor = repColor; string path = "Assets/LibraryData/Enemies/" + enemyUuid + ".asset"; enemyLibrary.InsertEntry(ee, 0); Undo.RecordObject(enemyLibrary, "Added enemy"); EditorUtility.SetDirty(enemyLibrary); AssetDatabase.CreateAsset(ee, path); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); currentEntryList = enemyLibrary.GetRepresentations("", filterStr); enemyUuid = ""; selEnemy = 0; SelectEnemy(); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //void TakeDamage(EnemyEntry, float, bool) // //Calculates damage from an enemy attack // //For balancing difficulty, I am considering allowing only certain enemies to crit, so LUCK is not considered for now// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public void TakeDamage(EnemyEntry otherStats, float baseDamage, bool isMagical) { if (iframesTimer < iframes) { //iframes are active, take no damage// return; } int damage = 0; if (DamageCalculator.Hits(stats.GetAGI(), otherStats.enemyAGI)) { if (isMagical) { damage = DamageCalculator.CalculateMagicalDamage(otherStats.enemyMATK, baseDamage, stats.GetMDEF()); } else { damage = DamageCalculator.CalculatePhysicalDamage(otherStats.enemyATK, baseDamage, stats.GetDEF()); } } currentHP -= damage; if (currentHP <= 0) { currentHP = 0; HandleDeath(); } iframesTimer = 0; }
public virtual void SpawnEnemies() { EnemyEntry[] _enemyEntries = enemyEntries; EnemyEntry nextEnemyEntry = null; int indexOfNextEnemyEntry; while (idealDifficulty - difficulty >= minEnemyDifficulty) { while (true) { indexOfNextEnemyEntry = Random.Range(0, _enemyEntries.Length); nextEnemyEntry = _enemyEntries[indexOfNextEnemyEntry]; if (difficulty + nextEnemyEntry.enemyPrefab.difficulty > idealDifficulty) { _enemyEntries = _enemyEntries.RemoveAt(indexOfNextEnemyEntry); } else { break; } } difficulty += nextEnemyEntry.enemyPrefab.difficulty; StartCoroutine(nextEnemyEntry.Spawn()); } }
/// <summary> /// Creates an enemy for the spirit side of the battlefield. /// </summary> /// <param name="values"></param> /// <param name="group"></param> /// <param name="index"></param> private void CreateS(EnemyEntry values, EnemyGroup group) { if (!spawnTop) { return; } ggobjS = Instantiate(values.enemyModelS) as Transform; int side = Random.Range(0, 2); SStateController state = ggobjS.GetComponent <SStateController>(); HurtableEnemyScript hurt = ggobjS.GetComponent <HurtableEnemyScript>(); AttackScript attack = ggobjS.GetComponent <AttackScript>(); if (side == 0) { state.leftSide = true; } ggobjS.position = state.GetRandomLocation(); hurt.group = group; state.enemyid = enemyId; state.values = ScriptableObject.CreateInstance <EnemyEntry>(); state.values.CopyValues(values); group.top = hurt; group.sStateController = state; group.sTransform = ggobjS; group.sAttackScript = attack; }
public static void AddEnemyEntry(EnemyEntry entry) { Tuple <Entry.Type, int> last = PlayerData.enemyTally.Keys.Last(); PlayerData.enemyTally.Add(last, entry); // Debug.Log (last); }
void SaveSelectedEnemy() { EnemyEntry ee = (EnemyEntry)enemyLibrary.GetEntryByIndex(selEnemy); ee.CopyValues(enemyValues); Undo.RecordObject(ee, "Updated enemy"); EditorUtility.SetDirty(ee); }
public static void UpdateEnemyEntry(Tuple <Entry.Type, int> key, EnemyEntry entry) { if (PlayerData.enemyTally.ContainsKey(key)) { PlayerData.enemyTally [key] = entry; } PrintEnemyDictionary(); }
/// <summary> /// Creates an enemy group with the given enemy index. /// </summary> /// <param name="index"></param> /// <returns></returns> private EnemyGroup CreateGroup(EnemyEntry ee) { EnemyGroup group = new EnemyGroup(enemyId, ee.maxhp); enemyId++; group.deadEnemy = deadEnemy; CreateN(ee, group); CreateS(ee, group); return(group); }
public void SetEnemyStats(EnemyEntry enemyData) { id = enemyData.id; type = enemyData.type; Health = enemyData.health; maxHealth = enemyData.maxHealth; transform.position = enemyData.position; healthBar.maxValue = maxHealth; }
void SelectEnemy() { GUI.FocusControl(null); // Nothing selected if (selEnemy == -1) { enemyValues.ResetValues(); } else { // Something selected EnemyEntry ee = (EnemyEntry)enemyLibrary.GetEntryByIndex(selEnemy); enemyValues.CopyValues(ee); } }
//SPAWNING private void SpawnEnemy(EnemyType type, float health) { EnemyEntry enemyData = new EnemyEntry(); enemyData.type = type; enemyData.position = new Vector3(6, 7.8f, 0); enemyData.health = health; enemyData.maxHealth = health; enemyData.id = ObjectsHolder.ins.GenerateID(); loadedEnemy = Instantiate(enemyArray[(int)type], enemyData.position, Quaternion.identity); loadedEnemy.GetComponent <EnemyAI>().SetEnemyStats(enemyData); ObjectsHolder.ins.AddToActiveObjects(enemyData); }
void DeleteEnemy() { GUI.FocusControl(null); EnemyEntry ee = (EnemyEntry)enemyLibrary.GetEntryByIndex(selEnemy); string path = "Assets/LibraryData/Enemies/" + ee.uuid + ".asset"; enemyLibrary.RemoveEntryByIndex(selEnemy); Undo.RecordObject(enemyLibrary, "Deleted enemy"); EditorUtility.SetDirty(enemyLibrary); bool res = AssetDatabase.MoveAssetToTrash(path); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); if (res) { Debug.Log("Removed enemy: " + ee.uuid); selEnemy = -1; } }
/// <summary> /// Creates an enemy for the normal side of the battlefield. /// </summary> /// <param name="values"></param> /// <param name="group"></param> /// <param name="index"></param> private void CreateN(EnemyEntry values, EnemyGroup group) { if (!spawnBottom) { return; } ggobjN = Instantiate(values.enemyModelN) as Transform; NStateController state = ggobjN.GetComponent <NStateController>(); HurtableEnemyScript hurt = ggobjN.GetComponent <HurtableEnemyScript>(); AttackScript attack = ggobjN.GetComponent <AttackScript>(); ggobjN.position = state.GetRandomLocation(); hurt.group = group; state.enemyid = enemyId; state.values = ScriptableObject.CreateInstance <EnemyEntry>(); state.values.CopyValues(values); group.bot = hurt; group.nStateController = state; group.nTransform = ggobjN; group.nAttackScript = attack; }
public unsafe void RefreshEnemy() { for (int i = 0; i < Memory.Enemy.Length; ++i) { EnemyEntry entry = Memory.Enemy[i]; IntPtr pointer = Pointers.Enemy[i]; fixed(byte *p = entry._typeMem) { byte[] value = new byte[entry._typeMem.Length]; entry._typeMem.CopyTo(value, 0); _processMemory.TryGetByteArrayAt(IntPtr.Add(pointer, 0x90A), 7, (IntPtr)p); if (!value.Equals(entry._typeMem)) { entry._type = BitConverter.ToInt64(entry._typeMem); entry.SendUpdateEvent("IsEmpty", "Type", "Name", "DebugMessage"); } } if (entry.Type == EnemyEnumeration.Undead) { entry.SetField(_processMemory, Pointers.ZombieMaxHP, ref entry._maximumHP, "IsAlive", "MaximumHP", "Percentage", "HealthMessage", "DebugMessage"); } else { entry.MaximumHP = 100; } entry.SetField(_processMemory, IntPtr.Add(pointer, 0x6C), ref entry._currentHP, "IsAlive", "CurrentHP", "DisplayHP", "Percentage", "HealthMessage", "DebugMessage"); if (entry.Room.SetField(_processMemory, IntPtr.Add(pointer, 0x76), ref entry.Room._id, "Id")) { entry.SendUpdateEvent("DebugMessage"); } } }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //void TakeTouchDamage(EnemyEntry) // //Calculates enemy touch damage (contact with the enemy hitbox) // //For balancing difficulty, I am considering allowing only certain enemies to crit, so LUCK is not considered for now// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public void TakeTouchDamage(EnemyEntry otherStats) { if (iframesTimer < iframes) { //iframes are active, take no damage// return; } if (DamageCalculator.Hits(otherStats.enemyAGI, stats.GetAGI())) { int damage = DamageCalculator.CalculatePhysicalDamage(otherStats.enemyATK, 1f, stats.GetDEF()); currentHP -= damage; if (currentHP <= 0) { currentHP = 0; HandleDeath(); } } iframesTimer = 0; }
public static void RemoveEnemyEntry(EnemyEntry entry) { Tuple <Entry.Type, int> key = PlayerData.enemyTally.FirstOrDefault(x => x.Value == entry).Key; PlayerData.enemyTally.Remove(key); }
private void LoadEnemy(EnemyEntry enemy) { loadedEnemy = Instantiate(enemiesArray[(int)enemy.type], enemy.position, Quaternion.identity); loadedEnemy.GetComponent <EnemyAI>().SetEnemyStats(enemy); ObjectsHolder.ins.AddToActiveObjects(enemy); }
public void RefreshEnemy() { if (!Memory.Room.IsLoaded) { for (int i = 0; i < Memory.Enemy.Length; i++) { Memory.Enemy[i].Clear(); } return; } IntPtr pointer = new IntPtr(Pointers.Enemy.ToInt64()); int entryOffset = Memory.Version.Console == ConsoleEnumeration.PS3 ? 0x0578 : Memory.Version.Console == ConsoleEnumeration.PS2 ? 0x0580 : 0x0570; int slotOffset = Memory.Version.Console == ConsoleEnumeration.GC ? 0x038C : 0x039C; int damageOffset = Memory.Version.Console == ConsoleEnumeration.GC ? 0x0564 : 0x0574; int healthOffset = Memory.Version.Console == ConsoleEnumeration.GC ? 0x040C : 0x041C; int modelOffset = Memory.Version.Console == ConsoleEnumeration.PS3 ? 0x0088 : 0x008B; int index = 0; int count = _process.ReadValue <int>(Pointers.EnemyCount, Emulator.IsBigEndian); for (int i = 0; i < count; ++i) { EnemyEnumeration type = GetEnemyType(_process.ReadValue <short>(IntPtr.Add(pointer, 0x0004), Emulator.IsBigEndian)); if (type != EnemyEnumeration.Unknown) { EnemyEntry entry = Memory.Enemy[index]; entry.Type = type; entry.Room = Memory.Room; entry.Slot = _process.ReadValue <int>(IntPtr.Add(pointer, slotOffset), Emulator.IsBigEndian); entry.Damage = _process.ReadValue <int>(IntPtr.Add(pointer, damageOffset), Emulator.IsBigEndian); entry.CurrentHP = _process.ReadValue <int>(IntPtr.Add(pointer, healthOffset), Emulator.IsBigEndian); // Not sure what to call these values. They are useful to help determine enemy life status. entry.Action = _process.ReadValue <byte>(IntPtr.Add(pointer, 0x000C)); entry.Status = _process.ReadValue <byte>(IntPtr.Add(pointer, 0x000F)); entry.Model = _process.ReadValue <byte>(IntPtr.Add(pointer, modelOffset)); switch (entry.Type) { case EnemyEnumeration.Tenticle: entry.MaximumHP = 160; entry.IsAlive = entry.Active && entry.CurrentHP >= 0 && entry.Model == 0 && entry.Room.Id != 0x091E; break; case EnemyEnumeration.GlupWorm: entry.MaximumHP = 300; entry.IsAlive = entry.Active && entry.Status > 0; break; case EnemyEnumeration.AnatomistZombie: entry.MaximumHP = 200; entry.IsAlive = entry.Active && entry.Status > 0; break; case EnemyEnumeration.Tyrant: entry.MaximumHP = entry.Room.Id == 0x0501 ? 700 : 500; entry.IsAlive = entry.Active && entry.CurrentHP >= 0; break; case EnemyEnumeration.Nosferatu: entry.MaximumHP = 600; entry.IsAlive = entry.Active && entry.Model == 0; break; case EnemyEnumeration.AlbinoidAdult: case EnemyEnumeration.MutatedSteve: entry.MaximumHP = 250; entry.IsAlive = entry.Active && entry.Model == 0; break; case EnemyEnumeration.GiantBlackWidow: entry.MaximumHP = 250; entry.IsAlive = entry.Active && entry.Status > 0; break; case EnemyEnumeration.AlexiaAshford: entry.MaximumHP = 300; entry.IsAlive = entry.Active && entry.Room.Id != 0x091E; break; case EnemyEnumeration.AlexiaAshfordB: entry.MaximumHP = 700; entry.IsAlive = entry.Active; break; case EnemyEnumeration.AlexiaAshfordC: entry.MaximumHP = 400; entry.IsAlive = !Memory.Enemy[0].IsAlive; break; case EnemyEnumeration.AlexiaBaby: entry.IsAlive = Memory.Enemy[0].IsAlive; break; case EnemyEnumeration.Hunter: entry.IsAlive = entry.Active && entry.Model == 0; break; default: entry.IsAlive = entry.Active && entry.Status > 0; break; } entry.IsEmpty = false; entry.SendUpdateEntryEvent(); if (++index >= Memory.Enemy.Length) { break; } } pointer = IntPtr.Add(pointer, entryOffset); } for (int i = index; i < Memory.Enemy.Length; i++) { Memory.Enemy[i].Clear(); } }
public void AddToActiveObjects(EnemyEntry enemy) { enemies.Add(enemy); }
public EnemyEditorWindow(ScrObjLibraryVariable entries, EnemyEntry container) { enemyLibrary = entries; enemyValues = container; LoadLibrary(); }
private void RenderOverlay() { Point textSize; int xWidth = 216; int yHeight = 29; int yMargin = 10; int alignX = _graphics.Width - xWidth; int alignY = 0; int baseX = alignX - 10; int baseY = alignY + 10; int offsetX = baseX; int offsetY = baseY; for (int i = 0; i < _gameMemory.Characters.Length; ++i) { CharacterEntry entry = _gameMemory.Characters[i]; SolidBrush healthBrush; if (!entry.IsAlive) { healthBrush = _red; } else if (entry.IsPoison) { healthBrush = _violet; } else if (entry.IsCaution) { healthBrush = _gold; } else if (entry.IsDanger) { healthBrush = _red; } else { healthBrush = _green; } int imageX = offsetX; int imageY = offsetY += i > 0 ? CHR_SLOT_HEIGHT : 0; int textX = imageX + CHR_SLOT_WIDTH + 2; int textY = imageY + 1; SharpDX.Mathematics.Interop.RawRectangleF drawRegion = new SharpDX.Mathematics.Interop.RawRectangleF(imageX, imageY, CHR_SLOT_WIDTH, CHR_SLOT_HEIGHT); SharpDX.Mathematics.Interop.RawRectangleF imageRegion; if (_characterToImageTranslation.ContainsKey(entry.Character)) { imageRegion = _characterToImageTranslation[entry.Character]; } else { imageRegion = new SharpDX.Mathematics.Interop.RawRectangleF(0, 0, CHR_SLOT_WIDTH, CHR_SLOT_HEIGHT); } imageRegion.Right += imageRegion.Left; imageRegion.Bottom += imageRegion.Top; drawRegion.Right += drawRegion.Left; drawRegion.Bottom += drawRegion.Top; if (_characterToImageTranslation.ContainsKey(entry.Character)) { _device.DrawBitmap(_characterSheet, drawRegion, (float)Config.Opacity / 255, SharpDX.Direct2D1.BitmapInterpolationMode.Linear, imageRegion); } DrawProgressBar(_darkergrey, healthBrush, textX, textY, 172, 36, entry.CurrentHP, entry.MaximumHP); DrawText(_consolas14Bold, _white, textX + 5, textY + 10, entry.HealthMessage); } if (Config.ShowTimer) { int timerX = offsetX + 3; int timerY = offsetY += CHR_SLOT_HEIGHT; textSize = DrawText(_consolas32Bold, _white, timerX, timerY, _gameMemory.IGT.FormattedString); offsetY += (int)textSize.Y + yMargin; } else { offsetY += CHR_SLOT_HEIGHT + yMargin; } if (Config.Debug) { textSize = DrawText(_consolas16Bold, _grey, offsetX, offsetY, String.Format("T: {0:0000000000}", _gameMemory.IGT.FrameCount.ToString("D10"))); offsetY += (int)textSize.Y; textSize = DrawText(_consolas16Bold, _grey, offsetX, offsetY, String.Format("P: {0}", _gameMemory.Process.ProcessName)); offsetY += (int)textSize.Y; textSize = DrawText(_consolas16Bold, _grey, offsetX, offsetY, String.Format("I: {0}", _gameMemory.Process.Id.ToString())); offsetY += (int)textSize.Y + yMargin; } if (Config.ShowEnemy) { int headerX = offsetX + 3; int headerY = offsetY; textSize = DrawText(_consolas16Bold, _red, headerX, headerY, "Enemy HP"); offsetY += (int)textSize.Y + yMargin; int index = -1; for (int i = 0; i < _gameMemory.Enemy.Length; ++i) { EnemyEntry enemy = _gameMemory.Enemy[i]; if (enemy.IsEmpty) { continue; } int healthX = offsetX - 2; int healthY = offsetY += ++index > 0 ? yHeight : 0; DrawProgressBar(_darkergrey, _darkred, healthX, healthY, xWidth, yHeight, enemy.DisplayHP, enemy.MaximumHP); DrawText(_consolas14Bold, _red, healthX + 5, healthY + 5, enemy.HealthMessage); } } }