I seems like we have --

Behaviors:

Government -- (use interface from the Govt model)
Religion -- (new interface needed)
Culture -- (I'm not sure, think this is a new interface)

That's exactly why we need to have these hash sessions. I'm not sure, to be honest. My thinking was that there is no such thing as a 'government', 'religion' or 'culture', they aren't actual 'things'. Just the behavior/interaction of a collection of people.

If so, then (like an 'ActionListener'), we code up some 'Command' objects that implement 'Government', each with it's own implementations of the desired methods (changeTaxRate(), setPolicy(Policy p), and that's how you can easily arrange it so people can easily code up a govt. You just show the coders the Interface, and tell them to write a class that implements it.

And there are many, many other benefits. Perhaps the single biggest one is how easily it fits into a 'mediator' pattern. But I'll wait until after we define the objects and behaviors before getting into that one . . .

Hi. These are my thoughts about this:

In civ game world the objects are fairly self-explainatory. To code them, you only have to decide which of their real-world properties and behaviours are game-relevant.

I think that none of the "behaviours" you mentioned shouldnt be coded as object, simply because they do not have evident behaviour of their own. They present simply a state, modified by other objects, so better way to represent them would be structs.

That is if you feel such abstract and fuzzy things really need to be defined.

It is a natural approach to try and model population so it has properties such as culture, religion and such.

Welcome to the chat. You're exactly the kind of person I'm hoping will be able to help us with this. I'm so new to OOA/OOD, I've got a lot to learn.

I'm inclined to agree with you, tho, these seem to be the interactions of objects rather than actual objects.

Struct is a c keyword used to describe a variable that has other sub-variables.

The difference from a class (object in c) is that it doesnt have any functions (methods) in it. I think java is simmilar.

When you try to define all objects you are going to be using in the game it is tempting to do this:

Player has:
civs, advisors, score ..

Civ has:
cities, technology, gold ..

City has
population, units, buildings ..

Population has
numberofpeople, tolerance, individualism ..

And so on for all game-world objects. This is a natural approach taken with variations in all civ games.

If you want to implement a complex model in the game, say Economy or Religion, you would derive them from low-level objects such as buildings, companies and population.

BTW Economy (ProvEcon actually) is a base object so far, since we don't have complex objects like buildings...

Hi Vetlegion. I hope you stay in this process and participate also in the OOA for the govt model. You seem helpful!

Ok. I'm going to shoot. I'm going to kind of ignore what has already been said and tell you what I see is needed, using a little bit of OOA language I've just learned...

Each ethnic group in the civ is (I guess) an object of the "ethnic groups" OOA class with the following info (in parenthesis the type of variable):
NATIONALITY (text)
PRIMITIVE RELIGION (single)
GRW (pointer, pointing to a GRW object)
GRW's SPREADING RATE (single)
RELIGIOUSLY DISCRIMINATED (boolean-false/true)
ETHNICALLY DISCRIMINATED (boolean)
SLAVERED (boolean)
ETHNIC TOLERANCE (integer)
RELIGIOUS TOLERANCE (integer)
AGGRESSIVENESS (integer)
ASCETICISM (integer)
INDIVIDUALISM (integer)
IMPORTANCE OF RELIGION (integer)
EDUCATION LEVEL (integer)
TRADITIONALISM (integer)
NATIONALISM (integer)
LAND CONNECTION (integer)
TV_ETHNIC TOLERANCE (integer)
TV_RELIGIOUS TOLERANCE (integer)
TV_AGGRESSIVENESS (integer)
TV_ASCETICISM (integer)
TV_INDIVIDUALISM (integer)
TV_IMPORTANCE OF RELIGION (integer)
TV_TRADITIONALISM (integer)

TV stands for "Tendency Values".

Each GRW (Great Religion of the World) is an object of another OOA class (GRW class). In this case these objects are at the "planet level" with this info:
NAME (text)
RELIGIOUS TOLERANCE (integer)
AGGRESSIVENESS (integer)
ASCETICISM (integer)
INDIVIDUALISM (integer)
SACRIFICE (integer)
COUNTDOWN (long integer)
HOLY LAND (pointer, pointing at a map square)

For each civ you need 2 vectors of values ("Contact Variables" and "Acceptance Variables"), each with N elements, where N is the number of GRW allowed in the game. All can take values 0 or 1, but cannot be boolean because they're used in sums in some procedures.

At the province level you need a dynamic array of ethic groups and their populations. "Dynamic" because the number of EGs can change as time passes. Example:
Romans, 10000
Franks, 70000
Celts, 120000
This same is needed at the map square level.

For each civ you need one object like this: "Environment Values", with variables:
RELIGIOUS TOLERANCE (integer)
AGGRESSIVENESS (integer)
ASCETICISM (integer)
INDIVIDUALISM (integer)

For each civ you need one object like this: "Majorities Cultural Attributes" (MCA), with variables:
ETHNIC TOLERANCE (integer)
RELIGIOUS TOLERANCE (integer)
AGGRESSIVENESS (integer)
ASCETICISM (integer)
INDIVIDUALISM (integer)
IMPORTANCE OF RELIGION (integer)
NATIONALISM (integer)

For each civ you need an object with the same variables MCA has, called "Religious Class Mentality". This one will be used only in the govt model.

For each civ you need a list of civs the former has trade with. The list is called Known Civs List and it has the name of the civ and the number of trade routes with it, like this:
Persia, 5
China, 11
France, 2

Each civ needs a nationality.

Procedures needed:
>>>>For ethnic groups:
>Change Nationalism and Land Connection
>Change all TV_* attributes using Environment Values, MCA values and attributes Aggressiveness, Religous Tolerance, Individualism and Asceticism from the GRW object the GRW pointer in the ethnic group is refering to.
>Change Religious Tolerance, Ethnic Tolerance, Traditionalism, Asceticism, Aggressiveness, Individualism and Importance of Religion using the civ's "Tendency Values".
>Check acceptance of GRW, using GRW objects and civ's Contact Variables. Acceptance Variables can change after this procedure is applied.
>Move population to ethnic group with the same nationality the civ has.
>Create ethnic group from merging.
>Change Education Level.

>>>>For the GRW
>Decrease Countdown, and if zero, give birth to GRW

>>>>For civ
>Create Environment Values
>Create MCA values
>Create Religous Class Mentality values.
>Change Contact Variables picking a random civ in the Known Civs List.

>>>>For the province
>Sum square map level populations to have province level populations on a ethnic group basis.

A data structure, then.

Java, I believe, uses an object for that purpose. Because of that 'gang-of-four' book on patterns, that class has come to be called a 'command' object, since it is an object to handle/command the variable states of interacting objects. And this sub-class typically implements an 'interface', rather than extending an abstract class, in order to help seperate objects from behaviors.

Does this approach seem similar to a 'struct'?

Good job, man! Great contribution!

Overall, very solid. I might suggest a few changes, tho:

Relating to public class EthnicGroup--

1) Would you mind if I lumped 'PRIMITIVE RELIGION', GRW and GRW SPREADING RATE' into another object called 'Religion'?

