home *** CD-ROM | disk | FTP | other *** search
/ Game Killer / Game_Killer.bin / 082.PORTDISP.INC < prev    next >
Text File  |  1992-07-27  |  10KB  |  308 lines
  1. { Trades:
  2.      0   1   2   3   4   5   6   7
  3.     BBB SBB BSB SSB BBS SBS BSS SSS
  4. BBB  x   x   x   x   x   x   x   x
  5. SBB  x   x   fo  x   fe  x  foe  x
  6. BSB  x  fo   x   x   oe ofe  x   x
  7. SSB  x   x   x   x  efo  oe  fe  x
  8. BBS  x  fe   oe efo  x   x   x   x
  9. SBS  x   x  ofe  oe  x   x   fo  x
  10. BSS  x  foe  x   fe  x   fo  x   x
  11. SSS  x   x   x   x   x   x   x   x  }
  12.  
  13.  
  14. function compatible( i1, i2 : stuff; greed : PortTradeType) : boolean;
  15. { if each sells something the other buys; note greed can limit displays }
  16. begin
  17.   if i2 = -1 then                                { not a port }
  18.     compatible := false
  19.   else case greed of
  20.     allTrades :
  21.       case i1 of
  22.         Class0, 0, 7 : compatible := false;
  23.         1 : compatible := i2 in [2, 4, 6];
  24.         2 : compatible := i2 in [1, 4, 5];
  25.         3 : compatible := i2 in [4, 5, 6];
  26.         4 : compatible := i2 in [1, 2, 3];
  27.         5 : compatible := i2 in [2, 3, 6];
  28.         6 : compatible := i2 in [1, 3, 5];
  29.       end; {all}
  30.     EquipOrganic :
  31.       case i1 of
  32.         Class0, 0, 1, 6, 7 : compatible := false;
  33.         2, 3 : compatible := i2 in [4,5];
  34.         4, 5 : compatible := i2 in [2,3];
  35.       end; {case EquipOrganic}
  36.     EquipFuel :
  37.       case i1 of
  38.         Class0, 0, 2, 5, 7 : compatible := false;
  39.         1, 3 : compatible := i2 in [4, 6];
  40.         4, 6 : compatible := i2 in [1, 3];
  41.       end; {case}
  42.     OrganicFuel :
  43.       case i1 of
  44.         Class0, 0, 3, 4, 7 : compatible := false;
  45.         1 : compatible := i2 in [2, 4, 6];
  46.         2 : compatible := i2 in [1, 5];
  47.         5 : compatible := i2 in [2, 6];
  48.         6 : compatible := i2 in [1, 5];
  49.       end; {case OrganicFuel}
  50.   end; {case greed}
  51. end;
  52.  
  53. function deal( good1, good2 : stuff ) : string;
  54. { Port type "good1" selling to port type "good2" }
  55. const
  56.   ND = 'no deal';
  57.   F  = 'Fuel Ore';
  58.   O  = 'Organics';
  59.   Q  = 'Equipment';
  60.   any = 'anything';
  61.  
  62. begin
  63.   deal := ND;
  64.   case good1 of
  65.     Class0, 0 : ;  {error}
  66.         1 : if good2 in [0,2,4,6] then deal := F;
  67.         2 : if good2 in [0,1,4,5] then deal := O;
  68.         3 : if good2 in [0,4] then deal := O + ' or ' + F
  69.             else if good2 in [1,5] then deal := O
  70.             else if good2 in [2,6] then deal := F;
  71.         4 : if good2 in [0,1,2,3] then deal := Q;
  72.         5 : if good2 in [0,2] then deal := Q + ' or ' + F
  73.             else if good2 in [1,3] then deal := Q
  74.             else if good2 in [4,6] then deal := F;
  75.         6 : if good2 in [0,1] then deal := Q + ' or ' + O
  76.             else if good2 in [2,3] then deal := Q
  77.             else if good2 in [4,5] then deal := O;
  78.         7 : case good2 of
  79.                Class0,7 : ; {error}
  80.                0 : deal := any;
  81.                1 : deal := Q + ' or ' + O;
  82.                2 : deal := Q + 'or ' + F;
  83.                3 : deal := Q;
  84.                4 : deal := O + ' or ' + F;
  85.                5 : deal := O;
  86.                6 : deal := F;
  87.              end; {case 7}
  88.         end; {case}
  89. end; {deal}
  90.  
  91. function letterOfGood( g : goods ) : char;
  92. begin
  93.   case g of
  94.     fuel      : LetterOfGood := 'F';
  95.     Organics  : LetterOfGood := 'O';
  96.     Equipment : LetterOfGood := 'E';
  97.   end; {case}
  98. end; {letterOfGood}
  99.  
  100. procedure ComputeStores( psell, pbuy : PortIndex; var f1, f2 : integer;
  101.                          which : goods; dump : boolean; var into : text);
  102. var
  103.   level1, level2 : integer;
  104.   mss : string;
  105. begin
  106.   level1 := space.ports.data[ psell ].amts[ which ];
  107.   level2 := -space.ports.data[ pbuy ].amts[ which ];
  108.   f1 := min( min( level1, level2), f1 );
  109.   mss := letterOfGood( which ) + ':' + str( level1, 5) + ' to ' +
  110.          str( level2, 4) + '  ';
  111.   write( mss );
  112.   if dump then
  113.     write( into, mss );
  114.   f2 := -min( -min( space.ports.data[ psell ].usage[ which ],
  115.                   space.ports.data[ pbuy ].usage[ which ] ), -f2 );
  116. end; {ComputeStores}
  117.  
  118. procedure DisplayStores( psell, pbuy : PortIndex; s : string;
  119.                         var f1, f2 : integer;
  120.                         Trade : portTradeType;
  121.                         Dump : boolean;  var T : text );
  122. { we are given two ports, and a string s that represents the goods we are
  123. going to be trading there.  For each good in s compute the minimum of
  124. the stores we have to sell and amount to purchase, and store the maximum in f,
  125. while also displaying the quantities the port holds. }
  126. begin
  127.   if trade in [allTrades, EquipFuel, OrganicFuel] then
  128.     if pos( 'Fuel', s ) > 0 then
  129.       ComputeStores( psell, pbuy, f1, f2, Fuel, Dump, t );
  130.   if trade in [allTrades, EquipOrganic, OrganicFuel] then
  131.     if pos( 'Organic', s ) > 0 then
  132.       begin
  133.         f2 := 0;
  134.         ComputeStores( psell, pbuy, f1, f2, Organics, Dump, t );
  135.       end;
  136.   if trade in [allTrades, EquipOrganic, EquipFuel ] then
  137.     if pos( 'Equip', s ) > 0 then
  138.       begin
  139.         f2 := 0;
  140.         ComputeStores( psell, pbuy, f1, f2, Equipment, Dump, t );
  141.       end;
  142. end; {DisplayStores}
  143.  
  144. procedure PortTradeFactor( s1, s2 : sector;
  145.                            items12, items21 : string;
  146.                            PortTrade : portTradeType;
  147.                            FileDump : boolean;
  148.                        var DumpFile : text );
  149. { Print port information from these two ports corresponding to trading
  150.   items from 1 to 2 and from 2 to 1; compute relative factor. }
  151. var
  152.   p1, p2 : PortIndex;
  153.   factor1, factor2 : integer;
  154.   result : integer;
  155.   line : string;
  156. begin
  157.   p1 := PortNumber( s1 );
  158.   p2 := PortNumber( s2 );
  159.   if (p1 = 0) or (p2 = 0) then
  160.     begin
  161.       if p1 = 0 then
  162.         line := 'No info available for ' + str( s1 , 1)
  163.       else if p2 = 0 then
  164.         line := 'No info available for ' +  str( s2, 1 );
  165.       writeln( line );
  166.       if Filedump then
  167.         writeln( Dumpfile, line );
  168.     end
  169.   else
  170.     begin
  171.       write( 'Quantities: ' );
  172.       if FileDump then
  173.         write(DumpFile, 'Quantities: ');
  174.       factor1 := maxint; factor2 := 0;
  175.       DisplayStores( p1, p2, items12, factor1, factor2, PortTrade, FileDump, DumpFile);
  176.       DisplayStores( p2, p1, items21, factor1, factor2, PortTrade, FileDump, DumpFile);
  177.       if factor2 = 0 then
  178.         writeln(' Factor: ???')
  179.       else
  180.         writeln(' Factor: ', factor1, ', ', factor2,'%' );
  181.       if FileDump then
  182.         writeln(DumpFile,' Factor: ', factor1, ', ', factor2,'%');
  183.     end; {else}
  184. end; {PortTradeFactor}
  185.  
  186. procedure AddEtc( s : sector; var line : string );
  187. { add special information to code Fighters there or SpaceLane there }
  188. var
  189.   p : PortIndex;
  190. begin
  191.   if space.sectors[s].etc and HasFighters <> nothing then
  192.     line := line + 'F';
  193.   if space.sectors[s].etc and Busted <> nothing then
  194.     line := line + 'X';
  195.   if space.sectors[s].etc and SpaceLane <> nothing then
  196.     line := line + 'SL';
  197.   p := PortNumber( s );
  198.   if p <> 0 then
  199.     with space.ports do
  200.       if (data[ p ].amts[equipment] <> 0) and 
  201.          (data[p].usage[equipment]=0) then
  202.         line := line + 'B';
  203. end; {AddEtc}
  204.  
  205. procedure DisplayLotsOfPortStuff( s, s1, WhichDistanceIndex : sector;
  206.                                  {logging,}AsciiDump, showLevels: boolean;
  207.                                   portTrade : portTradetype;
  208.                                   var f{, h} : text);
  209. var
  210.   g, g1 : stuff;
  211.   line  : string;
  212. begin
  213. {  if logging then
  214.     begin
  215.       writeln( h, 'R', s );
  216.       writeln( h, 'R', s1);
  217.     end; {log}
  218.   g := space.sectors[s].portType;
  219.   g1 := space.sectors[s1].portType;
  220.   line := '(' + str( s, 3);
  221.   AddEtc( s, line );
  222.   line := line + ' & ' + str(s1,3);
  223.   AddEtc( s1, line );
  224.   line := line + ' ) at distance ' + str( distances[WhichDistanceIndex].d,3)
  225.           + ' trading ' +  deal( g, g1) + ' for ' +
  226.            deal( g1, g );
  227.   writeln( line );
  228.   if AsciiDump then
  229.     writeln( f, line );
  230.   if ShowLevels then
  231.     PortTradeFactor( s, s1, deal( g, g1), deal( g1, g ),
  232.                      PortTrade, AsciiDump, f );
  233. end; {Display Lots of Port Stuff}
  234.  
  235. procedure SearchPairs( NumPorts : integer;
  236.                      { logging : boolean; var h : text; }
  237.                        ASCIIDump : boolean; var f : text;
  238.                        PortTrade : PortTradeType;
  239.                        ShowLevels : boolean );
  240. var
  241.   i         : integer;
  242.   s, s1     : sector;
  243.   g, g1     : stuff;
  244.   t         : warpIndex;
  245.   NumPairs  : integer;
  246.   PauseAt   : integer;
  247.   line      : string;
  248.  
  249. begin
  250.   NumPairs := 0;
  251.   if ShowLevels then
  252.     PauseAt := 10
  253.   else
  254.     PauseAt := 20;
  255.   for i := 1 to NumPorts do
  256.     begin
  257.       s := distances[ i ].s;
  258.       g := space.sectors[s].portType;
  259.       if space.sectors[s].number <> Unexplored then
  260.         for t := 1 to space.sectors[s].number do
  261.           begin
  262.             s1 := space.sectors[s].data[t];
  263.             g1 := space.sectors[s1].porttype;
  264.             if  (g1<> NotAPort) and (g < g1) and IsWarp( s1, s) then
  265.                 { must be a port; print only once; check if can get back }
  266.               if compatible( g, g1, PortTrade ) then
  267.                 begin
  268.                   DisplayLotsOfPortStuff(s, s1, i, {logging,} ASCIIdump,
  269.                                         showlevels, PortTrade, f{, h});
  270.                   NumPairs := NumPairs + 1;
  271.                   if numPairs mod PauseAt = 0 then
  272.                     if not prompt('more? ') then
  273.                       exit;
  274.                 end; {if if}
  275.           end; {for t}
  276.     end; {for i}
  277. end; {SearchPairs}
  278.  
  279. procedure pairport;
  280. var
  281.   s        : sector;
  282.   TradeInt : integer;
  283.   Greedy   : PortTradeType;
  284.   NumSectors : sectorIndex;
  285.   QuantInfo,
  286.   AsciiDump: boolean;
  287.   h, fp    : text;
  288. begin
  289.   SortPorts( NumSectors );
  290.   QuantInfo := prompt('Do you want to see port quantity information? ');
  291.   repeat
  292.     write('Type of trade: 0 = all, 1 = Equip/Organic, 2 = Equip/Fuel, 3 = Organic/Fuel ? ');
  293.     tradeInt := readNumberFromTerminal;
  294.   until (tradeint >= 0) and (tradeInt <= 3);
  295.   Greedy := PortTradeType( tradeInt );
  296. {  loggit := LogToDisk( h,
  297.         'Do you want to log the results in a format suitable for upload? ',
  298.         BBSname+'.upl' ); }
  299.   AsciiDump := LogToDisk( fp,
  300.         'Do you want an echo of the results to an ASCII file? ',
  301.         BBSName+'.txt');
  302.   SearchPairs( NumSectors, {Loggit, h,} AsciiDump, fp, greedy, QuantInfo );
  303. {  if loggit then
  304.     close( h ); }
  305.   if AsciiDump then
  306.     close( fp );
  307. end; {pair ports}
  308.