public NPCPlayer CreateNPCPlayer(LocatorService ls)
{
string username = _npcNameProvider.GetRandomName(2, a => { return(a[0] + " " + a[1]); });
while (_usernameToPlayer.ContainsKey(username.ToLower()))
{
username += _npcNameProvider.GetRandomName();
}
var p = new NPCPlayer(_playerIDManager.PopFreeID(), username, ls);
//p.area = new Area();
_objects.TryAdd(p.Id, p);
_usernameToPlayer.TryAdd(username, p);
if (!_usernameToPlayer.ContainsKey(username.ToLower()))
{
// Any player that has Caps in their name is added twice
_usernameToPlayer.TryAdd(username.ToLower(), p);
}
p.CashOnHand = 1000000; // I am a kind god ;D
return(p);
}
public float GetAIAimcone()
{
NPCPlayer ownerPlayer = base.GetOwnerPlayer() as NPCPlayer;
if (!ownerPlayer)
{
return(this.aiAimCone);
}
return(ownerPlayer.GetAimConeScale() * this.aiAimCone);
}
public float GetAIAimcone()
{
NPCPlayer nPCPlayer = GetOwnerPlayer() as NPCPlayer;
if ((bool)nPCPlayer)
{
return(nPCPlayer.GetAimConeScale() * aiAimCone);
}
return(aiAimCone);
}
public BTNPCPlayer(NPCPlayer player, MainPlayer main)
{
npc = player;
mainPlayer = main;
constructCountQuery = new QueryList <ConstructId, float>();
agentCountQuery = new QueryList <Soldier, float>();
InitBT();
ResetAgentCheckUpdated();
}
void UpdateDeath(Message m)
{
DeathInfo info = m.deathInfo;
if (info.id != player.Id)
{
NPCPlayer p = playersList[info.id].transform.gameObject.GetComponent <NPCPlayer>();
p.Die();
ScoreUpdate(info);
}
}
private void Start()
{
MainPlayer player = FindObjectOfType <MainPlayer>();
NPCPlayer npc = GetComponent <NPCPlayer>();
decisionTree = new BTNPCPlayer(player: npc, main: player)
{
LocationOffset = this.LocationOffset,
ConstructPrice = this.ConstructPrice,
AgentPrice = this.AgentPrice,
};
}
public virtual bool ShotTest()
{
AttackEntity heldEntity = base.GetHeldEntity() as AttackEntity;
if (heldEntity == null)
{
return(false);
}
BaseProjectile baseProjectile = heldEntity as BaseProjectile;
if (baseProjectile)
{
if (baseProjectile.primaryMagazine.contents <= 0)
{
baseProjectile.ServerReload();
NPCPlayerApex nPCPlayerApex = this as NPCPlayerApex;
if (nPCPlayerApex && nPCPlayerApex.OnReload != null)
{
nPCPlayerApex.OnReload();
}
return(false);
}
if (baseProjectile.NextAttackTime > Time.time)
{
return(false);
}
}
if (Mathf.Approximately(heldEntity.attackLengthMin, -1f))
{
heldEntity.ServerUse(this.damageScale);
this.lastGunShotTime = Time.time;
return(true);
}
NPCPlayer nPCPlayer = this;
if (base.IsInvoking(new Action(nPCPlayer.TriggerDown)))
{
return(true);
}
if (Time.time < this.nextTriggerTime)
{
return(true);
}
NPCPlayer nPCPlayer1 = this;
base.InvokeRepeating(new Action(nPCPlayer1.TriggerDown), 0f, 0.01f);
this.triggerEndTime = Time.time + UnityEngine.Random.Range(heldEntity.attackLengthMin, heldEntity.attackLengthMax);
this.TriggerDown();
return(true);
}
protected override Player _instantiateObject(IDBObject pm, LocatorService ls)
{
PlayerModel model = pm as PlayerModel;
if (model.PlayerType == PlayerTypes.Human)
{
return(new HumanPlayer(model, ls));
}
else
{
var p = new NPCPlayer(model, ls);
p.MessageService = new RedisOutgoingMessageService(_redisServer, p);
return(p);
}
}
public virtual void TriggerDown()
{
AttackEntity heldEntity = base.GetHeldEntity() as AttackEntity;
if (heldEntity != null)
{
heldEntity.ServerUse(this.damageScale);
}
this.lastGunShotTime = Time.time;
if (Time.time > this.triggerEndTime)
{
NPCPlayer nPCPlayer = this;
base.CancelInvoke(new Action(nPCPlayer.TriggerDown));
this.nextTriggerTime = Time.time + (heldEntity != null ? heldEntity.attackSpacing : 1f);
}
}
public ActorObj CreateAvatar(int avatarType)
{
ActorObj actor = null;
AvatarType type = (AvatarType)avatarType;
switch (type)
{
case AvatarType.NPC_Player:
actor = new NPCPlayer();
break;
case AvatarType.NPC_Enemy:
actor = new NPCEnemy();
break;
default:
break;
}
return(actor);
}
private void UpdateHits(Message m)
{
HitInfo HI = m.hitInfo;
if (HI.hitId != player.Id && playersList.ContainsKey(HI.hitId))
{
NPCPlayer p = playersList[HI.hitId].GetComponent <NPCPlayer>();
Entity shooter = null;
if (HI.shooter != null)
{
if (playersList.ContainsKey(HI.shooter))
{
shooter = playersList[HI.hitId].GetComponent <Entity>();
}
}
p.ReceiveDamage(HI.healthDamage, HI.shieldDamage, shooter);
}
}
private void SpawnNewPlayer(Message m)
{
GameObject playerGO = Instantiate(enemyPlayerPrefab, new Vector3(m.PlayerInfo.X, m.PlayerInfo.Y, m.PlayerInfo.Z), Quaternion.identity);
// playerGO.GetComponent<PlayerUiController>().playerName.text = m.PlayerInfo.Name;
playersList.Add(m.PlayerInfo.Id, playerGO);
if (mainPlayer != null)
{
mainPlayer.SendMovementInfo();
}
else
{
Debug.Log("Player was null");
}
NPCPlayer p = playerGO.GetComponent <NPCPlayer>();
p.nickName = m.PlayerInfo.Name;
p.id = m.PlayerInfo.Id;
p.alive = m.PlayerInfo.alive;
playerGO.SetActive(m.PlayerInfo.alive);
}
/// <summary>
/// Moves the goal pin to the next random position.
/// </summary>
protected void MoveGoalPin(NPCPlayer player)
{
GameObject pin = GameObject.FindGameObjectWithTag("Goal");
if(pin != null)
{
// Random labyrinth position based on its size
Vector3 randomLabyrinthPosition = CalculateRandomPointInLabyrinth();
// Sample position on navmesh
NavMeshHit hit;
bool found = NavMesh.SamplePosition(randomLabyrinthPosition, out hit, 10f, NavMesh.AllAreas);
if (found)
{
pin.transform.position = hit.position;
}
}
}
private void Awake()
{
S = this;
num = 0; //Counter for minimax
maxLevel = 16;
}
public override void ServerUse(float damageModifier, Transform originOverride = null)
{
if (base.isClient || HasAttackCooldown())
{
return;
}
BasePlayer ownerPlayer = GetOwnerPlayer();
bool flag = ownerPlayer != null;
if (primaryMagazine.contents <= 0)
{
SignalBroadcast(Signal.DryFire);
StartAttackCooldownRaw(1f);
return;
}
primaryMagazine.contents--;
if (primaryMagazine.contents < 0)
{
primaryMagazine.contents = 0;
}
bool flag2 = flag && ownerPlayer.IsNpc;
if (flag2 && (ownerPlayer.isMounted || ownerPlayer.GetParentEntity() != null))
{
NPCPlayer nPCPlayer = ownerPlayer as NPCPlayer;
if (nPCPlayer != null)
{
nPCPlayer.SetAimDirection(nPCPlayer.GetAimDirection());
}
else
{
HTNPlayer hTNPlayer = ownerPlayer as HTNPlayer;
if (hTNPlayer != null)
{
hTNPlayer.AiDomain.ForceProjectileOrientation();
hTNPlayer.ForceOrientationTick();
}
}
}
StartAttackCooldownRaw(repeatDelay);
UnityEngine.Vector3 vector = (flag ? ownerPlayer.eyes.position : MuzzlePoint.transform.position);
UnityEngine.Vector3 inputVec = MuzzlePoint.transform.forward;
if (originOverride != null)
{
vector = originOverride.position;
inputVec = originOverride.forward;
}
ItemModProjectile component = primaryMagazine.ammoType.GetComponent <ItemModProjectile>();
SignalBroadcast(Signal.Attack, string.Empty);
Projectile component2 = component.projectileObject.Get().GetComponent <Projectile>();
BaseEntity baseEntity = null;
if (flag && ownerPlayer.IsNpc && AI.npc_only_hurt_active_target_in_safezone && ownerPlayer.InSafeZone())
{
IAIAgent iAIAgent = ownerPlayer as IAIAgent;
if (iAIAgent != null)
{
baseEntity = iAIAgent.AttackTarget;
}
else
{
IHTNAgent iHTNAgent = ownerPlayer as IHTNAgent;
if (iHTNAgent != null)
{
baseEntity = iHTNAgent.MainTarget;
}
}
}
bool flag3 = flag && ownerPlayer is IHTNAgent;
if (flag)
{
inputVec = ((!flag3) ? ownerPlayer.eyes.BodyForward() : (ownerPlayer.eyes.rotation * UnityEngine.Vector3.forward));
}
for (int i = 0; i < component.numProjectiles; i++)
{
UnityEngine.Vector3 vector2 = ((!flag3) ? AimConeUtil.GetModifiedAimConeDirection(component.projectileSpread + GetAimCone() + GetAIAimcone() * 1f, inputVec) : AimConeUtil.GetModifiedAimConeDirection(component.projectileSpread + aimCone, inputVec));
List <RaycastHit> obj = Facepunch.Pool.GetList <RaycastHit>();
GamePhysics.TraceAll(new Ray(vector, vector2), 0f, obj, 300f, 1219701505);
for (int j = 0; j < obj.Count; j++)
{
RaycastHit hit = obj[j];
BaseEntity entity = RaycastHitEx.GetEntity(hit);
if ((entity != null && (entity == this || entity.EqualNetID(this))) || (entity != null && entity.isClient))
{
continue;
}
ColliderInfo component3 = hit.collider.GetComponent <ColliderInfo>();
if (component3 != null && !component3.HasFlag(ColliderInfo.Flags.Shootable))
{
continue;
}
BaseCombatEntity baseCombatEntity = entity as BaseCombatEntity;
if (entity != null && baseCombatEntity != null && (baseEntity == null || entity == baseEntity || entity.EqualNetID(baseEntity)))
{
HitInfo hitInfo = new HitInfo();
AssignInitiator(hitInfo);
hitInfo.Weapon = this;
hitInfo.WeaponPrefab = base.gameManager.FindPrefab(base.PrefabName).GetComponent <AttackEntity>();
hitInfo.IsPredicting = false;
hitInfo.DoHitEffects = component2.doDefaultHitEffects;
hitInfo.DidHit = true;
hitInfo.ProjectileVelocity = vector2 * 300f;
hitInfo.PointStart = MuzzlePoint.position;
hitInfo.PointEnd = hit.point;
hitInfo.HitPositionWorld = hit.point;
hitInfo.HitNormalWorld = hit.normal;
hitInfo.HitEntity = entity;
hitInfo.UseProtection = true;
component2.CalculateDamage(hitInfo, GetProjectileModifier(), 1f);
hitInfo.damageTypes.ScaleAll(GetDamageScale() * damageModifier * (flag2 ? npcDamageScale : turretDamageScale));
baseCombatEntity.OnAttacked(hitInfo);
component.ServerProjectileHit(hitInfo);
if (entity is BasePlayer || entity is BaseNpc)
{
hitInfo.HitPositionLocal = entity.transform.InverseTransformPoint(hitInfo.HitPositionWorld);
hitInfo.HitNormalLocal = entity.transform.InverseTransformDirection(hitInfo.HitNormalWorld);
hitInfo.HitMaterial = StringPool.Get("Flesh");
Effect.server.ImpactEffect(hitInfo);
}
}
if (!(entity != null) || entity.ShouldBlockProjectiles())
{
break;
}
}
Facepunch.Pool.FreeList(ref obj);
UnityEngine.Vector3 vector3 = ((flag && ownerPlayer.isMounted) ? (vector2 * 6f) : UnityEngine.Vector3.zero);
CreateProjectileEffectClientside(component.projectileObject.resourcePath, vector + vector3, vector2 * component.projectileVelocity, UnityEngine.Random.Range(1, 100), null, IsSilenced(), true);
}
}
/// <summary>
/// Returns created NPCPlayers
/// </summary>
/// <param name="galaxyManager"></param>
/// <param name="IDManager"></param>
/// <param name="rm"></param>
/// <param name="pm"></param>
/// <param name="npcShips"></param>
/// <returns></returns>
async Task <IEnumerable <NPCPlayer> > CreateNPCs(GalaxyManager galaxyManager, LocalIDManager IDManager, GalaxyRegistrationManager rm, PlayerManager pm, LocatorService locatorService, CargoSynchronizer cargoSynchronizer, GlobalTeamManager teamManager, LocalIDManager galaxyIDManager)
{
Random r = new Random(666);
var players = new List <NPCPlayer>();
var systems = galaxyManager.Systems;
int npcCount = 0;
foreach (PSystem s in systems)
{
List <Player> team1 = new List <Player>();
List <Player> team2 = new List <Player>();
List <Player> team3 = new List <Player>();
for (int i = 0; i < _config.NumNPCsPerSystem; i++)
{
List <WeaponTypes> weapons = new List <WeaponTypes>();
ShipTypes shipType = ShipTypes.Barge;
switch (npcCount % 3)
{
case 0:
shipType = ShipTypes.Penguin;
break;
case 1:
shipType = ShipTypes.Barge;
break;
case 2:
shipType = ShipTypes.Reaper;
break;
}
if (shipType == ShipTypes.Reaper)
{
weapons.Add(WeaponTypes.LaserWave);
weapons.Add(WeaponTypes.PlasmaCannon);
}
else
{
weapons.Add(WeaponTypes.AltLaser);
weapons.Add(WeaponTypes.LaserWave);
}
ShipCreationProperties props = new ShipCreationProperties(r.Next(-20, 20), r.Next(-20, 20), (int)galaxyManager.SolAreaID, PilotTypes.NPC, shipType, weapons);
IShip tempShip = _dbFillerUtils.ShipFactory.CreateShip(props);
tempShip.ShipStats.ShieldType = ShieldTypes.QuickRegen;
NPCPlayer p = pm.CreateNPCPlayer(locatorService);
pm.RegisterPlayer(p);
players.Add(p);
tempShip.SetPlayer(p);
p.SetActiveShip(tempShip, MockServer.WarpManager);
TransactionAddStatelessCargo tr = new TransactionAddStatelessCargo(tempShip,
StatelessCargoTypes.AmbassadorMissile, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
tr = new TransactionAddStatelessCargo(tempShip, StatelessCargoTypes.Biodome, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
Helpers.DebugWarp(s, p, tempShip);
ships.Add(tempShip);
//Random team assignment
switch (npcCount % 2)
{
case 0:
team1.Add(p);
break;
case 1:
team2.Add(p);
break;
case 2:
team3.Add(p);
break;
}
//Give the guy some turrets
for (int j = 0; j < _config.NumTurretsPerNPC; j++)
{
var t = StructureFactory.CreateStructure(StructureTypes.LaserTurret, r.Next(-20, 20),
r.Next(-20, 20), p, null, (int)p.CurrentAreaID, locatorService.PlayerLocator, true, dbm);
p.GetArea().AddStructure(t);
}
AddModulesToShip(tempShip, 5, cargoSynchronizer, galaxyIDManager);
npcCount++;
}
foreach (Planet pl in s.GetPlanets())
{
npcCount = 0;
for (int i = 0; i < _config.NumNpcsPerPlanet; i++)
{
ShipTypes shipType = ShipTypes.Barge;
switch (npcCount % 3)
{
case 0:
shipType = ShipTypes.Penguin;
break;
case 1:
shipType = ShipTypes.Barge;
break;
case 2:
shipType = ShipTypes.Reaper;
break;
}
NPCPlayer p = pm.CreateNPCPlayer(locatorService);
pm.RegisterPlayer(p);
players.Add(p);
IShip tempShip = new NPCShip(ShipStatManager.TypeToStats[shipType], locatorService);
tempShip.ShipStats.ShieldType = ShieldTypes.QuickRegen;
tempShip.Id = IDManager.PopFreeID();
rm.RegisterObject(tempShip);
p.SetActiveShip(tempShip, MockServer.WarpManager);
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.MissileLauncher));
if (shipType == ShipTypes.Reaper)
{
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.LaserWave));
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.PlasmaCannon));
}
else
{
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.AltLaser));
tempShip.SetWeapon(WeaponManager.GetNewWeapon(WeaponTypes.LaserWave));
}
TransactionAddStatelessCargo tr = new TransactionAddStatelessCargo(tempShip,
StatelessCargoTypes.AmbassadorMissile, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
tr = new TransactionAddStatelessCargo(tempShip, StatelessCargoTypes.Biodome, 666666, true);
cargoSynchronizer.RequestTransaction(tr);
await tr.ResultTask;
tempShip.PosX = r.Next(-20, 20);
tempShip.PosY = r.Next(-20, 20);
Helpers.DebugWarp(pl, p, tempShip);
ships.Add(tempShip);
//Random team assignment
switch (npcCount % 2)
{
case 0:
team1.Add(p);
break;
case 1:
team2.Add(p);
break;
case 2:
team3.Add(p);
break;
}
AddModulesToShip(tempShip, 5, cargoSynchronizer, galaxyIDManager);
npcCount++;
}
teamManager.DebugCreateNewTeam(team1);
teamManager.DebugCreateNewTeam(team2);
teamManager.DebugCreateNewTeam(team3);
}
}
return(players);
}
/// <summary>
/// Recalculates the path.
/// </summary>
protected void RecalculatePath(NPCPlayer player)
{
NavMeshAgent agent = GetComponent<NavMeshAgent>();
if (Target != null && agent != null)
agent.SetDestination(Target.transform.position);
}
public PlayerWalk(StateID stateID, NPCPlayer player)
{
this.stateID = stateID;
this.playerReference = player;
}
/// <summary>
/// Instantiates and registers all objects associated with a PSystem (planets, players, ships, etc)
/// </summary>
public static async Task <PSystem> DeserializePSystemAsync(PSystemModel system, RedisServer redisServer, LocatorService ls, IGalaxyRegistrationManager rm, IDatabaseManager dbm)
{
PSystem retSys = new PSystem(system, ls);
List <IShip> deserializedShips = new List <IShip>();
List <IStructure> loadedStructures = new List <IStructure>();
List <Player> loadedPlayers = new List <Player>();
//For now we just run the whole lambda synchronously in its own thread. Marking it async makes this method return complete before the task is complete, need to investigate...
await Task.Factory.StartNew(() =>
{
HashSet <int> colonyIDsToLoad = new HashSet <int>();
HashSet <int> shipIDsToLoad = new HashSet <int>();
HashSet <int> areaIDsToLoad = new HashSet <int>();
List <int> structureIDsToLoad = new List <int>();
HashSet <int> layoutIDsToLoad = new HashSet <int>();
foreach (int id in system.ShipIDs)
{
if (shipIDsToLoad.Contains(id))
{
throw new CorruptStateException("Multiple areas contain the same shipID.");
}
shipIDsToLoad.Add(id);
}
foreach (var id in retSys.MoonIDs)
{
areaIDsToLoad.Add(id);
}
foreach (var id in retSys.PlanetIDs)
{
areaIDsToLoad.Add(id);
}
foreach (var id in retSys.PortIDs)
{
areaIDsToLoad.Add(id);
}
IEnumerable <AreaModel> loadedAreaModels = dbm.GetAreasAsync(areaIDsToLoad).Result;
foreach (var am in loadedAreaModels)
{
switch (am.AreaType)
{
case AreaTypes.Planet:
layoutIDsToLoad.Add(((PlanetModel)am).LayoutId);
break;
}
}
IEnumerable <PlanetLayout> loadedLayouts = dbm.GetLayoutsAsync(layoutIDsToLoad).Result.Select(s => (PlanetLayout)s);
Dictionary <int, PlanetLayout> layouts = new Dictionary <int, PlanetLayout>();
foreach (var l in loadedLayouts)
{
layouts.Add(l.Id, l);
}
var loadedAreas = new List <IArea>();
// Instantiate all areas
foreach (AreaModel am in loadedAreaModels)
{
IArea loadedArea = null;
structureIDsToLoad.AddRange(am.StructureIDs);
// Planets
if (am.AreaType == AreaTypes.Planet)
{
loadedArea = new Planet((PlanetModel)am, layouts[((PlanetModel)am).LayoutId], ls);
var p = loadedArea as Planet;
//rm.RegisterObject(p);
if (p.ColonyID != null)
{
colonyIDsToLoad.Add((int)p.ColonyID);
}
}
// Ports
else if (am.AreaType == AreaTypes.Port)
{
loadedArea = new Port((PortModel)am, ls);
}
else
{
throw new Exception("Error: Loaded area not handled in DeserializePSystem()");
}
foreach (var id in am.ShipIDs)
{
if (shipIDsToLoad.Contains(id))
{
throw new CorruptStateException("Multiple areas contain the same shipID.");
}
shipIDsToLoad.Add(id);
}
loadedAreas.Add(loadedArea);
rm.RegisterObject(loadedArea);
}
// Colonies
IEnumerable <AreaModel> LoadedColonies = dbm.GetAreasAsync(colonyIDsToLoad).Result;
List <Colony> deserializedColonies = new List <Colony>();
foreach (AreaModel am in LoadedColonies)
{
if (am.AreaType == AreaTypes.Colony)
{
Colony c = new Colony((ColonyModel)am, ls);
c.DisableUpdates = true;
rm.RegisterObject(c);
deserializedColonies.Add(c);
}
else
{
throw new Exception("AreaID query resulted in an AreaModel which was not a ColonyModel in DeserializePSystem()");
}
foreach (var id in am.ShipIDs)
{
if (shipIDsToLoad.Contains(id))
{
throw new CorruptStateException("Multiple areas contain the same shipID.");
}
shipIDsToLoad.Add(id);
}
}
// Structures
loadedStructures.AddRange(LoadStructures(retSys, dbm, rm, ls.PlayerLocator).Result);
foreach (IArea loadedArea in loadedAreas)
{
if (loadedArea is IHasStructures)
{
loadedStructures.AddRange(LoadStructures((IHasStructures)loadedArea, dbm, rm, ls.PlayerLocator).Result);
}
}
// Ships
IEnumerable <ShipModel> loadedShipModels = dbm.GetShipsAsync(shipIDsToLoad).Result;
HashSet <int> playerIDsToLoad = new HashSet <int>();
foreach (var s in loadedShipModels)
{
var loadedShip = DeserializeShip(s, ls, rm);
deserializedShips.Add(loadedShip);
if (loadedShip.PlayerID != null)
{
playerIDsToLoad.Add((int)s.PlayerID);
}
}
// Players
IEnumerable <PlayerModel> loadedPlayerModels = dbm.GetPlayersAsync(playerIDsToLoad).Result;
HashSet <int> accountIDsToLoad = new HashSet <int>();
foreach (var p in loadedPlayerModels)
{
if (p.PlayerType == PlayerTypes.Human)
{
HumanPlayer hp = new HumanPlayer(p, ls);
rm.RegisterObject(hp);
loadedPlayers.Add(hp);
}
else
{
NPCPlayer np = new NPCPlayer(p, ls);
np.MessageService = new RedisOutgoingMessageService(redisServer, np);
rm.RegisterObject(np);
loadedPlayers.Add(np);
}
if (p.AccountID != null)
{
accountIDsToLoad.Add((int)p.AccountID);
}
}
//Accounts
IEnumerable <AccountModel> loadedAccounts = dbm.GetAccountsAsync(accountIDsToLoad).Result;
foreach (var a in loadedAccounts)
{
rm.RegisterObject(new Account(a));
}
foreach (var c in deserializedColonies)
{
c.DisableUpdates = false;
}
}
);
rm.RegisterObject(retSys);
foreach (Player p in loadedPlayers)
{
if (p.PlayerType == PlayerTypes.NPC)
{
p.GetArea().MovePlayerHere(p, false);
}
}
foreach (var s in deserializedShips)
{
IArea a = s.GetArea();
if (a == null)//Corrupt state, the ship's CurrentAreaId doesn't match the list is for an area which hasn't been loaded yet. Abort the ship read.
{
//I'm not sure that there's a way to gracefully handle this without a major rewrite and a bunch of overhead, so it'll be an exception for now.
throw new CorruptStateException("Ship's CurrentAreaId does not match the area from which it was loaded. Expect exceptions.");
}
else
{
a.AddShip(s, true);
}
}
return(retSys);
}
private void Awake()
{
npc = GetComponent <NPCPlayer>();
npc.displayName = RandomUsernames.Get(Random.Range(0, RandomUsernames.All.Length - 1));
enabled = false;
}
