void
ModConfig::DisableMod(const char* name)
{
if (!name || !*name)
return;
Text* mod_name;
ListIter<Text> iter = enabled;
while (++iter) {
Text* t = iter.value();
if (*t == name) {
mod_name = t;
iter.removeItem();
break;
}
}
if (mod_name) {
disabled.append(mod_name);
ListIter<ModInfo> iter = mods;
while (++iter) {
ModInfo* mod_info = iter.value();
if (mod_info->Name() == *mod_name) {
delete iter.removeItem();
break;
}
}
}
}
void
Scene::Collect()
{
ListIter<Graphic> iter = graphics;
while (++iter) {
Graphic* g = iter.value();
if (g->Life() == 0) {
delete iter.removeItem();
}
}
iter.attach(sprites);
while (++iter) {
Graphic* g = iter.value();
if (g->Life() == 0) {
delete iter.removeItem();
}
}
ListIter<Light> iter1 = lights;
while (++iter1) {
Light* l = iter1.value();
if (l->Life() == 0) {
delete iter1.removeItem();
}
}
}
void
Element::HandleRadioMessage(RadioMessage* msg)
{
if (!msg) return;
static RadioHandler rh;
// if this is a message from within the element,
// then all ships should report in. Otherwise,
// just the leader will acknowledge the message.
int full_report = ships.contains(msg->Sender());
int reported = false;
ListIter<Ship> s = ships;
while (++s) {
if (rh.ProcessMessage(msg, s.value())) {
if (full_report) {
if (s.value() != msg->Sender())
rh.AcknowledgeMessage(msg, s.value());
}
else if (!reported) {
rh.AcknowledgeMessage(msg, s.value());
reported = true;
}
}
}
}
void
CameraDirector::SetViewObjectGroup(ListIter<Ship> group, bool quick)
{
if (!ship) return;
Starshatter* stars = Starshatter::GetInstance();
if (!stars->InCutscene()) {
// only view solid contacts:
while (++group) {
Ship* s = group.value();
if (s->GetIFF() != ship->GetIFF()) {
Contact* c = ship->FindContact(s);
if (!c || !c->ActLock())
return;
}
if (s->Life() == 0 || s->IsDying() || s->IsDead())
return;
}
}
group.reset();
if (external_group.size() > 1 &&
external_group.size() == group.size()) {
bool same = true;
for (int i = 0; same && i < external_group.size(); i++) {
if (external_group[i] != group.container()[i])
same = false;
}
if (same) {
SetMode(MODE_ZOOM);
return;
}
}
ClearGroup();
if (quick) {
mode = MODE_ORBIT;
transition = 0;
}
else {
SetMode(MODE_TRANSLATE);
}
external_group.append(group.container());
ListIter<Ship> iter = external_group;
while (++iter) {
Ship* s = iter.value();
region = s->GetRegion();
Observe(s);
}
}
void
UVMapView::SelectInverse()
{
ListIter<Poly> iter = polys;
while (++iter) {
Poly* p = iter.value();
if (p->material != material)
continue;
for (int i = 0; i < p->nverts; i++) {
WORD p_index = iter.index();
DWORD value = (p_index << 16) | i;
bool contains = false;
auto svi = selverts.begin();
for (; svi != selverts.end(); ++svi) {
if (*svi == value) {
contains = true;
break;
}
}
if (contains)
selverts.erase(svi);
else
selverts.push_back(value);
}
}
}
bool
Screen::Resize(int w, int h)
{
// scale all root-level windows to new screen size:
ListIter<Window> iter = window_list;
while (++iter) {
Window* win = iter.value();
double w_x = win->GetRect().x / (double) width;
double w_y = win->GetRect().y / (double) height;
double w_w = win->GetRect().w / (double) width;
double w_h = win->GetRect().h / (double) height;
Rect r;
r.x = (int) (w_x * w);
r.y = (int) (w_y * h);
r.w = (int) (w_w * w);
r.h = (int) (w_h * h);
win->MoveTo(r);
}
width = w;
height = h;
return true;
}
void
ModConfig::EnableMod(const char* name)
{
if (!name || !*name)
return;
Text* mod_name;
ListIter<Text> iter = disabled;
while (++iter) {
Text* t = iter.value();
if (*t == name) {
mod_name = t;
iter.removeItem();
break;
}
}
if (mod_name) {
enabled.append(mod_name);
if (!IsDeployed(*mod_name)) {
ModInfo* mod_info = new(__FILE__,__LINE__) ModInfo;
if (mod_info->Load(*mod_name) && mod_info->Enable()) {
mods.append(mod_info);
}
}
}
}
void
ModConfig::FindMods()
{
disabled.destroy();
DataLoader* loader = DataLoader::GetLoader();
if (loader) {
loader->UseFileSystem(true);
loader->ListFiles("*.dat", disabled, true);
loader->UseFileSystem(Starshatter::UseFileSystem());
ListIter<Text> iter = disabled;
while (++iter) {
Text* name = iter.value();
name->setSensitive(false);
if (*name == "shatter.dat" ||
*name == "beta.dat" ||
*name == "start.dat" ||
*name == "irunin.dat" ||
*name == "vox.dat" ||
name->contains("uninstall") ||
enabled.contains(name))
delete iter.removeItem();
}
}
}
void
CampaignPlanStrategic::ScoreDefend(Combatant* c, CombatGroup* g)
{
if (!g || g->IsReserve())
return;
if (g->IsDefensible()) {
g->SetPlanValue(g->Value());
c->GetDefendList().append(g);
CombatZone* zone = campaign->GetZone(g->GetRegion());
ZoneForce* force = 0;
if (zone)
force = zone->FindForce(c->GetIFF());
if (force)
force->GetDefendList().append(g);
}
ListIter<CombatGroup> iter = g->GetComponents();
while (++iter) {
ScoreDefend(c, iter.value());
}
}
System::System(const System& s)
: type(s.type), id(s.id), ship(0), subtype(s.subtype), status(s.status),
availability(s.availability), safety(s.safety), stability(s.stability),
crit_level(s.crit_level), net_avail(-1.0f),
mount_rel(s.mount_rel), radius(s.radius), safety_overload(0.0f),
hull_factor(s.hull_factor), energy(s.energy), capacity(s.capacity),
sink_rate(s.sink_rate), power_level(s.power_level), power_flags(s.power_flags),
source_index(s.source_index), power_on(s.power_on), max_value(s.max_value),
explosion_type(s.explosion_type), name(s.name), abrv(s.abrv), design(s.design),
emcon(s.emcon)
{
if (design) {
// cast-away const
ListIter<Component> c = (List<Component>&) s.components;
while (++c) {
Component* comp = new(__FILE__,__LINE__) Component(*(c.value()));
comp->SetSystem(this);
components.append(comp);
}
}
emcon_power[0] = s.emcon_power[0];
emcon_power[1] = s.emcon_power[1];
emcon_power[2] = s.emcon_power[2];
}
void
NetClientConfig::Save()
{
FILE* f;
fopen_s(&f, "client.cfg", "w");
if (f) {
fprintf(f, "CLIENT_CONFIG\n\n");
ListIter<NetServerInfo> iter = servers;
while (++iter) {
NetServerInfo* server = iter.value();
if (server->save) {
int port = (int) server->port;
fprintf(f, "server: {\n");
fprintf(f, " name: \"%s\",\n", (const char*) server->name);
fprintf(f, " addr: \"%s\",\n", (const char*) server->hostname);
fprintf(f, " port: %d,\n", port);
if (server->password.length())
fprintf(f, " pass: \"%s\",\n", (const char*) server->password);
fprintf(f, "}\n\n");
}
}
fclose(f);
}
}
void
GroundAI::ExecFrame(double secs)
{
const int exec_period = 1000;
if ((int) Game::GameTime() - exec_time > exec_period) {
exec_time = (int) Game::GameTime();
SelectTarget();
}
if (ship) {
Shield* shield = ship->GetShield();
if (shield)
shield->SetPowerLevel(100);
ListIter<WeaponGroup> iter = ship->Weapons();
while (++iter) {
WeaponGroup* group = (WeaponGroup*) iter.value();
if (group->NumWeapons() > 1 && group->CanTarget(Ship::DROPSHIPS))
group->SetFiringOrders(Weapon::POINT_DEFENSE);
else
group->SetFiringOrders(Weapon::AUTO);
group->SetTarget((Ship*) target, 0);
}
if (carrier_ai)
carrier_ai->ExecFrame(secs);
}
}
void
CampaignPlanStrategic::PlaceGroup(CombatGroup* g)
{
if (!g)
return;
Text rgn = g->GetRegion();
CombatZone* zone = campaign->GetZone(rgn);
// if we couldn't find anything suitable,
// just pick a zone at random:
if (!zone && g->IsMovable()) {
int nzones = campaign->GetZones().size();
int n = RandomIndex() % nzones;
zone = campaign->GetZones().at(n);
Text assigned_rgn;
if (!campaign->GetZone(rgn)) {
assigned_rgn = *zone->GetRegions().at(0);
g->AssignRegion(assigned_rgn);
}
}
if (zone && !zone->HasGroup(g))
zone->AddGroup(g);
ListIter<CombatGroup> iter = g->GetComponents();
while (++iter)
PlaceGroup(iter.value());
}
void
NetGameClient::ExecFrame()
{
if (local_player) {
if (local_player->GetObjID() == 0) {
SendJoinRequest();
}
else if (active) {
// check health of server:
NetPeer* server_peer = link->FindPeer(server_id);
if (server_peer && (NetLayer::GetUTC() - server_peer->LastReceiveTime() > 15)) {
NetMsg net_disco(0, NET_DISCONNECT, 0, 0, 0);
DoDisconnect(&net_disco);
}
// if server is still there,
else if (server_peer) {
// check if any old join announcements still need to be processed:
ListIter<NetJoinAnnounce> iter = join_backlog;
while (++iter) {
NetJoinAnnounce* join_ann = iter.value();
if (DoJoinBacklog(join_ann)) {
iter.removeItem();
delete join_ann;
}
}
}
}
}
NetGame::ExecFrame();
}
void
NetClientDlg::ShowServers()
{
if (!config || !lst_servers) return;
lst_servers->ClearItems();
lst_servers->SetSelectedStyle(ListBox::LIST_ITEM_STYLE_FILLED_BOX);
lst_servers->SetLeading(2);
int i = 0;
ListIter<NetServerInfo> iter = config->GetServerList();
while (++iter) {
NetServerInfo* info = iter.value();
lst_servers->AddItemWithData(info->name, (DWORD) i);
lst_servers->SetItemText(i, 1, info->type);
lst_servers->SetItemText(i, 2, info->password);
lst_servers->SetItemText(i, 3, Game::GetText("NetClientDlg.offline"));
lst_servers->SetItemText(i, 4, "0");
lst_servers->SetItemText(i, 5, Game::GetText("NetClientDlg.not-avail"));
i++;
}
ping_index = 0;
server_index = -1;
if (btn_host) btn_host->SetEnabled(false);
if (btn_join) btn_join->SetEnabled(false);
if (btn_del) btn_del->SetEnabled(false);
}
void
CampaignPlanStrategic::ExecFrame()
{
if (campaign && campaign->IsActive()) {
if (Campaign::Stardate() - exec_time < 300)
return;
ListIter<CombatZone> zone = campaign->GetZones();
while (++zone)
zone->Clear();
ListIter<Combatant> iter = campaign->GetCombatants();
while (++iter) {
Combatant* c = iter.value();
CombatGroup* force = c->GetForce();
force->CalcValue();
PlaceGroup(force);
ScoreCombatant(c);
ScoreNeeds(c);
force->ClearUnlockedZones();
AssignZones(c);
ResolveZoneMovement(force);
}
exec_time = Campaign::Stardate();
}
}
void
SimObject::Notify()
{
if (!notifying) {
notifying = true;
int nobservers = observers.size();
int nupdate = 0;
if (nobservers > 0) {
ListIter<SimObserver> iter = observers;
while (++iter) {
SimObserver* observer = iter.value();
observer->Update(this);
nupdate++;
}
observers.clear();
}
if (nobservers != nupdate) {
::Print("WARNING: incomplete notify sim object '%s' - %d of %d notified\n",
Name(), nupdate, nobservers);
}
notifying = false;
}
else {
::Print("WARNING: double notify on sim object '%s'\n", Name());
}
}
void
CampaignPlanStrategic::ScoreTarget(Combatant* c, CombatGroup* g)
{
if (!g || g->IntelLevel() <= Intel::SECRET)
return;
if (g->IsTargetable()) {
g->SetPlanValue(g->Value() * c->GetTargetStratFactor(g->Type()));
c->GetTargetList().append(g);
CombatZone* zone = campaign->GetZone(g->GetRegion());
ZoneForce* force = 0;
if (zone)
force = zone->FindForce(c->GetIFF());
if (force)
force->GetTargetList().append(g);
}
ListIter<CombatGroup> iter = g->GetComponents();
while (++iter) {
ScoreTarget(c, iter.value());
}
}
void
SeekerAI::CheckDecoys(double target_distance)
{
// if the assigned target has the burner lit,
// ignore the decoys:
if (orig_target && orig_target->Augmenter()) {
SetTarget(orig_target);
return;
}
if (target &&
target == orig_target &&
orig_target->GetActiveDecoys().size()) {
ListIter<Shot> decoy = orig_target->GetActiveDecoys();
while (++decoy) {
double decoy_distance = Point(decoy->Location() - self->Location()).length();
if (decoy_distance < target_distance) {
if (rand() < 1600) {
SetTarget(decoy.value(), 0);
return;
}
}
}
}
}
int
CombatGroup::CountUnits() const
{
int n = 0;
CombatGroup* g = (CombatGroup*) this;
ListIter<CombatUnit> unit = g->units;
while (++unit)
n += unit->Count() - unit->DeadCount();
CombatGroup* pThis = ((CombatGroup*) this);
pThis->live_comp.clear();
ListIter<CombatGroup> iter = g->components;
while (++iter) {
CombatGroup* comp = iter.value();
if (!comp->IsReserve()) {
int unit_count = comp->CountUnits();
if (unit_count > 0)
pThis->live_comp.append(comp);
n += unit_count;
}
}
return n;
}
void
MsnWepDlg::OnLoadout(AWEvent* event)
{
if (!elem) return;
ShipDesign* design = (ShipDesign*) elem->GetDesign();
ShipLoad* shipload = 0;
if (loadout_list && design) {
int index = loadout_list->GetListIndex();
Text loadname = loadout_list->GetItemText(index);
ListIter<ShipLoad> sl = (List<ShipLoad>&) design->loadouts;
while (++sl) {
if (sl->name == loadname) {
shipload = sl.value();
}
}
if (!shipload) return;
if (lbl_weight) {
char weight[32];
sprintf_s(weight, "%d kg", (int) ((design->mass + shipload->mass) * 1000));
lbl_weight->SetText(weight);
}
if (elem->Loadouts().size() < 1) {
MissionLoad* l = new(__FILE__,__LINE__) MissionLoad(-1, shipload->name);
elem->Loadouts().append(l);
}
else {
ListIter<MissionLoad> l = elem->Loadouts();
while (++l) {
// if the player chooses a std loadout,
// tell the sim loader to use a named
// loadout from the ship design:
l->SetName(shipload->name);
}
}
int nstations = design->hard_points.size();
int* loadout = shipload->load;
for (int i = 0; i < 8; i++)
loads[i] = -1;
for (int i = 0; i < nstations; i++)
loads[i + first_station] = PointIndexToLoad(i, loadout[i]);
for (int i = 0; i < 8; i++) {
for (int n = 0; n < 8; n++) {
btn_load[i][n]->SetPicture(i == loads[n] ? led_on: led_off);
}
}
}
}
void
DisplayView::Refresh()
{
ListIter<DisplayElement> iter = elements;
while (++iter) {
DisplayElement* elem = iter.value();
// convert relative rect to window rect:
Rect elem_rect = elem->rect;
if (elem_rect.x == 0 && elem_rect.y == 0 && elem_rect.w == 0 && elem_rect.h == 0) {
// stretch to fit
elem_rect.w = width;
elem_rect.h = height;
}
else if (elem_rect.w < 0 && elem_rect.h < 0) {
// center image in window
elem_rect.w *= -1;
elem_rect.h *= -1;
elem_rect.x = (width - elem_rect.w)/2;
elem_rect.y = (height - elem_rect.h)/2;
}
else {
// offset from right or bottom
if (elem_rect.x < 0) elem_rect.x += width;
if (elem_rect.y < 0) elem_rect.y += height;
}
// compute current fade,
// assumes fades are 1 second or less:
double fade = 0;
if (elem->fade_in > 0) fade = 1 - elem->fade_in;
else if (elem->hold > 0) fade = 1;
else if (elem->fade_out > 0) fade = elem->fade_out;
// draw text:
if (elem->text.length() && elem->font) {
elem->font->SetColor(elem->color);
elem->font->SetAlpha(fade);
window->SetFont(elem->font);
window->DrawText(elem->text, elem->text.length(), elem_rect, DT_WORDBREAK);
}
// draw image:
else if (elem->image) {
window->FadeBitmap( elem_rect.x,
elem_rect.y,
elem_rect.x + elem_rect.w,
elem_rect.y + elem_rect.h,
elem->image,
elem->color * fade,
elem->blend );
}
}
}
void
CameraDirector::CycleViewObject()
{
if (!ship) return;
Ship* current = external_ship;
external_ship = 0;
ListIter<Contact> iter = ship->ContactList();
while (++iter && !external_ship) {
Contact* c = iter.value();
Ship* c_ship = c->GetShip();
if (c_ship && !current) {
external_ship = c_ship;
}
else if (current && c_ship == current) {
while (++iter && !external_ship) {
c = iter.value();
if (c->ActLock())
external_ship = c->GetShip();
}
}
}
if (external_ship != current) {
if (external_ship) {
if (external_ship->Life() == 0 || external_ship->IsDying() || external_ship->IsDead()) {
external_point = external_ship->Location();
external_ship = 0;
}
else {
Observe(external_ship);
}
}
if (mode == MODE_ORBIT) {
SetMode(MODE_TRANSLATE);
ExternalRange(1);
}
}
}
void
ListBox::SizeColumns()
{
ListBoxColumn* c = columns.first();
if (c->percent < 0.001) {
double total = 0;
ListIter<ListBoxColumn> iter = columns;
while (++iter) {
c = iter.value();
total += c->width;
}
iter.reset();
while (++iter) {
c = iter.value();
c->percent = c->width / total;
}
}
int usable_width = rect.w;
int used = 0;
if (IsScrollVisible()) {
usable_width -= SCROLL_WIDTH + 2;
}
else {
usable_width -= 3;
}
for (int i = 0; i < columns.size(); i++) {
c = columns[i];
if (i < columns.size() - 1)
c->width = (int) (c->percent * usable_width);
else
c->width = usable_width - used;
used += c->width;
}
}
StarSystem*
Galaxy::GetSystem(const char* name)
{
ListIter<StarSystem> sys = systems;
while (++sys) {
if (!strcmp(sys->Name(), name))
return sys.value();
}
return 0;
}
StarSystem*
Galaxy::FindSystemByRegion(const char* rgn_name)
{
ListIter<StarSystem> iter = systems;
while (++iter) {
StarSystem* sys = iter.value();
if (sys->FindRegion(rgn_name))
return sys;
}
return 0;
}
void
CombatGroup::ClearUnlockedZones()
{
if (!zone_lock)
assigned_zone = 0;
ListIter<CombatGroup> iter = components;
while (++iter) {
CombatGroup* g = iter.value();
g->ClearUnlockedZones();
}
}
void
CampaignPlanStrategic::BuildGroupList(CombatGroup* g, List<CombatGroup>& groups)
{
if (!g || g->IsReserve())
return;
if (g->IsAssignable())
groups.append(g);
ListIter<CombatGroup> iter = g->GetComponents();
while (++iter)
BuildGroupList(iter.value(), groups);
}
void
CombatGroup::SetAssignedSystem(const char* s)
{
assigned_system = s;
assigned_zone = 0;
zone_lock = false;
ListIter<CombatGroup> iter = components;
while (++iter) {
CombatGroup* g = iter.value();
g->SetAssignedSystem(s);
}
}
void
CombatGroup::SetAssignedZone(CombatZone* z)
{
assigned_zone = z;
if (!assigned_zone)
zone_lock = false;
ListIter<CombatGroup> iter = components;
while (++iter) {
CombatGroup* g = iter.value();
g->SetAssignedZone(z);
}
}