ansaurus

Question

Need an approach for automatically-propagating values in/across hierarchical structures (Faction system for a game)

Answer 1

+2 A:

I don't know if this has a name, but I would use an iterative approach, giving to the faction class, which knows the factions structure, the task to update the player's standings.
Something like this:

using System;
using System.Collections.Generic;

class Faction { 
    // the parent faction
    protected Faction _parent;
    // list of children factions
    protected List<Faction> _children = new List<Faction>();

    // the Faction knows the structure, so this approach is iterative but not
    // for this difficult to maintain.
    public void ModifyStanding(Player p,Decimal amount) {
        p[this] += amount;
        foreach (Faction child in _children) {
            child.ModifyStanding(p, amount / 2);
        }
    }
}

class Player {
    // standings
    Dictionary<Faction, Decimal> _standings = new Dictionary<Faction,decimal>();
    // get / set standing indexing on faction
    public Decimal this[Faction f] {
        get { return _standings[f]; }
        set { _standings[f] = value; }
    }
}

Paolo Tedesco 2009-12-16 08:04:14

This was the Other Way that I had considered. I ended up feeling like pushing the task off to the player would be a better use of resources. Ultimately, the factions don't *need* to know the player exists, so long as whenever the player encounters one, they can poll him for this information. I was thinking of a multiplayer environment in which I'd want to lessen the strain on the faction process, but I'd never "trust" the player on that, so the server would have to verify all that work anyway.

Superstringcheese 2009-12-16 12:42:39

Answer 2

+3 A:

The problem as I see it is that you haven't defined exactly what you want the propagation rules to be. In fact, you give 2 examples which contradict each other:

"So if I gain 100 standing directly with ColorFolk, I should get 50 standing with both RedFolk and BlueFolk [etc]" - this example only propagates down the tree, not to siblings. (No gain to DirectionFolk is mentioned.)

"If instead I gained 100 standing directly with RedFolk, I should get 50 with BlueFolk, and 25 with both PinkFolk and ScarletFolk." - whereas this example does propagate to siblings.

Obviously these both can't be true, without there being at least one more rule to decide why it propagates to some siblings and not others. In particular, it makes it very awkward to write a recursive algorithm to do this if the standing propagates sideways to siblings because your 2 child factions will get updated twice, once from their parent and once from their sibling.

You can run a generic propagation algorithm instead, if you want:

void propagateStanding(amount)
{
    // calculate relative weightings
    totalWeighting = 0.0;
    for (relationship in faction.relationships)
    {
        totalWeighting += relationship.weight;
    }

    // propagate value    
    for (relationship in faction.relationships)
    {
        amountToGive = amount * relationship.weight / totalWeighting;
        relationship.otherFaction.standing += amountToGive;
    }
}

Note that this only covers the propagation, not the increase to the original faction.

Kylotan 2009-12-16 11:10:36

You're right, that's the problem. I tried to simplify the rules for the sake of the example, but in practice, I'd want the values to be granular, not evenly distributed; on further consideration, I can see that there is a distinct difference in the two approaches. Your example does not seem to handle the recursion, but I'll take a look at modifying it to do so. Thanks for the stab at it.

Superstringcheese 2009-12-16 12:37:02

In the first example, it *does* propagate to siblings (red and blue both get 50) - further on, recall that increases to Color result in decreases to Direction, because Color and Direction are enemies (Color, at least, has a "FactionRelationships[ColorFolk].ForeignFaction=DirectionFolk; FactionRelationships[ColorFolk].Multiplier=-1M;" kind of value - I'll update the code to make this a little clearer). But perhaps it should not - would it be simpler to not be able to gain standing directly with a parentless faction, only with children?

Superstringcheese 2009-12-16 12:55:35

You've misunderstood what I meant by siblings - I don't just mean any pair of siblings, I mean explicitly the ones that are siblings to the initial faction whose standing you're altering. In your first example, it all goes to children recursively. In your second example, it goes 'sideways' to BlueFolk. You can't use the same recursive solution for both.

Kylotan 2009-12-16 13:42:39

Additionally, if you're going to have arbitrary links where raising one faction score lowers another, I suggest removing the hierarchy entirely and constructing it as a graph, setting the weights to whatever you need, and forgetting about recursion too. It doesn't appear that the situation you're trying to model maps well to a tree structure at all, and hacks such as treating parent-less factions differently just complicate matters. A simple graph of factions and their standing propagation weights should do fine.

Kylotan 2009-12-16 13:45:29

ansaurus

tags:

views:

answers:

Need an approach for automatically-propagating values in/across hierarchical structures (Faction system for a game)

related questions