public InfusionTestProxy()
{
ServerPacketHandler = new ServerPacketHandler();
ClientPacketHandler = new ClientPacketHandler();
Server = new UltimaServer(ServerPacketHandler, packet =>
{
var filteredPacket = ClientPacketHandler.FilterOutput(packet);
if (filteredPacket.HasValue)
{
packetsSentToServer.Add(filteredPacket.Value);
}
});
Client = new UltimaClient(ClientPacketHandler, packet =>
{
var filteredPacket = ServerPacketHandler.FilterOutput(packet);
if (filteredPacket.HasValue)
{
packetsSentToClient.Add(filteredPacket.Value);
}
});
var logger = new NullLogger();
Api = new Legacy(new Configuration(), new CommandHandler(logger), Server, Client, logger);
}
public HeadlessClient(Legacy legacyApi, IConsole console, HeadlessStartConfig startConfig)
{
this.legacyApi = legacyApi;
this.console = console;
this.startConfig = startConfig;
packetRegistry = PacketDefinitionRegistryFactory.CreateClassicClient(startConfig.ClientVersion);
diagnosticProvider = new InfusionDiagnosticPushStreamProvider(LogConfig, console);
serverDiagnosticPushStream =
new CompositeDiagnosticPushStream(new ConsoleDiagnosticPushStream(packetLogger, "headless -> server", packetRegistry),
new InfusionBinaryDiagnosticPushStream(DiagnosticStreamDirection.ClientToServer, diagnosticProvider.GetStream));
serverDiagnosticPullStream = new ConsoleDiagnosticPullStream(packetLogger, "server -> headless", packetRegistry);
serverConnection = new ServerConnection(ServerConnectionStatus.Initial, serverDiagnosticPullStream,
serverDiagnosticPushStream, packetRegistry, startConfig.Encryption);
serverConnection.PacketReceived += ServerConnectionOnPacketReceived;
ultimaServer = new UltimaServer(serverPacketHandler, SendToServer, packetRegistry);
serverPacketHandler = new ServerPacketHandler(packetRegistry);
clientPacketHandler = new ClientPacketHandler(packetRegistry);
serverEndpoint = startConfig.ServerEndPoint;
ultimaClient = new UltimaClient(clientPacketHandler, SendToClient);
serverPacketHandler.RegisterFilter(FilterServerPacket);
serverPacketHandler.Subscribe(PacketDefinitions.GameServerList, HandleGameServerList);
serverPacketHandler.Subscribe(PacketDefinitions.CharactersStartingLocations, HandleCharactersStartingLocationsPacket);
serverPacketHandler.Subscribe(PacketDefinitions.EnableLockedClientFeatures, HandleEnableLockedClientFeatures);
clientPacketHandler.Subscribe(PacketDefinitions.LoginRequest, HandleLoginRequest);
clientPacketHandler.Subscribe(PacketDefinitions.GameServerLoginRequest, HandleGameServerLoginRequest);
clientPacketHandler.Subscribe(PacketDefinitions.SelectServerRequest, HandleSelectServerRequest);
}
internal StaminaFilter(IServerPacketSubject serverPacketHandler, UltimaClient ultimaClient)
{
serverPacketHandler.RegisterOutputFilter(FilterStamina);
this.ultimaClient = ultimaClient;
serverPacketHandler.Subscribe(PacketDefinitions.UpdateCurrentStamina, HandleUpdateCurrentStamina);
serverPacketHandler.Subscribe(PacketDefinitions.StatusBarInfo, HandleStatusBarInfo);
}
public override void Intitialize(UltimaClient client)
{
base.Intitialize(client);
m_LoginGump = (LoginGump)UltimaEngine.UserInterface.AddControl(new LoginGump(), 0, 0);
m_LoginGump.OnLogin += this.OnLogin;
UltimaVars.EngineVars.Map = -1;
}
internal InfusionTestProxy(ITimeSource timeSource, PacketDefinitionRegistry packetRegistry = null)
{
packetRegistry = packetRegistry ?? PacketDefinitionRegistryFactory.CreateClassicClient();
ServerPacketHandler = new ServerPacketHandler(PacketDefinitionRegistryFactory.CreateClassicClient());
ClientPacketHandler = new ClientPacketHandler(PacketDefinitionRegistryFactory.CreateClassicClient());
Server = new UltimaServer(ServerPacketHandler, packet =>
{
var filteredPacket = ClientPacketHandler.FilterOutput(packet);
if (filteredPacket.HasValue)
{
packetsSentToServer.Add(filteredPacket.Value);
}
}, packetRegistry);
Client = new UltimaClient(ClientPacketHandler, packet =>
{
var filteredPacket = ServerPacketHandler.FilterOutput(packet);
if (filteredPacket.HasValue)
{
packetsSentToClient.Add(filteredPacket.Value);
}
});
var console = new NullConsole();
Api = new Legacy(new LogConfiguration(), new CommandHandler(console), Server, Client, console, packetRegistry,
timeSource, ClilocSource, KeywordSource, new MemoryConfigBagRepository(), new NullInjectionWindow(), new NullSoundPlayer());
UO.Initialize(Api);
ServerApi = new TestServerApi(PacketReceivedFromServer, Api);
}
public PlayerObservers(Player player, UltimaClient client, UltimaServer server, IConsole console,
Legacy legacyApi, GameObjectCollection gameObjects, EventJournalSource eventJournalSource,
PacketDefinitionRegistry packetRegistry)
{
this.client = client;
this.server = server;
this.player = player;
this.console = console;
this.legacyApi = legacyApi;
this.gameObjects = gameObjects;
this.eventJournalSource = eventJournalSource;
this.packetRegistry = packetRegistry;
IClientPacketSubject clientPacketSubject = client;
clientPacketSubject.Subscribe(PacketDefinitions.MoveRequest, HandleMoveRequest);
clientPacketSubject.RegisterOutputFilter(FilterSentClientPackets);
server.RegisterFilter(FilterServerPackets);
server.Subscribe(PacketDefinitions.CharacterLocaleAndBody, HandleCharLocaleAndBodyPacket);
server.Subscribe(PacketDefinitions.DrawGamePlayer, HandleDrawGamePlayerPacket);
server.Subscribe(PacketDefinitions.CharMoveRejection, HandleCharMoveRejectionPacket);
server.Subscribe(PacketDefinitions.UpdateCurrentHealth, HandleUpdateCurrentHealthPacket);
server.Subscribe(PacketDefinitions.UpdateCurrentStamina, HandleUpdateCurrentStaminaPacket);
server.Subscribe(PacketDefinitions.UpdateCurrentMana, HandleUpdateCurrentManaPacket);
server.Subscribe(PacketDefinitions.StatusBarInfo, HandleStatusBarInfoPacket);
server.Subscribe(PacketDefinitions.SendSkills, HandleSendSkillsPacket);
server.Subscribe(PacketDefinitions.DrawObject, HandleDrawObjectPacket);
server.Subscribe(PacketDefinitions.AllowRefuseAttack, HandleAllowRefuseAttack);
server.Subscribe(PacketDefinitions.UpdatePlayer, HandleUpdatePlayerPacket);
server.Subscribe(PacketDefinitions.BoatMoving, HandleBoatMovingPacket);
clientPacketSubject.Subscribe(PacketDefinitions.RequestSkills, HandleRequestSkills);
}
public override void Intitialize(UltimaClient client)
{
base.Intitialize(client);
m_SelectServerGump = (SelectServerGump)UltimaEngine.UserInterface.AddControl(new SelectServerGump(), 0, 0);
m_SelectServerGump.OnBackToLoginScreen += this.OnBackToLoginScreen;
m_SelectServerGump.OnSelectLastServer += this.OnSelectLastServer;
m_SelectServerGump.OnSelectServer += this.OnSelectServer;
}
internal LightObserver(IServerPacketSubject serverPacketHandler, UltimaClient client, Player player, Legacy legacy)
{
this.client = client;
this.player = player;
this.legacy = legacy;
serverPacketHandler.RegisterFilter(FilterBlockedServerPackets);
serverPacketHandler.Subscribe(PacketDefinitions.PersonalLightLevel, HandlePersonalLightLevelPacket);
}
public override void Intitialize(UltimaClient client)
{
base.Intitialize(client);
m_Gump = (LoggingInGump)UltimaEngine.UserInterface.AddControl(new LoggingInGump(), 0, 0);
m_Gump.OnCancelLogin += this.OnCancelLogin;
if (Client.IsConnected)
Client.Disconnect();
}
public override void Intitialize(UltimaClient client)
{
base.Intitialize(client);
m_CharListGump = (CharacterListGump)UltimaEngine.UserInterface.AddControl(new CharacterListGump(), 0, 0);
m_CharListGump.OnBackToSelectServer += this.OnBackToSelectServer;
m_CharListGump.OnLoginWithCharacter += this.OnLoginWithCharacter;
m_CharListGump.OnDeleteCharacter += this.OnDeleteCharacter;
m_CharListGump.OnNewCharacter += this.OnNewCharacter;
}
internal Phantoms(UltimaClient ultimaClient, IServerPacketSubject serverPacketSubject, PacketDefinitionRegistry packetRegistry)
{
this.ultimaClient = ultimaClient;
this.packetRegistry = packetRegistry;
var clientPacketSubject = (IClientPacketSubject)ultimaClient;
clientPacketSubject.RegisterFilter(PhantomsFilter);
serverPacketSubject.Subscribe(PacketDefinitions.DrawObject, HandleDrawObject);
}
public GumpObservers(UltimaServer server, UltimaClient client, EventJournalSource eventSource, Cancellation cancellation)
{
this.server = server;
this.client = client;
this.eventSource = eventSource;
this.cancellation = cancellation;
server.RegisterFilter(FilterSendGumpMenuDialog);
IClientPacketSubject clientPacketSubject = client;
clientPacketSubject.RegisterFilter(FilterGumpMenuSelection);
clientPacketSubject.Subscribe(PacketDefinitions.GumpMenuSelection, GumpMenuSelectionRequest);
}
internal Legacy(Configuration configuration, CommandHandler commandHandler,
UltimaServer ultimaServer, UltimaClient ultimaClient, ILogger logger)
{
Trace = new GlobalTrace(logger);
cancellation = new Cancellation(() => CancellationToken);
eventJournalSource = new EventJournalSource();
Me = new Player(() => GameObjects.OfType <Item>().OnLayer(Layer.Mount).FirstOrDefault() != null,
ultimaServer, this, eventJournalSource);
gumpObservers = new GumpObservers(ultimaServer, ultimaClient, eventJournalSource, cancellation);
GameObjects = new GameObjectCollection(Me);
Items = new ItemCollection(GameObjects);
Mobiles = new MobileCollection(GameObjects);
Corpses = new CorpseCollection(GameObjects);
itemsObserver = new ItemsObservers(GameObjects, ultimaServer, ultimaClient, this, eventJournalSource);
Me.LocationChanged += itemsObserver.OnPlayerPositionChanged;
journalSource = new SpeechJournalSource();
journalSource.NewMessageReceived +=
(sender, entry) => eventJournalSource.Publish(new SpeechReceivedEvent(entry));
Journal = new SpeechJournal(journalSource, cancellation, () => DefaultTimeout, Trace.JournalTrace);
journalObservers = new JournalObservers(journalSource, ultimaServer);
targeting = new Targeting(ultimaServer, ultimaClient, cancellation, eventJournalSource);
blockedPacketsFilters = new BlockedClientPacketsFilters(ultimaClient);
lightObserver = new LightObserver(ultimaServer, ultimaClient, Me, this);
weatherObserver = new WeatherObserver(ultimaServer, ultimaClient, this);
soundObserver = new SoundObserver(ultimaServer, eventJournalSource);
questArrowObserver = new QuestArrowObserver(ultimaServer, eventJournalSource);
shapeShifter = new ShapeshiftingFilter(ultimaServer, ultimaClient);
var speechRequestObserver = new SpeechRequestObserver(ultimaClient, commandHandler, eventJournalSource, logger);
var staminaFilter = new StaminaFilter(ultimaServer, ultimaClient);
dialogBoxObervers = new DialogBoxObservers(ultimaServer, eventJournalSource);
playerObservers = new PlayerObservers(Me, ultimaClient, ultimaServer, logger, this, GameObjects, eventJournalSource);
playerObservers.WalkRequestDequeued += Me.OnWalkRequestDequeued;
this.logger = logger;
Server = ultimaServer;
Client = ultimaClient;
CommandHandler = commandHandler;
CommandHandler.CancellationTokenCreated += (sender, token) => CancellationToken = token;
Configuration = configuration;
legacyEventJournal = CreateEventJournal();
ClientFilters = new LegacyFilters(staminaFilter, lightObserver, weatherObserver, soundObserver, shapeShifter);
RegisterDefaultCommands();
}
public Targeting(UltimaServer server, UltimaClient client, Cancellation cancellation,
EventJournalSource eventSource)
{
this.server = server;
this.client = client;
this.cancellation = cancellation;
this.eventSource = eventSource;
server.Subscribe(PacketDefinitions.TargetCursor, HanldeServerTargetCursorPacket);
eventJournal = new EventJournal(eventSource, cancellation);
IClientPacketSubject clientPacketSubject = client;
clientPacketSubject.RegisterFilter(FilterClientTargetCursorPacket);
IServerPacketSubject serverPacketSubject = server;
serverPacketSubject.RegisterFilter(FilterSeverTargetCursorPacket);
}
public GumpObservers(UltimaServer server, UltimaClient client, EventJournalSource eventSource,
Cancellation cancellation, PacketDefinitionRegistry packetRegistry)
{
this.server = server;
this.client = client;
this.eventSource = eventSource;
this.cancellation = cancellation;
this.packetRegistry = packetRegistry;
server.RegisterFilter(FilterSendGumpMenuDialog);
IClientPacketSubject clientPacketSubject = client;
clientPacketSubject.RegisterFilter(FilterGumpMenuSelection);
clientPacketSubject.Subscribe(PacketDefinitions.GumpMenuSelection, GumpMenuSelectionRequest);
IServerPacketSubject serverPacketSubject = server;
serverPacketSubject.Subscribe(PacketDefinitions.SendGumpMenuDialog, HandleGump);
serverPacketSubject.Subscribe(PacketDefinitions.CompressedGump, HandleGump);
}
public WeatherObserver(IServerPacketSubject serverPacketHandler, UltimaClient client, Legacy legacy)
{
this.client = client;
this.legacy = legacy;
serverPacketHandler.RegisterFilter(FilterBlockedServerPackets);
}
public void Initialize(UltimaClient client)
{
Client = client;
OnInitialize();
}
internal WalkingObserver(IClientPacketSubject clientPacketSubject, UltimaClient client, Player player)
{
clientPacketSubject.RegisterFilter(FilterClientPackets);
this.client = client;
this.player = player;
}
public SceneManager(UltimaClient client)
{
Client = client;
}
public virtual void Intitialize(UltimaClient client)
{
Client = client;
}
public override void Intitialize(UltimaClient client)
{
base.Intitialize(client);
m_Status = CreateCharacterSceneStates.Default;
openSkillsGump();
}
public ShapeshiftingFilter(IServerPacketSubject serverPacketHandler, UltimaClient client)
{
serverPacketHandler.RegisterOutputFilter(FilterItemShapes);
}
public ShapeshiftingFilter(IServerPacketSubject serverPacketHandler, UltimaClient client,
PacketDefinitionRegistry packetRegistry)
{
serverPacketHandler.RegisterOutputFilter(FilterItemShapes);
this.packetRegistry = packetRegistry;
}
