public bool UseItem(GameCharacter character, UsableItem item, Tile targetTile)
{
bool usedItem = false;
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
if (character.CheckAP(item.actionPoints))
{
if (item.activeEffects != null)
{
foreach (var a in item.activeEffects)
{
character.AddActiveEffect(a, this);
}
usedItem = true;
character.SpendAP(item.actionPoints);
item.uses--;
}
else if (item.itemAbility != null)
{
bool usedAbility = AbilityHelper.UseAbility(ActiveCharacter, item.itemAbility, targetTile, this);
if (usedAbility)
{
usedItem = true;
character.SpendAP(item.actionPoints);
item.uses--;
}
}
if (item.uses <= 0)
{
//should this logic be here?
battleLog.AddEntry(string.Format("{0} has no more uses.", item.name));
ActiveCharacter.removeUsableItem(item);
//ActiveCharacter.inventory.Remove(item);
}
}
if (usedItem)
{
battleLog.AddEntry(string.Format("{0} used item {1}", character.name, item.name));
return(true);
}
else
{
battleLog.AddEntry(string.Format("{0} was unable to use item {1}", character.name, item.name));
return(false);
}
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable to use {1}.", character.name, item.name));
}
return(false);
}
public Task Jump(MoveJumpRequest request)
{
VerifyIngame();
return(Task.WhenAll(
Move(request),
ActiveCharacter.Jump()
));
}
public void StartMainTurn()
{
Log("Start main turn for " + ActiveCharacter.ToString());
IsMainTurn = true;
foreach (CharacterEnum target in UserDict.Keys.ToList())
{
UserDict[target].Write(new ResponseMessage(new MainTurnResponse()));
}
}
public void OnInteract(SquadType interactorSquadType)
{
if (squadType != interactorSquadType)
{
return;
}
ActiveCharacter?.HideVisual();
ActiveCharacter = this;
UpdateVisual();
}
public void Init()
{
//Initialise the Unit stats.
_HP = MaxHP;
_EN = MaxEN;
foreach (Character ActiveCharacter in ArrayCharacterActive)
{
ActiveCharacter.Init();
}
_UnitStat.Init();
DoInit();
}
public Task SetTarget(ObjectID unitId)
{
VerifyIngame();
if (unitId == ObjectID.Null)
{
return(ActiveCharacter.ClearTarget());
}
else
{
return(ActiveCharacter.SetTarget(unitId));
}
}
public void NextTurnActiveDied()
{
TurnCounter++;
NewTurn = true;
if (currentCharacter >= characterList.Count)
{
currentCharacter = 0;
}
ActiveCharacter.ResetAP();
ActiveCharacter.UpdateCooldownTimers();
battleLog.AddEntry(string.Format("{0}'s turn", ActiveCharacter.name));
}
public void StartTurn()
{
Log("Start turn for " + ActiveCharacter.ToString());
IsMainTurn = false;
// Draw card
int damage = 0;
Card drawnCard = UserDict[ActiveCharacter].Player.Draw();
if (drawnCard == null) // Handle if deck is finished
{
if (UserDict[ActiveCharacter].Player.Deck.Count == 0)
{
damage = 1;
}
}
// Give mana
UserDict[ActiveCharacter].Player.Mana += CurrentRound * AmaruConstants.MANA_TURN_FACTOR;
// Add EP and execute onturnstart for each card on table
OnTurnStartVisitor OTSVisitor = new OnTurnStartVisitor(ActiveCharacter, AmaruConstants.GAME_PREFIX + Id);
List <Card> Modified = new List <Card>();
foreach (CreatureCard card in UserDict[ActiveCharacter].Player.Inner)
{
card.Energy++;
card.Visit(OTSVisitor, ActiveCharacter, null);
Modified.Add(card);
}
foreach (CreatureCard card in UserDict[ActiveCharacter].Player.Outer)
{
card.Energy++;
card.Visit(OTSVisitor, ActiveCharacter, null);
Modified.Add(card);
}
// Disable immunity
if (UserDict[ActiveCharacter].Player.IsImmune)
{
UserDict[ActiveCharacter].Player.IsImmune = false;
}
UserDict[ActiveCharacter].Write(new ResponseMessage(new NewTurnResponse(CurrentRound, ActiveCharacter, UserDict[ActiveCharacter].Player.Mana, drawnCard, Modified, damage)));
foreach (CharacterEnum target in CharacterManager.Instance.Others(ActiveCharacter))
{
UserDict[target].Write(new ResponseMessage(new NewTurnResponse(CurrentRound, ActiveCharacter, UserDict[ActiveCharacter].Player.Mana, drawnCard != null, Modified, damage)));
}
}
private void UnloadCharacter()
{
if (ActiveCharacter != null)
{
ActiveCharacter.Deactivate();
}
ActiveCharacter = null;
if (this.OptionGroups != null)
{
foreach (IOptionGroupViewModel ogVM in this.OptionGroups)
{
ogVM.RemoveDesktopKeyEventHandlers();
}
}
}
private void Update()
{
if (RpguiPauseGame.IsVisible())
{
Time.timeScale = 0;
return;
}
if (IsAutoPlay != isAutoPlayDirty)
{
if (IsAutoPlay)
{
uiUseSkillManager.Hide();
if (ActiveCharacter != null)
{
ActiveCharacter.RandomAction();
}
}
isAutoPlayDirty = IsAutoPlay;
}
Time.timeScale = !isEnding && IsSpeedMultiply ? 2 : 1;
if (Input.GetMouseButtonDown(0) && ActiveCharacter != null && ActiveCharacter.IsPlayerCharacter)
{
//Ray ray = inputCamera.ScreenPointToRay(RPGInputManager.MousePosition());
//Debug.DrawRay(ray.origin, ray.direction, Color.red);
//RaycastHit hitInfo;
//if (!Physics.Raycast(ray, out hitInfo))
// return;
if (CurrentSelectedEntity == null)
{
return;
}
//var targetCharacter = hitInfo.collider.GetComponent<CharacterEntity>();
var targetCharacter = CurrentSelectedEntity.GetComponent <CharacterEntity>();
if (targetCharacter != null)
{
if (ActiveCharacter.DoAction(targetCharacter))
{
playerFormation.SetCharactersSelectable(false);
foeFormation.SetCharactersSelectable(false);
}
}
}
}
private void CreateCharacterRosterDependencies()
{
foreach (Character ActiveCharacter in TeamCharacters.ListAll)
{
foreach (KeyValuePair <string, Character.CharacterLinkTypes> CharacterLink in ActiveCharacter.DicCharacterLink)
{
foreach (Character ActiveLinkCharacter in TeamCharacters.ListAll)
{
if (ActiveLinkCharacter.FullName == CharacterLink.Key)
{
ActiveCharacter.ShareStats(ActiveLinkCharacter, CharacterLink.Value);
break;
}
}
}
}
}
public void OnDisconnect()
{
AccountManager.Instance.RemoveAccount(Id);
if (ActiveCharacter == null)
{
return;
}
if (!ActiveCharacter.IsInternalDisconnect)
{
ActiveCharacter.Save();
}
ActiveCharacter.Friends.GetOffline();
WorldManager.Instance.Despawn(ActiveCharacter);
}
public bool SetAccountActive(bool active, DateTime?statusUntil)
{
var acc = AccountMgr.GetAccount(Name);
if (acc == null)
{
return(false);
}
acc.StatusUntil = statusUntil;
acc.IsActive = active;
acc.SaveLater();
IsActive = active;
StatusUntil = statusUntil;
if (ActiveCharacter != null && !active)
{
ActiveCharacter.Kick("Banned");
}
return(true);
}
private void SetActiveCharacter()
{
switch (activeCharacter)
{
case ActiveCharacter.NONE:
femaleCharacter.SetActive(false);
maleCharacter.SetActive(false);
m_demoCharacter = null;
break;
case ActiveCharacter.FEMALE:
femaleCharacter.SetActive(true);
maleCharacter.SetActive(false);
m_demoCharacter = femaleCharacter;
break;
case ActiveCharacter.MALE:
femaleCharacter.SetActive(false);
maleCharacter.SetActive(true);
m_demoCharacter = maleCharacter;
break;
default:
break;
}
previousActiveCharacter = activeCharacter;
if (m_demoCharacter)
{
if (m_demoCharacter.GetComponent <Animator>())
{
m_characterAnimator = m_demoCharacter.GetComponent <Animator>();
SetWlakingAnimationTransition(enableCharacterWalking);
}
else
{
Debug.LogWarning("No demo character animator.");
}
}
}
public Task SendChatMessage(ChatMessageRequest request)
{
VerifyIngame();
switch (request.MessageType)
{
case ChatMessageType.Say:
return(ActiveCharacter.Say(request.Message, request.Language));
case ChatMessageType.Yell:
return(ActiveCharacter.Yell(request.Message, request.Language));
case ChatMessageType.Whisper:
return(SendWhisper(request));
default:
// not yet implemented or nonsense
return(Task.CompletedTask);
}
}
private async Task SendWhisper(ChatMessageRequest request)
{
var characterList = GrainFactory.GetGrain <ICharacterList>(ShardName);
var characterId = await characterList.GetCharacterByName(request.TargetName);
if (characterId != null)
{
var character = GrainFactory.GetGrain <ICharacter>(characterId.Value);
// technically a race condition, but probably okay
if (await character.IsOnline())
{
var myEntity = await ActiveCharacter.GetCharacterEntity();
await character.ReceiveWhisper(myEntity.Id, request.Message, request.Language);
var chatConfirm = new ChatMessageResponse()
{
// TODO: language support needed here
Language = ChatLanguage.Universal,
Message = request.Message,
MessageType = ChatMessageType.WhisperConfirm,
// sender and target are reversed for WhisperConfirm
SenderId = characterId.Value,
Tag = ChatTag.None,
TargetId = myEntity.Id,
};
await Send(chatConfirm);
}
else
{
// TODO: "character is not online" notification
}
}
else
{
// TODO: "character does not exist" notification
}
}
public Task Move(MovementInPacket request)
{
VerifyIngame();
Jump jump = null;
if (request.Falling != null)
{
jump = new Jump()
{
Velocity = request.Falling.Velocity,
SineAngle = request.Falling.SinAngle,
CosineAngle = request.Falling.CosAngle,
XYSpeed = request.Falling.XYSpeed,
};
}
return(Task.WhenAll(
ActiveCharacter.SetPosition(request.Position, request.Orientation),
ActiveCharacter.SetMovementState(request.MovementFlags, request.Time, request.FallTime, jump)
));
}
public async Task Login(ObjectID characterId)
{
VerifyAuthenticated();
var character = GrainFactory.GetGrain <ICharacter>(characterId);
if (await character.Exists())
{
var entity = await character.GetCharacterEntity();
// sanity checks
if (entity.Account != AuthenticatedIdentity)
{
GetLogger().Warn($"received login request from account {AuthenticatedIdentity} for character {entity.Name}, owned by {entity.Account}");
return;
}
if (entity.Shard != ShardName)
{
GetLogger().Warn($"received login request from account {AuthenticatedIdentity} for character {entity.Name} which exists in shard {entity.Shard}, but this shard is {ShardName}");
return;
}
GetLogger().Info($"account {AuthenticatedIdentity} logs in as character {entity.Name}");
ActiveCharacter = character;
await ActiveCharacter.Login(this.GetPrimaryKey());
var sendTasks = new LinkedList <Task>();
var loginVerifyWorld = new LoginVerifyWorldRequest()
{
MapId = entity.MapId,
Position = entity.Position,
Orientation = entity.Orientation,
};
sendTasks.AddLast(Send(loginVerifyWorld));
var accountDataTimes = new AccountDataTimesRequest();
sendTasks.AddLast(Send(accountDataTimes));
var loginSetRestStart = new LoginSetRestStartRequest();
sendTasks.AddLast(Send(loginSetRestStart));
var updateBindPoint = new UpdateBindPointRequest()
{
// TODO: implement bind point
Position = entity.Position,
MapId = entity.MapId,
ZoneId = entity.ZoneId,
};
sendTasks.AddLast(Send(updateBindPoint));
var loginInitializeTutorial = new LoginTutorialRequest();
sendTasks.AddLast(Send(loginInitializeTutorial));
var loginInitializeSpells = new LoginInitializeSpellsRequest();
sendTasks.AddLast(Send(loginInitializeSpells));
var loginInitializeActionButtons = new LoginInitializeActionButtonsRequest();
sendTasks.AddLast(Send(loginInitializeActionButtons));
var timeService = GrainFactory.GetGrain <ITimeService>(0);
var loginSetTimeAndSpeed = new LoginSetTimeAndSpeedRequest()
{
// TODO: configurize this?
GameSpeed = 0.01666667f,
ServerTime = await timeService.GetNow(),
};
sendTasks.AddLast(Send(loginSetTimeAndSpeed));
var friendList = new FriendListResponse();
sendTasks.AddLast(Send(friendList));
var ignoreList = new IgnoreListResponse();
sendTasks.AddLast(Send(ignoreList));
var initializeWorldState = new InitializeWorldStateRequest()
{
MapId = entity.MapId,
ZoneId = entity.ZoneId,
};
sendTasks.AddLast(Send(initializeWorldState));
await Task.WhenAll(sendTasks);
}
else
{
GetLogger().Warn($"received login request from account {AuthenticatedIdentity} for non-existing character id {characterId}");
}
}
public void NewTurn()
{
if (ActiveCharacter != null)
{
ActiveCharacter.currentTimeCount = 0;
}
CharacterEntity activatingCharacter = null;
var maxTime = int.MinValue;
List <BaseCharacterEntity> characters = new List <BaseCharacterEntity>();
characters.AddRange(playerFormation.Characters.Values);
characters.AddRange(foeFormation.Characters.Values);
for (int i = 0; i < characters.Count; ++i)
{
CharacterEntity character = characters[i] as CharacterEntity;
if (character != null)
{
if (character.Hp > 0)
{
int spd = (int)character.GetTotalAttributes().spd;
if (spd <= 0)
{
spd = 1;
}
character.currentTimeCount += spd;
if (character.currentTimeCount > maxTime)
{
maxTime = character.currentTimeCount;
activatingCharacter = character;
}
}
else
{
character.currentTimeCount = 0;
}
}
}
ActiveCharacter = activatingCharacter;
bool isStun = activatingCharacter.IsStun();
ActiveCharacter.ApplySkillAndBuff(CustomSkill.TriggerType.beforeFight);
ActiveCharacter.DecreaseBuffsTurn();
ActiveCharacter.DecreaseSkillsTurn();
ActiveCharacter.ResetStates();
if (ActiveCharacter.Hp > 0 && !isStun)
{
if (ActiveCharacter.IsPlayerCharacter)
{
if (IsAutoPlay)
{
ActiveCharacter.RandomAction();
}
else
{
//RpguiCharacterActionManager.Show();
uiUseSkillManager.SetData(ActiveCharacter);
}
}
else
{
ActiveCharacter.RandomAction();
}
}
else
{
ActiveCharacter.NotifyEndAction();
}
}
public void Setup()
{
myCollider = GetComponent<BoxCollider2D>();
character = GetComponentInParent<ActiveCharacter>();
animator = GetComponentInParent<ActiveAnimator>();
}
public Task Logout()
{
VerifyIngame();
return(ActiveCharacter.Logout());
}
