void PerformUpgradeLink(OneObject* OBJ) {
word OI=OBJ->LocalOrder->info.PUpgrade.NewUpgrade;
Nation* NT=OBJ->Nat;
byte NI=NT->NNUM;
SimpleUTP* SU=NT->UPG.utp[OI];
if(!CheckCost(NI,1,SU->Cost))return;
OBJ->LocalOrder->info.PUpgrade.Stage++;
OBJ->Ustage=OBJ->LocalOrder->info.PUpgrade.Stage;
if(OBJ->LocalOrder->info.PUpgrade.Stage>=OBJ->LocalOrder->info.PUpgrade.NStages) {
OBJ->Ready=true;
for(int i=0; i<SU->NLinks; i++)
NT->UPG.utp[SU->Links[i]]->Enabled=true;
if(SU->NLinks)SU->Enabled=false;
for(i=0; i<SU->NAuto; i++)
NT->UPG.utp[SU->AutoPerf[i]]->DoUpgrade(NI,OBJ);
RESRC[NT->NNUM][1]-=SU->Cost;
SU->DoUpgrade(NT->NNUM,OBJ);
SU->Finished=true;
if(int(OBJ->LocalOrder)) {
Order1* Or1=OBJ->LocalOrder->NextOrder;
OBJ->FreeOrdBlock(OBJ->LocalOrder);
OBJ->LocalOrder=Or1;
OBJ->Important=false;
return;
};
};
};
void OneObject::PerformUpgrade(word NewU) {
if(Nat->UPG.NUpgrades<=NewU||!Ready)return;
word NUP=Ref.General->NUpgrades;
word* UPL=Ref.General->Upg;
bool canU=false;
for(int pp=0; pp<NUP; pp++)if(UPL[pp]==NewU)canU=true;
if(!canU)return;
if(!Nat->UPG.utp[NewU]->Enabled)return;
if(!CheckCost(NNUM,1,Nat->UPG.utp[NewU]->Cost))return;
Order1* Or1=GetOrdBlock();
Or1->PrioryLevel=0;
Or1->NextOrder=LocalOrder;
Or1->OrderType=75;//Upgrade
Or1->OrderTime=0;
Or1->DoLink=&PerformUpgradeLink;
Or1->info.PUpgrade.NewUpgrade=NewU;
Or1->info.PUpgrade.Stage=1;
Or1->info.PUpgrade.NStages=Nat->UPG.utp[NewU]->Time;
//Nat->UPG.utp[NewU]->Stage=1;
Order1* LOR=LocalOrder;
if(int(InLineCom))FreeAsmLink();
LocalOrder=Or1;
//OrderReport=NULL;
//MessageKind=0;
//Sender=0xFFFF;
SimpleUTP* SU=Nat->UPG.utp[NewU];
//if(SU->OneTime)
if(SU->OneTime) {
SU->Done=true;
SU->Enabled=false;
};
Ustage=0;
NUstages=SU->Time;
Ready=false;
};
bool UGameplayAbility::CanActivateAbility(const FGameplayAbilitySpecHandle Handle, const FGameplayAbilityActorInfo* ActorInfo) const
{
SetCurrentActorInfo(Handle, ActorInfo);
if (ActorInfo->AbilitySystemComponent->GetUserAbilityActivationInhibited())
{
/**
* Input is inhibited (UI is pulled up, another ability may be blocking all other input, etc).
* When we get into triggered abilities, we may need to better differentiate between CanActviate and CanUserActivate or something.
* E.g., we would want LMB/RMB to be inhibited while the user is in the menu UI, but we wouldn't want to prevent a 'buff when I am low health'
* ability to not trigger.
*
* Basically: CanActivateAbility is only used by user activated abilities now. If triggered abilities need to check costs/cooldowns, then we may
* want to split this function up and change the calling API to distinguish between 'can I initiate an ability activation' and 'can this ability be activated'.
*/
return false;
}
if (!CheckCooldown(ActorInfo))
{
return false;
}
if (!CheckCost(ActorInfo))
{
return false;
}
// If we're instance per actor and we already have an instance, don't let us activate again as this breaks the graph
if (GetInstancingPolicy() == EGameplayAbilityInstancingPolicy::InstancedPerActor)
{
if (bIsActive)
{
return false;
}
}
if (HasBlueprintCanUse)
{
if (K2_CanActivateAbility(*ActorInfo) == false)
{
ABILITY_LOG(Log, TEXT("CanActivateAbility %s failed, blueprint refused"), *GetName());
return false;
}
}
return true;
}
bool UGameplayAbility::CommitCheck(const FGameplayAbilityActorInfo* ActorInfo, const FGameplayAbilityActivationInfo ActivationInfo)
{
/**
* Checks if we can (still) commit this ability. There are some subtleties here.
* -An ability can start activating, play an animation, wait for a user confirmation/target data, and then actually commit
* -Commit = spend resources/cooldowns. Its possible the source has changed state since he started activation, so a commit may fail.
* -We don't want to just call CanActivateAbility() since right now that also checks things like input inhibition.
* -E.g., its possible the act of starting your ability makes it no longer activatable (CanaCtivateAbility() may be false if called here).
*/
if (!CheckCooldown(ActorInfo))
{
return false;
}
if (!CheckCost(ActorInfo))
{
return false;
}
return true;
}
