/// struct _FieldPoint_ and globals concerning the masses alive
/* Everything to maintain the field, which is a wrapping matrix
   containing all mass pixels. It's a kind of map, and usually much
   bigger than the visible part of the screen. */
#ifndef __FIELD__
#define __FIELD__

/* FIXME: is this really needed? It's only for the struct mass, which
   is only referenced by pointer anyway... */
#include "mass.h"

#include "fieldwrap.h"
#include "fieldcells.h"
#include "optimize.h"

/* 10 bits ==> field of 1024x1024 pixels */
#define FIELDSIZE_BITS (10)
#define FIELDSIZE (1<<FIELDSIZE_BITS)
/* So 'x & FIELDWRAP' will wrap around the border (also for x<0).
   See also comments for 'field' below. */
#define FIELDWRAP (FIELDSIZE-1)

/* the field consists of a frozen area, never visible, where masses
   are just being around to thaw when the player approaches */
#define FIELDFREEZE (128 + 80)


/* This ist *the* field, where the game takes place.  It's an array
 * with wrapping borders, dimensions FIELDSIZE*FIELDSIZE. The wrapping
 * is handled automagically by the FieldXY() and FieldPoint() macros
 * below, but it's somewhat more tricky for comparing coordinates and
 * measuring distances.
 *
 * I've chosen a periodical field in order to make the field (from the
 * player's point of view) unlimited. The idea is to leave a big part
 * of the field frozen, and update only the regions around the
 * player. While he moves, either old masses will be thawn, or new
 * onces generated just in time. (PLANNED: maybe a 'big' map, so when
 * the player moves up and then down, it will at least look similar).
 */
typedef struct _FieldPoint_ {
  //Sint32 height;
  int height;
  Mass * owner;
} FieldPoint;
extern FieldPoint * field;

// what is finally to be displayed (including debug offset)
extern Point displayCenter;
extern int displayHeading;
/* accessing the field */
//#define FieldXY(x, y) (field + FIELDSIZE*((y)&(FIELDWRAP)) + ((x)&(FIELDWRAP)))

#define BLOCKSIZE (1 << /*!TRY: 7 6 8 5 9*/BLOCKBITS)
#define BLOCKWRAP (BLOCKSIZE-1)
/* To keep geographically close memory together, pixels are numbered in
   blocks of BLOCKSIZE*BLOCKSIZE, like this (for BLOCKBITS = 2):
   +-------------+-------------+--
   |  0  1  2  3 | 16 17 18 19 | ...
   |  4  5  6  7 | 20 21 22 23 | 
   |  8  9 10 11 | 24 25 26 27 |
   | 12 13 14 15 | 28 29 30 31 |
   +-------------+-------------+--
   | ...         |             |
   This helps to keep them in the CPU cache. (On my system: engine 11%
   faster, optimal BLOCKBITS=7, but the optimal value certainly depends
   on the masses / game / FIELDSIZE / CPU cache)
 */
#define FieldXY(x, y) (field /* Dear compiler. Please simplify this all. */ \
                       /* block position */ + ((x)&FIELDWRAP&(~BLOCKWRAP))*BLOCKSIZE + ((y)&FIELDWRAP&(~BLOCKWRAP))*FIELDSIZE \
                       /* within a block */ + BLOCKSIZE*((y)&BLOCKWRAP) + ((x)&BLOCKWRAP))
/* FIXME: name conflict! FieldPoint is already used as struct.
   Looks like the macro only gets expanded with (), thus it works. */
#define FieldPoint(p) FieldXY((p).x, (p).y)

/* for main() */
extern void InitFieldMemory(void);
extern void FreeFieldMemory(void);
extern void CleanField(void);
extern void UnbanMassZombies(void);
extern void InitMassesMemory(void);
extern void FreeMassesMemory(void);
extern void CleanMasses(void);
extern void FreeFrontendMemory(void);
extern void UpdateDisplayCenter(void);

/* Strictly, this needs to be called every time m->maxRect is altered
   (except if only shrinking). But since the only consequence is that
   GetMassesInRect() might still use the old position, calling it once
   at the end of the round should do. */
extern void MassPositionHasChanged(Mass * m);

/* returns a list of masses that at least touch the rect r with 
   their maxrect; the list must bee freed */
extern List * GetMassesInRect(Rect r);
/* called from time to time to speed up the above */
extern void DistributePendingMasses(void);
/* returns a list of all masses that are not frozen */
extern List * GetThawnMasses(void);
/* all masses (except zombies) */
extern List * GetAllMasses(void);

/* check wether the pointer is valid; for debugging only, it is slow */
extern int IsValidMass(Mass * m);
/* Expensive! */
extern void DebugCheckField(void);

/* calculate a quick checksum */
extern Uint8 NetworkChecksum(void);
/* a quite expensive one */
extern Uint16 FullChecksum(void);
extern void PrintFieldStatistics(void);

// This transfers ownership of the mass (its memory will be freed in field.c)
// Mass-enters-game actions go here.
extern void AddMassToField(Mass * m);
// Destroy a mass. It will be cleanly removed from the field immediately, and freed later.
// Mass-leaves-game actions go here.
extern void RemoveMassFromField(Mass * m);

#endif