empire/empserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix confused and buggy bridge splashing code

Browse source 
A bridge (span or tower) must be splashed when it gets damaged below
SCT_MINEFF.  Likewise when its last supporting sector (bridge head or
tower) gets damaged below SCT_MINEFF, unless EASY_BRIDGES is enabled.
We need to check this whenever a bridge head, span or tower gets
damaged.  This is done in three places, and all of them screw up:

* checksect() ignores damage to bridge heads.  It also leaves writing
  back the sector it checks to the caller, which never happens when
  it's called from sct_postread().

  Note that checksect() drowns all planes on bridges it splashes.
  Functions that need to exempt flying planes from such a fate have to
  splash bridges themselves.

* sect_damage() ignores damage to bridge towers, and damage to bridge
  spans unless EASY_BRIDGES is enabled.  It then runs checksect(),
  which compensates for these omissions, but happily drowns the planes
  sect_damage() attempts to protect.

* eff_bomb() ignores damage to bridge heads.  Collateral damage makes
  sect_damage() run, which compensates for the omission.

This causes the following bugs:

* Efficiency damage going through sect_damage() can drown planes it
  shouldn't.  This affects pinpoint bombing when collateral damage
  splashes a bridge, and strategic bombing.  The drowned planes then
  crash and burn when they attempt to land at their (just splashed)
  base.

* Efficiency damage to bridge heads not going through sect_damage()
  fails to collapse unsupported bridges.  This affects pin-bombing
  efficiency without collateral damage, and ground combat.  Also deity
  commands edit, setsector and add, but that could be regarded as a
  feature.

* If the sector file somehow ends up with an inefficient bridge span,
  it collapses on every read again and again, until it collapses on a
  write.  Related problems exist with other actions of checksect(),
  and they're not addressed here.

* If the sector file somehow ends up with adjacent inefficient bridge
  towers, checksect() on any of them recurses infinitely:

  - checksect() inefficient tower T1
    - knockdown() T1, but don't write that back to the sector file
    - bridgefall() T1; this reads all adjacent sectors, including
      inefficient towert T2
      - checksect() T2
        - knockdown() T2, but don't write that back to the sector file
	- bridgefall() T1; this reads adjacent sectors including T1
	  - checksect() T1
	    ...

This commit creates a new function bridge_damaged() to splash any
bridges that became inefficient or unsupported after damage to a
sector.  To avoid the inifinite recursion, we call it in
sct_prewrite() instead of checksect().

No uses knockdown() outside bridgefall.c remain, so give it internal
linkage.
This commit is contained in:
Markus Armbruster 2008-02-11 23:14:04 +01:00
parent 13cca55a9d
commit 40eb78eb74
5 changed files with 30 additions and 25 deletions
Download patch file Download diff file Expand all files Collapse all files

27
src/lib/subs/bridgefall.c
View file

@ -48,6 +48,31 @@
#include "sect.h"
#include "xy.h"
static void knockdown(struct sctstr *, struct emp_qelem *);
/*
* Check bridges at and around SP after damage to SP.
* If SP is an inefficent bridge, splash it.
* If SP can't support a bridge, splash unsupported adjacent bridges.
* Don't drown planes in LIST when splashing bridges.
* Write back splashed bridges, except for SP; writing that one is
* left to the caller.
*/
void
bridge_damaged(struct sctstr *sp, struct emp_qelem *list)
{
int des;
if (sp->sct_effic >= SCT_MINEFF)
return;
des = sp->sct_type;
if (des == SCT_BSPAN || des == SCT_BTOWER)
knockdown(sp, list);
if ((des == SCT_BHEAD || des == SCT_BTOWER) && !opt_EASY_BRIDGES)
bridgefall(sp, list);
}
void
bridgefall(struct sctstr *sp, struct emp_qelem *list)
{
@ -94,7 +119,7 @@ bridgefall(struct sctstr *sp, struct emp_qelem *list)
/* Knock down a bridge span. Note that this does NOT write the
* sector out to the database, it's up to the caller to do that. */
void
static void
knockdown(struct sctstr *sp, struct emp_qelem *list)
{
struct lndstr land;