Idea for a clearer transfer type

[Coronia]

Description

So far we have several unfinished transfer type pull requests, but all of them are too complex to be implemented or used:
#834
#836
#849

After looking into them deeply, I have the following considerations:
1 - We want to make stats transfer from some technos to others. If we don't need to care about values inheritance, it'll just be setting stats on techno group A, and then setting stats on group B. Hence, we could just make such inheritance an option of it, instead of a thing that always active.

[TransferType]
Receiver=    ; if set to true, an extra stat setting process will begin after the current one is done, which will make use of its actual changed values

2 - there's this complex system in the old draft

Direction determines the sender and receiver side of the transfer. Senders use Send. tags and receivers use Receive..
sourcetotarget [s2t for short] makes warhead firer (source) sender and target(s) within CellSpread of the warhead receiver(s). Requires source to be techno (the warhead is fired by weapon of specific techno) unless resource to send is money, otherwise transfer fails (nothing happens). Default value.
sourcetosource [s2s] makes warhead firer both sender and receiver. Requires source to be techno unless resources to send and receive are money, otherwise transfer fails.
targettosource [t2s] makes target(s) within CellSpread of the warhead sender(s) and warhead firer receiver. Requires source to be techno unless resource to receive is money, otherwise transfer fails.
targettoextra [t2e] makes target(s) within CellSpread of warhead sender(s) and units within CellSpread of Extra.Warhead receivers. Extra warhead's epicenter can be initial target or source and requires source to be techno if epicenter is set to be source.
targettotarget [t2t] makes target(s) within CellSpread of warhead both sender(s) and receiver(s).
extratotarget [e2t] makes units within CellSpread of Extra.Warhead senders and target(s) within CellSpread of warhead receiver(s). Extra warhead's epicenter can be initial target or source and requires source to be techno if epicenter is set to be source.

Let's see if we can abstract it: it'll firstly select a group of technos as the sender, then another group as the receiver. When choosing them, it can simply pick the firer and its target only, or select a group of units around them, with Extra.Warhead to determine its CellSpread.

Actually, we don't have to care about the 'A to B' like relationship, but just select variable targets for sender and receiver independently. And in order to cover all cases between source and target, single and multiple, we can simply make them into 2 warheads:

[TransferType]
SourceWarhead=
TargetWarhead=
Receiver.SourceWarhead=
Receiver.TargetWarhead=

3 - Then we look at this part of the draft:

Target.ConsiderArmor modifies targets' transfer values according to warhead Verses. Units with armor that have 0% in Verses do not participate in the transfer. Defaults to no.
Target.VersusWarhead uses specified warhead's Verses to calculate Target.ConsiderArmor modifications instead of initial warhead. Does not have other uses. Defaults to initial warhead.
Target.AffectHouses determines houses to be affected by transfer. Others do not participate in the transfer. Defaults to all.
Extra.ConsiderArmor and Extra.AffectHouses work in the same manner as Target.ConsiderArmor and Target.AffectHouses, respectively, but they make changes for extra targets instead. Defaults to no.
Extra.EpicenterIsSource changes epicenter of extra warhead to be source (warhead firer) instead of the same epicenter as initial warhead. As stated above, requires source to be techno for transfer to work. Defaults to no.

Well, if we're using warheads to pick targets, then these are not really needed. We can just let it follow the versus and AffectsX (Allies, Enemies, Owner) of SourceWarhead and TargetWarhead, instead of using a lot of tags to define it.

4 - about the stats being transfered, I think that it should be treated case by case, cuz they have different properties:

Money - owned by House (generally applied), no upper limit
Strength - owned by Techno (generally applied), has upper limit
Experience - owned by Techno (generally applied), has upper limit
SWTimer - owned by House (each SW case by case), has upper limit
Ammo - owned by Techno (part of them), has upper limit, usually small number
Reload - owned by Techno (part of them), has upper limit
GatlingStage - owned by Techno (part of them), has upper limit, usually small number
GatlingRateUp - owned by Techno (part of them), has upper limit

Hence, I think we should divide these stats to different sets of tags, instead of using a same set which catagorized by enums. These different sets should have a generic rule for easier understanding and coding

X could be: Money, Strength, Experience, SWTimer, Ammo, Reload, GatlingStage, GatlingRateUp and anything we want to modify

