public void Serialize(GenericWriter writer)
{
writer.Write(SpawnedObjects.Count);
for (int i = 0; i < SpawnedObjects.Count; i++)
{
ISpawnable spawn = SpawnedObjects[i];
int serial = spawn.Serial;
writer.Write(serial);
}
writer.Write(Running);
if (m_SpawnTimer != null)
{
writer.Write(true);
writer.WriteDeltaTime(m_NextSpawn);
}
else
{
writer.Write(false);
}
}
public void RemoveSpawns()
{
Defrag();
for (int i = 0; i < m_Entries.Count; i++)
{
SpawnerEntry entry = m_Entries[i];
for (int j = entry.Spawned.Count - 1; j >= 0; j--)
{
ISpawnable e = entry.Spawned[j];
if (e != null)
{
m_Spawned.Remove(e);
entry.Spawned.RemoveAt(j);
e.Delete();
}
}
}
if (m_Running && !IsFull && m_Timer != null && !m_Timer.Running)
{
DoTimer();
}
InvalidateProperties();
}
void Awake()
{
GameObject g = Instantiate(Spawn, transform.position, Quaternion.identity);
ISpawnable sp = g.GetComponent(typeof(ISpawnable)) as ISpawnable;
sp.spawn(gameObject);
}
public void Serialize(GenericWriter writer)
{
writer.Write(0);
writer.Write(SpawnedObjects.Count);
for (var index = 0; index < SpawnedObjects.Count; index++)
{
ISpawnable sp = SpawnedObjects[index];
if (sp is Item item)
{
writer.Write(item);
}
else if (sp is Mobile mobile)
{
writer.Write(mobile);
}
else
{
writer.Write(Serial.MinusOne);
}
}
writer.Write(SpawnName);
writer.Write(MaxCount);
}
public void Replace(ISpawnable oldEntity, ISpawnable newEntity)
{
if (m_State == SpawnState.Active)
{
m_Spawned = newEntity;
}
}
public void Remove(ISpawnable spawnable)
{
/* In this implementation we can ignore the argument since we
* already know it. This is more like a signal function so. */
m_Spawned = null;
if (m_DeactivateOnRemove)
{
m_State = SpawnState.Inactive;
}
else
{
m_State = SpawnState.Respawning;
TimeSpan respawnDelay = GetRespawnDelay();
m_NextSpawn = DateTime.UtcNow + respawnDelay;
m_Timer = Timer.DelayCall(respawnDelay, Respawn);
m_Timer.Start();
}
m_Owner.OnEntityRemoved(spawnable);
}
private void SpawnEnemy()
{
GameObject newSpawnObj = ObjectPool.Instance.GetObject(spawnType.ToPoolObject());
if (newSpawnObj)
{
newSpawnObj.transform.position = ActualSpawnPos;
ISpawnable spawnable = newSpawnObj.GetComponentInChildren <ISpawnable>();
if (!spawnable.HasWillBeenWritten())
{
spawnable.RegisterDeathEvent(ReportDeath);
}
EnemyBase enemyBase = newSpawnObj.GetComponent <EnemyBase>();
if (enemyBase)
{
enemyBase.SpawnWithRagdoll(ActualSpawnPos);
}
EventSystem.Instance.TriggerEvent(Strings.Events.ENEMY_SPAWNED, newSpawnObj);
}
else
{
OnEnemyDeath();
Debug.LogFormat("<color=#ffff00>" + "NOT ENOUGH SPAWN-OBJECTS for: " + spawnType + "</color>");
}
}
/// <summary>
/// 1회 Spawn 수행.
/// </summary>
public override void Start()
{
var pool = PoolManager.GetOrCreate(PrefabName);
Vector3 position = SpawnPosition;
Quaternion rotation = SpawnRotation;
if (RelativeToOwner)
{
position += owner.transform.position;
rotation *= owner.transform.rotation;
}
//풀에서 ISpawnable 객체를 가져온다.
asPooledObject = pool.Instantiate(position, rotation);
asSpawnedObject = asPooledObject.gameObject.GetComponent <FieldObject>() as ISpawnable;
if (asSpawnedObject == null)
{
Debug.LogError("ISpawnable을 구현하지 않은 FieldObject는 Spawn할 수 없습니다 ");
pool.Dispose(asPooledObject);
asPooledObject = null;
return;
}
asSpawnedObject.SpawnOwner = owner;
asSpawnedObject.OnSpawn(owner);
IsActive = true;
}
void ISpawner.Remove(ISpawnable spawn)
{
if (_Spawn != null)
{
_Spawn.Remove(spawn);
}
}
public void Remove(ISpawnable spawn)
{
if (spawn is AncientClayVase vase)
{
RemoveVase(vase);
}
}
public void Serialize(GenericWriter writer)
{
writer.Write((int)this.m_SpawnedObjects.Count);
for (int i = 0; i < this.m_SpawnedObjects.Count; i++)
{
ISpawnable spawn = this.m_SpawnedObjects[i];
int serial = spawn.Serial;
writer.Write((int)serial);
}
writer.Write((bool)this.m_Running);
if (this.m_SpawnTimer != null)
{
writer.Write(true);
writer.WriteDeltaTime((DateTime)this.m_NextSpawn);
}
else
{
writer.Write(false);
}
}
public void Deserialize(GenericReader reader, int version)
{
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
int serial = reader.ReadInt();
ISpawnable spawnableEntity = World.FindEntity(serial) as ISpawnable;
if (spawnableEntity != null)
{
this.Add(spawnableEntity);
}
}
this.m_Running = reader.ReadBool();
if (reader.ReadBool())
{
this.m_NextSpawn = reader.ReadDeltaTime();
if (this.Spawning)
{
if (this.m_SpawnTimer != null)
{
this.m_SpawnTimer.Stop();
}
TimeSpan delay = this.m_NextSpawn - DateTime.UtcNow;
this.m_SpawnTimer = Timer.DelayCall(delay > TimeSpan.Zero ? delay : TimeSpan.Zero, new TimerCallback(TimerCallback));
}
}
this.CheckTimer();
}
public void Remove(ISpawnable spawn)
{
if (spawn is KhaldunChest chest)
{
RemoveChest(chest);
}
}
public static void Spawn(ISpawnable ObjectToSpawn)
{
if (instance == null)
{
Debug.LogError("Trying to access a null spawn pool");
}
}
public virtual Point3D GetSpawnPosition(ISpawnable spawned)
{
Map map = Map;
if (map == null || map == Map.Internal)
{
return(Location);
}
bool waterMob, waterOnlyMob;
if (spawned is Mobile)
{
Mobile mob = (Mobile)spawned;
waterMob = mob.CanSwim;
waterOnlyMob = (mob.CanSwim && mob.CantWalk);
}
else
{
waterMob = false;
waterOnlyMob = false;
}
// Try 10 times to find a Spawnable location.
for (int i = 0; i < 10; i++)
{
int x = Location.X + (Utility.Random((m_HomeRange * 2) + 1) - m_HomeRange);
int y = Location.Y + (Utility.Random((m_HomeRange * 2) + 1) - m_HomeRange);
int z = Map.GetAverageZ(x, y);
int mapZ = map.GetAverageZ(x, y);
if (waterMob)
{
if (Server.Mobiles.Spawner.IsValidWater(map, x, y, this.Z))
{
return(new Point3D(x, y, this.Z));
}
else if (Server.Mobiles.Spawner.IsValidWater(map, x, y, mapZ))
{
return(new Point3D(x, y, mapZ));
}
}
if (!waterOnlyMob)
{
if (map.CanSpawnMobile(x, y, this.Z))
{
return(new Point3D(x, y, this.Z));
}
else if (map.CanSpawnMobile(x, y, mapZ))
{
return(new Point3D(x, y, mapZ));
}
}
}
return(this.Location);
}
IEnumerator SpawnCheeseAway(GameObject spawn)
{
yield return(new WaitForSeconds(Random.Range(0.5f, 1f)));
float altCheese = Random.Range(1.8f, -2.5f);
float max = spawn.transform.position.y - 0.8f;
float min = spawn.transform.position.y + 0.8f;
if (max > 1.5f)
{
max = 1.8f;
}
if (min < -2.4f)
{
min = -2.4f;
}
ISpawnable iPreFab = (ISpawnable)prefabCheese.GetComponent(typeof(ISpawnable));
iPreFab.setMovSpeed(movBallon);
Instantiate(iPreFab.getPreFab(), new Vector3(spawn.transform.position.x + (DisInstance / 2), altCheese, 0), Quaternion.identity);
}
public Session(ISpawnable spawnable, string line_terminator)
{
_spawnable = spawnable;
LineTerminator = line_terminator;
Expect = new ExpectCommands(this);
Send = new SendCommands(this);
}
public void Spawn(int index)
{
Map map = Map;
if (map == null || map == Map.Internal || SpawnNamesCount == 0 || index >= SpawnNamesCount || Parent != null)
{
return;
}
Defrag();
if (CheckSpawnerFull())
{
return;
}
ISpawnable spawned = CreateSpawnedObject(index);
if (spawned == null)
{
return;
}
spawned.Spawner = this;
m_Spawned.Add(spawned);
Point3D loc = (spawned is BaseVendor ? this.Location : GetSpawnPosition(spawned));
spawned.OnBeforeSpawn(loc, map);
spawned.MoveToWorld(loc, map);
spawned.OnAfterSpawn();
if (spawned is BaseCreature)
{
BaseCreature bc = (BaseCreature)spawned;
if (m_WalkingRange >= 0)
{
bc.RangeHome = m_WalkingRange;
}
else
{
bc.RangeHome = m_HomeRange;
}
bc.CurrentWayPoint = m_WayPoint;
bc.SeeksHome = m_MobilesSeekHome;
if (m_Team > 0)
{
bc.Team = m_Team;
}
bc.Home = (m_UsesSpawnerHome) ? this.HomeLocation : bc.Location;
}
InvalidateProperties();
}
public Session(ISpawnable spawnable, string line_terminator, CancellationToken ct)
{
_spawnable = spawnable;
LineTerminator = line_terminator;
Expect = new ExpectCommands(this);
Send = new SendCommands(this);
Ct = ct;
}
private static void CheckForISpawnable(GameObject obj, SpawnAreaName areaName, string objectTag)
{
ISpawnable pooledObject = obj.GetComponent <ISpawnable>();
pooledObject?.SetEnemySpawnName(objectTag);
// TODO: Revisar si se necesita eventualmente
pooledObject?.SetSpawnArea(areaName);
}
public void doSpawn(GameObject preFab)
{
GameObject spawn = preFab;
ISpawnable iPreFab = (ISpawnable)preFab.GetComponent(typeof(ISpawnable));
criaInstancia(iPreFab, spawn);
}
public BoomerangFlyingProjectile(SpriteBatch spriteBatch, Point spawnPosition, Constants.ProjectileOwner owner, ISpawnable itemToTrack, Vector2 velocity) : base(spriteBatch, spawnPosition, owner)
{
sprite = ProjectileSpriteFactory.Instance.CreateBoomerangFlyingSprite();
Velocity = velocity;
returningToOwner = false;
this.itemToTrack = itemToTrack;
projectileType = LinkConstants.ProjectileType.Boomerang;
}
private void DrawList <T>(List <T> list)
{
for (int i = 0; i < list.Count; i++)
{
ISpawnable spawnable = (ISpawnable)list[i];
spawnable.Draw();
}
}
public void Remove(ISpawnable spawn)
{
var chest = spawn as KhaldunChest;
if (chest != null)
{
RemoveChest(chest);
}
}
public void Spawn(ISpawnable s)
{
if (spawned.Count < maxSpawns)
{
float x = transform.position.x + (2 * Random.Range(0, radius) - radius);
float z = transform.position.z + (2 * Random.Range(0, radius) - radius);
spawned.Add(s.Spawn(x, z));
}
}
public void Spawn(int index)
{
Map map = this.Map;
if (map == null || map == Map.Internal || this.SpawnNamesCount == 0 || index >= this.SpawnNamesCount || this.Parent != null)
{
return;
}
this.Defrag();
if (this.CheckSpawnerFull())
{
return;
}
ISpawnable spawned = this.CreateSpawnedObject(index);
if (spawned == null)
{
return;
}
spawned.Spawner = this;
this.m_Spawned.Add(spawned);
Point3D loc = (spawned is BaseVendor ? this.Location : this.GetSpawnPosition(spawned));
spawned.OnBeforeSpawn(loc, map);
this.InvalidateProperties();
spawned.MoveToWorld(loc, map);
if (spawned is BaseCreature)
{
BaseCreature bc = (BaseCreature)spawned;
if (this.m_WalkingRange >= 0)
{
bc.RangeHome = this.m_WalkingRange;
}
else
{
bc.RangeHome = this.m_HomeRange;
}
bc.CurrentWayPoint = this.m_WayPoint;
if (this.m_Team > 0)
{
bc.Team = this.m_Team;
}
bc.Home = this.HomeLocation;
}
}
public void RemoveSpawn(ISpawnable e)
{
SpawnObject so = m_SpawnObjects.FirstOrDefault(s => s.SpawnedObjects.Contains(e));
if (so != null)
{
so.SpawnedObjects.Remove(e);
}
}
/*
* public override bool OnDefragSpawn(ISpawnable spawned, bool remove)
* {
* // To despawn a mob that was lured 4x away from its spawner
* // TODO: Move this to a config
* if (spawned is BaseCreature c && c.Combatant == null && c.GetDistanceToSqrt( Location ) > c.RangeHome * 4)
* {
* c.Delete();
* remove = true;
* }
*
* return base.OnDefragSpawn(entry, spawned, remove);
* }
*/
public override Point3D GetSpawnPosition(ISpawnable spawned, Map map)
{
if (map == null || map == Map.Internal)
{
return(Location);
}
bool waterMob, waterOnlyMob;
if (spawned is Mobile mob)
{
waterMob = mob.CanSwim;
waterOnlyMob = mob.CanSwim && mob.CantWalk;
}
else
{
waterMob = false;
waterOnlyMob = false;
}
// Try 10 times to find a valid location.
for (var i = 0; i < 10; i++)
{
var x = Location.X + (Utility.Random(HomeRange * 2 + 1) - HomeRange);
var y = Location.Y + (Utility.Random(HomeRange * 2 + 1) - HomeRange);
var mapZ = map.GetAverageZ(x, y);
if (waterMob)
{
if (IsValidWater(map, x, y, Z))
{
return(new Point3D(x, y, Z));
}
if (IsValidWater(map, x, y, mapZ))
{
return(new Point3D(x, y, mapZ));
}
}
if (!waterOnlyMob)
{
if (map.CanSpawnMobile(x, y, Z))
{
return(new Point3D(x, y, Z));
}
if (map.CanSpawnMobile(x, y, mapZ))
{
return(new Point3D(x, y, mapZ));
}
}
}
return(HomeLocation);
}
public void Spawn(SpawnObject so)
{
Map map = Map;
if (map == null || map == Map.Internal || SpawnObjectCount == 0 || so == null || Parent != null || GetSpawnCount(so) >= so.MaxCount)
{
return;
}
Defrag();
if (CheckSpawnerFull())
{
return;
}
ISpawnable spawned = CreateSpawnedObject(so);
if (spawned == null)
{
return;
}
spawned.Spawner = this;
so.SpawnedObjects.Add(spawned);
Point3D loc = (spawned is BaseVendor ? Location : GetSpawnPosition(spawned));
spawned.OnBeforeSpawn(loc, map);
InvalidateProperties();
spawned.MoveToWorld(loc, map);
if (spawned is BaseCreature)
{
BaseCreature bc = (BaseCreature)spawned;
if (m_WalkingRange >= 0)
{
bc.RangeHome = m_WalkingRange;
}
else
{
bc.RangeHome = m_HomeRange;
}
bc.CurrentWayPoint = m_WayPoint;
if (m_Team > 0)
{
bc.Team = m_Team;
}
bc.Home = HomeLocation;
}
}
private void Spawn()
{
ISpawnable spawn = this.m_Definition.Spawn(this);
if (spawn != null)
{
this.Add(spawn);
}
}
public virtual Point3D GetSpawnPosition( ISpawnable spawned )
{
Map map = Map;
if ( map == null || map == Map.Internal )
return Location;
bool waterMob, waterOnlyMob;
if ( spawned is Mobile )
{
Mobile mob = (Mobile)spawned;
waterMob = mob.CanSwim;
waterOnlyMob = ( mob.CanSwim && mob.CantWalk );
}
else
{
waterMob = false;
waterOnlyMob = false;
}
// Try 10 times to find a Spawnable location.
for ( int i = 0; i < 10; i++ )
{
int x = Location.X + (Utility.Random( (m_HomeRange * 2) + 1 ) - m_HomeRange);
int y = Location.Y + (Utility.Random( (m_HomeRange * 2) + 1 ) - m_HomeRange);
int z = Map.GetAverageZ( x, y );
int mapZ = map.GetAverageZ( x, y );
if ( waterMob )
{
if ( Server.Mobiles.Spawner.IsValidWater( map, x, y, this.Z ) )
return new Point3D( x, y, this.Z );
else if ( Server.Mobiles.Spawner.IsValidWater( map, x, y, mapZ ) )
return new Point3D( x, y, mapZ );
}
if ( !waterOnlyMob )
{
if ( map.CanSpawnMobile( x, y, this.Z ) )
return new Point3D( x, y, this.Z );
else if ( map.CanSpawnMobile( x, y, mapZ ) )
return new Point3D( x, y, mapZ );
}
}
return this.Location;
}
public override Point3D GetSpawnPosition( ISpawnable spawned, Map map )
{
//Eliminate children on different facets than the chosen map.
List<IChildDistSpawner> children = new List<IChildDistSpawner>( m_Children );
for ( int i = children.Count-1; i >= 0; i-- )
if ( children[i].Map != map || children[i].RootParent != null ) //Not in a container or not on the same map!
children.RemoveAt( i );
if ( children.Count > 0 )
return children[Utility.Random( children.Count )].GetSpawnPosition( spawned );
else
return GetSpawnPosition( spawned );
}
public Point3D GetSpawnPosition(ISpawnable spawned)
{
Map map = Map;
if (map == null)
return Location;
bool waterMob, waterOnlyMob;
if (spawned is Mobile)
{
Mobile mob = (Mobile)spawned;
waterMob = mob.CanSwim;
waterOnlyMob = (mob.CanSwim && mob.CantWalk);
}
else
{
waterMob = false;
waterOnlyMob = false;
}
for (int i = 0; i < 10; ++i)
{
int x = GetAdjustedLocation(m_HomeRange, m_SpawnArea.Width, m_SpawnArea.X, X);
int y = GetAdjustedLocation(m_HomeRange, m_SpawnArea.Height, m_SpawnArea.Y, Y);
int mapZ = map.GetAverageZ(x, y);
if (m_IgnoreHousing || ((BaseHouse.FindHouseAt(new Point3D(x, y, mapZ), Map, 16) == null &&
BaseHouse.FindHouseAt(new Point3D(x, y, this.Z), Map, 16) == null)))
{
if (waterMob)
{
if (IsValidWater(map, x, y, this.Z))
return new Point3D(x, y, this.Z);
else if (IsValidWater(map, x, y, mapZ))
return new Point3D(x, y, mapZ);
}
if (!waterOnlyMob)
{
if (map.CanSpawnMobile(x, y, this.Z))
return new Point3D(x, y, this.Z);
else if (map.CanSpawnMobile(x, y, mapZ))
return new Point3D(x, y, mapZ);
}
}
}
return this.Location;
}
void ISpawner.Remove( ISpawnable spawn )
{
m_SpawnedObjects.Remove( spawn );
CheckTimer();
}
public void Remove(ISpawnable spawn)
{
if (m_SpawnObjects == null) return;
foreach (SpawnObject so in m_SpawnObjects)
{
for (int i = 0; i < so.SpawnedObjects.Count; ++i)
{
if (so.SpawnedObjects[i] == spawn)
{
so.SpawnedObjects.Remove(spawn);
m_killcount++;
return;
}
}
}
}
private void Add(ISpawnable spawn)
{
this.m_SpawnedObjects.Add(spawn);
spawn.Spawner = this;
if (spawn is BaseCreature)
((BaseCreature)spawn).RemoveIfUntamed = this.RemoveIfUntamed;
}
protected virtual void OnAfterSpawn( ISpawnable spawnable )
{
}
public virtual bool IsComponentItem(ISpawnable item)
{
if (item == null)
return false;
if (item == this || (m_TillerMan is Item && item == (Item)m_TillerMan) || item == m_SPlank || item == m_PPlank || item == m_Hold)
return true;
return false;
}
public override bool IsComponentItem(ISpawnable item)
{
return item == this || item == m_Line || item == m_Rudder || item is RudderHandle;
}
void ISpawner.Remove(ISpawnable spawn)
{
this.m_Spawned.Remove(spawn);
this.InvalidateProperties();
}
public Point3D GetSpawnPosition(ISpawnable spawned)
{
Map map = this.Map;
if (map == null)
return this.Location;
bool waterMob, waterOnlyMob;
if (spawned is Mobile)
{
Mobile mob = (Mobile)spawned;
waterMob = mob.CanSwim;
waterOnlyMob = (mob.CanSwim && mob.CantWalk);
}
else
{
waterMob = false;
waterOnlyMob = false;
}
// Try 10 times to find a spawnable location.
for (int i = 0; i < 10; ++i)
{
int x, y;
if (this.m_HomeRange > 0)
{
x = this.Location.X + (Utility.Random((this.m_HomeRange * 2) + 1) - this.m_HomeRange);
y = this.Location.Y + (Utility.Random((this.m_HomeRange * 2) + 1) - this.m_HomeRange);
}
else
{
x = this.Location.X;
y = this.Location.Y;
}
int mapZ = map.GetAverageZ(x, y);
if (waterMob)
{
if (IsValidWater(map, x, y, this.Z))
return new Point3D(x, y, this.Z);
else if (IsValidWater(map, x, y, mapZ))
return new Point3D(x, y, mapZ);
}
if (!waterOnlyMob)
{
if (map.CanSpawnMobile(x, y, this.Z))
return new Point3D(x, y, this.Z);
else if (map.CanSpawnMobile(x, y, mapZ))
return new Point3D(x, y, mapZ);
}
}
return this.Location;
}
public virtual Point3D GetSpawnPosition( ISpawnable spawn )
{
return base.GetSpawnPosition( spawn, Map );
}
public SpawnInstance( GenericReader reader, CreatureSpawner owner )
{
m_Owner = owner;
m_State = (SpawnState) reader.ReadInt();
m_DeactivateOnRemove = reader.ReadBool();
switch ( m_State )
{
// TODO: It seems a good place to use the State pattern...
case SpawnState.Inactive:
break;
case SpawnState.Active:
m_Spawned = World.Instance.FindEntity( reader.ReadInt() ) as ISpawnable;
if ( m_Spawned != null )
m_Spawned.Spawner = this;
else
m_State = SpawnState.Inactive;
break;
case SpawnState.Respawning:
m_NextSpawn = reader.ReadDateTime();
TimeSpan delay = m_NextSpawn - DateTime.Now;
if ( delay.TotalMilliseconds < 0 )
delay = TimeSpan.Zero;
m_Timer = Timer.DelayCall( delay, Respawn );
break;
}
}
public void Remove( ISpawnable spawn )
{
//spawn.Delete();
}
void ISpawner.Remove(ISpawnable spawn)
{
m_Spawned.Remove(spawn);
InvalidateProperties();
}
public override bool IsComponentItem(ISpawnable spawnable)
{
if (!(spawnable is Item))
return false;
Item item = (Item)spawnable;
if (m_MooringLines.Contains(item) || m_Cannons.Contains(item) || m_CannonTiles.Contains(item)
|| m_FillerTiles.Contains(item) || m_HoldTiles.Contains(item) || m_Addons.Contains(item) || item == m_Wheel || item == m_GalleonHold)
return true;
return base.IsComponentItem(spawnable);
}
public void OnEntityRemoved( ISpawnable spawnable )
{
if ( Group && TotalSpawned == 0 )
{
if ( m_GroupRespawnTimer != null )
{
m_GroupRespawnTimer.Stop();
m_GroupRespawnTimer = null;
}
TimeSpan delay = TimeSpan.FromSeconds( Utility.RandomMinMax( (int) m_MinDelay.TotalSeconds, (int) m_MaxDelay.TotalSeconds ) );
m_GroupRespawnTimer = Timer.DelayCall( delay, GroupRespawn );
m_NextGroupRespawn = DateTime.Now + delay;
}
InvalidateProperties();
}
public void Respawn()
{
Despawn();
ISpawnable spawnable = m_Owner.Spawn();
if ( spawnable != null )
{
spawnable.Spawner = this;
m_Spawned = spawnable;
m_State = SpawnState.Active;
}
m_Owner.OnEntityAdded( spawnable );
}
public void OnEntityAdded( ISpawnable spawnable )
{
InvalidateProperties();
}
public void Replace( ISpawnable oldEntity, ISpawnable newEntity )
{
if ( m_State == SpawnState.Active )
{
m_Spawned = newEntity;
}
}
void ISpawner.Remove(ISpawnable spawn)
{
this.m_SpawnedObjects.Remove(spawn);
this.CheckTimer();
}
public void Remove( ISpawnable spawnable )
{
/* In this implementation we can ignore the argument since we
* already know it. This is more like a signal function so. */
m_Spawned = null;
if ( m_DeactivateOnRemove )
{
m_State = SpawnState.Inactive;
}
else
{
m_State = SpawnState.Respawning;
TimeSpan respawnDelay = GetRespawnDelay();
m_NextSpawn = DateTime.Now + respawnDelay;
m_Timer = Timer.DelayCall( respawnDelay, Respawn );
m_Timer.Start();
}
m_Owner.OnEntityRemoved( spawnable );
}
public void Remove(ISpawnable spawn)
{
if (m_SpawnObjects == null)
{
return;
}
foreach (SpawnObject so in m_SpawnObjects)
{
for (int i = 0; i < so.SpawnedObjects.Count; ++i)
{
if (so.SpawnedObjects[i] == spawn)
{
so.SpawnedObjects.Remove(spawn);
// if sequential spawning is active and the RestrictKillsToSubgroup flag is set, then check to see if
// the object is in the current subgroup before adding to the total
// Rel Por: NOTE it seems like this was supposed to be handled in Defrag.. not sure why it is handled here?... in any case I added it here - mob
if (SequentialSpawn >= 0 && so.RestrictKillsToSubgroup)
{
if (so.SubGroup == SequentialSpawn)
{
m_killcount++;
}
}
else
{
// just add it
m_killcount++;
}
return;
}
}
}
}
public void Remove(ISpawnable spawn)
{
}
private void Initialize( CreatureSpawner owner, bool deactivateOnRemove, SpawnState initialState, ISpawnable initialSpawned, Timer initialTimer )
{
m_Owner = owner;
m_DeactivateOnRemove = deactivateOnRemove;
m_State = initialState;
m_Spawned = initialSpawned;
m_Timer = initialTimer;
}
public void Remove( ISpawnable spawn )
{
Defrag();
if ( spawn != null )
{
SpawnerEntry entry;
m_Spawned.TryGetValue( spawn, out entry );
if ( entry != null )
entry.Spawned.Remove( spawn );
m_Spawned.Remove( spawn );
}
if ( m_Running && !IsFull && m_Timer != null && !m_Timer.Running )
DoTimer();
}
