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);
}
}
}