[TransferType]
X.SetToFixedAmount=  ; if set to true, it'll set this stat to the given value or percentage. If false, it'll use plus computation
X.Value=                       ; set/add fixed value into the stat
X.AbsolutePercent=      ; set/add a percentage of total into the stat. Stat without upper limit (e.g. Money) can't use it
X.RelativePercent=        ; set/add a percentage of current value into the stat. These 3 values will be calculated one by one, so it will base on the value after computing ```X.Value``` and ```X.AbsolutePercent```
X.MaxValue=                 ; this operation can set the stat to this maximum value
X.MinValue=                 ; this operation can set the stat to this minimum value
X.MaxPercent=             ; this operation can set the stat to this maximum percentage of total
X.MinPercent=             ; this operation can set the stat to this minimum percentage of total
; for each stat, we could define their own extra tags if needed, take Money as example
Money.MaxAffectPerHouse=  ; how many times this detonation can affect a house's money
Money.Display=                      ; same as the display function of TransactionMoney.Display
Money.Display.Houses=
Money.Display.AtFirer=
Money.Display.Offset=

So to sum up, the new transfer type would be like this:

Tags for target filter

• SourceWarhead determines the affected technos around the firer, by CellSpread, AffectHouses and Versus of this warhead
• TargetWarhead works similarly but is for technos around the detonate coordinate
• AffectTargets adds an extra selection of which technos would be vulnerable
• IgnoreTargets adds an extra selection of which technos wouldn't be vulnerable
• IgnoreSelf, if set to true, will keep firer out of the affected list

Generic tags for stat setting, already explained above. Notice that Receiver's calculation will not rely on these, but'll only plus the actual changed values of the sender (processed by send factors first) instead, for the sake of simplicity

• X.SetToFixedAmount
• X.Value
• X.AbsolutePercent
• X.RelativePercent
• X.MaxValue
• X.MinValue
• X.MaxPercent
• X.MinPercent

Special tags for each stat, so far I could think of these

• Money.MaxAffectPerHouse, explained above
• Money.Display, Money.Display.Houses, Money.Display.AtFirer, Money.Display.Offset, explained above
• SWTimer.Types determines which SW's timer will be affected
• SWTimer.MaxAffectPerHouse is similar to Money.MaxAffectPerHouse. This could be a generic rule for transfering something about House

Tags for receiver transfer type. These tags are defined under sender for better flexibility (multiple senders could use the same receiver)

• Receiver, as written above, is the toggle of the whole Receiver logic
• Receiver.SourceWarhead, Receiver.TargetWarhead, Receiver.AffectTargets, Receiver.IgnoreTargets and Receiver.IgnoreSelf are filters for Receiver, default to sender's values
• Receiver.X.SendFactor works like the draft proposed, which determines whether receiver's transfer value is influenced by sent transfer value. Can be set to sum, highest, lowest, average and count with sum as default value
• Receiver.X.SendRate will multiply the sent values by this rate. Default value should be -1.0 given the most common usage of this is stealing health/money
• Receiver.X.SendSplit works like the draft proposed, which divides each receivers transfer value by receivers' count if set to true
• Receiver.X.MaxValue, Receiver.X.MinValue, Receiver.X.MaxPercent, Receiver.X.MinPercent are kept in case we don't want the targets affected by receiver has a stat beyond certain value/percentage
• Receiver.SWTimer.Types, Receiver.Money.Display, Receiver.Money.MaxAffectPerHouse etc are the same tags to control extra options for certain stat, default to sender's values

An example of its usage is written below

INI code

[TransferTypes]
0=TransferType

[Warheads]
0=SourceWarheadA
1=TargetWarheadA
2=SourceWarheadB
3=FinalWarhead

[SourceWarheadA]
Verses=0%,0%,0%,3%,3%,3%,0%,0%,0%,3%,0% ; only vehicles around firer would be affected
CellSpread=2
AffectsAllies=no
AffectsEnemies=yes

[TargetWarheadA]
Verses=3%,3%,3%,3%,3%,3%,0%,0%,0%,3%,0% ; both vehicles and infantry near the target coordinate would be affected
CellSpread=1
AffectsAllies=yes
AffectsEnemies=yes

[SourceWarheadB]
Verses=0%,0%,0%,0%,0%,0%,0%,0%,0%,0%,0%
Versus.armor=3%                         ; only the firer will be affected
AffectsOwner=yes
AffectsAllies=no
AffectsEnemies=no

