path: root/Stars45/Power.cpp

/*  Project Starshatter 4.5
    Destroyer Studios LLC
    Copyright © 1997-2004. All Rights Reserved.

    SUBSYSTEM:    Stars.exe
    FILE:         Power.cpp
    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    Power generation and usage classes
*/

#include "MemDebug.h"
#include "Power.h"
#include "Ship.h"
#include "NetUtil.h"

#include "Game.h"

// +----------------------------------------------------------------------+

static char*   source_type[] = {
   "sys.power.battery", "sys.power.auxilliary", "sys.power.fusion"
};

static int     source_value[] = {
   1, 2, 4
};

PowerSource::PowerSource(SUBTYPE s, double max_out, double f_ratio)
   : System(POWER_SOURCE, (int) s, "Power", source_value[s], 0),
     max_output((float) max_out), fuel_ratio((float) f_ratio),
     route_changed(false), requested_power_level(1.0f)
{
   name = Game::GetText(source_type[s]);
   abrv = Game::GetText(Text(source_type[s]) + ".abrv");

   if (fuel_ratio < 1) {
      switch (subtype) {    // enough to last for [n] hours at full power
      case BATTERY:     fuel_ratio = max_output *   5 * 3600 / 100; break;
      case AUX:         fuel_ratio = max_output *  50 * 3600 / 100; break;
      case FUSION:      fuel_ratio = max_output * 100 * 3600 / 100; break;
      }
   }

   capacity = 100.0f;

   if (subtype != BATTERY) {
      emcon_power[0] =  10;
      emcon_power[1] =  50;
      emcon_power[2] = 100;
   }
}

PowerSource::PowerSource(const PowerSource& p)
   : System(p),
     max_output(p.max_output), fuel_ratio(p.fuel_ratio),
     route_changed(false), requested_power_level(1.0f)
{
   Mount(p);
   SetAbbreviation(p.Abbreviation());
}

// +----------------------------------------------------------------------+

void
PowerSource::AddClient(System* client)
{
   if (client) {
      int old_src_index = client->GetSourceIndex();

      client->SetSourceIndex(GetID());
      clients.append(client);
      route_changed = true;

      if (ship && old_src_index != GetID())
         NetUtil::SendSysStatus(ship, client);
   }
}

void
PowerSource::RemoveClient(System* client)
{
   if (client && clients.contains(client)) {
      client->SetSourceIndex(-1);
      clients.remove(client);
      route_changed = true;
   }
}

// +----------------------------------------------------------------------+

int
PowerSource::Charge() const
{
   return (int) capacity;
}

void
PowerSource::SetFuelRange(double hours)
{
   if (hours > 0)
      fuel_ratio = (float) (max_output * hours * 3600 / 100);
}

// +----------------------------------------------------------------------+

void
PowerSource::ExecFrame(double seconds)
{
   if (seconds < 0.001)
      seconds = 0.001;

   if (capacity <= 0)
      capacity = 0;

   System::ExecFrame(seconds);

   double energy_requested = 0;
   double energy_avail     = 0;
   double total_distrib    = 0;

   // fuel leak?
   if (availability < 0.4 && capacity > 0)
      capacity -= (float) (0.03 * seconds);

   if (IsPowerOn() && capacity > 0) {
      energy_avail = max_output * seconds * power_level * availability;

      if (power_level < requested_power_level) {
         power_level += (float) (seconds * 0.03);     // thirty seconds to charge up

         if (power_level > requested_power_level)
            power_level = (float) requested_power_level;
      }
      else if (power_level > requested_power_level) {
         power_level -= (float) (seconds * 0.10);     // ten seconds to power down

         if (power_level < requested_power_level)
            power_level = (float) requested_power_level;
      }
   }
   
   ListIter<System> iter = clients;
   while (++iter) {
      System* sink = iter.value();
      
      if (sink->IsPowerOn()) {
         double joules = sink->GetRequest(seconds);

         if (joules > 0) {
            if (sink->IsPowerCritical()) {

               if (joules > energy_avail)
                  joules = energy_avail;

               energy_avail  -= joules;
               total_distrib += joules;
               sink->Distribute(joules, seconds);
            }
            else {
               energy_requested += joules;
            }
         }
      }
      else {
         sink->Distribute(-0.2 * sink->GetCapacity() * seconds, seconds);
      }
   }

   if (energy_avail > 0) {
   
      // enough to go around:
      if (energy_requested <= energy_avail) {
         iter.reset();
      
         while (++iter) {
            System* sink = iter.value();

            if (sink->IsPowerOn() && !sink->IsPowerCritical()) {
               double joules = sink->GetRequest(seconds);
               total_distrib += joules;
               sink->Distribute(joules, seconds);
            }
         }
      }
   
      // load balancing:
      else {
         iter.reset();
         while (++iter) {
            System* sink = iter.value();
         
            if (sink->IsPowerOn() && !sink->IsPowerCritical()) {
               double request  = sink->GetRequest(seconds);
               double delivery = 0;

               if (request > 0)
                  delivery = energy_avail * (request/energy_requested);
         
               if (delivery > 0) {
                  total_distrib += delivery;
                  sink->Distribute(delivery, seconds);
               }
            }
         }
      }
   }

   if (IsPowerOn() && capacity > 0 && !Game::Paused()) {
      // reactors always burn at least 10% of max (to maintain operating temp):
      if (subtype != BATTERY) {
         double baseline = 0.1 * max_output * seconds;

         if (total_distrib < baseline)
            total_distrib = baseline;
      }

      // expend fuel:
      if (total_distrib > 0) {
         double effective_fuel_ratio = fuel_ratio;
         
         switch (Ship::GetFlightModel()) {
         default:
         case Ship::FM_STANDARD:
            effective_fuel_ratio = 1 * fuel_ratio * (0.25 + 0.75 * availability);
            break;

         case Ship::FM_RELAXED:
            effective_fuel_ratio = 3 * fuel_ratio * (0.25 + 0.75 * availability);
            break;

         case Ship::FM_ARCADE:
            effective_fuel_ratio = 4 * fuel_ratio * (0.25 + 0.75 * availability);
            break;
         }

         capacity -= (float) (total_distrib / effective_fuel_ratio);
      }
   }

   else if (capacity <= 0) {
      capacity = 0.0f;
      PowerOff();
   }
}

// +--------------------------------------------------------------------+

void
PowerSource::SetPowerLevel(double level)
{
   if (level > 100)
      level = 100;
   else if (level < 0)
      level = 0;

   level /= 100;

   if (requested_power_level != level) {
      // if the system is on emergency override power,
      // do not let the EMCON system use this method
      // to drop it back to normal power:
      if (requested_power_level > 1 && level == 1) {
         requested_power_level = 1.2f;
      }

      else {
         requested_power_level = (float) level;
      }
   }
}

void
PowerSource::SetOverride(bool over)
{
   bool changed = false;

   if (over && requested_power_level != 1.2f) {
      requested_power_level = 1.2f;
      changed = true;
   }

   else if (!over && requested_power_level > 1) {
      requested_power_level = 1.0f;
      changed = true;
   }

   if (changed)
      NetUtil::SendSysStatus(ship, this);
}

void
PowerSource::DrainPower(double to_level)
{
   if (to_level >= 0 && to_level < power_level)
      power_level = (float) to_level;
}