Sorry your browser is not supported!

 keep it "RTS", but in a modified form:
 - the "galaxy map" displays "planets" and "Fleets". 
 - players have very few fleets (possibly equal to the # of colonies they control)
 - "Combat" is a seperate screen, and is pure RTS shoot'em'up

because we have trouble diplaying so many units on the screen at once 
(my game caps at 250, and that's not very many)
it causes significant slow-down

 - when a planet builds a ship, it goes into a "pool"
 - a player may create a fleet at an owned planet, as long as he has an 'empty fleet' available.
 - the fleet may have any number of ships, drawn from your 'pool', when you "Deploy" the fleet
 - the fleet then moves around the galaxy, as a single entity, and only splits into its component ships when "combat" is joined.
 - it can take time to 'deploy' a fleet. 1 sec. per ship, or 1 sec per ship-size. whatever seems fair and balanced.
 - it might also take time to "disperse" a fleet
 - (these later considerations are to stop a player from instantly making and disbanding fleets to counter every attack by an enemy)

Some Possible Solutions:
 - all owned planets produce all the time (build wealth, possibly ships), but they don't *Do* anything, they "turtle"
[i]until[/i] the human player gets close... then they start moving.
 - - and perhaps they colonize up to 4 planets.

 - *or* - maybe the story is like this:
"all races in the galaxy are basically peaceful, except you. it's your job to unite the galaxy under one rule : Yours!"
 - - so, the aliens build forever, sending out fleets, etc. , but they simply don't fight eachother.
 - they would probably attack you on sight, though.

 - *or* - maybe they DO fight eachother
 - but battles that don't include the human player are resolved instantly and mathematically. by the race's ship's stats.
 - this model would need some AI arrays like Anger(20,20) which says how angry each race is with each other race, to decide who they will attack.
 - this model could also have an AI-Only stat, called .Tactics, 
  which is a 0.5 - 1.5 (or 50 - 150) which gives them a bonus or penalty to their 'mathematical combat' , as mentioned above.
 - - this way, large empires will emerge, who are truly your equals, because they have the highest .Tactics stat.

here are the relevant stats that already exist in the game:

ATK - Attack. The race's base damage done by attacks, which is used to calculate each ship's damage.

DEF - Defense. how much damage a ship can take before destroyed. race stat multiplied by ship size

SPD - speed. this was previously just based on ship size (FF is fast, BB is slow). this can now however be a technology, unique to each race.

RNG - Range. how far away a ship's weapons can hit a target. Previously based on ship size. also can now be a tech.

GRO - Population Growth. How fast a race's population grows (really?) 

ECO - Economy. How much 'wealth' a population generates over a unit of time.

other things that can be technologies:

SEN - Sensors. How far off into space a planet can see. Used to detect incoming enemy fleets . (also used for how far Ships can see when exploring)

DPL - Deployment. How fast a race can deploy fleets (see above deplyment model)

WHT - What do you think about it all?

 - each 'sector' is like a new game, with ~30 planets, and a new alien race to conquer.
 - the whole gameplay is just like the old game: RTS. colonize, build, seek, destroy
 - once you eradicate an enemy in one sector, you go to the next sector, and face a new enemy.
 - You start each 'sector' with only one planet, but it might be at full population.
 - you also start with whatever 'stats' and 'technology' that you had from all previous sectors.
 - each new race that you face receives bonuses according to how many sectors you've cleared so far, and / or how much elapsed time you've played so far (star-date)
 - - that gives fresh and exciting challenges, AND the desire to win quickly, so the next enemy you face is not too strong.
 - perhaps when you conquer the enemy [i]homeworld[/i], you find an 'interesting technological device', which adds to your abilities. (this could be the case for any game model)

 - in this game, you will eventually be defeated, and you will be scored on various things, like sectors taken over, ships built, enemies killed, etc.
 - this style of game will only need to be aware of 1 alien race at a time, approximately 30 planets, and however many ships each side builds.
 - perhaps the player's previous sectors from a game can be saved as files, so they can go back and look at them. but they can't get any ships or anything from them.

 size = (X^3)/(Y*1.357) mod 12 + 1 ,
 water percentage = ((3x+15)*(4y+3)) mod 100 , etc.

sectors 10x10 (100 total)

30 stars per sector (3000 stars)

~9 planets / sector (3-9 planets) (9000-27000 planets)

ONLY the SECTOR that you are currently IN is dealt with.

when you LEAVE a sector, a SECTOR_X_Y FILE is created.

it stores ALL the data relevant to that sector,

AND IT STORES THE CURRENT *STARDATE*.

when you come BACK to that sector,

A GROUP OF PROCESSES UPDATE THE SECTOR FROM THE *SAVED* STARDATE 
 UP TO WHATEVER THE CURRENT STARDATE IS.

 - this way, if you make friends or enemies, it can be saved.
 - anything that individual planets have or want can be saved.
 - the computer doesn't have to keep everything in memory at once.
 - time can still appear to have passed in the sector 

 - if a planet was experiencing a natural disaster, it can be resolved (for better or worse).
 - if a war was brewing, it might be over (or in progress) (or negotiated and never happened)
 
 - also populations can increase accordingly, races can advance technologically, planets can be colonized or destroyed, etc.

 - fights are between 'planets'
 - each planet has ships & troops (which are automatically built by the AI
 - when one planet 'fights' another, first 'ship' combat is resolved.
 - if there is a clear & decisive winner , then 'troop' combat takes place.
 - if there is a clear winner of that , then the planet belongs to whoever won (with ties going to the original owner)
 - perhaps the player can not even directly influence these fights.
 
 * the way the player DOES influence these fights is by the things he has found on his journeys (technologies, weapons, defenses, etc.)
 * AND by the way he tells his planets to grow and build.

`*********************************************************************************
` My Fibonacci sequence generator
`
` This version calculates the correct Fibonacci sequence but I then strip away
` all digits except the units value of the products, so 346 is stored as 6
`
` The idea is that the string is `pseudo-random` and at the same time using the 
` same seed (or starting point) I can recreate the universe
` the benefit is that I don't have to save the universe to any save game
`
`
` The function takes 1 parameter: cnt - this equates to how far down the sequence
` should be calculated
`
` The function returns a string that contains all the single digits of the products
`
` version 1.0 created 1st January 2010 by Steven Devonport
`
`*********************************************************************************
m$ = myfib(2000)
print m$

open to write 1,"E:\TWOE\elite\fibonacci.dat"
write string 1, m$
close file 1

end

function myfib(cnt as integer)
a$="01"
a=0
b=0
for zzz = 1 to cnt
    a=val(mid$(a$,zzz)) ` 1st fib seq number
    b=val(mid$(a$,zzz+1)) `2nd fib seq number
    c=a+b
    z=len(str$(c))
    b$=right$(str$(c),1)
`    if z =1 then b$=str$(c) : rem single digit length
`    if z>1 then b$=right$(str$(c),1) : rem >single digit length
    a$ = a$ + b$
next zzz

endfunction a$

`
` load in a pregenerated Fibonacci sequence
'
function myfib()
    open to read 1, "E:\TWOE\elite\fibonacci.dat"
    read string 1, fib$
    a$ = fib$
endfunction a$

`load the stored fibbonacci sequence in M$
m$ = myfib()

`
` find a random starting point within the Fibbonacci sequence
` the returning value is the numerical location within the fib sequence - not
` the value of the location - that has to be determined later
`
function fibstart(fib as string)
    fiblen = len(fib) - 1
    for x = 1 to 10    `short sequence to select a random starting point
        fibseed = 1 + rnd(fiblen) `this number determines the "random" starting point along the fib seq
    next x
endfunction fibseed

`find the start point within the fib sequence
fbloc = fibstart(m$)

stardata:
`how many star systems in the universe
data 300,350,500,600,650,700,750,800,900,1000
planetdata:
` The following data statement represents the number of planetary bodies per solar system
data 5,10,15,18,20,22,25,30,35,40

planet_types:
data "sun","gas giant","desert","water","swamp","jungle","forest","glacial","moon","asteroid"
planet_sizes:
data 1000,3000,5000,7000,12000,15000,20000,75000,95000
temperature:
data "hot","warm","termperate","cool","cold","icy"

fibvalue = getfibvalue(m$,fbloc)

    restore stardata
    for a = 0 to fibvalue
        read stnbr  
    next a
    numberofstarsystems = stnbr

    for a = 1 to numberofstarsystems
`define where the star systems are located in the game universe
`might want to do some positioning based on racial type    
        rx = 1+rnd (xgrid-1)
        ry = 1+rnd(ygrid-1)
        zy = rnd(zgrid)
        fibvalue = getfibvalue(fbstring, fbloc)
        mp = ppl(fibvalue) ` the number of planets to assign to the current star system
        starsystems(a).id = a      
        starsystems(a).tag = "Dummy:" + str$(a)
        starsystems(a).maxplanets = mp        
`        starsystems(a).maxstations = 1
        starsystems(a).xloc = rx
        starsystems(a).yloc = ry
        starsystems(a).zloc = zy

`        populate_starsystems(starsystems(a).maxplanets)        
    next a 

`
` get the next numerical value from the fibbonacci sequence and move the pointer on by +1
`
function getfibvalue(fibstring as string, fbloc as integer )
    fibloc = fbloc
    fbv = val(mid$(fibstring, fibloc))
    inc fbloc,1
endfunction fbv

dim vowels(4) as string
Dim Vowel_combos(3) as string
Dim Consonants(20) as string
Dim Consonant_combos(11) as string

dim name (40000) as string

Set_Alphabet()

open to write 1, "E:\twoe\elite\planets.txt"

for a = 1 to 40000
	nm$ = set_name(rnd(9)+3)
	write string 1, nm$
next a
	
close file 1


end

'-------------------------------------------------------------------------
' create the alphabet used to generate starsystem and/or planet names
'-------------------------------------------------------------------------

function Set_Alphabet()
    restore alphabet
   for a = 0 to 4
      read vowels(a)
   next a

   for a=0 to 3
     read vowel_combos(a)
   next a

   for a = 0 to 20
      read consonants(a)
   next a

   for a = 0 to 11
      read consonant_combos(a)
   next a
endfunction

'-------------------------------------------------------------------------
' generate planet name
'-------------------------------------------------------------------------

function set_name(namelen as integer)
`   number_letters=rnd(9)+3
   temp$=""
   select namelen
   case 3 'c-v-c
   	temp$ = consonants(rnd(20))
	temp$=temp$ + vowels(rnd(4))
   	temp$=temp$ + consonants(rnd(20))
   endcase
   case 4 ' c-v-c2
   	temp$ = consonants(rnd(20))
    temp$=temp$ + vowels(rnd(4))
    temp$=temp$ + consonant_combos(rnd(11))
   endcase
   case 5 'c-v2-c2
   	temp$ = consonants(rnd(20))
    temp$=temp$ + vowel_combos(rnd(3))	
 	temp$=temp$ + consonant_combos(rnd(11))
   endcase
   case 6 'c-v-c-v-c2
   	temp$ = consonants(rnd(20))
	temp$=temp$ + vowels(rnd(4))
   	temp$=temp$ + consonants(rnd(20))
	temp$=temp$ + vowels(rnd(4))
    temp$=temp$ + consonant_combos(rnd(11))
   endcase
   case 7 'c2-v2-c-v-c
   	temp$ = consonant_combos(rnd(11))
    temp$=temp$ + vowel_combos(rnd(3))	
   	temp$=temp$ + consonants(rnd(20))
	temp$=temp$ + vowels(rnd(4))
   	temp$=temp$ + consonants(rnd(20))       	
   endcase
   case 8 'c2-v-c2-v2-c
   	temp$ = consonant_combos(rnd(11))
	temp$=temp$ + vowels(rnd(4))   	
    temp$=temp$ + consonant_combos(rnd(11))	
    temp$=temp$ + vowel_combos(rnd(3))
   	temp$=temp$ + consonants(rnd(20))    
   	endcase
   case 9 'c2-v-v-c2-c-v-c
   	temp$ = consonant_combos(rnd(11))
	temp$=temp$ + vowels(rnd(4))
	temp$=temp$ + vowels(rnd(4))	   	
    temp$=temp$ + consonant_combos(rnd(11))	
   	temp$=temp$ + consonants(rnd(20)) 
	temp$=temp$ + vowels(rnd(4))	   	
   	temp$=temp$ + consonants(rnd(20))    	    
   endcase
   case 10 'c-v2-c2-v-v-c2-v
   	temp$ = consonants(rnd(20))
    temp$=temp$ + vowel_combos(rnd(3))   	
   	temp$=temp$ + consonant_combos(rnd(11))
	temp$=temp$ + vowels(rnd(4))
	temp$=temp$ + vowels(rnd(4))	   	
   	temp$=temp$ + consonant_combos(rnd(11))
	temp$=temp$ + vowels(rnd(4))	   	   	
   endcase
   case 11 'c2-v2-c2-v-v-c-v-c
   	temp$ = consonant_combos(rnd(11))
    temp$=temp$ + vowel_combos(rnd(3))   	
   	temp$=temp$ + consonant_combos(rnd(11))
	temp$=temp$ + vowels(rnd(4))
	temp$=temp$ + vowels(rnd(4))   	
   	temp$=temp$ + consonants(rnd(20)) 
	temp$=temp$ + vowels(rnd(4))	   	
   	temp$=temp$ + consonants(rnd(20))     	
   endcase
   case 12 'c-v2-c2-v-v-c2-v-c2
   	temp$ = consonants(rnd(20))
    temp$=temp$ + vowel_combos(rnd(3))     	
   	temp$=temp$ + consonant_combos(rnd(11))
	temp$=temp$ + vowels(rnd(4))
	temp$=temp$ + vowels(rnd(4))   	   	    
   	temp$=temp$ + consonant_combos(rnd(11))
	temp$=temp$ + vowels(rnd(4)) 	        
   	temp$=temp$ + consonant_combos(rnd(11))
   endcase
   
   endselect 
 
endfunction temp$

alphabet:
Data "a","e","i","o","u" : rem vowels
Data "oo","oa","ee","ia" : rem vowel combos
Data "b","c","d","f","g","h","j","k","l","m","n","p","qu","r","s","t","v","w","x","y","z" : rem constanants
Data "st","th","ph","pr","ch","cl","tr","spl","str","fl","bl","br" : rem constanant combos

rem # Obese87's Random Name Generator
Function Random_Name$(name_len)
  rem Empty the string.
  planet$=""

  for i = 0 to name_len
    rem Get a random parent character.
    Parent = rnd(25)+65
    rem Make sure name doesn't end in "QU".
    if i=name_len and Parent=81 then Parent=Parent-1-rnd(15)

    rem Add parent to planet name.
    planet$ = planet$+chr$(Parent)

    rem Generate child from parent.
    Select Parent
      rem Q can only be followed by U.
      Case 81 : planet$=planet$+"U" : Endcase
      rem Vowel.
      Case 65 or 69 or 73 or 79 or 85
        child = rnd(4)
        if child=0 then planet$=planet$+"L"
        if child=1 then planet$=planet$+"N"
        if child=2 then planet$=planet$+"R"
        if child=3 then planet$=planet$+"S"
        if child=4 then planet$=planet$+"T"
      Endcase
      rem Consonant.
      Case Default
        child = rnd(4)
        if child=0 then planet$=planet$+"A"
        if child=1 then planet$=planet$+"E"
        if child=2 then planet$=planet$+"I"
        if child=3 then planet$=planet$+"O"
        if child=4 then planet$=planet$+"U"
      Endcase
  next i
Endfunction planet$

do
cls
for t=1 to 25
 print Random_Name$(rnd(1)+1)
next t
wait key
loop

rem # Obese87's Random Name Generator
Function Random_Name$(name_len)
  rem Empty the string.
  planet$=""

  for i = 0 to name_len
    rem Get a random parent character.
    Parent = rnd(25)+65
    rem Make sure name doesn't end in "QU".
    if i=name_len and Parent=81 then Parent=Parent-1-rnd(15)

    rem Add parent to planet name.
    planet$ = planet$+chr$(Parent)

    rem Generate child from parent.
    Select Parent

      Case 65,69,73,79,85
        child = rnd(4)
        if child=0 then planet$=planet$+"L"
        if child=1 then planet$=planet$+"N"
        if child=2 then planet$=planet$+"R"
        if child=3 then planet$=planet$+"S"
        if child=4 then planet$=planet$+"T"
      Endcase

      Case 81 : planet$=planet$+"U" 
       Endcase

      Case Default
        child = rnd(4)
        if child=0 then planet$=planet$+"A"
        if child=1 then planet$=planet$+"E"
        if child=2 then planet$=planet$+"I"
        if child=3 then planet$=planet$+"O"
        if child=4 then planet$=planet$+"U"
      Endcase
     
    Endselect
      
  next i
Endfunction planet$

 - 'galaxy map' - do we agree that there is a large 'galaxy' screen that shows 'stars', and when you click on/navigate to that, it shows you the 'planets' that are there?
 - - if not then what?

 - planets: how many things are important about planets?
 some possiblilities:
 - size (1000-5000 max. pop.)
 - mineral richness (poor,avg.,rich)
 - how many per solar system?
 - 'class' : there are many possibililties here:
 - - terrestrial, ocean, gas giant, arctic, volcanic, etc.
 - atmosphere : none, oxygen, argon, methane, hydrogen, etc.
 - gravity
 - chickens

note that the more things are important, the more data we need, 
and the more reasons we need to justify having those things to begin with.

i would suggest size & wealth for now.


 - i plan on attempting a version of Devonps's ideas