2) Similarly, can 'RELIGIOUSLY DISCRIMINATE', 'ETHNICALLY DISCRIMINATED', 'SLAVERED', 'ETHNIC TOLERANCE', 'RELIGIOUS TOLERANCE', 'ASCETICISM', 'INDIVIDUALISM' and 'IMPORTANCE OF RELIGION' be combined into a 'Culture' object?

3) Again, 'EDUCATION LEVEL', 'TRADITIONALISM', 'NATIONALISM' and 'LAND CONNECTION' could become something like BodyPolitic, perhaps?

4) And absolutely we should encapsulate all the TV variables in a 'TendencyValues' object, agreed?

About your proposals:
"1) Would you mind if I lumped 'PRIMITIVE RELIGION', GRW and GRW SPREADING RATE' into another object called 'Religion'?"
It makes sense.

"2) Similarly, can 'RELIGIOUSLY DISCRIMINATE', 'ETHNICALLY DISCRIMINATED', 'SLAVERED', 'ETHNIC TOLERANCE', 'RELIGIOUS TOLERANCE', 'ASCETICISM', 'INDIVIDUALISM' and 'IMPORTANCE OF RELIGION' be combined into a 'Culture' object?

3) Again, 'EDUCATION LEVEL', 'TRADITIONALISM', 'NATIONALISM' and 'LAND CONNECTION' could become something like BodyPolitic, perhaps?"

I'd suggest this grouping instead:
group1
AGRESSIVENESS
INDIVIDUALISM
RELIGIOUS TOLERANCE
ASCETICISM

group2
EDUCATION LEVEL
IMPORTANCE OF RELIGION
NATIONALISM
TRADITIONALISM
LAND CONNECTION
ETHNIC TOLERANCE

group3
ETHNICALLY DISCRIMINATED
RELIGIOUSLY DISCRIMINATED
SLAVERED

This suggestion arises because of the calculations needed, so in each group calculations are kind of the same for each variable. In particular, group1 groups the same variables the Great Religions of the World OO-class contains as thier "moral codes".

"4) And absolutely we should encapsulate all the TV variables in a 'TendencyValues' object, agreed?"
agreed

