mirror of
https://github.com/ProjectSWGCore/Holocore.git
synced 2026-10-21 11:03:13 -04:00
304 lines
11 KiB
Java
304 lines
11 KiB
Java
/***********************************************************************************
|
|
* Copyright (c) 2015 /// Project SWG /// www.projectswg.com *
|
|
* *
|
|
* ProjectSWG is the first NGE emulator for Star Wars Galaxies founded on *
|
|
* July 7th, 2011 after SOE announced the official shutdown of Star Wars Galaxies. *
|
|
* Our goal is to create an emulator which will provide a server for players to *
|
|
* continue playing a game similar to the one they used to play. We are basing *
|
|
* it on the final publish of the game prior to end-game events. *
|
|
* *
|
|
* This file is part of Holocore. *
|
|
* *
|
|
* -------------------------------------------------------------------------------- *
|
|
* *
|
|
* Holocore is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Affero General Public License as *
|
|
* published by the Free Software Foundation, either version 3 of the *
|
|
* License, or (at your option) any later version. *
|
|
* *
|
|
* Holocore is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Affero General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Affero General Public License *
|
|
* along with Holocore. If not, see <http://www.gnu.org/licenses/>. *
|
|
* *
|
|
***********************************************************************************/
|
|
package services.galaxy;
|
|
|
|
import intents.PlayerEventIntent;
|
|
import intents.network.CloseConnectionIntent;
|
|
import intents.network.ForceDisconnectIntent;
|
|
import intents.network.GalacticPacketIntent;
|
|
import intents.player.ZonePlayerSwapIntent;
|
|
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.Set;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.ScheduledExecutorService;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import network.packets.swg.zone.HeartBeat;
|
|
import resources.control.Intent;
|
|
import resources.control.Service;
|
|
import resources.network.DisconnectReason;
|
|
import resources.objects.creature.CreatureObject;
|
|
import resources.objects.player.PlayerObject;
|
|
import resources.player.Player;
|
|
import resources.player.PlayerEvent;
|
|
import resources.player.PlayerFlags;
|
|
import resources.player.PlayerState;
|
|
import resources.player.Player.PlayerServer;
|
|
import resources.server_info.Log;
|
|
import services.CoreManager;
|
|
import utilities.ThreadUtilities;
|
|
|
|
public class ConnectionService extends Service {
|
|
|
|
private static final double DISAPPEAR_THRESHOLD = TimeUnit.MINUTES.toMillis(3); // Time after the LD
|
|
|
|
private final ScheduledExecutorService updateService;
|
|
private final Runnable disappearRunnable;
|
|
private final Set <DisappearPlayer> disappearPlayers;
|
|
private final Set <Player> zonedInPlayers;
|
|
|
|
public ConnectionService() {
|
|
updateService = Executors.newSingleThreadScheduledExecutor(ThreadUtilities.newThreadFactory("conn-update-service"));
|
|
zonedInPlayers = new LinkedHashSet<Player>();
|
|
disappearPlayers = new HashSet<DisappearPlayer>();
|
|
disappearRunnable = new Runnable() {
|
|
public void run() {
|
|
synchronized (disappearPlayers) {
|
|
Iterator<DisappearPlayer> iter = disappearPlayers.iterator();
|
|
while (iter.hasNext()) {
|
|
DisappearPlayer p = iter.next();
|
|
if ((System.nanoTime()-p.getTime())/1E6 >= DISAPPEAR_THRESHOLD) {
|
|
disappear(p.getPlayer(), false, DisconnectReason.APPLICATION);
|
|
iter.remove();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
registerForIntent(PlayerEventIntent.TYPE);
|
|
registerForIntent(GalacticPacketIntent.TYPE);
|
|
registerForIntent(ForceDisconnectIntent.TYPE);
|
|
registerForIntent(ZonePlayerSwapIntent.TYPE);
|
|
}
|
|
|
|
@Override
|
|
public boolean start() {
|
|
return super.start();
|
|
}
|
|
|
|
@Override
|
|
public boolean terminate() {
|
|
updateService.shutdownNow();
|
|
boolean success = false;
|
|
try {
|
|
success = updateService.awaitTermination(5, TimeUnit.SECONDS);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return super.terminate() && success;
|
|
}
|
|
|
|
@Override
|
|
public void onIntentReceived(Intent i) {
|
|
if (i instanceof PlayerEventIntent)
|
|
onPlayerEventIntent((PlayerEventIntent) i);
|
|
else if (i instanceof GalacticPacketIntent)
|
|
onGalacticPacketIntent((GalacticPacketIntent) i);
|
|
else if (i instanceof ForceDisconnectIntent)
|
|
onForceDisconnectIntent((ForceDisconnectIntent) i);
|
|
else if (i instanceof ZonePlayerSwapIntent)
|
|
onZonePlayerSwapIntent((ZonePlayerSwapIntent) i);
|
|
}
|
|
|
|
private void onPlayerEventIntent(PlayerEventIntent pei) {
|
|
switch (pei.getEvent()) {
|
|
case PE_FIRST_ZONE: {
|
|
Player p = pei.getPlayer();
|
|
removeFromLists(p);
|
|
synchronized (zonedInPlayers) {
|
|
zonedInPlayers.add(p);
|
|
}
|
|
break;
|
|
}
|
|
case PE_ZONE_IN_SERVER:
|
|
CoreManager.getGalaxy().incrementPopulationCount();
|
|
clearPlayerFlag(pei.getPlayer(), pei.getEvent(), PlayerFlags.LD);
|
|
break;
|
|
case PE_LOGGED_OUT: {
|
|
Player p = pei.getPlayer();
|
|
synchronized (zonedInPlayers) {
|
|
if (!zonedInPlayers.contains(p)) {
|
|
// No reason to set flags, log out and disappear
|
|
// characters that aren't zoned in
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (p.getPlayerServer() != PlayerServer.ZONE)
|
|
CoreManager.getGalaxy().decrementPopulationCount();
|
|
setPlayerFlag(p, pei.getEvent(), PlayerFlags.LD);
|
|
logOut(p, true);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void onGalacticPacketIntent(GalacticPacketIntent gpi) {
|
|
Player p = gpi.getPlayerManager().getPlayerFromNetworkId(gpi.getNetworkId());
|
|
if (p != null) {
|
|
p.updateLastPacketTimestamp();
|
|
if (gpi.getPacket() instanceof HeartBeat)
|
|
p.sendPacket(gpi.getPacket());
|
|
}
|
|
}
|
|
|
|
private void onForceDisconnectIntent(ForceDisconnectIntent fdi) {
|
|
logOut(fdi.getPlayer(), !fdi.getDisappearImmediately());
|
|
disconnect(fdi.getPlayer(), fdi.getDisconnectReason());
|
|
if (fdi.getDisappearImmediately())
|
|
disappear(fdi.getPlayer(), fdi.getDisappearImmediately(), fdi.getDisconnectReason());
|
|
}
|
|
|
|
private void onZonePlayerSwapIntent(ZonePlayerSwapIntent zpsi) {
|
|
Player before = zpsi.getBeforePlayer();
|
|
Player after = zpsi.getAfterPlayer();
|
|
CreatureObject creature = zpsi.getCreature();
|
|
removeFromLists(before);
|
|
updatePlayTime(before);
|
|
Log.i("ConnectionService", "Logged out %s with character %s", before.getUsername(), before.getCharacterName());
|
|
new PlayerEventIntent(before, PlayerEvent.PE_LOGGED_OUT).broadcast();
|
|
Log.i("ConnectionService", "Disconnected %s with character %s and reason: %s", before.getUsername(), before.getCharacterName(), DisconnectReason.NEW_CONNECTION_ATTEMPT);
|
|
new CloseConnectionIntent(before.getNetworkId(), DisconnectReason.NEW_CONNECTION_ATTEMPT).broadcast();
|
|
before.setPlayerState(PlayerState.DISCONNECTED);
|
|
creature.setOwner(after);
|
|
}
|
|
|
|
private void removeFromLists(Player player) {
|
|
synchronized (zonedInPlayers) {
|
|
zonedInPlayers.remove(player);
|
|
}
|
|
removeFromDisappear(player);
|
|
}
|
|
|
|
private void removeFromDisappear(Player player) {
|
|
synchronized (disappearPlayers) {
|
|
Iterator <DisappearPlayer> disappearIterator = disappearPlayers.iterator();
|
|
while (disappearIterator.hasNext()) {
|
|
DisappearPlayer old = disappearIterator.next();
|
|
Player oldPlayer = old.getPlayer();
|
|
CreatureObject oldObj = old.getPlayer().getCreatureObject();
|
|
if (oldObj == null || player.equals(oldPlayer) || player == oldPlayer) {
|
|
disappearIterator.remove();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setPlayerFlag(Player p, PlayerEvent event, PlayerFlags flag) {
|
|
PlayerObject player = getPlayerObject(p, event);
|
|
if (player == null)
|
|
return;
|
|
player.setFlagBitmask(flag);
|
|
}
|
|
|
|
private void clearPlayerFlag(Player p, PlayerEvent event, PlayerFlags flag) {
|
|
PlayerObject player = getPlayerObject(p, event);
|
|
if (player == null)
|
|
return;
|
|
player.clearFlagBitmask(flag);
|
|
}
|
|
|
|
private PlayerObject getPlayerObject(Player p, PlayerEvent event) {
|
|
if (p.getPlayerServer() != PlayerServer.ZONE)
|
|
return null;
|
|
CreatureObject creature = p.getCreatureObject();
|
|
if (creature == null) {
|
|
Log.e("ConnectionService", "Unable to set player flags for user: %s on event: %s - CreatureObject is null", p.getUsername(), event);
|
|
return null;
|
|
}
|
|
PlayerObject player = creature.getPlayerObject();
|
|
if (player == null) {
|
|
Log.e("ConnectionService", "Unable to set player flags for user: %s on event: %s - PlayerObject is null", p.getUsername(), event);
|
|
return null;
|
|
}
|
|
return player;
|
|
}
|
|
|
|
private void logOut(Player p, boolean addToDisappear) {
|
|
Log.i("ConnectionService", "Logged out %s with character %s", p.getUsername(), p.getCharacterName());
|
|
removeFromLists(p);
|
|
updatePlayTime(p);
|
|
if (addToDisappear) {
|
|
synchronized (disappearPlayers) {
|
|
disappearPlayers.add(new DisappearPlayer(System.nanoTime(), p));
|
|
}
|
|
updateService.schedule(disappearRunnable, (long) DISAPPEAR_THRESHOLD + 100, TimeUnit.MILLISECONDS);
|
|
}
|
|
}
|
|
|
|
private void disappear(Player p, boolean newConnection, DisconnectReason reason) {
|
|
Log.i("ConnectionService", "Disappeared %s with character %s with reason %s", p.getUsername(), p.getCharacterName(), reason);
|
|
|
|
if (newConnection) // Attempting to re-zone
|
|
removeFromDisappear(p);
|
|
else
|
|
removeFromLists(p);
|
|
p.setPlayerState(PlayerState.DISCONNECTED);
|
|
Intent i = new PlayerEventIntent(p, PlayerEvent.PE_DISAPPEAR);
|
|
new PlayerEventIntent(p, PlayerEvent.PE_DESTROYED).broadcastAfterIntent(i);
|
|
i.broadcast();
|
|
}
|
|
|
|
private void disconnect(Player player, DisconnectReason reason) {
|
|
Log.i("ConnectionService", "Disconnected %s with character %s with reason %s", player.getUsername(), player.getCharacterName(), reason);
|
|
new CloseConnectionIntent(player.getNetworkId(), reason).broadcast();
|
|
}
|
|
|
|
private void updatePlayTime(Player p) {
|
|
PlayerObject playerObject = p.getPlayerObject();
|
|
if (playerObject == null)
|
|
return;
|
|
|
|
playerObject.updatePlayTime();
|
|
}
|
|
|
|
private static class DisappearPlayer {
|
|
private final long time;
|
|
private final Player player;
|
|
|
|
public DisappearPlayer(long time, Player player) {
|
|
this.time = time;
|
|
this.player = player;
|
|
}
|
|
|
|
public long getTime() { return time; }
|
|
public Player getPlayer() { return player; }
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (o == null)
|
|
return false;
|
|
if (!(o instanceof DisappearPlayer))
|
|
return false;
|
|
return ((DisappearPlayer) o).getPlayer().equals(player);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return player.hashCode();
|
|
}
|
|
}
|
|
|
|
}
|