protected override async Task OnInitializedAsync()
{
Game = await GameDataService.GetGameDetails(new Guid(GameId));
Friends.AddRange((await FriendDataService.GetAllFriends()).ToList());
}
protected async Task HandleTakeGameBackSubmit()
{
Saved = await GameDataService.TakeGame(Game.Id);
}
public async void AddGameDialog_OnDialogClose()
{
Games = (await GameDataService.GetAllGames()).ToList();
StateHasChanged();
}
public GameController(GameService gameService, GameDataService gameDataService)
{
_gameService = gameService;
_gameDataService = gameDataService;
}
public void DeleteGame_Executed(object sender, ExecutedRoutedEventArgs e)
{
GameDataService.RemoveGame(game);
mainWindow.DisplayGames();
}
public GameDataController(GameDataService gameDataService)
{
_gameDataService = gameDataService;
}
internal Character(ILogger <Character> logger, CharacterManager characterManager, PlayerCharacterEntity entity,
GameDataService gameDataService)
{
SetExistsState(true);
CharacterManager = characterManager;
Weapons = new CharacterInventory(this, 3, ItemCategory.Weapon);
Skills = new CharacterInventory(this, 1, ItemCategory.Skill);
Costumes = new CharacterInventory(this, 7, ItemCategory.Costume);
Id = entity.Id;
Slot = entity.Slot;
Gender = (CharacterGender)entity.Gender;
Hair = gameDataService.GetDefaultItem(Gender, CostumeSlot.Hair, entity.BasicHair);
Face = gameDataService.GetDefaultItem(Gender, CostumeSlot.Face, entity.BasicFace);
Shirt = gameDataService.GetDefaultItem(Gender, CostumeSlot.Shirt, entity.BasicShirt);
Pants = gameDataService.GetDefaultItem(Gender, CostumeSlot.Pants, entity.BasicPants);
Gloves = gameDataService.GetDefaultItem(Gender, CostumeSlot.Gloves, 0);
Shoes = gameDataService.GetDefaultItem(Gender, CostumeSlot.Shoes, 0);
var plr = characterManager.Player;
var inventory = CharacterManager.Player.Inventory;
plr.AddContextToLogger(logger);
SetInventoryIfNeeded(entity.Weapon1Id, (byte)WeaponSlot.Weapon1, Weapons);
SetInventoryIfNeeded(entity.Weapon2Id, (byte)WeaponSlot.Weapon2, Weapons);
SetInventoryIfNeeded(entity.Weapon3Id, (byte)WeaponSlot.Weapon3, Weapons);
SetInventoryIfNeeded(entity.HairId, (byte)CostumeSlot.Hair, Costumes);
SetInventoryIfNeeded(entity.FaceId, (byte)CostumeSlot.Face, Costumes);
SetInventoryIfNeeded(entity.ShirtId, (byte)CostumeSlot.Shirt, Costumes);
SetInventoryIfNeeded(entity.PantsId, (byte)CostumeSlot.Pants, Costumes);
SetInventoryIfNeeded(entity.GlovesId, (byte)CostumeSlot.Gloves, Costumes);
SetInventoryIfNeeded(entity.ShoesId, (byte)CostumeSlot.Shoes, Costumes);
SetInventoryIfNeeded(entity.AccessoryId, (byte)CostumeSlot.Accessory, Costumes);
SetInventoryIfNeeded(entity.SkillId, (byte)SkillSlot.Skill, Skills);
Weapons.ItemAdded += SendEquip;
Weapons.ItemRemoved += SendUnEquip;
Costumes.ItemAdded += SendEquip;
Costumes.ItemRemoved += SendUnEquip;
Skills.ItemAdded += SendEquip;
Skills.ItemRemoved += SendUnEquip;
void SendEquip(object _, CharacterInventoryEventArgs e)
{
plr.Session.Send(new SUseItemAckMessage(Slot, e.Slot, e.Item.Id, UseItemAction.Equip));
}
void SendUnEquip(object _, CharacterInventoryEventArgs e)
{
plr.Session.Send(new SUseItemAckMessage(Slot, e.Slot, e.Item.Id, UseItemAction.UnEquip));
}
void SetInventoryIfNeeded(long?id, byte itemSlot, CharacterInventory characterInventory)
{
var log = logger.ForContext(
("CharacterSlot", Slot),
("ItemSlot", itemSlot),
("ItemId", id));
if (id == null)
{
return;
}
var item = inventory[(ulong)id];
if (item == null)
{
log.Warning("Character has non-existant item");
return;
}
var error = characterInventory.Add(itemSlot, item);
if (error != CharacterInventoryError.OK)
{
log.Warning("Unable to equip item Error={Error}", error);
}
}
}
public AuthenticationHandler(ILogger <AuthenticationHandler> logger,
IOptions <NetworkOptions> networkOptions, IOptionsMonitor <AppOptions> appOptions, IOptions <GameOptions> gameOptions,
ICacheClient cacheClient, ISessionManager sessionManager, DatabaseService databaseService,
IServiceProvider serviceProvider, PlayerManager playerManager, GameDataService gameDataService)
{
_logger = logger;
_networkOptions = networkOptions.Value;
_appOptions = appOptions;
_gameOptions = gameOptions.Value;
_cacheClient = cacheClient;
_sessionManager = sessionManager;
_databaseService = databaseService;
_serviceProvider = serviceProvider;
_playerManager = playerManager;
_gameDataService = gameDataService;
}
async public void PlayDay(MouseEventArgs args)
{
GameDataService.PlayAndProcessDay();
await RefreshData();
}
async public void StartNextCompetition(MouseEventArgs args)
{
GameDataService.StartNextCompetition();
await RefreshData();
}
async public void StartNextYear(MouseEventArgs args)
{
GameDataService.StartNextYear();
await RefreshData();
}
public void Update()
{
if (!photonView.isMine)
{
return;
}
if (player.gameData.gameState.Equals("world"))
{
inWorld = true;
}
else
{
inWorld = false;
}
xChange = 0;
yChange = 0;
if (!isMoving && inWorld)
{
if (Input.GetMouseButton(0))
{
Debug.Log("trying to move via mouse click.");
// movement by mouse takes priority
Vector3 mouseWorldPos = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0f));
if (Mathf.Abs(mouseWorldPos.x - player.transform.position.x) > Mathf.Abs(mouseWorldPos.y - player.transform.position.y))
{
// horiz movement
if (mouseWorldPos.x > player.transform.position.x)
{
xChange += 1;
}
else
{
xChange -= 1;
}
}
else
{
// vert movement
if (mouseWorldPos.y > player.transform.position.y)
{
yChange += 1;
}
else
{
yChange -= 1;
}
}
}
else if (Input.GetAxis("Horizontal") != 0 || Input.GetAxis("Vertical") != 0)
{
// movement by keyboard
Vector2 input = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
if (!allowDiagonals)
{
if (Mathf.Abs(input.x) > Mathf.Abs(input.y))
{
input.y = 0;
if (input.x > 0)
{
xChange += 1;
}
else
{
xChange -= 1;
}
}
else
{
input.x = 0;
if (input.y > 0)
{
yChange += 1;
}
else
{
yChange -= 1;
}
}
}
}
//Debug.Log("After move input, xChange = " + xChange + " and yChange = " + yChange);
if ((xChange != 0 || yChange != 0))
{
Debug.Log("Current x: " + player.gameData.locX + " Current y: " + player.gameData.locY);
Debug.Log("Trying to move to: " + ((int)player.gameData.locX + xChange).ToString() + ", " + ((int)player.gameData.locY + yChange).ToString() + " Tile type: " + world.GetTileAt((int)player.gameData.locX + xChange, (int)player.gameData.locY + yChange).GroundType.ToString());
GroundType groundType = world.GetTileAt((int)player.gameData.locX + xChange, (int)player.gameData.locY + yChange).GroundType;
if (groundType == GroundType.WATER || groundType == GroundType.MOUNTAIN)
{
Debug.Log("Cannot move, impassable tile.");
}
else
{
GameDataService.updateGameData(player.gameData);
StartCoroutine(move(transform));
}
}
}
}
public override void InitData()
{
serviceGameData = new GameDataService();
}
public static async Task <long> GetCharacterLastActivityTime(GameDataService gameData, XIVAPIService xivapi, ulong id) => await GetCharacterLastActivityTime(gameData, xivapi, await xivapi.GetCharacter(id));
public override void InitData()
{
mGameDataService = new GameDataService();
mGameListDataService = new GameListDataService();
}
public HomeController(ILogger <HomeController> logger, GameService gameService, GameDataService gameDataService)
{
_logger = logger;
_gameService = gameService;
_gameDataService = gameDataService;
}
public void BeforeAnyTestStarted()
{
// Perform setup here?
sut = new GameDataService();
}
public ShopHandler(GameDataService gameDataService, IOptions <GameOptions> gameOptions, ILogger <ShopHandler> logger)
{
_gameDataService = gameDataService;
_logger = logger;
_gameOptions = gameOptions.Value;
}
public void SetupDataServices()
{
TeamDataService = new BaseDataService <TeamDAO>();
GameDataService = new GameDataService();
}
protected override async Task OnInitializedAsync()
{
Games = await GameDataService.GetAllGames();
//AddGameDialog.OnDialogClose += AddGameDialog_OnDialogClose;
}
public WebApiService(IServiceProvider serviceProvider, IOptions <WebApiOptions> options, GameDataService gameDataService)
{
_gameDataService = gameDataService;
Terminal.Settings.DisplayLoggingMessageType = LogMessageType.None;
Terminal.OnLogMessageReceived += (_, e) =>
{
var logger = Log.ForContext(Constants.SourceContextPropertyName, $"WebApi-{e.Source}");
switch (e.MessageType)
{
case LogMessageType.Info:
logger.Information(e.Exception, e.Message);
break;
case LogMessageType.Debug:
logger.Debug(e.Exception, e.Message);
break;
case LogMessageType.Trace:
logger.Verbose(e.Exception, e.Message);
break;
case LogMessageType.Error:
logger.Error(e.Exception, e.Message);
break;
case LogMessageType.Warning:
logger.Warning(e.Exception, e.Message);
break;
case LogMessageType.Fatal:
logger.Fatal(e.Exception, e.Message);
break;
}
};
_webServer = new WebServer(options.Value.Listener);
_webServer.RegisterModule(new WebApiModule());
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var type in assembly.DefinedTypes)
{
if (type.IsClass && !type.IsAbstract && type.IsSubclassOf(typeof(WebApiController)))
{
var parameters = new List <object>
{
null
};
var ctor = type.GetConstructors().First();
parameters.AddRange(ctor.GetParameters()
.Skip(1)
.Select(x => serviceProvider
.GetRequiredService(x.ParameterType)));
var arr = parameters.ToArray();
_webServer
.Module <WebApiModule>()
.RegisterController(type, ctx =>
{
arr[0] = ctx;
return(Activator.CreateInstance(type, arr));
});
}
}
}
}
protected override async Task OnInitializedAsync()
{
Games = (await GameDataService.GetAllGames()).ToList();
}
public GameDataController(IHttpContext context, GameDataService gameDataService)
: base(context)
{
_gameDataService = gameDataService;
}
public ReplayDetailsWriter(ILogger <ReplayDetailsWriter> logger, IOptions <Settings> settings, ReplayHelper replayHelper, HeroesProfileService heroesProfileService, GameDataService gameDataService)
{
this.logger = logger;
this.heroesProfileService = heroesProfileService;
this.gameDataService = gameDataService;
this.settings = settings.Value;
}
protected override async Task OnInitializedAsync()
{
Game = await GameDataService.GetGameDetails(new System.Guid(GameId));
}