Great! Keep on going, F_Smith!

Simple stuff to code up. I'm finished with coding the objects. We can change their details at will, and I'm betting that will happen, but it will be a simple matter to change the methods involved.

If anyone wants a copy, I'll send it to you. Altho it's pretty self-explanatory from the above. In fact, I'll make a post later tonight repeating the design hierarchy in as clear and concise a fashion as possible.

Open-source approach front and center, I suppose. Here's the beginnings of the code for the social model. Feel free to use this/change this/slam this/all of the above. This is just version .00001! I am not a genius. I need your help to do this right. I'm very sure I've missed a few of the changes that have been discussed over the last few days -- feel free to point out loudly whenever my natural ignorance leaked thru.

You can get all the source for both models I'm working on at http://home.austin.rr.com/lostmerchant/Clash/source/.

code:

---

*******************************************
import java.util.*;
public interface Culture
{
    public void         addTrait(Policy p);
    public Policy       getTrait(String t);    
    public Enumeration  getAllTraits();
}
*******************************************
import java.util.*;
public class PopularCulture implements Culture
{
    private String name;
    private Vector traits;
    
    public PopularCulture(String n)
    {
        name = n;
        
        traits = new Vector();
    }
    
    public void addTrait(Policy p)
    {
        traits.addElement(p);        
    }
    
    public Policy getTrait(String t)
    {
        Enumeration enum = traits.elements();
        
        while(enum.hasMoreElements())
        {
            Policy trait = (Policy)enum.nextElement();
            
            if(trait.equals(t))
            {
                return trait;
            }
        }
        
        return null;
    }
    
    public Enumeration getAllTraits()
    {
        return traits.elements();
    }
}
***************************************

/**
 * This data structure could be a simple HashMap instead, but making it an object
 *   leaves room for further enhancement of the 'values' or implementations
 *   of a 'policy' beyond a single integer.
 * 
 * @author The gang
 * @version .00001
 * @since Jun 2000
 */
 
public class Policy
{
    private String name;
    private int    value;
    
    public Policy(String n)
    {
        name = n;        
    }
    
    public Policy(String key, int value)
    {
        name = key;
        setValue(value);
    }
    
    public void setValue(int v)
    {
        value = v;
    }
    
    public int getValue()
    {
        return value;
    }
    
    public boolean equals(Object o)
    {
        return o.equals(name);
    }
}
*****************************************
import java.util.*;
public interface Religion
{
    public void         addReligousDoctrine(Policy p);
    public void         addReligousDoctrine(String key, int value);
    public Policy       getReligousDoctrine(String p);
    public Enumeration  getAllDoctrines();    
}
****************************************
import java.util.*;
public class PrimitiveReligion implements Religion, Culture
{
    private String name;
    private Vector doctrines;
    private Vector traits;
    
    public PrimitiveReligion(String n)
    {
        name = n;
        
        doctrines = new Vector();
        traits = new Vector();
    }
    
    public void addReligousDoctrine(Policy p)
    {
        doctrines.removeElement(p);
        doctrines.addElement(p);
    }
    
    public void addReligousDoctrine(String key, int value)
    {           
        doctrines.removeElement(key);        
        doctrines.addElement(new Policy(key, value));
    }
    
    public Policy getReligousDoctrine(String p)
    {
        Enumeration enum = doctrines.elements();
        
        while(enum.hasMoreElements())
        {
            Policy pol = (Policy)enum.nextElement();
            
            if(pol.equals(p))            
                return pol;
        }
        
        return null;
    }
    
    public Enumeration getAllDoctrines()
    {
        return doctrines.elements();
    }
    
    public void addTrait(Policy p)
    {
        traits.removeElement(p);
        traits.addElement(p);
    }
    
    public Policy getTrait(String t)
    {
        Enumeration enum = traits.elements();
        
        while(enum.hasMoreElements())
        {
            Policy p = (Policy)enum.nextElement();
            
            if(p.equals(t))
                return p;                
        }
        
        return null;
    }
    
    public Enumeration getAllTraits()
    {
        return traits.elements();
    }
    
    public String toString()
    {
        return name;
    }    
}
*******************************************
public class GreatWorldReligion extends PrimitiveReligion
{    
    private int counter;
    private MapSquare holy_land;
    
    public GreatWorldReligion(String n)
    {
        super(n);
    }
    
    public void setHolyLand(MapSquare h)
    {
        holy_land = h;
    }
    
    public MapSquare getHolyLand()
    {
        return holy_land;
    }
}

---

And there is still more to add to 'EthnicGroups', I should think. 'SocialClasses', for one. But that's for another post, since I didn't see a consensus on how social classes will work out (did I miss it? Please help!) . . .

