User Tools

Site Tools


game:source_diving

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision
Previous revision
Last revisionBoth sides next revision
game:source_diving [2012/06/08 06:53] star_weavergame:source_diving [2012/09/28 16:50] – version notice star_weaver
Line 1: Line 1:
 +====== 1.08b source code .... stuff ... ======
 +===== Random Data Obtained from the C++ Source Code =====
  
 +I just need a place to plonk this stuff for the moment, it really needs to go somewhere else later. -Weaver
 +
 +
 +==== AI States 1.08b ====
 +
 +This might be useful for debuggery? Also a full list of hardcoded controllers because the states vary per controller. From TSE/TSEShipControllersImpl.h
 +
 +<code>
 +class CStandardShipAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateAttackingOnPatrol,                 //  Attacking m_pTarget while on patrol
 +
 +1       stateAttackingTarget,                   //  Attacking m_pTarget
 +2       stateAttackingThreat,                   //  Attacking m_pTarget to protect principal
 +3       stateDeterTarget,                       //  Attack m_pTarget, but stop if target doesn't attack back
 +4       stateDeterTargetNoChase,                //  Attack m_pTarget, but don't chase it
 +5       stateEscorting,                         //  Escorting m_pDest
 +6       stateHolding,                           //  Doing nothing indefinitely
 +7       stateLookingForLoot,                    //  Looking for loot in the system
 +8       stateLooting,                           //  Looting stuff from station
 +9       stateLootingOnce,                       //  Looting stuff from station
 +10      stateMaintainBearing,                   //  Move in m_rDistance (angle) direction
 +                                                //      until we run into enemies.
 +11      stateNone,                              //  Ship needs to consult orders
 +12      stateOnCourseForDocking,                //  Heading for m_pDest to dock
 +13      stateOnCourseForStargate,               //  Heading for m_pDest to gate out
 +14      stateOnPatrolOrbit,                     //  Orbiting m_pDest at m_rDistance
 +15      stateReturningFromThreat,               //  Dock with m_pDest
 +16      stateWaiting,                           //  Waiting for countdown (m_iCountdown)
 +17      stateWaitingForThreat,                  //  Waiting for a threat to m_pDest
 +18      stateWaitingUnarmed,                    //  If threat shows up, we gate out
 +19      stateWaitForPlayerAtGate,               //  Waiting for player at gate
 +20      stateFollowing,
 +
 +21      stateOnCourseForLootDocking,            //  Going to dock with loot
 +22      stateDeterTargetWhileLootDocking,       //  Attack the target, but continue towards loot
 +23      stateFollowNavPath,                     //  Follow current nav path
 +24      stateReturningViaNavPath,               //  Follow current nav path
 +25      stateOnCourseForDockingViaNavPath,      //  Follow current nav path
 +26      stateOnCourseForPatrolViaNavPath,       //  Follow current nav path
 +27      stateOnCourseForPoint,                  //  Going to a given point
 +28      stateWaitingForTarget,                  //  Waiting for m_pTarget
 +29      stateWaitingForEnemy,                   //  Waiting for an enemy
 +30      stateAttackingTargetAndAvoiding,        //  Attacking m_pTarget and avoiding enemy stations
 +        
 +31      stateAvoidingEnemyStation,              //  Attacking m_pTarget and avoiding m_pDest
 +32      stateOnCourseForPointViaNavPath,        //  Follow current nav path
 +33      stateBombarding,                        //  Attacking m_pTarget while holding
 +34      stateApproaching,                       //  Get within m_rDistance of m_pDest
 +35      stateAimingAtTarget,                    //  Aiming at m_pTarget
 +36      stateOnCourseForOrbitViaNavPath,        //  Follow current nav path
 +37      stateOrbit,                             //  Orbit m_pTarget
 +38      stateReturningToEscort,                 //  Return to m_pDest from an attack
 +39      stateHoldingCourse,                     //  Hold course
 +40      stateAttackingPrincipalThreat,          //  Attacking m_pTarget, which attacked principal
 +
 +41      stateTurningTo,                         //  Turning to angle
 +42      stateAttackingTargetAndHolding,         //  Attacking m_pTarget while holding position
 +        };
 +
 +
 +class CAutonAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateNone,
 +1       stateEscorting,
 +2       stateAttackingTarget,
 +3       stateOnCourseForStargate,
 +4       stateFollowing,
 +5       stateWaiting,
 +        };
 +
 +class CFerianShipAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateNone,
 +1       stateOnCourseForMine,
 +2       stateMining,
 +3       stateAttackingThreat,
 +4       stateOnCourseForStargate,
 +5       stateAvoidThreat,
 +6       stateAttackingTarget,
 +7       stateWaitForPlayerAtGate,
 +        };
 +
 +class CFleetCommandAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateNone,
 +1       stateAttackAtWill,
 +2       stateChargeInFormation,
 +3       stateFormAtRallyPoint,
 +4       stateAttackFromRallyPoint,
 +5       stateOnCourseForStargate,
 +6       stateWaiting,
 +7       stateWaitingForThreat,
 +        };
 +
 +class CFleetShipAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateNone,
 +1       stateKeepFormation,
 +2       stateAttackAtWill,
 +3       stateAttackInFormation,
 +4       stateAttackTarget,
 +5       stateOnCourseForStargate,               //  Heading for m_pDest to gate out
 +6       stateOnCourseForDocking,                //  Heading for m_pDest to dock
 +7       stateWaitForPlayerAtGate,
 +8       stateOnPatrolOrbit,
 +9       stateAttackOnPatrol,
 +10      stateWaiting,
 +        };
 +
 +class CGaianProcessorAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateNone,
 +1       stateLookingForWreck,
 +2       statePulverizingWreck,
 +3       stateConsumingWreck
 +        };
 +
 +class CGladiatorAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateNone,
 +1       stateAttackingTarget,
 +2       stateOnCourseForDocking,
 +3       stateOnCourseForStargate,
 +        };
 +
 +
 +
 +class CZoanthropeAI : public CBaseShipAI
 +    enum StateTypes
 +        {
 +0       stateNone,
 +1       stateAttackingThreat,
 +2       stateOnCourseForStargate,
 +3       stateReturningFromThreat,
 +4       stateWaitingForThreat,
 +5       stateOnPatrolOrbit,
 +6       stateAttackingOnPatrol,
 +7       stateOnEscortCourse,
 +8       stateWaiting,
 +        };
 +</code>
 +
 +
 +==== Distance ====
 +
 +Having nothing to do with scale, but with positioning and travel distance.
 +
 +From TSE/TSETypes.h
 +
 +  * Light_Speed = Light_Second = 299792.5 km
 +  * Klicks_Per_Pixel = 12500.0
 +  * Therefore 1 light_second = 23.9834 pixels (how did I get 18.3something last time?)
 +
 +==== Devices ====
 +
 +From TSE/CShip.h, I think
 +
 +  * Drive devices do replace both maxspeed and thrust, nothing is additive
 +
 +==== Encounters ====
 +
 +From TSE/CSystem.cpp
 +
 +  * A system spawns an encounter every 6000 to 9000 ticks
 +
 +  * There is a 10% chance of just reading from a level-based random encounter list
 +
 +  * Otherwise a list of all the encounter tables and events attached to objests in the system is collated based on raritys given, and one is picked from that list.
 +
 +
 +==== Rarity ====
 +
 +From TSE/TSETypes.h
 +
 +I think george may have said this already, but I looked it up in relation to the last exploration anyway
 +
 +<code>
 +enum FrequencyTypes
 +    {
 +    ftCommon                = 20,
 +    ftUncommon              = 10,
 +    ftRare                  = 4,
 +    ftVeryRare              = 1,
 +    ftNotRandom             = 0
 +    };
 +</code>
 +
 +I believe this is generally used by the game by creating a list with [rarity] copies of each item, and then rolling against that list.
 +
 +
 +==== System Map Grid ====
 +
 +The map grid is 100 ls per square:
 +
 +<code>
 +TSE/CSystem.cpp:3216: PaintViewportGrid(Dest, rcView, Trans, CVector(), 100.0 * LIGHT_SECOND);
 +</code>
 +
 +
 +==== Shield Regen Rates ====
 +
 +Shield regen in the xml seems to be based on hp per 6 seconds, but is broken down into different actual periods of no more than 3 seconds via a rather complicated wad of math in CShieldClas.cpp:
 +
 +<code>
 +// Load regen value
 +
 +int iRegen;
 +if (pDesc->FindAttributeInteger(REGEN_ATTRIB, &iRegen))
 + {
 + // Regen specified in hp per 180 ticks. We need to convert that to RegenHP and RegenRate
 +
 + if ((iRegen % 12) == 0)
 + pShield->m_iRegenRate = 15;
 + else if ((iRegen % 10) == 0)
 + pShield->m_iRegenRate = 18;
 + else if ((iRegen % 9) == 0)
 + pShield->m_iRegenRate = 20;
 + else if ((iRegen % 6) == 0)
 + pShield->m_iRegenRate = 30;
 + else if ((iRegen % 5) == 0)
 + pShield->m_iRegenRate = 36;
 + else if ((iRegen % 4) == 0)
 + pShield->m_iRegenRate = 45;
 + else if ((iRegen % 3) == 0)
 + pShield->m_iRegenRate = 60;
 + else
 + pShield->m_iRegenRate = 90;
 +
 + pShield->m_iRegenHP = iRegen * pShield->m_iRegenRate / 180;
 +
 + int iDepletion;
 + if (pDesc->FindAttributeInteger(DEPLETION_DELAY_ATTRIB, &iDepletion))
 + pShield->m_iDepletionDelay = iDepletion / pShield->m_iRegenRate;
 + else
 + pShield->m_iDepletionDelay = 360 / pShield->m_iRegenRate;
 + }
 +else
 + {
 + pShield->m_iRegenHP = pDesc->GetAttributeInteger(REGEN_HP_ATTRIB);
 + pShield->m_iRegenRate = (int)((pDesc->GetAttributeInteger(REGEN_TIME_ATTRIB) / STD_SECONDS_PER_UPDATE) + 0.5);
 + pShield->m_iDepletionDelay = pDesc->GetAttributeInteger(DEPLETION_DELAY_ATTRIB);
 +
 + if (pShield->m_iRegenRate == 0)
 + {
 + pShield->m_iRegenRate = 15;
 + pShield->m_iRegenHP = 0;
 + }
 + }
 +</code>
 +
 +==== Enhancment ====
 +
 +From TSE/TSEDesign.h ... think this is more complete that the data we have in legend?
 +
 +<code>
 +enum ItemEnhancementTypes
 +    {
 +    etNone =                            0x0000,
 +    etBinaryEnhancement =               0x0001,
 +    etLoseEnhancement =                 0x0002, //  Lose enhancements
 +
 +    etStrengthen =                      0x0100, //  +hp, data1 = %increase (10% increments)
 +    etRegenerate =                      0x0200, //  data1 = rate
 +    etReflect =                         0x0300, //  data2 = damage type reflected
 +    etRepairOnHit =                     0x0400, //  repair damage on hit, data2 = damage type of hit
 +    etResist =                          0x0500, //  -damage, data1 = %damage adj
 +    etResistEnergy =                    0x0600, //  -energy damage, data1 = %damage adj (90%, 80%, etc)
 +    etResistMatter =                    0x0700, //  -matter damage, data1 = %damage adj (90%, 80%, etc)
 +    etResistByLevel =                   0x0800, //  -damage, data1 = %damage adj, data2 = damage type
 +    etResistByDamage =                  0x0900, //  -damage, data1 = %damage adj, data2 = damage type
 +    etResistByDamage2 =                 0x0a00, //  -damage, data1 = %damage adj, data2 = damage type
 +    etSpecialDamage =                   0x0b00, //  Immunity to damage effects:
 +                                                //      data2 = 0: immune to radiation
 +                                                //      data2 = 1: immune to blinding
 +                                                //      ... see SpecialDamageTypes
 +    etImmunityIonEffects =              0x0c00, //  Immunity to ion effects (blinding, EMP, etc.)
 +                                                //      (if disadvantage, interferes with shields)
 +    etPhotoRegenerate =                 0x0d00, //  regen near sun
 +    etPhotoRecharge =                   0x0e00, //  refuel near sun
 +    etPowerEfficiency =                 0x0f00, //  power usage decrease, 01 = 90%/110%, 02 = 80%/120%
 +    etSpeed =                           0x1000, //  decrease cycle time
 +    etTurret =                          0x1100, //  weapon turret, data1 is angle
 +    etMultiShot =                       0x1200, //  multiple shots, data2 = count, data1 = %weakening
 +
 +    etData1Mask =                       0x000f, //  4-bits of data (generally for damage adj)
 +    etData2Mask =                       0x00f0, //  4-bits of data (generally for damage type)
 +    etTypeMask =                        0x7f00, //  Type
 +    etDisadvantage =                    0x8000, //  If set, this is a disadvantage
 +    };
 +</code>
 +
 +
 +==== DamageTypes ====
 +They're refrenced above, and this contains george's comments on them. TSE/TSEDesign.h
 +
 +<code>
 +
 +enum DamageTypes
 +    {
 +    damageError         = -100,                 //  invalid damage
 +    damageGeneric       = -1,                   //  generic damage
 +
 +    damageLaser         = 0,                    //  standard lasers
 +    damageKinetic       = 1,                    //  mass drivers
 +    damageParticle      = 2,                    //  charged particle beam
 +    damageBlast         = 3,                    //  chemical explosives
 +    damageIonRadiation  = 4,                    //  ionizing radiation
 +    damageThermonuclear = 5,                    //  hydrogen bomb
 +    damagePositron      = 6,                    //  anti-matter charged particles
 +    damagePlasma        = 7,                    //  fusion weapons
 +    damageAntiMatter    = 8,                    //  anti-matter torpedo
 +    damageNano          = 9,                    //  nano-machines
 +    damageGravitonBeam  = 10,                   //  graviton beam
 +    damageSingularity   = 11,                   //  spacetime weapons
 +    damageDarkAcid      = 12,                   //  exotics
 +    damageDarkSteel     = 13,                   //  exotics
 +    damageDarkLightning = 14,                   //  exotics
 +    damageDarkFire      = 15,                   //  exotics
 +
 +    damageCount         = 16
 +    };
 +
 +</code>
 +
 +==== SpecialDamageTypes ====
 +
 +Wormhole? TSE/TSEDesign.h
 +<code>
 +enum SpecialDamageTypes
 +    {
 +    specialRadiation    = 0,
 +    specialBlinding     = 1,
 +    specialEMP          = 2,
 +    specialDeviceDamage = 3,
 +    specialDisintegration = 4,
 +    specialMomentum     = 5,
 +    specialShieldDisrupt = 6,
 +    specialWMD          = 7,
 +    specialMining       = 8,
 +
 +    specialDeviceDisrupt= 9,
 +    specialWormhole     = 10,
 +    specialFuel         = 11,
 +    specialShatter      = 12,
 +    //  max 15 (because it is used in CItemEnhancement)
 +    };
 +</code>
 +
 +==== Sovereigns and Alignment ====
 +Oh, RPC must have added this for me, cool.
 +This is from TSE/CSoverign.cpp and TSE/TSEDesign.h ... I think. soverign and some header file anyway.
 +
 +<code>
 +enum DispositionClasses
 +    {
 +    alignNone =                 -1,
 +
 +    alignConstructiveChaos =    0,
 +    alignConstructiveOrder =    1,
 +    alignNeutral =              2,
 +    alignDestructiveOrder =     3,
 +    alignDestructiveChaos =     4,
 +    };
 +
 +class CSovereign : public CDesignType
 +    {
 +    public:
 +        enum Alignments
 +            {
 +            alignUnknown =              -1,
 +
 +            alignRepublic =             0,  //  constructive    community       knowledge       evolution       (constructive chaos)
 +            alignFederation =           1,  //  constructive    community       knowledge       tradition       (constructive order)
 +            alignUplifter =             2,  //  constructive    community       spirituality    evolution       (constructive chaos)
 +            alignFoundation =           3,  //  constructive    community       spirituality    tradition       (neutral)
 +            alignCompetitor =           4,  //  constructive    independence    knowledge       evolution       (neutral)
 +            alignArchivist =            5,  //  constructive    independence    knowledge       tradition       (constructive order)
 +            alignSeeker =               6,  //  constructive    independence    spirituality    evolution       (constructive chaos)
 +            alignHermit =               7,  //  constructive    independence    spirituality    tradition       (constructive order)
 +
 +            alignCollective =           8,  //  destructive     community       knowledge       evolution       (destructive chaos)
 +            alignEmpire =               9,  //  destructive     community       knowledge       tradition       (destructive order)
 +            alignSterelizer =           10, //  destructive     community       spirituality    evolution       (destructive chaos)
 +            alignCorrector =            11, //  destructive     community       spirituality    tradition       (destructive order)
 +            alignMegalomaniac =         12, //  destructive     independence    knowledge       evolution       (destructive chaos)
 +            alignCryptologue =          13, //  destructive     independence    knowledge       tradition       (destructive order)
 +            alignPerversion =           14, //  destructive     independence    spirituality    evolution       (destructive chaos)
 +            alignSolipsist =            15, //  destructive     independence    spirituality    tradition       (destructive order)
 +
 +            alignUnorganized =          16, //  unorganized group of beings                                     (neutral)
 +            alignSubsapient =           17, //  animals, zoanthropes, cyberorgs, and other creatures            (neutral)
 +
 +            alignCount =                18,
 +            };
 +
 +        enum Disposition
 +            {
 +            dispEnemy = 0,
 +            dispNeutral = 1,
 +            dispFriend = 2,
 +            };
 +
 +        CSovereign (void);
 +        ~CSovereign (void);
 +
 +        void DeleteRelationships (void);
 +        inline void FlushEnemyObjectCache (void) { m_pEnemyObjectsSystem = NULL; }
 +        Disposition GetDispositionTowards (CSovereign *pSovereign);
 +        inline const CSpaceObjectList &GetEnemyObjectList (CSystem *pSystem) { InitEnemyObjectList(pSystem); return m_EnemyObjects; }
 +        CString GetText (MessageTypes iMsg);
 +        inline bool IsEnemy (CSovereign *pSovereign) { return (m_bSelfRel || (pSovereign != this)) && (GetDispositionTowards(pSovereign) == dispEnemy); }
 +        inline bool IsFriend (CSovereign *pSovereign) { return (!m_bSelfRel && (pSovereign == this)) || (GetDispositionTowards(pSovereign) == dispFriend); }
 +        static Alignments ParseAlignment (const CString &sAlign);
 +        void SetDispositionTowards (CSovereign *pSovereign, Disposition iDisp);
 +
 +        //  CDesignType overrides
 +        static CSovereign *AsType (CDesignType *pType) { return ((pType && pType->GetType() == designSovereign) ? (CSovereign *)pType : NULL); }
 +        virtual bool FindDataField (const CString &sField, CString *retsValue);
 +        virtual DesignTypes GetType (void) { return designSovereign; }
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +CSovereign::Disposition g_DispositionTable[5][5] =
 +    {
 +        //  WE are constructive chaos...
 +        {
 +            CSovereign::dispFriend,         //  THEY are constructive chaos
 +            CSovereign::dispFriend,         //  THEY are constructive order
 +            CSovereign::dispNeutral,        //  THEY are neutral
 +            CSovereign::dispEnemy,          //  THEY are destructive order
 +            CSovereign::dispEnemy,          //  THEY are destructive chaos
 +        },
 +
 +        //  WE are constructive order...
 +        {
 +            CSovereign::dispNeutral,        //  THEY are constructive chaos
 +            CSovereign::dispFriend,         //  THEY are constructive order
 +            CSovereign::dispNeutral,        //  THEY are neutral
 +            CSovereign::dispEnemy,          //  THEY are destructive order
 +            CSovereign::dispEnemy,          //  THEY are destructive chaos
 +        },
 +
 +        //  WE are neutral...
 +        {
 +            CSovereign::dispNeutral,        //  THEY are constructive chaos
 +            CSovereign::dispNeutral,        //  THEY are constructive order
 +            CSovereign::dispNeutral,        //  THEY are neutral
 +            CSovereign::dispNeutral,        //  THEY are destructive order
 +            CSovereign::dispEnemy,          //  THEY are destructive chaos
 +        },
 +
 +        //  WE are destructive order...
 +        {
 +            CSovereign::dispEnemy,          //  THEY are constructive chaos
 +            CSovereign::dispEnemy,          //  THEY are constructive order
 +            CSovereign::dispNeutral,        //  THEY are neutral
 +            CSovereign::dispNeutral,        //  THEY are destructive order
 +            CSovereign::dispEnemy,          //  THEY are destructive chaos
 +        },
 +
 +        //  WE are destructive chaos...
 +        {
 +            CSovereign::dispEnemy,          //  THEY are constructive chaos
 +            CSovereign::dispEnemy,          //  THEY are constructive order
 +            CSovereign::dispEnemy,          //  THEY are neutral
 +            CSovereign::dispEnemy,          //  THEY are destructive order
 +            CSovereign::dispEnemy,          //  THEY are destructive chaos
 +        },
 +    };
 +
 +const DWORD ALIGN_FLAG_CONSTRUCTIVE =       0x00000001;
 +const DWORD ALIGN_FLAG_DESTRUCTIVE =        0x00000002;
 +const DWORD ALIGN_FLAG_COMMUNITY =          0x00000004;
 +const DWORD ALIGN_FLAG_INDEPENDENCE =       0x00000008;
 +const DWORD ALIGN_FLAG_KNOWLEDGE =          0x00000010;
 +const DWORD ALIGN_FLAG_SPIRITUALITY =       0x00000020;
 +const DWORD ALIGN_FLAG_EVOLUTION =          0x00000040;
 +const DWORD ALIGN_FLAG_TRADITION =          0x00000080;
 +
 +struct SAlignData
 +    {
 +    int iNameLen;
 +    char pszName[32];
 +    DispositionClasses iDispClass;
 +    DWORD dwFlags;
 +    };
 +
 +static SAlignData ALIGN_DATA[CSovereign::alignCount] =
 +    {
 +        {   CONSTDEF("republic"),       alignConstructiveChaos,     ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("federation"),     alignConstructiveOrder,     ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
 +        {   CONSTDEF("uplifter"),       alignConstructiveChaos,     ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("foundation"),     alignNeutral,               ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
 +        {   CONSTDEF("competitor"),     alignNeutral,               ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("archivist"),      alignConstructiveOrder,     ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
 +        {   CONSTDEF("seeker"),         alignConstructiveChaos,     ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("hermit"),         alignConstructiveOrder,     ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
 +
 +        {   CONSTDEF("collective"),     alignDestructiveChaos,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("empire"),         alignDestructiveOrder,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
 +        {   CONSTDEF("sterilizer"),     alignDestructiveChaos,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("corrector"),      alignDestructiveOrder,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
 +        {   CONSTDEF("megalomaniac"),   alignDestructiveChaos,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("cryptologue"),    alignDestructiveOrder,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
 +        {   CONSTDEF("perversion"),     alignDestructiveChaos,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
 +        {   CONSTDEF("solipsist"),      alignDestructiveOrder,      ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
 +
 +        {   CONSTDEF("unorganized"),    alignNeutral,               0 },
 +        {   CONSTDEF("subsapient"),     alignNeutral,               0 },
 +    };
 +</code>
game/source_diving.txt · Last modified: 2014/12/27 04:40 by 127.0.0.1