/// <summary>
/// Gives the object a unique free ID, registers the object with various managers and collections
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public int PopFreeID()
{
int ID;
if (!_freeIDs.TryPop(out ID))
{
//This should never happen, but just in case
_networkIDSupplier.RequestFreeIDs(_minIDCount, _IDType);
ConsoleManager.WriteLine("Warning: GalaxyManager ran out of IDs. This should not be possible, except during initialization", ConsoleMessageType.Warning);
while (_freeIDs.Count == 0)
{
//This will fail if we move to single threaded, but it isn't supposed to happen anyway.....
Thread.Sleep(100);
}
}
if (_freeIDs.Count < _minIDCount)
{
_networkIDSupplier.RequestFreeIDs(_minIDCount, _IDType);
}
return(ID);
}
/// <summary>
/// The message recieved from the client will have the /t, /s, etc removed
/// Function handles chat message according to chat type which is sent as a byte by the client
/// </summary>
/// <param name="msg"></param>
/// <param name="server"></param>
/// <param name="messageConnection"></param>
public async void HandleMessage(NetworkMessageContainer message, Player player)
{
if (message == null)
{
ConsoleManager.WriteLine("Invalid chat message handled. Message is null.",
ConsoleMessageType.Error);
}
var messageData = message.MessageData as MessageChatMessage;
var chatMessageData = messageData.ChatMessageData;
if (player == null)
{
ConsoleManager.WriteLine("Player connection not found while handling chat message.",
ConsoleMessageType.Warning);
return;
}
var outboundChats = await _chatCommandHandler.FetchOutboundChats(player, chatMessageData.ChatJson);
if (outboundChats == null || outboundChats.Count == 0)
{
return;
}
SendChatList(outboundChats);
}
/// <summary>
/// Initializes the Lidgren connection, returns a reference to the NetPeer for sending messages
/// </summary>
/// <param name="serverName"></param>
/// <param name="serverPort"></param>
/// <returns></returns>
public NetPeer Initialize(ConnectionManagerConfig c)
{
_config = c;
NetPeerConfiguration _myConfig = new NetPeerConfiguration(c.MyConfig.ServerName);
_myConfig.ConnectionTimeout = 5;
_myConfig.ReceiveBufferSize = c.MyConfig.ReceiveBufferSize;
_myConfig.SendBufferSize = c.MyConfig.SendBufferSize;
_myConfig.Port = c.MyConfig.Port;
_myConfig.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);
_myConfig.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);
_myConfig.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
_myConfig.AcceptIncomingConnections = true;
//ExternalIP = new IPEndPoint(new IPAddress(GetExternalIPAddressIpify().GetAddressBytes()), c.MyConfig.Port);
//ExternalIP = new IPEndPoint(new IPAddress(GetExternalIPAddressDyndns().GetAddressBytes()), c.MyConfig.Port);
ExternalIP = new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), c.MyConfig.Port);
ConsoleManager.WriteLine("Slave using IP Address " + ExternalIP, ConsoleMessageType.NetworkMessage);
if (_isInit)
{
Server.Shutdown("Resetting server...");
System.Threading.Thread.Sleep(200);
}
Server = new NetServer(_myConfig);
Server.Start();
_isInit = true;
return(Server);
}
public void SendMessageToSimulator(SimulatorBoundMessage message)
{
if (_areaIdToSimulatorInterface.ContainsKey(message.TargetAreaId))//Not all areas are simulated currently, e.g. colonies
{
_areaIdToSimulatorInterface[message.TargetAreaId].SendMessage(message);
}
else
{
ConsoleManager.WriteLine("Attempted to send simulator message to a non simulated area.", ConsoleMessageType.Error);
}
}
/// <summary>
/// Creates a projectile, returns projectileID
/// If there is a projectileID collision, the projectile will simply be discarded
/// </summary>
/// <param name="ship"></param>
/// <returns></returns>
public int CreateProjectile(ICanFire ship, int projectileID)
{
var tempProj = new Projectile(ship, projectileID);
if (!idToProjectile.TryAdd(tempProj.ID, tempProj))
{
ConsoleManager.WriteLine("Proj Collision " + tempProj.ID, ConsoleMessageType.Warning);
}
//ConsoleManager.WriteToFreeLine("Projectiles: " + idToProjectile.Count.ToString());
return(projectileID);
}
/// <summary>
/// TODO: clean this nasty mess up.
/// </summary>
void _addCargoToArea(object sender, ITransactionRemoveStatefulCargo tr)
{
IFloatyAreaObject fa = (IFloatyAreaObject)tr.RemovedCargo;
List <IFloatyAreaObject> l = new List <IFloatyAreaObject> {
fa
};
IArea a = _areaLocator.GetArea(fa.NextAreaID);
a.AddFloatyAreaObjects(l);
ConsoleManager.WriteLine("NPC dropped " + tr.RemovedCargo.GetType().Name, ConsoleMessageType.Notification);
}
/// <summary>
/// Returns a clone of the appropriate StructureStats object
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public static StructureStats GetStats(StructureTypes s)
{
if (_stats.ContainsKey(s))
{
return(_stats[s].GetClone());
}
else
{
ConsoleManager.WriteLine("Error: " + s.ToString() + " not found in StructureStatManager.GetStats.", ConsoleMessageType.Error);
return(null);
}
}
/// <summary>
/// Checks if the passed clientConnection is currently pending and if the username/password match the expected account
/// Use this overload for logins
/// </summary>
/// <param name="clientConnection"></param>
/// <returns></returns>
public bool IsConnectionValid(NetConnection clientConnection, string username, string password, bool removeIfPending, out string message, out Account account)
{
byte[] address = clientConnection.RemoteEndPoint.Address.GetAddressBytes();
//WARNING: Debug, remove before release. Logging in from the same IP as the server causes problems
byte[] localAddress = ExternalIP.Address.GetAddressBytes();
PendingLogin foundLogin = null;
lock (_searchingLoginLock)
{
foreach (PendingLogin p in _pendingConnections)
{
if (p.IsAddressEqual(address) || p.IsAddressEqual(localAddress))
{
foundLogin = p;
break;
}
}
if (removeIfPending && foundLogin != null)
{
bool success = _pendingConnections.Remove(foundLogin);
foundLogin.Account.IsLoginPending = false;
if (success)
{
ConsoleManager.WriteLine("Removing pending login. Current count: " + _pendingConnections.Count);
}
else
{
ConsoleManager.WriteLine("Failed to remove foundLogin.");
}
}
else
{
message = "Pending address " + clientConnection.RemoteEndPoint.Address.ToString() + " was not found.";
account = null;
return(false);
}
}
if (foundLogin.Account.Username != username || foundLogin.Account.Password != password)
{
message = "Invalid username or password. Error, or attempted spoofing?";
account = null;
return(false);
}
message = "success";
account = foundLogin.Account;
return(true);
}
public void AddPendingHandoff(byte[] IPAddress, Account a, int destinationAreaID, int shipID, int?serverGameStateId)
{
if (a == null)
{
ConsoleManager.WriteLine("Warning: account not found in db in LoginManager.AddPendingHandoff");
return;
}
lock (_addingLoginLock)
{
_pendingConnections.Add(new PendingHandoff(_loginTimeout, IPAddress, a, destinationAreaID, shipID, serverGameStateId, TimeKeeper.MsSinceInitialization));
}
}
/// <summary>
/// Call this to complete changing area when recieving client on handoff
/// </summary>
/// <param name="newArea"></param>
/// <param name="ship"></param>
/// <param name="isWarping"></param>
public async Task HandoffCompleteAreaChange(int newAreaID, IShip ship, Player player)
{
//There's a small chance that setting areas to null won't work properly...we'll find out soon!
ship.SetArea(null);
player.SetArea(null);
await ChangeArea(newAreaID, ship, true);
//If these collections aren't empty on server startup, a server crashed mid handoff and there could be ships/players which aren't stored in any area and might not be loaded.
_databaseManager.HandoffDeleteAsync(ship.Id, ModelTypes.ShipModel);
_databaseManager.HandoffDeleteAsync(player.Id, ModelTypes.PlayerModel);
ConsoleManager.WriteLine("Completed Handoff.");
}
public LocalIDManager(INetworkIDSupplier networkIDSupplier, IDTypes IDType)
{
_IDType = IDType;
_networkIDSupplier = networkIDSupplier;
if (networkIDSupplier != null)
{
_networkIDSupplier.RequestFreeIDs(_minIDCount * 2, _IDType);
}
else
{
ConsoleManager.WriteLine("Warning: networkIDSupplier is null in LocalIDManager constructor. This should only be the case when running DBFiller.", ConsoleMessageType.Warning);
}
}
void _handleSimulatorMessage(object sender, NetworkMessageContainer message)
{
if (message.MessageType == MessageTypes.Redis_SimulatorConnectionRequest)
{
var data = message.MessageData as MessageSimulatorConnectionRequest;
IsConnected = true;
var response = new MessageSimulatorConnectionResponse()
{
SimulatorID = SimulatorID
};
_redisServer.PublishObject(ChannelTypes.ServerToSimulator_Network, SimulatorID, new NetworkMessageContainer(response, MessageTypes.Redis_SlaveConnectionResponse));
ConsoleManager.WriteLine("Simulator spawn complete, ID " + data.SimulatorID, ConsoleMessageType.Startup);
}
}
/// <summary>
/// Adds a pending login as instructed by the master server, and awaits a connection from IPAddress until timeout
/// Ensures that Account corresponding to accountID is registered with AccountManager
/// </summary>
/// <param name="IPAddress"></param>
/// <param name="accountNumber"></param>
public void AddPendingLogin(byte[] IPAddress, Account a)
{
if (a == null)
{
ConsoleManager.WriteLine("Warning: account not found in db in LoginManager.AddPendingLogin");
return;
}
lock (_addingLoginLock)
{
_pendingConnections.Add(new PendingLogin(_loginTimeout, IPAddress, a, TimeKeeper.MsSinceInitialization));
a.IsLoginPending = true;
ConsoleManager.WriteLine("Account " + a.Username + " added to pending connections with address " + IPAddress.GetString());
}
}
public void LogOut(Player p)
{
if (p.PlayerType != PlayerTypes.Human)
{
return;
}
p.LogOut(_databaseManager);
Player temp;
connectionToPlayer.TryRemove(((LidgrenOutgoingMessageService)p.MessageService).Connection, out temp);
ConsoleManager.WriteLine("Player " + p.Username + " has been logged out.", ConsoleMessageType.Notification);
}
public Player GetPlayer(NetConnection connection)
{
Player p;
if (connectionToPlayer.ContainsKey(connection))
{
p = connectionToPlayer[connection];
}
else
{
ConsoleManager.WriteLine("Failed to find player using connection");
p = null;
}
return(p);
}
/// <summary>
/// Call this to begin changing area when handing off a local client.
/// </summary>
/// <param name="newArea"></param>
/// <param name="ship"></param>
/// <param name="isWarping"></param>
async Task HandoffInitiateAreaChange(int destinationAreaID, AreaTypes newAreaType, IShip ship, Player warpingPlayer)
{
var shipSaveTask = _databaseManager.SaveAsync(warpingPlayer);
var playerSaveTask = _databaseManager.SaveAsync(ship);
var shipSaveHandoffTask = _databaseManager.HandoffSaveAsync(ship);//If these collections aren't empty on server startup, a server crashed mid handoff and there could be ships/players which aren't stored in any area and might not be loaded.
var playerSaveHandoffTask = _databaseManager.HandoffSaveAsync(warpingPlayer);
//Ensure that db versions of ship and player are most recent, since they'll be loaded by slave
List <Task> tasklist = new List <Task>
{
shipSaveTask,
shipSaveHandoffTask,
playerSaveTask,
playerSaveHandoffTask,
};
await Task.WhenAll(tasklist);
if (!(shipSaveTask.Result.IsAcknowledged && shipSaveHandoffTask.Result.IsAcknowledged && playerSaveTask.Result.IsAcknowledged && playerSaveHandoffTask.Result.IsAcknowledged))
{
throw new InvalidOperationException("Error: db write failed during handoff, handoff aborted.");
}
//Send handoff to be handled by server
NetworkMessageContainer redismsg = new NetworkMessageContainer(new MessageClientHandoff((int)warpingPlayer.AccountID, (int)warpingPlayer.ActiveShipId, destinationAreaID, ((LidgrenOutgoingMessageService)warpingPlayer.MessageService).Connection.RemoteEndPoint.Address.GetAddressBytes()), MessageTypes.Redis_ClientHandoff);
_redisServer.PublishObject(MessageTypes.Redis_ClientHandoff, redismsg);
IArea currentArea = null;
if (ship.CurrentAreaId != null)
{
currentArea = _areaLocator.GetArea((int)ship.CurrentAreaId);
}
OnAreaExit(ship, currentArea, newAreaType);
currentArea.RemovePlayer(ship.GetPlayer()); //There doesn't seem to be a convenient way to avoid putting this here
currentArea.RemoveShip(ship); //Sends removeship Command to clients in area
ConsoleManager.WriteLine("Initiated Handoff");
ship.GetPlayer().IsHandedOff = true;
_registrationManager.DeRegisterObject(warpingPlayer);
_registrationManager.DeRegisterObject(ship);
_accountManager.DeregisterAccount(warpingPlayer.GetAccount());
}
static private IPAddress GetExternalIPAddressIpify()
{
//// Todo: Use Regex here.
ConsoleManager.WriteLine("Querying https://api.ipify.org/ for external IP...", ConsoleMessageType.NetworkMessage);
string url = "https://api.ipify.org/";
WebRequest req = WebRequest.Create(url);
req.Method = "GET";
req.Proxy = null;
req.Timeout = 15000;
WebResponse resp = req.GetResponse();
StreamReader sr = new StreamReader(resp.GetResponseStream());
string response = sr.ReadToEnd().Trim();
return(IPAddress.Parse(response));
}
/// <summary>
/// Gets an area being handled by this server, null if the area is non-local
/// NOTE: If ID==null, GetArea returns limbo
/// </summary>
/// <param name="ID"></param>
/// <returns></returns>
public IArea GetArea(int?ID)
{
if (ID == null)
{
return(null);
}
IArea outArea;
AllAreas.TryGetValue((int)ID, out outArea);
if (outArea == null)
{
ConsoleManager.WriteLine("Non-local area requested from GetLocalArea", ConsoleMessageType.Warning);
}
return(outArea);
}
/// <summary>
/// Performs a bunch of checks and returns a created account if succesful
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="persistAccount">If false, account will not be stored in the manager or the db</param>
/// <returns>Check flags if returned account is null</returns>
public async Task <Tuple <Account, AccountCreationFailFlags> > CreateAccountAsync(string username, string password, bool persistAccount = true)
{
AccountCreationFailFlags failFlags = 0;
// Checks
_usernameCharCheck(username, ref failFlags);
_passwordCheck(password, ref failFlags);
var res = await _usernameExistsAsync(username, failFlags);
failFlags = res.Item2;
Account retAccount = null;
if (failFlags == 0)
{
#if DEBUG
//ConsoleManager.WriteToFreeLine("Creating Account with username " + username);
#endif
retAccount = new Account(username, password, _accountIDManager.PopFreeID(), false);
if (persistAccount)
{
await _databaseManager.SaveAsync(retAccount);
var writeResult = await _usernameExistsAsync(username, 0);
if (writeResult.Item1)
{
#if DEBUG
ConsoleManager.WriteLine("DB write failed when creating a new account.");
#endif
_accountIDManager.PushFreeID(retAccount.Id);
retAccount = null;
failFlags = failFlags | AccountCreationFailFlags.DBWriteFailed;
}
}
}
if (persistAccount && retAccount != null)
{
RegisterAccount(retAccount);
}
return(new Tuple <Account, AccountCreationFailFlags>(retAccount, failFlags));
}
/// <summary>
/// This function checks if a player has timed out or not.
/// </summary>
public void updatesHeartbeats()
{
var currentTime = DateTime.Now.Ticks / 10000L;
foreach (var player in _objects)
{
if (player.Value.IsOnline)
{
var elapsedTime = currentTime - player.Value.lastHeartbeat;
if (elapsedTime > player.Value.disconnectTime) // Disconnect if true
{
ConsoleManager.WriteLine(
string.Format("Disconnecting Player {0}", player.Value.Username));
player.Value.LogOut(_databaseManager);
}
}
}
}
/// <summary>
/// Handles login of a client. Returns true if login succesful
/// </summary>
/// <param name="receiveMessage">Incoming Message</param>
/// <param name="accountManager">Account Manager</param>
/// <param name="sendMessage">Blank message to write to.</param>
/// <param name="messageConnection">Peer that is logging in, used to send success/fail.</param>
public async Task HandleLogin(NetConnection messageConnection, Account a, ChatManager chatManager, SimulatorManager simulationManager, LocatorService ls)
{
try
{
HumanPlayer tempPlayer = (HumanPlayer)await _playerManager.GetObjectAsync(a.PlayerID, true, ls, true);
_redisServer.SetHashValue(RedisDBKeyTypes.PlayerIDToCurrentAreaID, tempPlayer.Id, tempPlayer.CurrentAreaID);
tempPlayer.IsOnline = true;
tempPlayer.MessageService = new LidgrenOutgoingMessageService(messageConnection, _connectionManager);
var currentArea = tempPlayer.GetArea();
a.connection = messageConnection;
_playerManager.connectionToPlayer.TryAdd(messageConnection, tempPlayer);
tempPlayer.GetArea().AddPlayer(tempPlayer, false);
SendLoginList(currentArea, tempPlayer, chatManager);
//currentArea.MovePlayerHere(tempPlayer, false);
currentArea.SendEntryData(tempPlayer, false, tempPlayer.GetActiveShip());
tempPlayer.lastHeartbeat = DateTime.Now.Ticks / 10000L;
var SuccessMessage = string.Format("Player {0} has logged in successfully, current area: {1}", new object[2] {
a.Username, tempPlayer.CurrentAreaID
});
ConsoleManager.WriteLine(SuccessMessage);
tempPlayer.HackCount = -1;
simulationManager.SendMessageToSimulator(new SimulatorBoundMessage(new MessageEmptyMessage {
Data = currentArea.NumOnlineHumanPlayers
}, MessageTypes.Redis_NumOnlinePlayersChanged, currentArea.Id));
}
catch (Exception e)
{
ConsoleManager.WriteLine(e.Message, ConsoleMessageType.Error);
ConsoleManager.WriteLine(e.StackTrace, ConsoleMessageType.Notification);
}
}
/// <summary>
/// Instantiates a new instance of the given weapon type
/// </summary>
/// <param name="weaponType"></param>
/// <param name="missileType">Used inly if weaponType is MissileLauncher</param>
/// <returns></returns>
static public Weapon GetNewWeapon(WeaponTypes weaponType, ProjectileTypes missileType = ProjectileTypes.AmbassadorMissile)
{
switch (weaponType)
{
case WeaponTypes.Laser:
return(new Laser());
case WeaponTypes.AltLaser:
return(new AltLaser());
case WeaponTypes.HurrDurr:
return(new HurrDurr());
case WeaponTypes.PlasmaCannon:
return(new PlasmaCannon());
case WeaponTypes.BC_Laser:
return(new BC_Laser());
case WeaponTypes.LaserWave:
return(new LaserWave());
case WeaponTypes.MissileLauncher:
return(new MissileLauncher(missileType));
case WeaponTypes.GravBomber:
return(new GravBomber());
case WeaponTypes.MineWeapon:
return(new MineWeapon());
case WeaponTypes.None:
return(new NullWeapon());
default:
ConsoleManager.WriteLine("Error: " + weaponType.ToString() + " flyweight not yet implemented in WeaponManager.cs.", ConsoleMessageType.Error);
return(new NullWeapon());
}
}
SimulatorInterface AttemptSpawn(List <PSystem> areasToSimulate, bool DEBUGSPAWNLOCAL = false) //TODO:Remove DEBUGSPAWNLOCAL Once debugging is complete
{
int simulatorID = Rand.Random.Next(-int.MaxValue, int.MaxValue); //TODO: remove collision potential
ConsoleManager.WriteLine("Attempting simulator spawn, ID " + simulatorID, ConsoleMessageType.Startup);
var newsim = new SimulatorInterface(simulatorID, _config, _redisServer);
if (!DEBUGSPAWNLOCAL)
{
newsim.Spawn(areasToSimulate);
}
else
{
newsim.DEBUGSpawnLocal(areasToSimulate);
}
return(newsim);
}
/// <summary>
/// Prunes expired pending logins
/// </summary>
public void Update()
{
List <PendingConnection> toRemove = new List <PendingConnection>();
lock (_updateLock)
{
foreach (PendingConnection p in _pendingConnections)
{
if (TimeKeeper.MsSinceInitialization > p.ExpireTime)
{
toRemove.Add(p);
}
}
foreach (PendingConnection p in toRemove)
{
_pendingConnections.Remove(p);
p.Account.IsLoginPending = false;
ConsoleManager.WriteLine("Warning: Pending Connection for user " + p.Account.Username + " timed out and was removed.");
}
}
PendingConnectionCount = _pendingConnections.Count;
}
/// <summary>
/// Only way to reliably get external IP address, sends request to checkIP.dyndns.org
/// </summary>
/// <returns></returns>
static private IPAddress GetExternalIPAddressDyndns()
{
// Todo: Use Regex here.
ConsoleManager.WriteLine("Querying http://checkip.dyndns.org for external IP...", ConsoleMessageType.NetworkMessage);
string url = "http://checkip.dyndns.org/";
WebRequest req = WebRequest.Create(url);
req.Method = "GET";
req.Proxy = null;
req.Timeout = 15000;
WebResponse resp = req.GetResponse();//dyndns fails intermittently. Ipify is more reliable, except right now their certificate is expired...
StreamReader sr = new StreamReader(resp.GetResponseStream());
string response = sr.ReadToEnd().Trim();
string[] a = response.Split(':');
string a2 = a[1].Substring(1);
string[] a3 = a2.Split('<');
string a4 = a3[0];
return(IPAddress.Parse(a4));
}
/// <summary>
/// Use this for reported collision, to add for majority resolution
/// If a collision has already been added, it will automatically be processed (since two clients reported the collision)
/// </summary>
/// <param name="projectileID"></param>
public void CreateCollision(int projectileID, ProjectileTypes projectileType, int hitObjectID, byte pctCharge, byte weaponSlot)
{
//If _collidableObjects does not contain hitObjectID, something is probably wrong.
//If ProjectileManager does not contain projectileID, the collision is probably from a silently denied projectile, which should be rare
//WARNING: Could optimize by telling client not to report collisions with denied projectiles
if (!_collidableObjects.ContainsKey(hitObjectID) || !_projectileManager.idToProjectile.ContainsKey(projectileID))//In case a collision is reported right after a kill
{
if (!_collidableObjects.ContainsKey(hitObjectID))
{
ConsoleManager.WriteLine("Error: collision reported for an object which was not registered with CollisionManager.", ConsoleMessageType.Error);
}
return;
}
ICollidable hitObject = _collidableObjects[hitObjectID];
if (hitObject.CurrentAreaId == null)//Received a collision report while an object was mid warp, ignore.
{
return;
}
CollisionObject tempCol;
try
{
if (_collisionsToCheck.TryGetValue(projectileID, out tempCol)) //If the collision has been reported
{
tempCol.numReported++;
//This means more than one client reported the collision, so always take damage
if (!tempCol.isExpired) //If it has not been handled yet
{
ConsoleManager.WriteLine("Damaging, multiple reports, id " + projectileID);
DamageObject(hitObject, _projectileManager.idToProjectile[projectileID].FiringObject, projectileType, pctCharge, weaponSlot, projectileID);
tempCol.isExpired = true;
}
}
else if (_galaxyManager.GetArea(hitObject.CurrentAreaId).NumOnlinePlayers == 1)
//If there is only one player in the system (e.g. a player simulating npcs alone)
{
ConsoleManager.WriteLine("Damaging, single user, id " + projectileID);
tempCol = getColObject(projectileID, projectileType, hitObject, pctCharge, weaponSlot);
_collisionsToCheck.TryAdd(projectileID, tempCol);
DamageObject(hitObject, _projectileManager.idToProjectile[projectileID].FiringObject, projectileType, pctCharge, weaponSlot, projectileID);//Take damage
tempCol.isExpired = true;
}
else //If the collision has not been reported
{
//Program.numCollided++;
tempCol = getColObject(projectileID, projectileType, hitObject, pctCharge, weaponSlot);
_collisionsToCheck.TryAdd(projectileID, tempCol);
}
}
catch (Exception e)
{
//TODO: figure out a way to deal with hitObject.CurrentAreaID==null, which can happen if a collision is created while the object is warping. Currently not concurrency safe.
ConsoleManager.WriteLine(e.Message, ConsoleMessageType.Error);
ConsoleManager.WriteLine(e.StackTrace, ConsoleMessageType.Error);
}
hitObject.DoCombatUpdates = true;
hitObject.TimeOfLastCollision = TimeKeeper.MsSinceInitialization;
}
protected void handleCollisions(GalaxyRegistrationManager rm, ProjectileManager pm)
{
ICollidable hitObj;
var keysToRemove = new List <int>();
foreach (var kvp in _collisionsToCheck)
{
hitObj = kvp.Value.hitObject;
int numOnline = 0;
try
{
//This line for some reason causes null reference exceptions, although none of the variables are null
numOnline = _galaxyManager.GetArea(hitObj.CurrentAreaId).NumOnlinePlayers;
}
catch (Exception e)
{
ConsoleManager.WriteLine("Mysterious null error in CollisionManager.HandleCollisions.", ConsoleMessageType.Warning);
continue;
}
if (kvp.Value.isExpired && (TimeKeeper.MsSinceInitialization - kvp.Value.reportTime) >= 3000)
{ //If it has been handled and the grace period for further reports has ended
keysToRemove.Add(kvp.Value.projectileID);
}
else if (kvp.Value.isExpired == false &&
(TimeKeeper.MsSinceInitialization - kvp.Value.reportTime) >= 200)
//Only one collision reported
{
//ConsoleManager.WriteToFreeLine("Single Reported");
//Program.numSingleCols++;
float probability = (1f / numOnline) * 100; //probability that the collision is valid
if (r.Next(0, 100) <= probability)
{
if (_projectileManager.idToProjectile.ContainsKey(kvp.Value.projectileID))
{
DamageObject(hitObj, _projectileManager.idToProjectile[kvp.Value.projectileID].FiringObject, kvp.Value.projectileType, kvp.Value.pctCharge, kvp.Value.WeaponSlot, kvp.Value.projectileID);//Collision considered valid
}
else
{
ConsoleManager.WriteLine("Error: projectileID not found for projectile collision. Skipping damage...", ConsoleMessageType.Error);
}
}
kvp.Value.isExpired = true;
}
}
#if DEBUG
//TODO: Remove this before release
for (int i = 0; i < keysToRemove.Count - 1; i++)
{
for (int j = i + 1; j < keysToRemove.Count; j++)
{
if (keysToRemove[i] == keysToRemove[j])
{
ConsoleManager.WriteLine("SAME KEY ADDED TWICE1!!!!");
throw new Exception("SAME KEY ADDED TWICE1!!!!");
}
}
}
#endif
try
{
for (int i = 0; i < keysToRemove.Count; i++)
{
CollisionObject tempCol;
//Program.numReports -= _collisionsToCheck[keysToRemove[i]].numReported;
recycleCollisionObject(_collisionsToCheck[keysToRemove[i]]);
_collisionsToCheck.TryRemove(keysToRemove[i], out tempCol);
}
}
catch
{
Console.WriteLine("bsdfjlehliau");
}
}
public IShip KillShip(IShip s, ICanFire killingObject)
{
if (s.IsDead)
{
ConsoleManager.WriteLine("Killing a ship which was already dead.", ConsoleMessageType.Warning);
return(s);
}
s.IsDead = true;
s.KillTimeStamp = TimeKeeper.MsSinceInitialization;
s.RespawnTimeDelay = 3000;//TODO: This will be a problem later, if a IShip warps into a new system where a dead IShip is waiting to respawn, the warping IShip will see a live ship. Needs to be fully implemented.
s.CurrentHealth = 0;
if (s.GetPlayer().IsTrading)
{
_tradeTerminator.TerminateTrade(s.Id, true);
}
var currentArea = s.GetArea();
if (currentArea.NumOnlinePlayers > 0)
{
MessageRemoveKillRevive msgData = new MessageRemoveKillRevive();
msgData.ActionType = ActionType.Kill;
msgData.ObjectType = RemovableObjectTypes.Ship;
msgData.ObjectIDs.Add(s.Id);
currentArea.BroadcastMessage(new NetworkMessageContainer(msgData, MessageTypes.RemoveKillRevive));
// Send chat messages
if (killingObject is IShip)
{
((IShip)killingObject).GetPlayer().PlayersKilled++;
var killingPlayer = ((IShip)killingObject).GetPlayer();
killingPlayer.PlayersKilled++;
var killText = string.Format("{0} was shot down by {1}!", s.GetPlayer().Username, killingPlayer.Username);
_chatManager.BroadcastSimpleChat(s.GetArea(), "", killText, ChatTypes.None);
}
else if (killingObject is Turret)
{
_playerLocator.GetPlayerAsync(((Turret)killingObject).OwnerID).Result.PlayersKilled++;
var killedPlayer = s.GetPlayer();
var defensesOwner = _playerLocator.GetPlayerAsync(((Turret)killingObject).OwnerID).Result.Username;
var killText = string.Format("{0} was shot down by defenses of {1}!", killedPlayer.Username, defensesOwner);
_chatManager.BroadcastSimpleChat(s.GetArea(), "", killText, ChatTypes.None);
}
}
#region Modules
//For now, just make the ship drop one mod to space. Later we'll figure out how many to destroy/keep with the ship
var moduleToRemove = s.Cargo.GetAnyStatefulCargo(StatefulCargoTypes.Module);
if (moduleToRemove != null)
{
var ct = new TransactionRemoveStatefulCargo(s, StatefulCargoTypes.Module, moduleToRemove.Id);
ct.OnCompletion += s.CargoRemoved;
ct.OnCompletion += _messageManager.NotifyCargoRemoved;
ct.OnCompletion += _addCargoToArea;
var mod = moduleToRemove as Module;
mod.PosX = s.PosX;
mod.PosY = s.PosY;
mod.Rotation = s.Rotation;
mod.NextAreaID = (int)s.CurrentAreaId;
_cargoSynchronizer.RequestTransaction(ct);
}
#endregion
s.CurrentHealth = s.ShipStats.MaxHealth;
//s.IsDead = false;
float tempx = 0;
float tempy = 0;
SpatialOperations.GetRandomPointInRadius(ref tempx, ref tempy, 10, 20);
s.PosX = tempx;
s.PosY = tempy;
return(s);
}
private void AdminShipChange(Player player, ShipStats shs)
{
ConsoleManager.WriteLine("Warning: AdminShipChange is currently disabled.", ConsoleMessageType.Warning);
}
/// <summary>
/// Handles a Command sent by a player with isAdmin = true
///
/// <summary>
/// Handles a Command sent by a player with isAdmin = true
/// </summary>
/// <param name="msg"></param>
/// <param name="server"></param>
/// <param name="messageConnection"></param>
public void AdminCommand(NetIncomingMessage msg, NetPeer server, NetConnection messageConnection)
{
ConsoleManager.WriteLine("Received Admin Command; Admin commands are disabled.", ConsoleMessageType.Warning);
return;
/*
* var player = _playerManager.connectionToPlayer[msg.SenderConnection]; // You can't spoof an admin
*
* if (!player.GetAccount().IsAdmin) // If you're not an admin, f**k you
* return;
*
* var chatType = msg.ReadByte();
* var chatText = msg.ReadString();
* //ConsoleManager.WriteToFreeLine(playerID.ToString() + chatType.ToString() + chatText.ToString());
*
* //Player tempPlayer = new Player();
*
* ConsoleManager.WriteLine("Admin Command " + chatType + " received.");
* switch ((AdminCommands) chatType) //Chat message type
* {
* case AdminCommands.killPlayer: // Not implemented
* _messageManager.SendChatMessage("Killed player Command parsed.", "", ChatTypes.admin, server,
* player.Connection);
* break;
*
* case AdminCommands.makeNPCs:
* var numToMake = int.Parse(chatText);
* //SR_connectionManager.Server.Program.createNPCs = numToMake;
* //SR_connectionManager.Server.Program.NPCCreatePlayer = player;
* ConsoleManager.WriteLine("makeNPCs Command is broken.");
* break;
*
* case AdminCommands.setShip:
*
* switch (chatText.ToLower())
* {
* case "penguin":
* AdminShipChange(player, ShipStatManager.TypeToStats[ShipTypes.Penguin]);
*
* _messageManager.SendChatMessage("Set IShip to a Penguin.", "", ChatTypes.admin, server,
* player.Connection);
* Logger.log(Log_Type.INFO, player.Username + " switched IShip to Penguin");
* break;
* case "bc":
* case "battlecruiser":
* AdminShipChange(player, ShipStatManager.TypeToStats[ShipTypes.BattleCruiser]);
*
* _messageManager.SendChatMessage("Set IShip to a Battlecruiser. Weapon ", "", ChatTypes.admin,
* server, player.Connection);
* Logger.log(Log_Type.INFO, player.Username + " switched IShip to Battlecruiser");
* break;
*
* case "reaper":
* case "jeyth":
* AdminShipChange(player, ShipStatManager.TypeToStats[ShipTypes.Reaper]);
*
* _messageManager.SendChatMessage("Set IShip to a Jeyth. Weapon ", "", ChatTypes.admin, server,
* player.Connection);
* Logger.log(Log_Type.INFO, player.Username + " switched IShip to Jeyth");
* break;
* case "zy":
* case "barge":
* AdminShipChange(player, ShipStatManager.TypeToStats[ShipTypes.Barge]);
*
* _messageManager.SendChatMessage("Set IShip to a ZY Barge. Weapon ", "", ChatTypes.admin,
* server, player.Connection);
* Logger.log(Log_Type.INFO, player.Username + " switched IShip to ZY Barge");
* break;
*
* case "dread":
* AdminShipChange(player, ShipStatManager.TypeToStats[ShipTypes.Dread]);
*
* _messageManager.SendChatMessage("Set IShip to a Dread class fighter. ", "",
* ChatTypes.admin, server, player.Connection);
* Logger.log(Log_Type.INFO, player.Username + " switched IShip to a Dread class fighter.");
* break;
*
* default:
*
* _messageManager.SendChatMessage("Invalid IShip Type: ", chatText, ChatTypes.admin,
* server, player.Connection);
* Logger.log(Log_Type.INFO,
* player.Username + " specified invalid IShip type " + chatText + ".");
* break;
* }
* break;
* case AdminCommands.systemStatistics:
* {
* var p = _playerManager.GetPlayer(messageConnection);
* if (p.CurrentAreaId == null)
* _messageManager.SendChatMessage("Player's area is currently null.", "", ChatTypes.admin, server,
* messageConnection);
*
*
* var a = _galaxyManager.GetArea(p.CurrentAreaId);
* if (a == null)
* //a = _galaxyManager.GetNonlocalArea((int)p.CurrentAreaId, _playerManager);//This might be a bad idea, since it registers non-local ships and players, but this is an admin Command, after all
* return;
*
* if (a.AreaType == (byte) AreaTypes.System)
* {
* var pp = (PSystem) a;
* _messageManager.SendChatMessage(
* "Current System: " + pp.SystemName + ", Is Cluster: " + pp.IsCluster + ", Total Planets: " +
* pp.PlanetCount + ", Total Moons: " + pp.MoonCount
* , "", ChatTypes.admin, server, messageConnection);
* //Logger.log(Log_Type.INFO, player.username + " switched IShip to Penguin"); lol wtf?
* }
* break;
* }
* case AdminCommands.whoplayer:
* break;
* }
*/
}