P.S.-- feel free to mentally (or otherwise) switch the simple Vectors to better, Java2 collections. I'm trying to keep this Java 1.x for now, so I can post demos at a website that will work in IE5.

The EG segment in the Ruling class use the cultural traits of their govt?

The Religous class uses the cultural traits of their religion?

Otherwise, use the cultural traits of the Ethnic group's culture?

Or, perhaps, some social classes have their own 'culture'? Intellectual class? Warrior class? 'Death Cult' class? 'Empath' class? Wizard class?

Each could have their own 'cultural traits'.

Thanks for plugging away at this The framework looks good, at least on cursory inspection. BTW there is a code tag you can put in your post so that the indentation doensn't get lost. It works like this IIRC(remove all . I put . in so it will show as text)

[.code.]
code goes here...
[./code.]

code:

---

  
...
void doNothing(){
     {;}
}
...

---

Well, this social class approach is actually built into the code already, but if has been decided against using this for the basic game, so be it.

I will keep it in as an option, tho, for game designers who want to customize social classes in a scenario . . . since they're the only ones that have to mess with this.

The player won't have to deal with it, since it will all be transparent to him. All the player will see is that people act differently, depending on the culture they're steeped in. Priests and warriors will not want the same things. And I like the idea that you might be forced to balance the wants of your people like that.

Clash Object/Scenario Editor, Mark I
http://home.austin.rr.com/lostmerchant/Clash/Editor/ClashEditor.html

Just a test for compatability. Please hit this page, and if you experience any errors or bugs, post them in one of the 'coders' threads.

Some comments on the code you posted: I understand very little, but:
1) We don't need a primitive religion object. One of the most important implications of the model approach is that primitive religion's traits are exactly equal to the EG's attributes that follows it. Having primitive religions as objects will double the number of objects in the game with redundant info.

2) You said "we will have 'EthnicGroups' that will hold a pop number, EG name, Religion object, Culture object, 'TendencyValues' object, and one other grouping of related vars. Each 'MapSquare' will have a collection of 'EthnicGroup' objects."
This is too much info at the mapsquare level! A mapsquare must have a "pseudo-ethnic group" object with nationality name and population only. All the info you grouped in the EthnicGroup object is fine, but at the civ level.

I'm about to begin putting in some 'SocialClass' stuff into that Beast, so perhaps after it's in it'll be clearer what I'm talking about. It's often easier to see it in action than it is to understand how an object design will work.

I completely agree and understand about your first bit. That's what is built in to the code now -- you can assign where each 'SocialClass' gets it's influence from. For convenience's sake, the code calls any 'influence' a 'Culture'. Which is why the Govt will have it's own 'Culture' which the BE class will use. The 'MCA' is a 'Culture', for the UC and LC (and perhaps the Middle-C?). And the Military's unique attitude is a 'Culture', for use by the 'MC'. From the code's viewpoint, anyway. But I love the implication, too . . .

About your specific comments:

1) Mainly, this 'PrimitiveReligion' object is for designing and loading religions from a file. It is necessary. At most, I can't imagine a world with more than 40 or 50 different 'Primitive Religions', unless you're going to seperate the religions by specific Deities, not types. Altho a Scenario designer could do that, if they chose, I suppose. But even so, it won't require much memory at all, merely a few kbytes at worst.

2) Each MapSquare will have to keep seperate the EGs in it. We will have to 'loop thru' population objects in each mapsquare for various reasons in game-flow.

Say you raise Taxes. Then every population group in a mapsquare must be 'processed', if that makes sense, if only to get their new tax contribution. Or perhaps to get their cultural reaction to higher taxes. Or for a million other reasons. It can't work any other way.

I think the Beast (the Object Builder) will help to put us all on the same page.

Thanks for working on this with me, tho. Discussing it with you makes me rethink some of my basic assumptions. And I guarantee you I've misunderstood something, somewhere!

"the code calls any 'influence' a 'Culture'"
Alright. I'll keep that in mind.
-------

"'PrimitiveReligion' object is for designing and loading religions from a file"

There're no primitive religions to load. Primitive religions are just a model's "trick". They don't really exist, and the model does nothing with them, ever. That's why the code should not have them either. In the model, an ethnic group "is said to follow a primitive religion", but that's it. No traits or anything is ever needed for them. What really exist are the GRW and they can be loaded from files and anything you want.
-------

Looping thru: OK, I understand your thinking. Two thing to say, then:
1)Don't start coding any "loop thru procedures" without telling me what actions you're envisioning in them. ok? I have the feeling you envision a lot of calculations at the mapsquare level, while I believe there're almost none.