public void ConstructorTest()
{
var atom = new DictionaryAtom();
atom.Should().NotBeNull();
atom.Type.Should().Be(AtomType.Dictionary);
}
/// <summary>
///
/// </summary>
/// <param name="initAtom"></param>
public void OnInit(DictionaryAtom initAtom)
{
Validation.IsNotNull(initAtom, "initAtom");
EventManager.RegisterListener(this, typeof(OnGameInitialize), Instance_OnGameInitialize);
_initAtom = initAtom;
}
private static void InitDatabaseLoaders(DictionaryAtom initAtom)
{
var loaderArgs = new ListAtom();
{
var loaderDbo = new DictionaryAtom();
loaderDbo.Set("Catalog", "Realm");
loaderDbo.Set("Schema", "dbo");
loaderDbo.Set("Prefix", "game");
loaderArgs.Add(loaderDbo);
}
{
var loaderLive = new DictionaryAtom();
loaderLive.Set("Catalog", "Realm");
loaderLive.Set("Schema", "live");
loaderLive.Set("Prefix", "game");
loaderArgs.Add(loaderLive);
}
{
var loaderRef = new DictionaryAtom();
loaderRef.Set("Catalog", "Realm");
loaderRef.Set("Schema", "ref");
loaderRef.Set("Prefix", "cp");
loaderArgs.Add(loaderRef);
}
{
var loaderAdmin = new DictionaryAtom();
loaderAdmin.Set("Catalog", "Realm");
loaderAdmin.Set("Schema", "admin");
loaderAdmin.Set("Prefix", "cp");
loaderArgs.Add(loaderAdmin);
}
initAtom.Set("Loaders", loaderArgs);
}
private DictionaryAtom ExecuteProcedure(DictionaryAtom dbCommand)
{
Validation.IsNotNull(dbCommand, "dbCommand");
var dbSchema = dbCommand.GetString("schema");
var dbCommandName = dbCommand.GetString("commandName");
var proc = GetProcedure(dbSchema, dbCommandName);
if (proc == null)
{
throw new ObjectNotFoundException(string.Format(Resources.ERR_DB_PROC_NOT_FOUND, dbSchema, dbCommandName));
}
var dbParameterSet = dbCommand.GetAtom <DictionaryAtom>("parameters");
var executor = new ProcedureExecutor <SqlCommand>(_connection, _log, proc);
var result = executor.ExecuteQuery(dbParameterSet?.ToDictionary());
var dataTable = result.Item2.CastAs <DataTable>();
var resultSet = new DictionaryAtom();
resultSet.Set("Results", dataTable.ToListAtom());
resultSet.Set("Schema", dbSchema);
resultSet.Set("CommandName", dbCommandName);
dataTable.Dispose();
return(resultSet);
}
public void OnInit(DictionaryAtom initAtom, IEventHandler eventHandler)
{
Validation.IsNotNull(initAtom, "initAtom");
_eventHandler = eventHandler;
_log.Info(Resources.MSG_MGR_INITIALIZE);
}
/// <summary>
///
/// </summary>
/// <param name="initAtom"></param>
public override void OnInit(DictionaryAtom initAtom)
{
base.OnInit(initAtom);
Contexts.Add(new PlayerChannelContext(this));
Contexts.Add(new AttributeContext(this));
}
public void OnInit(DictionaryAtom initAtom)
{
var commands = _staticDataManager.GetStaticData(Globals.SystemTypes.GameCommand);
commands.Keys.ToList().ForEach(command => Repository.Add(command,
new Tuple <Action, Definition>(Helper.Get(command), commands[command])));
}
public void OnLoad(DictionaryAtom data)
{
Username = data.GetString("Username");
ID = data.GetInt("UserID");
PreHashId = data.GetInt("PreHashID");
PostHashId = data.GetInt("PostHashID");
}
public void OnGameInitialize_Fact()
{
_callback = false;
var logger = A.Fake <LogWrapper>();
var initAtom = new DictionaryAtom();
initAtom.Add(new StringAtom("Logger"), new ObjectAtom(logger));
var booleanSet = new BooleanSet("Fact", Callback);
booleanSet.AddItem("FakeSingleton");
var args = new RealmEventArgs(new EventTable {
{ "BooleanSet", booleanSet }, { "InitAtom", initAtom }
});
var singleton = new FakeSingleton();
singleton.Instance_OnGameInitialize(args);
_callback.Should().BeTrue();
//Assert.That(_callback, Is.True.After(250));
}
/// <summary>
///
/// </summary>
public void OnInit(Zone zone, DictionaryAtom initAtom)
{
_zone = zone;
base.OnInit(initAtom);
EventManager.RegisterListener(this, _zone, typeof(OnZonePop), OnZonePop);
}
public void SetTest <T>(string key, T value)
{
var atom = new DictionaryAtom();
atom.Set(key, value);
atom.ContainsKey(key).Should().BeTrue();
}
/// <summary>
///
/// </summary>
public new void OnInit(DictionaryAtom initAtom)
{
base.OnInit(initAtom);
_timer.Interval = ZoneDef.RecycleTime;
EventManager.RegisterListener(this, typeof(OnStartupEntitiesLoaded), OnInitComplete);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
/// <param name="data"></param>
/// <param name="def"></param>
public Channel(long id, string name, DictionaryAtom data, Definition def)
: base(id, name, def)
{
MemberRepository = new ChannelMemberRepository();
Data = data;
OwnerId = data.GetInt("OwnerID");
ChannelType = EnumerationExtensions.GetEnum <Globals.ChannelTypes>(data.GetInt("ChannelTypeID"));
Bits = data.GetInt("Bits");
}
public void OnInit(DictionaryAtom initAtom)
{
Validation.IsNotNull(initAtom, "initAtom");
_initAtom = initAtom;
Log.DebugFormat("{0} setup.", GetType());
EventManager.RegisterListener(this, typeof(OnGameInitialize), Instance_OnGameInitialize);
EventManager.RegisterListener(this, typeof(OnGameStop), Instance_OnGameStop);
}
public void OnInit(DictionaryAtom initAtom)
{
Validation.IsNotNull(initAtom, "initAtom");
EventManager.RegisterListener(this, typeof(OnGameInitialize), Instance_OnGameInitialize);
_initAtom = initAtom;
Log.DebugFormat("Created new TcpServer on {0}:{1}", Server.Host, Server.Port);
Server.OnTcpUserStatusChanged += OnTcpUserStatusChanged;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="id">Unique ID of the Definition</param>
/// <param name="name">Name of the Definition</param>
/// <param name="definition">Dictionary Atom containing definition data</param>
protected Definition(long id, string name, DictionaryAtom definition)
{
Validation.Validate <ArgumentOutOfRangeException>(id > 0 && id < Int64.MaxValue);
Validation.IsNotNullOrEmpty(name, "name");
Validation.IsNotNull(definition, "definition");
ID = id;
Name = name;
Def = definition;
}
/// <summary>
///
/// </summary>
/// <param name="initAtom"></param>
/// <param name="repository"></param>
/// <param name="logger"></param>
public ChannelLoader(DictionaryAtom initAtom, ChannelRepository repository, ILogWrapper logger)
: base(1, "ChannelLoader")
{
_dbManager = initAtom.GetObject("DatabaseManager").CastAs <IDatabaseManager>();
_entityManager = initAtom.GetObject("EntityManager").CastAs <IEntityManager>();
_staticDataManager = initAtom.GetObject("StaticDataManager").CastAs <IStaticDataManager>();
_repository = repository;
_log = logger;
}
/// <summary>
///
/// </summary>
/// <param name="initAtom"></param>
public void OnInit(DictionaryAtom initAtom)
{
InitializationAtom = initAtom;
Channels = new ChannelRepository();
Helper.OnInit(InitializationAtom, Channels);
Log.DebugFormat("{0} setup.", GetType());
EventManager.RegisterListener(this, typeof(OnGameInitialize), Instance_OnGameInitialize);
}
public void ContainsKeyTest()
{
const string key = "test";
const int value = 5000;
var atom = new DictionaryAtom();
atom.Set(key, value);
atom.ContainsKey(key).Should().BeTrue();
}
public void CountTest()
{
const string key = "test";
const int value = 25;
var atom = new DictionaryAtom();
atom.Set(key, value);
atom.Count.Should().Be(1);
}
public void ListAtomGetDictionaryInvalidTest()
{
var atom1 = new DictionaryAtom();
atom1.Set("Test1", "Tester tester 1 2 3");
var listAtom = new ListAtom {
atom1, "test"
};
listAtom.GetDictionary(1).Should().BeNull();
}
/// <summary>
/// Converts a datatable to a listatom
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public static ListAtom ToListAtom(this DataTable table)
{
var resultList = new ListAtom();
table.Rows.OfType <DataRow>().ToList().ForEach(row =>
{
var rowResult = new DictionaryAtom();
table.Columns.OfType <DataColumn>().ToList().ForEach(col => rowResult.Set(col.ColumnName, row[col]));
resultList.Add(rowResult);
});
return(resultList);
}
/// <summary>
///
/// </summary>
public virtual void OnInit(DictionaryAtom initAtom)
{
InitializationAtom = initAtom;
EventManager = initAtom.GetObject("EventManager").CastAs <EventManager>();
StaticDataManager = initAtom.GetObject("StaticDataManager").CastAs <StaticDataManager>();
EntityManager = initAtom.GetObject("EntityManager").CastAs <EntityManager>();
Logger = initAtom.GetObject("Logger").CastAs <LogWrapper>();
Contexts.Add(new FlagContext(this));
Contexts.Add(new TagContext(this));
Contexts.Add(new BitContext(this));
Contexts.Add(new PropertyContext(this));
}
/// <summary>
///
/// </summary>
/// <param name="initAtom"></param>
public void OnInit(DictionaryAtom initAtom)
{
var cacheDuration = initAtom.GetInt("PathCacheDuration");
MaxMobileMovementCost = initAtom.GetInt("MaxMobileMovementCost");
_pathRepository = new CachedObjectRepository <KeyValuePair <long, long>, Path>(cacheDuration);
_pathBuilder = new PathBuilder(initAtom, EntityManager);
Log.DebugFormat("PathManager initialized with PathCacheDuration of {0} and MaxMobileMovementCost of {1}",
cacheDuration, MaxMobileMovementCost);
EventManager.RegisterListener(this, typeof(OnGameInitialize), Instance_OnGameInitialize);
}
public void GetValueTest()
{
const string key = "test";
const int value = 5000;
var atom = new DictionaryAtom();
atom.Set(key, value);
var actual = atom.GetAtom <IntAtom>("test");
actual.Should().NotBeNull();
actual.Value.Should().Be(value);
}
/// <summary>
///
/// </summary>
/// <param name="initAtom"></param>
/// <param name="entityInitializer"></param>
public void OnInit(DictionaryAtom initAtom, IEntityInitializer entityInitializer)
{
EntityInitializer = entityInitializer;
InitializationAtom = initAtom;
var recycleFrequency = initAtom.GetInt("RecycleFrequency");
Validation.Validate <ArgumentOutOfRangeException>(recycleFrequency > 0);
Log.DebugFormat("EntityManager initialized with Recycle Frequency of {0}", recycleFrequency);
_recycler.Timer.Interval = recycleFrequency;
EventManager.RegisterListener(this, typeof(OnGameInitialize), Instance_OnGameInitialize);
}
/// <summary>
///
/// </summary>
/// <param name="ipAddress"></param>
/// <param name="tcpClient"></param>
/// <param name="initAtom"></param>
public GameUser(string ipAddress, ITcpUser tcpClient, DictionaryAtom initAtom)
: base(0, "NewUser")
{
var kernel = (IKernel)initAtom.GetObject("Ninject.Kernel");
IpAddress = ipAddress;
TcpClient = tcpClient;
TcpServer = kernel.Get <ITcpServer>();
MenuRepository = new MenuHandlerRepository();
MenuRepository.Add("MainMenu",
kernel.Get <IMenuHandler>("MainMenu", new Parameter("initAtom", initAtom, false)));
TcpServer.OnNetworkMessageReceived += Server_OnNetworkMessageReceived;
}
public void CopyConstructorTest()
{
const string key = "test";
const int value = 25;
var atom = new DictionaryAtom();
atom.Set(key, value);
var newAtom = new DictionaryAtom(atom);
newAtom.Count.Should().Be(1);
newAtom.GetInt(key).Should().Be(value);
}
/// <summary>
///
/// </summary>
/// <param name="initAtom"></param>
public void OnInit(DictionaryAtom initAtom)
{
Validation.IsNotNull(initAtom, "initAtom");
_numberVMs = initAtom.GetInt("NumberLuaVMs");
Validation.Validate <ArgumentOutOfRangeException>(_numberVMs >= 1);
_dataPath = initAtom.GetString("DataPath");
Log.DebugFormat("{0} asked to initialize {1} LuaVMs.", GetType(), _numberVMs);
var kernel = (IKernel)initAtom.GetObject("Ninject.Kernel");
EventManager.RegisterListener(this, kernel.Get <IGame>(), typeof(OnGameInitialize), Instance_OnGameInitialize);
}
private void Login(GameUser user, string message)
{
// Syntax: login/connect username password
_dataSet = new DictionaryAtom();
_dataSet.Set("Username", message.SecondWord());
_dataSet.Set("Password", message.ThirdWord());
_dataSet.Set("Message", message);
_dataSet.Set("User", user);
//var loader = new GameUserLoader(user, _dbLoadBalancer, _log);
var loader = _kernel.Get <IGameUserLoader>(new Parameter("owner", user, false));
var processor = new GameUserLoginProcessor((GameUserLoader)loader, string.Empty, 30, 3);
processor.Execute(user, message.SecondWord(), message.ThirdWord(), OnLoginComplete);
}
