public override void TakeAction()
{
if (this.NeedAndCanRecover())
{
this.GameAction.DoCreatureRest(this.Creature.CreatureId);
return;
}
// Get target
FDCreature target = this.LookForAggressiveTarget();
// According to the target, find the nearest position within the Move scope, and get the path to that position
FDMovePath movePath = this.DecidePositionAndPath(target.Position);
// Do the walk
this.GameAction.CreatureWalk(new SingleWalkAction(this.Creature.CreatureId, movePath));
FDPosition destination = movePath.Desitination ?? this.Creature.Position;
AttackItemDefinition item = this.Creature.Data.GetAttackItem();
if (item != null)
{
FDSpan span = item.AttackScope;
DirectRangeFinder finder = new DirectRangeFinder(this.GameAction.GetField(), destination, span.Max, span.Min);
FDRange range = finder.CalculateRange();
if (range.Contains(target.Position))
{
// If in attack range, attack the target
this.GameAction.DoCreatureAttack(this.Creature.CreatureId, target.Position);
}
}
this.GameAction.DoCreatureRest(this.Creature.CreatureId);
}
public void ComposeCreature(CreatureFaction faction, int creatureId, int definitionId, FDPosition position, int dropItem = 0)
{
CreatureDefinition creatureDef = DefinitionStore.Instance.GetCreatureDefinition(definitionId);
FDCreature creature = new FDCreature(creatureId, faction, creatureDef, position);
switch (faction)
{
case CreatureFaction.Friend:
this.Friends.Add(creature);
break;
case CreatureFaction.Enemy:
if (dropItem > 0)
{
creature.Data.DropItem = dropItem;
}
this.Enemies.Add(creature);
break;
case CreatureFaction.Npc:
this.Npcs.Add(creature);
break;
default:
break;
}
CreatureComposePack pack = new CreatureComposePack(creatureId, creatureDef.AnimationId, position);
gameCallback.OnHandlePack(pack);
}
// Start is called before the first frame update
void Start()
{
DefinitionStore.Instance.LoadChapter(25);
//DefinitionStore.Instance.LoadChapter(18);
//CreatureDefinition def = DefinitionStore.Instance.GetCreatureDefinition(50508);
FDCreature subject = new FDCreature(4, CreatureFaction.Friend, DefinitionStore.Instance.GetCreatureDefinition(15), FDPosition.At(0, 0));
FDCreature target = new FDCreature(11, CreatureFaction.Enemy, DefinitionStore.Instance.GetCreatureDefinition(52502), FDPosition.At(0, 0));
int hp1 = target.Data.HpMax;
int hp2 = hp1 / 2;
int hp3 = hp2 / 2;
int hp4 = subject.Data.HpMax;
int hp5 = hp4 / 2;
int hp6 = hp5 / 2;
Debug.Log(string.Format(@"hp1: {0}, hp2: {1}, hp3: {2}", hp1, hp2, hp3));
AttackInformation a1 = new AttackInformation(hp1, hp2, false);
AttackInformation a2 = new AttackInformation(hp2, hp3, false);
AttackInformation b1 = new AttackInformation(hp4, hp5, false);
AttackInformation b2 = new AttackInformation(hp5, hp6, false);
FightInformation fightInfo = new FightInformation(a1, a2, b1, b2);
this.Initialize(subject, target, fightInfo);
fightPhase = FightPhase.Attack1;
Invoke("DoSubjectAttack", 1.2f);
}
public override StateOperationResult OnSelectPosition(FDPosition position)
{
if (range == null || !range.Contains(position))
{
return(StateOperationResult.Pop());
}
// No creature or not a friend/NPC
FDCreature targetCreature = this.gameAction.GetCreatureAt(position);
if (targetCreature == null || targetCreature.Faction == Definitions.CreatureFaction.Enemy)
{
return(StateOperationResult.None());
}
if (!targetCreature.Data.IsItemsFull())
{
gameAction.DoCreatureExchangeItem(this.CreatureId, this.SelectedItemIndex, targetCreature.CreatureId);
return(StateOperationResult.Clear());
}
else
{
subState = SubState.SelectExchangeItem;
this.TargetCreature = targetCreature;
CreatureShowInfoPack pack = new CreatureShowInfoPack(targetCreature, CreatureInfoType.SelectAllItem);
SendPack(pack);
return(StateOperationResult.None());
}
}
public List <FDCreature> GetAdjacentFriends(int creatureId)
{
List <FDCreature> result = new List <FDCreature>();
FDCreature creature = this.GetCreature(creatureId);
if (creature == null)
{
return(result);
}
foreach (FDPosition direction in creature.Position.GetAdjacentPositions())
{
FDCreature candidate = this.GetCreatureAt(direction);
if (candidate == null)
{
continue;
}
if (!creature.IsOppositeFaction(candidate))
{
result.Add(candidate);
}
}
return(result);
}
private PackBase HandleWalkAction(SingleWalkAction walkAction)
{
if (walkAction == null)
{
return(null);
}
CreatureMovePack movePack = new CreatureMovePack(walkAction.CreatureId, walkAction.MovePath);
FDCreature creature = GetCreature(walkAction.CreatureId);
if (creature == null)
{
return(null);
}
if (walkAction.MovePath?.Desitination != null)
{
creature.SetMoveTo(walkAction.MovePath.Desitination);
}
if (walkAction.DelayUnits > 0)
{
IdlePack idle = IdlePack.FromTimeUnit(walkAction.DelayUnits);
return(new SequencedPack(idle, movePack));
}
return(movePack);
}
public void SwitchCreature(int creatureId, CreatureFaction faction)
{
FDCreature creature = GetCreature(creatureId);
if (creature != null)
{
DisposeCreature(creatureId, false);
switch (faction)
{
case CreatureFaction.Friend:
this.Friends.Add(creature);
break;
case CreatureFaction.Npc:
this.Npcs.Add(creature);
break;
case CreatureFaction.Enemy:
this.Enemies.Add(creature);
break;
default:
break;
}
}
}
private int GetMoveCost(FDPosition position, FDCreature creature)
{
ShapeDefinition targetShape = gameField.GetShapeAt(position.X, position.Y);
if (targetShape == null)
{
return(-1);
}
int moveCost = 0;
if (creature.Definition.CanFly())
{
if (targetShape.CanFly)
{
moveCost = 1;
}
else
{
moveCost = -1;
}
}
else if (creature.Definition.IsKnight())
{
moveCost = targetShape.MoveCostForKnight;
}
else
{
moveCost = targetShape.MoveCost;
}
return(moveCost);
}
public FDCreature GetPreferredAttackTargetInRange(int creatureId)
{
FDCreature creature = this.GetCreature(creatureId);
AttackItemDefinition attackItem = creature.Data.GetAttackItem();
if (attackItem == null)
{
return(null);
}
FDSpan span = attackItem.AttackScope;
DirectRangeFinder finder = new DirectRangeFinder(this.gameField, creature.Position, span.Max, span.Min);
FDRange range = finder.CalculateRange();
// Get a preferred target in range
foreach (FDPosition position in range.Positions)
{
FDCreature target = this.GetCreatureAt(position);
if (target != null && target.Faction == CreatureFaction.Enemy)
{
return(target);
}
}
return(null);
}
private bool IsMenuAttackEnabled()
{
bool canAttack = this.Creature.Data.CanAttack();
FDCreature target = gameAction.GetPreferredAttackTargetInRange(this.Creature.CreatureId);
return(canAttack && (target != null));
}
public void ShowConversationDialog(FDCreature creature, ConversationId conversation)
{
// Canvas
if (currentDialog != null)
{
Destroy(currentDialog);
currentDialog = null;
}
// Move the map to corresponding location
// Show dialog
int animationId = creature?.Definition?.AnimationId ?? 0;
string message = LocalizedStrings.GetConversationString(conversation);
//Debug.Log("Showing message dialog: " + message);
Vector3 popupPosition = Vector3.zero;
if (creature != null)
{
UICreature uiCreature = GetUICreature(creature.CreatureId);
Vector3 viewPoint = mainCamera.WorldToViewportPoint(uiCreature.transform.position);
RectTransform canvasRect = GameCanvas.GetComponent <RectTransform>();
popupPosition = new Vector3(
viewPoint.x * canvasRect.sizeDelta.x - canvasRect.sizeDelta.x * 0.5f,
viewPoint.y * canvasRect.sizeDelta.y - canvasRect.sizeDelta.y * 0.5f,
0);
}
MessageDialog messageDialog = GameObjectExtension.CreateFromPrefab <MessageDialog>("Prefabs/MessageDialog");
messageDialog.Initialize(uiCamera, popupPosition, animationId, message, (index) => { this.OnDialogCallback(index); }, this.ChapterId);
currentDialog = messageDialog.gameObject;
}
public override StateOperationResult OnSelectPosition(FDPosition position)
{
FDCreature creature = gameAction.GetCreatureAt(position);
if (creature == null)
{
// Empty space, show system menu
MenuSystemState state = new MenuSystemState(gameAction, position);
return(new StateOperationResult(StateOperationResult.ResultType.Push, state));
}
else if (creature.IsActionable())
{
// Actionable friend
ShowMoveRangeState nextState = new ShowMoveRangeState(gameAction, creature);
return(new StateOperationResult(StateOperationResult.ResultType.Push, nextState));
}
else
{
// Show creature information
CreatureShowInfoPack pack = new CreatureShowInfoPack(creature.Clone(), CreatureInfoType.View);
var gameCallback = gameAction.GetCallback();
gameCallback.OnHandlePack(pack);
return(new StateOperationResult(StateOperationResult.ResultType.None));
}
}
public void Initialize(Camera camera, FDCreature creature, ShowType showType, Action <int> callback)
{
this.gameObject.name = "CreatureDialog";
canvas.worldCamera = camera;
this.camera = camera;
this.creature = creature;
this.showType = showType;
this.onCallback = callback;
containerBase = this.transform.Find("Canvas/ContainerBase");
Clickable clickable = containerBase.GetComponent <Clickable>();
clickable.Initialize(() => { this.OnClicked(); });
creatureDetailBase = this.transform.Find("Canvas/CreatureDetail");
clickable = creatureDetailBase.gameObject.GetComponent <Clickable>();
clickable.Initialize(() => { this.OnCancelled(); });
datoBase = this.transform.Find("Canvas/DatoBase");
datoControl = GameObjectExtension.CreateFromPrefab <DatoControl>("Prefabs/DatoControl");
datoControl.Initialize(datoBase, creature.Definition.AnimationId, new Vector2(0, 0));
//// datoControl.transform.localPosition = new Vector3(0, 0, 0);
RenderDetails();
if (IsItemDialog)
{
RenderItemsContainer();
}
else
{
RenderMagicsContainer();
}
}
public BattleFightPack(FDCreature subject, FDCreature target, FightInformation fightInfo) : base()
{
this.Type = PackType.BattleFight;
this.Subject = subject;
this.Target = target;
this.FightInformation = fightInfo;
}
public void Initialize(FDCreature creature)
{
this.creature = creature;
// SpriteRenderer renderer = this.gameObject.AddComponent<SpriteRenderer>();
// renderer.sprite = Resources.Load<Sprite>("OthersLegacy/CreatureInfoBarBase");
this.mpBar.SetActive(this.creature.Data.MpMax > 0);
}
public void DoCreatureUseItem(int creatureId, int itemIndex, int targetCreatureId)
{
FDCreature creature = this.GetCreature(creatureId);
FDCreature targetCreature = this.GetCreature(targetCreatureId);
ItemDefinition item = DefinitionStore.Instance.GetItemDefinition(itemIndex);
creature.Data.RemoveItemAt(itemIndex);
PostCreatureAction(creature);
}
public void DisposeCreature(int creatureId, bool disposeFromUI = true, bool playDeadAnimation = false)
{
FDCreature creature = GetCreature(creatureId);
if (creature != null)
{
for (int i = 0; i < this.Friends.Count; i++)
{
if (this.Friends[i].CreatureId == creatureId)
{
this.Friends.RemoveAt(i);
break;
}
}
for (int i = 0; i < this.Enemies.Count; i++)
{
if (this.Enemies[i].CreatureId == creatureId)
{
this.Enemies.RemoveAt(i);
break;
}
}
for (int i = 0; i < this.Npcs.Count; i++)
{
if (this.Npcs[i].CreatureId == creatureId)
{
this.Npcs.RemoveAt(i);
break;
}
}
if (disposeFromUI)
{
if (playDeadAnimation)
{
CreatureDeadPack dead = new CreatureDeadPack(creatureId);
gameCallback.OnHandlePack(dead);
}
else
{
CreatureDisposePack pack = new CreatureDisposePack(creatureId);
gameCallback.OnHandlePack(pack);
}
}
}
else
{
creature = GetDeadCreature(creatureId);
if (creature != null)
{
this.Deads.Remove(creature);
}
}
}
private void RunAIDelegate(FDCreature creature)
{
AIDelegate aiDelegate = null;
switch (creature.Data.AIType)
{
case CreatureData.AITypes.AIType_Aggressive:
if (creature.Definition.IsMagical())
{
aiDelegate = new AIMagicalAggressiveDelegate(gameAction, creature);
}
else
{
aiDelegate = new AIAggressiveDelegate(gameAction, creature);
}
break;
case CreatureData.AITypes.AIType_Defensive:
if (creature.Definition.IsMagical())
{
aiDelegate = new AIMagicalDefensiveDelegate(gameAction, creature);
}
else
{
aiDelegate = new AIDefensiveDelegate(gameAction, creature);
}
break;
case CreatureData.AITypes.AIType_Guard:
if (creature.Definition.IsMagical())
{
aiDelegate = new AIMagicalGuardDelegate(gameAction, creature);
}
else
{
aiDelegate = new AIGuardDelegate(gameAction, creature);
}
break;
case CreatureData.AITypes.AIType_Escape:
aiDelegate = new AIEscapeDelegate(gameAction, creature);
break;
case CreatureData.AITypes.AIType_Treasure:
aiDelegate = new AITreasureDelegate(gameAction, creature);
break;
}
if (aiDelegate != null)
{
lastOperatedCreatureId = creature.CreatureId;
aiDelegate.TakeAction();
}
}
private static ActivityBase BuildShowCreatureInfoActivity(CreatureShowInfoPack pack)
{
if (pack == null)
{
throw new ArgumentNullException("pack");
}
FDCreature creature = pack.Creature;
CreatureDialog.ShowType showType = CreatureDialog.ShowType.SelectAllItem;
switch (pack.InfoType)
{
case CreatureInfoType.SelectAllItem:
showType = CreatureDialog.ShowType.SelectAllItem;
break;
case CreatureInfoType.SelectEquipItem:
showType = CreatureDialog.ShowType.SelectEquipItem;
break;
case CreatureInfoType.SelectUseItem:
showType = CreatureDialog.ShowType.SelectUseItem;
break;
case CreatureInfoType.SelectMagic:
showType = CreatureDialog.ShowType.SelectMagic;
break;
case CreatureInfoType.View:
showType = CreatureDialog.ShowType.ViewItem;
break;
default:
showType = CreatureDialog.ShowType.SelectAllItem;
break;
}
CallbackActivity activity = new CallbackActivity(
(gameInterface) => { gameInterface.ShowCreatureDialog(pack.Creature, showType); });
if (pack.InfoType == CreatureInfoType.View && creature.Data.HasMagic())
{
SequenceActivity sequenceActivity = new SequenceActivity();
sequenceActivity.Add(activity);
CallbackActivity activity2 = new CallbackActivity(
(gameInterface) => { gameInterface.ShowCreatureDialog(pack.Creature, CreatureDialog.ShowType.ViewMagic); });
sequenceActivity.Add(activity2);
return(sequenceActivity);
}
return(activity);
}
public List <FDCreature> GetOppositeCreatures(FDCreature creature)
{
if (creature.Faction == CreatureFaction.Enemy)
{
List <FDCreature> result = new List <FDCreature>();
result.AddRange(this.Friends);
result.AddRange(this.Npcs);
return(result);
}
else
{
return(this.Enemies);
}
}
/// <summary>
///
/// </summary>
/// <param name="creatureId"></param>
/// <param name="sequenceId"></param>
/// <param name="startIndex"></param>
/// <param name="endIndex"></param>
public void ShowTalk(int sequenceId, int startIndex, int endIndex)
{
for (int i = startIndex; i <= endIndex; i++)
{
ConversationId conversationId = ConversationId.Create(this.ChapterId(), sequenceId, i);
string key = conversationId.GetKeyForId();
if (chapterDefinition.ConversationIds.ContainsKey(key))
{
int creatureId = chapterDefinition.ConversationIds[key];
FDCreature creature = this.GetCreature(creatureId);
TalkPack pack = new TalkPack(creature.Clone(), conversationId);
gameCallback.OnHandlePack(pack);
}
}
}
public SelecteMagicTargetState(IGameAction action, FDCreature creature, MagicDefinition magic) : base(action)
{
this.Creature = creature;
this.Magic = magic;
if (this.Creature == null)
{
throw new ArgumentNullException("creature");
}
if (this.Magic == null)
{
throw new ArgumentNullException("magic");
}
}
private void WalkOnPosition(FDPosition position, int leftMovePoint, FDMoveRange range)
{
int moveCost = GetMoveCost(position, creature);
if (moveCost == -1 || leftMovePoint < moveCost)
{
// Nothing to walk
return;
}
// If this is ZOC, stop the move
if (!position.AreSame(this.creature.Position) && HasAdjacentEnemy(position))
{
return;
}
int leftPoint = leftMovePoint - moveCost;
foreach (FDPosition direction in position.GetAdjacentPositions())
{
if (direction.X <= 0 || direction.X > gameField.Width ||
direction.Y <= 0 || direction.Y > gameField.Height)
{
continue;
}
if (range.Contains(direction))
{
continue;
}
// If already occupied by creature
FDCreature existing = gameAction.GetCreatureAt(direction);
if (existing != null && existing.IsOppositeFaction(creature))
{
continue;
}
if (GetMoveCost(direction, creature) == -1)
{
// Cannot land on target direction
continue;
}
range.AddPosition(direction, position);
positionQueue.Enqueue(new MoveRangeQueueObject(direction, leftPoint));
}
}
private static AttackInformation MagicFrom(MagicDefinition magic, FDCreature subject, FDCreature target, GameField field)
{
bool isHit = FDRandom.BoolFromRate(magic.HittingRate);
int changedHp = 0;
if (isHit)
{
OccupationDefinition occupation = DefinitionStore.Instance.GetOccupationDefinition(target.Definition.Occupation);
double hitRate = 1.0f;
if (occupation != null)
{
hitRate = (100 - occupation.MagicDefendRate) / 100.0f;
}
switch (magic.Type)
{
case MagicType.Attack:
changedHp = -FDRandom.IntFromSpan(magic.Span) + magic.ApInvoledRate * subject.Data.CalculatedAp / 100;
changedHp = (int)(changedHp * hitRate);
changedHp = Math.Min(0, changedHp);
break;
case MagicType.Recover:
changedHp = FDRandom.IntFromSpan(magic.Span);
changedHp = Math.Max(0, changedHp);
break;
case MagicType.Offensive:
TakeOffensiveEffect(magic, target);
break;
case MagicType.Defensive:
TakeDefensiveEffect(magic, target);
break;
default:
break;
}
}
AttackInformation info = new AttackInformation(target.Data.Hp, target.Data.Hp + changedHp, false);
target.Data.UpdateHp(changedHp);
return(info);
}
private static CallbackActivity BuildBattleFightActivity(BattleFightPack fightPack)
{
if (fightPack == null)
{
throw new ArgumentNullException("fightPack");
}
FDCreature subject = fightPack.Subject;
FDCreature target = fightPack.Target;
FightInformation fightInfo = fightPack.FightInformation;
CallbackActivity activity = new CallbackActivity(
(gameInterface) => { gameInterface.BattleFight(subject, target, fightInfo); });
return(activity);
}
public void ShowCreatureDialog(FDCreature creature, CreatureDialog.ShowType showType)
{
// Canvas
if (currentDialog != null)
{
Destroy(currentDialog);
currentDialog = null;
}
CreatureDialog dialog = GameObjectExtension.CreateFromPrefab <CreatureDialog>("Prefabs/CreatureDialog");
currentDialog = dialog.gameObject;
dialog.Initialize(this.uiCamera, creature, showType,
(index) => { this.OnDialogCallback(index); });
}
private static AttackInformation AttackFrom(FDCreature subject, FDCreature target, GameField field)
{
bool isHit = FDRandom.BoolFromRate(subject.Data.CalculatedHit - target.Data.CalculatedEv);
bool isCritical = FDRandom.BoolFromRate(commonCriticalAttackRate);
int reduceHp = 0;
if (isHit)
{
FDPosition pos = subject.Position;
ShapeDefinition shape = field.GetShapeAt(pos.X, pos.Y);
int adjustedAp = subject.Data.CalculatedAp * (100 + shape.AdjustedAp) / 100;
FDPosition targetPos = target.Position;
ShapeDefinition targetShape = field.GetShapeAt(targetPos.X, targetPos.Y);
int adjustedDp = target.Data.CalculatedDp * (100 + shape.AdjustedDp) / 100;
int attackMax = adjustedAp - adjustedDp;
int attackMin = (int)(attackMax * 0.9f);
reduceHp = FDRandom.IntFromSpan(attackMin, attackMax);
reduceHp = (reduceHp < 0) ? 0 : reduceHp;
if (isCritical)
{
reduceHp *= 2;
}
// Poisoned
AttackItemDefinition attackItem = subject.Data.GetAttackItem();
if (attackItem != null)
{
bool isPoisoned = FDRandom.BoolFromRate(attackItem.GetPoisonRate());
if (isPoisoned)
{
target.Data.SetEffect(CreatureData.CreatureEffects.Poisoned);
}
}
}
AttackInformation info = new AttackInformation(target.Data.Hp, target.Data.Hp - reduceHp, isCritical);
target.Data.UpdateHp(-reduceHp);
return(info);
}
private CreatureInfoBar CreateCreatureInfoBar(FDCreature creature, Transform placeHolder)
{
GameObject creatureInfoBarPrefab = Resources.Load <GameObject>("Prefabs/CreatureInfo");
GameObject obj = GameObject.Instantiate(creatureInfoBarPrefab);
obj.transform.parent = placeHolder;
obj.transform.localPosition = Vector3.zero;
// obj.transform.localScale = new Vector3(15, 15, 15);
obj.transform.localScale = new Vector3(1, 1, 1);
obj.transform.localEulerAngles = new Vector3(0, 0, 0);
CreatureInfoBar infoBar = obj.GetComponent <CreatureInfoBar>();
infoBar.Initialize(creature);
return(infoBar);
}
private bool HasAdjacentEnemy(FDPosition position)
{
foreach (FDPosition direction in position.GetAdjacentPositions())
{
FDCreature c = gameAction.GetCreatureAt(direction);
if (c == null)
{
continue;
}
if (this.creature.IsOppositeFaction(c))
{
return(true);
}
}
return(false);
}
public void ShowMessageDialog(FDCreature creature, MessageId messageId)
{
// Canvas
if (currentDialog != null)
{
Destroy(currentDialog);
currentDialog = null;
}
// Move the map to corresponding location
// Show dialog
int animationId = creature?.Definition?.AnimationId ?? 0;
string message = LocalizedStrings.GetMessageString(messageId);
if (messageId.MessageType == MessageId.MessageTypes.Confirm)
{
PromptDialog dialog = GameObjectExtension.CreateFromPrefab <PromptDialog>("Prefabs/PromptDialog");
dialog.Initialize(uiCamera, animationId, message, (index) => { this.OnDialogCallback(index); });
currentDialog = dialog.gameObject;
}
else
{
Vector2 popupPosition = Vector2.zero;
if (creature != null)
{
UICreature uiCreature = GetUICreature(creature.CreatureId);
popupPosition = mainCamera.WorldToScreenPoint(uiCreature.transform.position);
}
MessageDialog dialog = GameObjectExtension.CreateFromPrefab <MessageDialog>("Prefabs/MessageDialog");
dialog.Initialize(uiCamera, popupPosition, animationId, message, (index) => { this.OnDialogCallback(index); });
currentDialog = dialog.gameObject;
}
/*
* currentDialog = new GameObject();
* MessageDialog dialog = currentDialog.AddComponent<MessageDialog>();
*
* int animationId = (creature != null) ? creature.Definition.AnimationId : 0;
* dialog.Initialize(this.GameCanvas, animationId, messageId,
* (index) => { this.OnDialogCallback(index); });
*/
}