[TransferType]
SourceWarhead=SourceWarheadA
TargetWarhead=TargetWarheadA
IgnoreTargets=TECHNO1                   ; TECHNO1 not be affected by stat change
IgnoreSelf=true                         ; ignore the firer itself
Money.Value=-1000                       ; -1000 credits from the affected house
Money.MaxAffectPerHouse=1               ; each house can only be reduced money once
Money.Display=yes
Money.Display.Houses=all
Money.Display.AtFirer=yes
Money.Display.Offset=0,0
Strength.AbsolutePercent=-5%            ; each attack reduce 5% of target's total health
Strength.MinValue=1                     ; prevent target from being killed
Experience.RelativePercent=5%           ; each attack increase 5% of target's current experience
SWTimer.Types=0                         ; superweapon with ID 0 would have its timer modified
SWTimer.SetToFixedAmount=true
SWTimer.AbsolutePercent=100%            ; set SW's timer to 100%, which is equal to reset
SWTimer.MaxAffectPerHouse=1
Ammo.Value=-1
GatlingStage.SetToFixedAmount=true
GatlingStage.Value=2
Receiver=true
Receiver.SourceWarhead=SourceWarheadB   ; use a different SourceWarhead but the same TargetWarhead
Receiver.IgnoreTargets=none             ; overide the values of sender
Receiver.IgnoreSelf=false
Receiver.Money.SendRate=-0.5            ; for $1000 money being reduced by sender, receiver will get $500 
Receiver.Money.SendSplit=true           ; for every target affected by the receiver, the money will be given to them in average
Receiver.Money.Display.AtFirer=false
Receiver.Strength.SendFactor=average    ; when the sender affects multiple targets, the average of them will be given to the receiver
Receiver.Strength.MaxPercent=80%        ; strength after leeching shouldn't go beyond 80% of its total strength
Receiver.Experience.SendRate=1.0        ; positive value means that for each experience gain, the receiver will also gain such amount
Receiver.SWTimer.Types=1,2              ; each timer change of sender's SW 0 will affect receiver's SW 1 and 2 instead
Receiver.SWTimer.MaxAffectPerHouse=1    ; every house affected by the receiver will have their SW timers being set once
Receiver.Ammo.MinValue=1                ; at least one ammo will be given to the targets of receiver
Receiver.GatlingStage.SendRate=0        ; we don't want this stat to be received from sender

[FinalWarhead]
Transfer.Type=TransferType

Additional context

No response

Checklist

• The suggestion is NOT related to functionality of Ares, HAres, Kratos or any other YR engine extension.
• The suggested feature / enhancement is NOT implemented in Ares/Phobos yet and the existing possibilites are not viable or good enough to achieve the wanted result.
• I agree to elaborate the details if requested and provide thorough testing if the feature is implemented.
• I added a very descriptive title to this topic.
• I used the GitHub search and read the topic list to find a similar topic and didn't find it.
• I thought out how the feature / enhancement should work and described it in the most detailed and clear way.

[Envoidener]

The main reason why the old implementations were scrapped was complexity AND tag clutter which is also the case with your implementation. Thanks for the suggestion, though. A solution I stopped at was integrating transfer type directly into warhead (read values from warhead and weapon, e.g. Damage is from weapon/animation, Versus from warhead, etc.) and dividing into multiple small parts that are not directly connected to each other: stat damage, percentage damage, damage limit, individual veterancy multiplier, and, finally, transfer. It has less features, but does the main job. Tags shown below:

[WARHEAD]
; -- STAT DAMAGE --
Resource                            = health ; health/hp | money | experience/exp | ammo | gatrate/rate
Experience.PreventDemote            = false ; boolean
GatlingRate.LimitStageChange        = -1 ; -1 = no limit
Health.PreventKill                  = false ; boolean
; -- % DAMAGE --
Factor.Type                         = flat ; flat | current | missing | total
Factor.Resource                     = health ; health/hp | money | experience/exp | ammo | gatrate/rate
Factor.FromSource                   = false ; boolean
; -- DAMAGE LIMIT --
FlatLimits                          = 0,0 ; minimum and maximum, 0 = no limit
; -- INDIVIDUAL VETERANCY MULTIPLIER --
VetMultiplier.SourceOverTarget      = 100%, 100%, 100% ; rookie, veteran, elite respectively
VetMultiplier.SourceOverSource      = 100%, 100%, 100% ; rookie, veteran, elite respectively
; ^ this tag is for transfer purposes, though
VetMultiplier.TargetOverTarget      = 100%, 100%, 100% ; rookie, veteran, elite respectively
; -- TRANSFER --
Transfer.Direction                  = s2t ; s2t | t2s | t2t, s = source, 2 = to, t = target 
Transfer.Warhead                    = ; WARHEAD2 to read receive info from
Transfer.Factor                     = 100% ; float
Transfer.Send.Overlimit             = false ; boolean
Transfer.Receive.Divide             = false ; boolean

