public ExchangeProvider(IItemProvider itemBuilderService, WorldConfiguration worldConfiguration, ILogger logger)
{
_exchangeDatas = new ConcurrentDictionary <long, ExchangeData>();
_exchangeRequests = new ConcurrentDictionary <long, long>();
_itemBuilderService = itemBuilderService;
_worldConfiguration = worldConfiguration;
_logger = logger;
}
public CommandPacketController(WorldConfiguration worldConfiguration, List <Item> items,
IItemBuilderService itemBuilderService, MapInstanceAccessService mapInstanceAccessService)
{
_worldConfiguration = worldConfiguration;
_items = items;
_itemBuilderService = itemBuilderService;
_mapInstanceAccessService = mapInstanceAccessService;
}
public CreateItemPackettHandler(ILogger logger, List <ItemDto> items, WorldConfiguration worldConfiguration,
IItemProvider itemProvider)
{
_logger = logger;
_items = items;
_itemProvider = itemProvider;
_worldConfiguration = worldConfiguration;
}
public static void Initialize()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
InternalInstance = new ServerMain();
InternalInstance.WriteConsoleLogo();
EngineLog.Write(EngineLogLevel.Startup, "Starting WorldManagerServer");
// Configuration
if (!NetworkConfiguration.Initialize(out var netConfigMsg))
{
throw new StartupException(netConfigMsg);
}
NetConfig = NetworkConfiguration.Instance;
if (!DatabaseConfiguration.Initialize(out var dbConfigMsg))
{
throw new StartupException(dbConfigMsg);
}
DbConfig = DatabaseConfiguration.Instance;
if (!WorldConfiguration.Initialize(out var loginConfigMsg))
{
throw new StartupException(loginConfigMsg);
}
WorldConfig = WorldConfiguration.Instance;
// Database
if (!DB.AddManager(DatabaseType.Character, DatabaseConfiguration.Instance))
{
throw new StartupException("Database connection failure! See above error.");
}
// Handlers
StoreHandlers();
// Networking
LoginServer.Connect(NetConfig.LoginNetConfig.S2SListenIP, (ushort)NetConfig.LoginNetConfig.S2SListenPort);
ZoneServer.Listen(NetConfig.WorldNetConfig.S2SListenIP, (ushort)NetConfig.WorldNetConfig.S2SListenPort);
ClientServer.Listen(NetConfig.WorldNetConfig.ListenIP, (ushort)NetConfig.WorldNetConfig.ListenPort);
// TODO: GameLogServer
// GameLogServer.Connect(NetConfig.GameLogNetConfig.S2SListenIP, (ushort)NetConfig.GameLogNetConfig.S2SListenPort);
// Main server loop
new Thread(() =>
{
while (true)
{
Update(Time.Milliseconds);
Thread.Sleep(10);
}
}).Start();
// Console commands?
}
public WorldServer(ILogger <WorldServer> logger, IOptions <WorldConfiguration> configuration, IGameWorld gameWorld, IInterServerClient interClient, ISelectionScreenFactory selectionScreenFactory)
: base(new ServerConfiguration(configuration.Value.Host, configuration.Value.Port, configuration.Value.MaximumNumberOfConnections), logger)
{
_logger = logger;
_worldConfiguration = configuration.Value;
_gameWorld = gameWorld;
_interClient = interClient;
_selectionScreenFactory = selectionScreenFactory;
}
public CommandPacketController(WorldConfiguration worldConfiguration, List <Item> items,
IItemProvider itemProvider, IMapInstanceProvider mapInstanceProvider, ILogger logger)
{
_worldConfiguration = worldConfiguration;
_items = items;
_itemProvider = itemProvider;
_mapInstanceProvider = mapInstanceProvider;
_logger = logger;
}
public DefaultPacketController(WorldConfiguration worldConfiguration,
IMapInstanceProvider mapInstanceProvider,
IGuriProvider guriProvider, ILogger logger)
{
_worldConfiguration = worldConfiguration;
_mapInstanceProvider = mapInstanceProvider;
_guriProvider = guriProvider;
_logger = logger;
}
public static ExtsPacket GenerateExts(this ICharacterEntity visualEntity, WorldConfiguration conf)
{
return(new ExtsPacket
{
EquipmentExtension = (byte)(visualEntity.InventoryService.Expensions[NoscorePocketType.Equipment] + conf.BackpackSize),
MainExtension = (byte)(visualEntity.InventoryService.Expensions[NoscorePocketType.Main] + conf.BackpackSize),
EtcExtension = (byte)(visualEntity.InventoryService.Expensions[NoscorePocketType.Etc] + conf.BackpackSize)
});
}
public CRegPacketHandler(WorldConfiguration configuration, IBazaarHttpClient bazaarHttpClient,
IDao <IItemInstanceDto?, Guid> itemInstanceDao,
IDao <InventoryItemInstanceDto, Guid> inventoryItemInstanceDao)
{
_configuration = configuration;
_bazaarHttpClient = bazaarHttpClient;
_itemInstanceDao = itemInstanceDao;
_inventoryItemInstanceDao = inventoryItemInstanceDao;
}
public MainViewModel(WorldConfiguration conf)
{
World = new ScreenWorld(conf);
foreach (var evt in Events)
{
World.AddElementToWorld(evt);
}
World.UpdateRangeOfWorld(50.0);
}
public WorldServer(WorldConfiguration worldConfiguration, NetworkManager networkManager,
IEnumerable <IGlobalEvent> events, ILogger logger, IChannelHttpClient channelHttpClient)
{
_worldConfiguration = worldConfiguration;
_networkManager = networkManager;
_events = events.ToList();
_logger = logger;
_channelHttpClient = channelHttpClient;
}
public QuestProvider(List <ScriptDto> scripts,
WorldConfiguration worldConfiguration, List <QuestDto> quests, List <QuestObjectiveDto> questObjectives, ILogger logger)
{
_scripts = scripts;
_quests = quests;
_worldConfiguration = worldConfiguration;
_logger = logger;
_questObjectives = questObjectives;
}
public ContainerWindow(WorldConfiguration conf, PlayerEntityManager player, IconFactory iconFactory, InputsManager inputsManager) :
base(null, iconFactory, new Point(0, 0), new Point(40, 200), inputsManager)
{
_conf = conf;
_player = player;
_iconFactory = iconFactory;
_inputsManager = inputsManager;
Bounds.Size = new UniVector(435, 387);
}
public WorldServer(ILogger <WorldServer> logger, WorldConfiguration configuration, IGameWorld gameWorld)
: base(new ServerConfiguration(configuration.Host, configuration.Port, configuration.MaximumNumberOfConnections))
{
_logger = logger;
_worldConfiguration = configuration;
_gameWorld = gameWorld;
InterClient = new ISClient(configuration);
InterClient.OnPacketArrived += InterClient_OnPacketArrived;;
}
public CScalcPacketHandler(WorldConfiguration worldConfiguration, IBazaarHttpClient bazaarHttpClient,
IItemProvider itemProvider, ILogger logger, IDao <IItemInstanceDto?, Guid> itemInstanceDao)
{
_worldConfiguration = worldConfiguration;
_bazaarHttpClient = bazaarHttpClient;
_itemProvider = itemProvider;
_logger = logger;
_itemInstanceDao = itemInstanceDao;
}
public ScreenWorld(WorldConfiguration config)
{
Configuration = config;
var conf = Configurations[config];
CameraUp = conf.Item1;
WorldAdjustment = conf.Item2;
Initialize();
}
public DeathSystem(ILogger <DeathSystem> logger, IOptions <WorldConfiguration> worldConfiguration, IGameResources gameResources, IMapManager mapManager, ITeleportSystem teleportSystem, IPlayerPacketFactory playerPacketFactory, IMoverPacketFactory moverPacketFactory)
{
_logger = logger;
_worldConfiguration = worldConfiguration.Value;
_gameResources = gameResources;
_mapManager = mapManager;
_teleportSystem = teleportSystem;
_playerPacketFactory = playerPacketFactory;
_moverPacketFactory = moverPacketFactory;
}
internal void NewGame(WorldConfiguration config)
{
World.Instance.Initialize(config);
GlobalRenderer.Instance.InitializeWorld();
while (Mode == GameMode.Gui)
{
CloseGui();
}
OpenGui(new GuiGenerateWorldForm());
}
/// <summary>
/// Creates a new <see cref="NpcLoader"/> instance.
/// </summary>
/// <param name="logger">Logger</param>
/// <param name="configuration">World server configuration</param>
/// <param name="defines">Define loader</param>
/// <param name="texts">Text loader</param>
/// <param name="dialogs">Dialogs loader</param>
/// <param name="shops">Shops loader</param>
public NpcLoader(ILogger <NpcLoader> logger, WorldConfiguration configuration, DefineLoader defines, TextLoader texts, DialogLoader dialogs, ShopLoader shops)
{
this._logger = logger;
this._npcData = new Dictionary <string, NpcData>();
this._configuration = configuration;
this._defines = defines;
this._texts = texts;
this._dialogs = dialogs;
this._shops = shops;
}
public FrmServiceAdd(WorldConfiguration conf)
{
_conf = conf;
InitializeComponent();
foreach (var wrp in _possibleTypes.Where(t => _conf.Services.All(s => s.GetType() != t.Type)))
{
listBox1.Items.Add(wrp);
}
}
public WorldServer(WorldConfiguration worldConfiguration, NetworkManager networkManager, List <Item> items,
List <NpcMonsterDto> npcmonsters, List <Map> maps, MapInstanceAccessService mapInstanceAccessService)
{
_worldConfiguration = worldConfiguration;
_networkManager = networkManager;
_items = items;
_npcmonsters = npcmonsters;
_maps = maps;
_mapInstanceAccessService = mapInstanceAccessService;
}
private WorldConfiguration InitializeConfiguration()
{
var builder = new ConfigurationBuilder();
WorldConfiguration worldConfiguration = new WorldConfiguration();
builder.SetBasePath(Directory.GetCurrentDirectory() + _configurationPath);
builder.AddJsonFile("world.json", false);
builder.Build().Bind(worldConfiguration);
return(worldConfiguration);
}
private static WorldParameters ExtractInformationData(string DBPath, out DateTime fileTimeStamp)
{
WorldParameters worldParameters = null;
FileInfo fi = new FileInfo(DBPath);
fileTimeStamp = fi.LastWriteTime;
SQLiteConnectionStringBuilder csb = new SQLiteConnectionStringBuilder
{
SyncMode = SynchronizationModes.Off,
DataSource = DBPath,
ReadOnly = true
};
SQLiteConnection connection = new SQLiteConnection(csb.ConnectionString);
try
{
connection.Open();
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "SELECT * FROM WorldParameters";
using (var dataReader = cmd.ExecuteReader())
{
dataReader.Read();
//RealmConfiguration configuration = new RealmConfiguration();
//using (var ms = new MemoryStream((byte[])dataReader.GetValue(2)))
//{
// configuration.Load(new BinaryReader(ms));
//}
//Load configuration File from file (not from DB)
WorldConfiguration configuration = WorldConfiguration.LoadFromFile(Path.GetDirectoryName(DBPath) + @"\" + Path.GetFileNameWithoutExtension(DBPath) + ".realm");
worldParameters = new WorldParameters()
{
WorldName = dataReader.GetString(0),
SeedName = dataReader.GetString(1),
Configuration = configuration
};
}
}
connection.Close();
connection.Dispose();
}
catch (Exception e)
{
logger.Error("Error ({1}) loading single player world data information for file {0}", DBPath, e.Message);
}
return(worldParameters);
}
public void WorldServerConnected(WorldConfiguration config)
{
var worldInfo = new WorldServerInfo(
(byte)_interServer.WorldServers.Count,
IPAddress.Parse(config.Host).GetAddressBytes(),
config.Name,
config.BuildVersion,
(ushort)config.MaximumNumberOfConnections);
_interServer.AddWorldServer(worldInfo);
}
public static void Authenticate(IClient client, WorldConfiguration configuration)
{
using var packet = new Packet(PacketType.AUTH_SERVER);
packet.Write <byte[]>(IPAddress.Parse(configuration.Host).GetAddressBytes());
packet.WriteString(configuration.Name, 32);
packet.Write <int>(configuration.BuildVersion);
packet.Write <ushort>((ushort)configuration.MaximumNumberOfConnections);
client.SendPacket(packet);
}
public GameTime(WorldConfiguration config)
{
if (config.FixedTimeStep is <= 0f or > 10f)
{
throw new InvalidOperationException("The fixed timestep can't be less than 0 or greater than 10.");
}
FixedTimeStepFrequency = config.FixedTimeStep;
_time = Stopwatch.StartNew();
_previousFrame = _time.Elapsed.TotalSeconds;
}
private static WorldConfiguration InitializeConfiguration()
{
var builder = new ConfigurationBuilder();
var worldConfiguration = new WorldConfiguration();
builder.SetBasePath(Directory.GetCurrentDirectory() + ConfigurationPath);
builder.AddJsonFile("world.json", false);
builder.Build().Bind(worldConfiguration);
Validator.ValidateObject(worldConfiguration, new ValidationContext(worldConfiguration), validateAllProperties: true);
return(worldConfiguration);
}
public SingleArrayLandscapeCursor(IChunkEntityImpactManager landscapeManager, Vector3I blockPosition, WorldConfiguration config)
{
if (landscapeManager == null)
{
throw new ArgumentNullException("landscapeManager");
}
_landscapeManager = landscapeManager;
GlobalPosition = blockPosition;
_config = config;
landscapeManager.CubesHolder.Index(blockPosition.X, blockPosition.Y, blockPosition.Z, true, out _bigArrayIndex);
}
public WorldServer(WorldConfiguration worldConfiguration, NetworkManager networkManager, List <Item> items,
List <NpcMonsterDto> npcmonsters, List <Map> maps, MapInstanceAccessService mapInstanceAccessService, IEnumerable <IGlobalEvent> events)
{
_worldConfiguration = worldConfiguration;
_networkManager = networkManager;
_items = items;
_npcmonsters = npcmonsters;
_maps = maps;
_mapInstanceAccessService = mapInstanceAccessService;
_events = events.ToList();
}
/// <summary>
/// Creates a new <see cref="ISCClient"/> instance.
/// </summary>
/// <param name="worldConfiguration"></param>
public ISCClient(WorldConfiguration worldConfiguration)
{
this.WorldConfiguration = worldConfiguration;
this.Configuration.Host = this.WorldConfiguration.ISC.Host;
this.Configuration.Port = this.WorldConfiguration.ISC.Port;
this.Configuration.BufferSize = 1024;
Logger.Trace("ISC config -> Host: {0}, Port: {1}, BufferSize: {2}",
this.Configuration.Host,
this.Configuration.Port,
this.Configuration.BufferSize);
}
public static WorldConfiguration FromXML(XElement worldElement)
{
WorldConfiguration configuration = new WorldConfiguration();
configuration.Name = worldElement.Attribute("name").Value;
foreach (XElement battleElement in worldElement.Elements("BattleSystem"))
{
switch (battleElement.Attribute("name").Value)
{
case "TeamBattle":
configuration.TeamBattleConfiguration = TeamBattleConfiguration.FromXML(battleElement);
break;
}
}
return configuration;
}