If you want to use multiple stats/transfers in one damage there is an extra warhead, critical damage feature or animation/warhead trick. I doubt this gets used like that much though.

I have my hands full doing IRL stuff which is why it is taking long. This solution doesn't have much stuff left to implement, so it might be finished this month (hopefully). If you have any ideas or objections, be my guest.

[Metadorius]

@Coronia check this out too, you were interested in this

[Metadorius]

DERP it was a thread, not a new discussion topic... nevermind me

[Coronia]

Yeah I don't mind separate a large TransferType entity into smaller pieces now that ExtraWarheads is a thing. But I have a few opinions regarding to the above tags: instead of using individual limit settings for different resources like GatlingRate.LimitStageChange, Health.PreventKill etc, I'd still suggest to use a generic minimum/maximum setting for all resources. So it'll be easier to control its behavior and understand.

MaxValue=
MinValue=
MaxPercent=
MinPercent=

So if you want to make PreventKill, just set Health.MinValue to 1. So are the other limits, Experience.PreventDemote can also be replaced by this theoratically if using a certain MinPercent.

Also I would still suggest to make the transfer values read from a standalone ones other than weapon damage, so it's easier to be referred and managed by modders. ExtraWarheads is applied on Weapon so it can't be freely changed.

As for VetMultiplier, it's a bit strange for it to be a series of standalone tags. I don't really understand what it supposed to do, but if it's only related to Transfer, better add a Transfer. prefix to them. In fact, maybe all these tags need a universal prefix as they're still a part of a whole system.

Here's my opinions of tags based on yours:

[WARHEAD]
; -- no need to differentiate stat damage and percentage damage if we're using a standalone value ---
Transfer.Type=
Transfer.Value= 0.0 ; float, actual transfer value or percentage
Transfer.Resource=
Transfer.FromSource=
Transfer.IgnoreSelf=false ; boolean
; -- LIMIT SETTINGS --
Transfer.MaxValue=
Transfer.MinValue=
Transfer.MaxPercent=
Transfer.MinPercent=
; -- DAMAGE LIMIT --
Transfer.FlatLimits=
; -- INDIVIDUAL VETERANCY MULTIPLIER --
Transfer.VetMultiplier.SourceOverTarget=
Transfer.VetMultiplier.SourceOverSource=
Transfer.VetMultiplier.TargetOverTarget=
; -- REAL TRANSFER --
Transfer.Direction= none ; none | s2t | t2s | t2t, s = source, 2 = to, t = target 
Transfer.Send.Overlimit=
; -- use a Receive infix to denote tags that only work for receivers --
Transfer.Receive.Warhead=
Transfer.Receive.Factor =
Transfer.Receive.IgnoreSelf=false ; boolean
Transfer.Receive.Divide=
; -- some special tags for certain resources like I've proposed before --
; -- for simplicity, it'll work on both senders and receivers --
Transfer.MoneyDisplay=
Transfer.MoneyDisplay.Houses=
Transfer.MoneyDisplay.AtFirer=
Transfer.MoneyDisplay.Offset=
Transfer.SWTypes=

[Coronia]

It's been long that this discussion was made, but I've thought about it a bit more. Since it's difficult and unintuitive to make an N to N bidirectional transfer type, maybe it's better to break it down into 2 parts:

• TransferToTarget: send values from the firer to affected targets (1 to N)
• TransferFromTarget: send values from affected targets to the firer (N to 1)

with this method, we can do it with the most basic warhead detonation instead of adding a whole new type for it, which is simpler and easier to understand. It can also naturally support ExtraWarheads well, which means that we don't need to make use of a lot of tags, but splitting each transfer to different extra warheads. Not making an N to N transfer is indeed a drawback, but I guess it won't be the most needed usecase

With this proposal, the tag would be like this

In rulesmd.ini

TransferToTarget.Type=health/hp | money | experience/exp | ammo | gatrate/stage | swtimer (only one can be filled in it)
TransferToTarget.Value=
TransferToTarget.ValueType=flat | current | missing | total
TransferToTarget.Factor=(no need to do it based on veterancy I think)
TransferToTarget.Overlimit=
TransferToTarget.Divide=
;;; some other properties for each type, such as TransferToTarget.Money.Display and TransferToTarget.Health.PreventKill
TransferFromTarget.Type=health/hp | money | experience/exp | ammo | gatrate/stage | swtimer (only one can be filled in it)
TransferFromTarget.Value=
TransferFromTarget.ValueType=flat | current | missing | total
TransferFromTarget.Factor=(no need to do it based on veterancy I think)
TransferFromTarget.Overlimit=