/*
* Descent 3
* Copyright (C) 2024 Parallax Software
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.

--- HISTORICAL COMMENTS FOLLOW ---

 * $Logfile: /DescentIII/Main/editor/Group.cpp $
 * $Revision: 1.1.1.1 $
 * $Date: 2003-08-26 03:57:38 $
 * $Author: kevinb $
 *
 * Functions for copying, pasting, etc. of groups
 *
 * $Log: not supported by cvs2svn $
 *
 * 35    9/15/99 1:56p Matt
 * Added the option to allow rooms or groups placed on the terrain to
 * either align with the terrain or with gravity.
 *
 * 34    8/30/99 1:01p Gwar
 * use the "true" center of faces for determining place position of a
 * group
 *
 * 33    8/17/99 6:12p Gwar
 * handle NEWEDITOR generic object management in AttachGroup
 *
 * 32    8/17/99 6:46a Gwar
 * added group support to NEWEDITOR
 *
 * 31    5/08/99 1:39a Matt
 * Added a function to delete all objects of a certain type, and support
 * for placing and attaching groups to the terrain.
 *
 * 30    4/21/99 10:19p Matt
 * DeleteGroup() wasn't setting the world changed flag
 *
 * 29    3/15/99 1:29p Matt
 * Added objects & triggers to save/load for groups.
 *
 * 28    1/29/99 12:48p Matt
 * Rewrote the doorway system
 *
 * 27    1/26/99 6:02p Matt
 * Fixed (I hope) a problem with pasted object having the wrong
 * orientation.
 *
 * 26    1/21/99 11:15p Jeff
 * pulled out some structs and defines from header files and moved them
 * into seperate header files so that multiplayer dlls don't require major
 * game headers, just those new headers.  Side effect is a shorter build
 * time.  Also cleaned up some header file #includes that weren't needed.
 * This affected polymodel.h, object.h, player.h, vecmat.h, room.h,
 * manage.h and multi.h
 *
 * 25    1/21/99 11:34a Matt
 * Got rid of portal triggers.  Since we don't have multi-face portals, a
 * face trigger works fine for a portal.  Also fixed a few editor/trigger
 * bugs.
 *
 * 24    1/14/99 11:06a Matt
 * Added names to triggers
 *
 * 23    1/08/99 2:56p Samir
 * Ripped out OSIRIS1.
 *
 * 22    12/01/98 11:17p Matt
 * Made copy/paste work with doors.
 *
 * 21    10/08/98 4:23p Kevin
 * Changed code to comply with memory library usage. Always use mem_malloc
 * , mem_free and mem_strdup
 *
 * 20    9/24/98 5:00p Matt
 * Improved error checking for running out of rooms.
 *
 * 19    9/02/98 5:57p Matt
 * Added code to make faces match exactly when forming a portal.  This
 * should get rid of all remaining cracking problems.
 *
 * 18    9/01/98 12:04p Matt
 * Ripped out multi-face portal code
 *
 * 17    8/15/98 10:50p Matt
 * When copying a portal, copy its flags
 *
 * 16    6/23/98 2:43p Matt
 * Changed calls to OutrageMessageBox() & Debug_MessageBox() to deal with
 * int return value (instead of bool).
 *
 * 15    4/21/98 2:43p Matt
 * Added system to disable render updates while deleting large numbers of
 * rooms, since the mine is not stable until this operation is done.
 *
 * 14    2/09/98 1:38p Matt
 * When pasting a group, ask the user if he also wants to paste objects
 * and triggers
 *
 * 13    2/04/98 6:23p Matt
 * Changed object room number to indicate a terrain cell via a flag.  Got
 * rid of the object flag which used to indicate terrain.
 *
 * 12    1/29/98 5:50p Matt
 * Changed old camera object type to be viewer object (for editor), and
 * now camera objects will just be for game cameras.
 *
 * 11    1/20/98 4:12p Samir
 * New script housekeeping system.
 *
 * 10    1/15/98 7:34p Matt
 * Revamped error checking when computing face normals
 *
 * 9     12/23/97 11:06a Samir
 * Added pserror.h
 *
 * 8     10/13/97 6:20p Matt
 * Fixed stupid bug copying objects in group
 *
 * 7     10/03/97 3:37p Matt
 * Fixed bug copying multiple objects in a room, and changed code to not
 * copy viewer or player objects
 *
 * 6     9/24/97 6:18p Samir
 * Use script names instead of script id values to identify scripts.
 *
 * 5     9/22/97 2:31p Matt
 * Made group code copy & paste objects & triggers
 *
 * 4     9/08/97 4:05p Samir
 * Fixed some warnings and took out extranneous includes to windows.h in
 * important headers.
 *
 * 3     9/02/97 6:42p Matt
 * Got paste & group save/load working
 *
 * 2     8/29/97 5:45p Matt
 * Converted group code to work with rooms (unfinished)
 *
 * 11    6/16/97 6:40p Matt
 * Fixed bug caused when Selected_segments[] was changed while
 * DeleteGroup() was indexing through it.
 *
 * 10    6/12/97 7:17p Matt
 * Deleted now-unused RotateWorld() function
 *
 * 9     5/23/97 5:46p Matt
 * Added SetMatrixBasedOnSide() functionality to ExtractMatrixFromSeg().
 *
 * 8     5/13/97 11:58a Matt
 * Made group file code save & load the level file version number to use
 * when reading segments
 *
 * 7     5/08/97 5:07p Matt
 * When rotating world, rotate the editor's wireframe window view vars
 *
 * 6     5/08/97 4:43p Matt
 * Fixed bug when rotating objects in RotateWorld()
 *
 * 5     5/06/97 2:26p Jason
 * fixed bug in rotate world
 *
 * 4     5/05/97 3:57p Matt
 * Added code to rotate the mine (& the objects in it) to join with the
 * terrain.
 *
 * 3     3/31/97 5:58p Matt
 * Revamped mine update flags
 *
 * 2     3/12/97 3:25p Matt
 * Added funcs for cut, copy, paste, & delete, and to save and load
 * groups.
 *
 * 1     3/11/97 9:34p Matt
 *
 * $NoKeywords: $
 */

#include "group.h"

#ifndef NEWEDITOR
#include "d3edit.h"
#else
#include "globals.h"
#endif

#include "selectedroom.h"
#include "room.h"
#include "hroom.h"
#include "erooms.h"
#include "loadlevel.h"

#ifndef NEWEDITOR
#include "moveworld.h"
#endif

#include "object.h"
#include "trigger.h"
#include "pserror.h"
#include "doorway.h"
#include "mem.h"
#include <string.h>
#include "door.h"

// Free a group.
// Parameters:	g - the group to be freed
void FreeGroup(group *g) {
  for (int r = 0; r < g->nrooms; r++)
    FreeRoom(&g->rooms[r]);

  mem_free(g->rooms);

  if (g->nobjects)
    mem_free(g->objects);

  if (g->ntriggers)
    mem_free(g->triggers);

  mem_free(g);
}

// Copy the given list of rooms to a group
// Parameters:	nrooms - the number of rooms in list
//					roomnums - pointer to list of room numbers
//					attachroom, attachface - where group attaches when pasted
// Returns:		pointer to group
group *CopyGroup(int nrooms, int *roomnums, int attachroom, int attachface) {
  group *g;
  int r;
  int room_xlate[MAX_ROOMS];
  int n_objects = 0, n_triggers = 0, n_doors = 0;

  // Allocate group & room arrays
  g = (group *)mem_malloc(sizeof(*g));
  ASSERT(g != NULL);
  g->nrooms = nrooms;
  g->rooms = (room *)mem_malloc(sizeof(*g->rooms) * nrooms);
  ASSERT(g->rooms != NULL);

  // Initialize xlate list
  for (r = 0; r < MAX_ROOMS; r++)
    room_xlate[r] = -1;

  // Copy the rooms & build xlate list.  Count objects while we're at it
  for (r = 0; r < nrooms; r++) {

    CopyRoom(&g->rooms[r], &Rooms[roomnums[r]]);
    room_xlate[roomnums[r]] = r;

    for (int o = Rooms[roomnums[r]].objects; o != -1; o = Objects[o].next)
      if ((Objects[o].type != OBJ_VIEWER) && (Objects[o].type != OBJ_CAMERA) && (Objects[o].type != OBJ_PLAYER)) {
        n_objects++;
        if (Objects[o].type == OBJ_DOOR)
          n_doors++;
      }
  }

  // Add portals for rooms in the group
  for (r = 0; r < nrooms; r++)
    for (int p = 0; p < Rooms[roomnums[r]].num_portals; p++) {
      portal *pp = &Rooms[roomnums[r]].portals[p];
      if ((pp->croom != -1) && IsRoomSelected(pp->croom)) {

        // link the two rooms
        if (r < room_xlate[pp->croom]) // only link lower to higher, so we don't double link
          LinkRoomsSimple(g->rooms, r, pp->portal_face, room_xlate[pp->croom],
                          Rooms[pp->croom].portals[pp->cportal].portal_face);

        // Copy the portal flags
        int new_portal_num = g->rooms[r].faces[pp->portal_face].portal_num;
        g->rooms[r].portals[new_portal_num].flags = pp->flags;
      }
    }

  // Fill in attach fields
  g->attachroom = room_xlate[attachroom];
  g->attachface = attachface;

  // Copy objects
  g->nobjects = n_objects;
  g->ndoors = n_doors;
  if (n_objects == 0)
    g->objects = NULL;
  else {
    int objnum = 0;

    // Get memory for objects
    g->objects = (object *)mem_malloc(sizeof(*g->objects) * n_objects);

    // Go through list of rooms & copy the objects
    for (r = 0; r < nrooms; r++) {
      for (int o = Rooms[roomnums[r]].objects; o != -1; o = Objects[o].next) {
        object *dest = &g->objects[objnum], *src = &Objects[o];

        if ((src->type == OBJ_VIEWER) || (src->type == OBJ_CAMERA) || (src->type == OBJ_PLAYER))
          continue; // don't copy cameras

        // Copy some selected data
        dest->type = src->type;
        dest->id = src->id;
        dest->flags = src->flags;
        dest->pos = src->pos;
        dest->orient = src->orient;
        dest->lifeleft = src->lifeleft;

        dest->contains_type = src->contains_type;
        dest->contains_id = src->contains_id;
        dest->contains_count = src->contains_count;

        if (src->control_type == CT_POWERUP)
          dest->ctype.powerup_info.count = src->ctype.powerup_info.count;

        if (src->type == OBJ_DOOR)
          dest->shields = src->shields;

        dest->roomnum = r;

        objnum++;
      }
    }
  }

  // Count the triggers in the group
  for (int t = 0; t < Num_triggers; t++)
    if (room_xlate[Triggers[t].roomnum] != -1)
      n_triggers++;

  // Copy triggers
  g->ntriggers = n_triggers;
  if (n_triggers == 0)
    g->triggers = NULL;
  else {
    int trignum = 0;

    // Get memory for triggers
    g->triggers = (trigger *)mem_malloc(sizeof(*g->triggers) * n_triggers);

    for (t = 0; t < Num_triggers; t++)
      if (room_xlate[Triggers[t].roomnum] != -1) {
        g->triggers[trignum] = Triggers[t];
        g->triggers[trignum].roomnum = room_xlate[Triggers[t].roomnum];
        trignum++;
      }
  }

  // Return the new group
  return g;
}

extern bool Disable_editor_rendering;

// Delete the given list of rooms
// Parameters:	nrooms - the number of rooms in list
//					roomnums - pointer to list of room numbers
void DeleteGroup(int nrooms, int *roomnums) {
  int i;
  int *troomnums;
  bool save_disable_flag = Disable_editor_rendering;

  Disable_editor_rendering = 1;

  // Make copy of list of rooms to delete.  We must do this because roomnums may be a pointer
  // to the global Selected_list, the contents of which may be changed by DeleteRoomFromMine()
  troomnums = (int *)mem_malloc(sizeof(*troomnums) * nrooms);
  for (i = 0; i < nrooms; i++)
    troomnums[i] = roomnums[i];

  // Now delete the rooms
  for (i = 0; i < nrooms; i++)
    DeleteRoomFromMine(&Rooms[troomnums[i]]);

  // Free up our array
  mem_free(troomnums);

  // Regenerate external object rooms
  CreateRoomObjects();

  // Restore old flag
  Disable_editor_rendering = save_disable_flag;

  // We're done!  Update flags and leave
  World_changed = 1;
}

// Place the given group at the specified room face
// The function merely causes the group to be drawn in the editor, allowing the user to line it up
// before attaching it.  The function AttachGroup() must be called to do the actual attachment.
// Parameters:	destroomp, destside - where to place the group
//					g - the group to place
void PlaceGroup(room *destroomp, int destface, group *g) {
  // Clear the placed room, if one exists
  Placed_room = -1;

  ASSERT(destroomp->faces[destface].portal_num == -1);

  // Set globals
  Placed_group = g;
  Placed_room_orient.fvec = destroomp->faces[destface].normal;
  Placed_room_angle = 0;
  Placed_baseroomp = destroomp;
  Placed_baseface = destface;

  // Compute attach points on each face
#ifndef NEWEDITOR
  ComputeCenterPointOnFace(&Placed_room_attachpoint, destroomp, destface);
  ComputeCenterPointOnFace(&Placed_room_origin, &g->rooms[g->attachroom], g->attachface);
#else
  float ComputeFaceBoundingCircle(vector * center, room * rp, int facenum);
  ComputeFaceBoundingCircle(&Placed_room_attachpoint, destroomp, destface);
  ComputeFaceBoundingCircle(&Placed_room_origin, &g->rooms[g->attachroom], g->attachface);
#endif

  // Compute initial orientation matrix
  ComputePlacedRoomMatrix();

  // Set the flag
  State_changed = 1;
}

#include "terrain.h"

// Place the given group at the specified terrain cell
// The function merely causes the group to be drawn in the editor, allowing the user to line it up
// before attaching it.  The function AttachGroup() must be called to do the actual attachment.
// Parameters:	cellnum - where to place the group
//					g - the group to place
void PlaceGroupTerrain(int cellnum, group *g, bool align_to_terrain) {
  // Clear the placed room, if one exists
  Placed_room = -1;

  // Set globals
  Placed_group = g;
  Placed_room_angle = 0;
  Placed_baseroomp = NULL;

  if (align_to_terrain)
    Placed_room_orient.fvec = TerrainNormals[MAX_TERRAIN_LOD - 1][cellnum].normal1;
  else
    Placed_room_orient.fvec = Identity_matrix.uvec;

  // Compute attach point on terrain
  ComputeTerrainSegmentCenter(&Placed_room_attachpoint, cellnum);

  // Compute attach points on face
  ComputeCenterPointOnFace(&Placed_room_origin, &g->rooms[g->attachroom], g->attachface);

  // Compute initial orientation matrix
  ComputePlacedRoomMatrix();

  // Set the flag
  State_changed = 1;
}

// Attach the already-placed group
void AttachGroup() {
  vector basecenter, attcenter;
  room *baseroomp, *attroomp;
  int baseface, attface;
  int room_xlate[MAX_ROOMS];
  int r;

  ASSERT(Placed_group != NULL);

  // Set some vars
  baseroomp = Placed_baseroomp;
  baseface = Placed_baseface;
  attroomp = &Placed_group->rooms[Placed_group->attachroom];
  attface = Placed_group->attachface;
  attcenter = Placed_room_origin;
  basecenter = Placed_room_attachpoint;

  // Copy the rooms into the main room list, build the xlate table, and rotate the verts
  for (r = 0; r < Placed_group->nrooms; r++) {
    int roomnum;
    room *newroomp;

    // Get a new room & copy into it
    roomnum = GetFreeRoom(0);
    if (roomnum == -1) {
      OutrageMessageBox("Cannot attach group: Not enough free rooms.");
      for (int t = 0; t < r; t++) // delete the rooms we just created
        DeleteRoomFromMine(&Rooms[room_xlate[t]]);
      return;
    }
    newroomp = &Rooms[roomnum];
    CopyRoom(newroomp, &Placed_group->rooms[r]);
    room_xlate[r] = roomnum;

    // Rotate verts in the new rooms
    for (int i = 0; i < newroomp->num_verts; i++)
      newroomp->verts[i] = ((newroomp->verts[i] - attcenter) * Placed_room_rotmat) + basecenter;

    // Recompute normals for the faces
    if (!ResetRoomFaceNormals(newroomp))
      Int3(); // Get Matt
  }

  // Add portals for new rooms
  for (r = 0; r < Placed_group->nrooms; r++)
    for (int p = 0; p < Placed_group->rooms[r].num_portals; p++) {
      portal *pp = &Placed_group->rooms[r].portals[p];
      if (r < pp->croom) // only link lower to higher, so we don't double link
        LinkRoomsSimple(Rooms, room_xlate[r], pp->portal_face, room_xlate[pp->croom],
                        Placed_group->rooms[pp->croom].portals[pp->cportal].portal_face);

      // Copy the portal flags
      int new_portal_num = Rooms[room_xlate[r]].faces[pp->portal_face].portal_num;
      Rooms[room_xlate[r]].portals[new_portal_num].flags = pp->flags;
    }

  // Get pointer to the placed attachroom
  room *newroomp = &Rooms[room_xlate[Placed_group->attachroom]];

  if (baseroomp) {
    // Clip the connecting faces against each other
    if (!ClipFacePair(newroomp, attface, baseroomp, baseface)) {
      OutrageMessageBox("Error making portal -- faces probably don't overlap.");
      for (r = 0; r < Placed_group->nrooms; r++)
        FreeRoom(&Rooms[room_xlate[r]]);
      return;
    }

    // Make the two faces match exactly
    MatchPortalFaces(baseroomp, baseface, newroomp, attface);

    // Link the attach room to the base room
    LinkRoomsSimple(Rooms, ROOMNUM(baseroomp), baseface, ROOMNUM(newroomp), attface);
  }

  // Paste objects
  if (Placed_group->nobjects) {
    bool place_all = 0;

    // Ask if the user wants the objects pasted
    if (Placed_group->nobjects > Placed_group->ndoors)
      place_all =
          (OutrageMessageBox(MBOX_YESNO,
                             "The group you are pasting has %d (non-door) object(s).  Do you wish to paste it/them?",
                             Placed_group->nobjects - Placed_group->ndoors) == IDYES);

    // Add the objects (either just doors or all objects)
    for (int o = 0; o < Placed_group->nobjects; o++) {
      object *src = &Placed_group->objects[o], *dest;

      if (place_all || (src->type == OBJ_DOOR)) {
        vector pos;
        matrix orient;
        int objnum;

        pos = ((src->pos - attcenter) * Placed_room_rotmat) + basecenter;
        orient = ~Placed_room_rotmat * src->orient;

        objnum = ObjCreate(src->type, src->id, room_xlate[src->roomnum], &pos, &orient);

#ifdef NEWEDITOR
        if (IS_GENERIC(src->type))
          LevelObjIncrementObject(src->id);
#endif

        dest = &Objects[objnum];

        dest->flags = src->flags;
        dest->lifeleft = src->lifeleft;

        dest->contains_type = src->contains_type;
        dest->contains_id = src->contains_id;
        dest->contains_count = src->contains_count;

        if (dest->control_type == CT_POWERUP)
          dest->ctype.powerup_info.count = src->ctype.powerup_info.count;

        if (src->type == OBJ_DOOR)
          dest->shields = src->shields;
      }
    }
  }

  // Paste triggers
  if (Placed_group->ntriggers) {

    // Ask if the user wants the triggers
    if (OutrageMessageBox(MBOX_YESNO, "The group you are pasting has %d trigger(s).  Do you wish to paste it/them?",
                          Placed_group->ntriggers) == IDYES) {

      // Add the triggers
      for (int t = 0; t < Placed_group->ntriggers; t++) {
        trigger *tp = &Placed_group->triggers[t];
        int trignum;

        trignum = AddTrigger("", room_xlate[tp->roomnum], tp->facenum, tp->activator, NULL);
        ASSERT(trignum != -1);

        Triggers[trignum].flags = tp->flags;
      }
    } else { // Triggers not being pasted, so must delete any floating trigger faces
      for (r = 0; r < Placed_group->nrooms; r++) {
        room *rp = &Rooms[room_xlate[r]];
        for (int f = 0; f < rp->num_faces; f++) {
          if (rp->faces[f].flags & FF_FLOATING_TRIG)
            DeleteRoomFace(rp, f);
        }
      }
    }
  }

  // Un-place the now-attached group
  Placed_group = NULL;

  // We're done!  Update flags and leave
  World_changed = 1;
}

#define GROUP_FILE_TAG "D3GP"
#define GROUP_FILE_VERSION 3
// Version number changes:
// 0 -> 1  Save the level file version to use when reading objects, rooms, etc.
// 1 -> 2  Now works for room engine
// 2 -> 3  Save objects, doors, & triggers

#define cf_ReadVector(f, v)                                                                                            \
  do {                                                                                                                 \
    (v)->x = cf_ReadFloat(f);                                                                                          \
    (v)->y = cf_ReadFloat(f);                                                                                          \
    (v)->z = cf_ReadFloat(f);                                                                                          \
  } while (0)
#define cf_WriteVector(f, v)                                                                                           \
  do {                                                                                                                 \
    cf_WriteFloat((f), (v)->x);                                                                                        \
    cf_WriteFloat((f), (v)->y);                                                                                        \
    cf_WriteFloat((f), (v)->z);                                                                                        \
  } while (0)
#define cf_WriteMatrix(f, m)                                                                                           \
  do {                                                                                                                 \
    cf_WriteVector((f), &(m)->rvec);                                                                                   \
    cf_WriteVector((f), &(m)->uvec);                                                                                   \
    cf_WriteVector((f), &(m)->fvec);                                                                                   \
  } while (0)
#define cf_ReadMatrix(f, m)                                                                                            \
  do {                                                                                                                 \
    cf_ReadVector((f), &(m)->rvec);                                                                                    \
    cf_ReadVector((f), &(m)->uvec);                                                                                    \
    cf_ReadVector((f), &(m)->fvec);                                                                                    \
  } while (0)

// Saves an object for a group
void WriteGroupObject(CFILE *ofile, object *objp) {
  cf_WriteByte(ofile, objp->type);
  cf_WriteShort(ofile, objp->id);
  cf_WriteInt(ofile, objp->flags);

  if (objp->type == OBJ_DOOR)
    cf_WriteShort(ofile, objp->shields);

  cf_WriteInt(ofile, objp->roomnum);
  cf_WriteVector(ofile, &objp->pos);
  cf_WriteMatrix(ofile, &objp->orient);

  cf_WriteByte(ofile, objp->contains_type);
  cf_WriteByte(ofile, objp->contains_id);
  cf_WriteByte(ofile, objp->contains_count);

  cf_WriteFloat(ofile, objp->lifeleft);
}

void WriteGroupTrigger(CFILE *ofile, trigger *tp) {
  cf_WriteShort(ofile, tp->roomnum);
  cf_WriteShort(ofile, tp->facenum);
  cf_WriteShort(ofile, tp->flags);
  cf_WriteShort(ofile, tp->activator);
}

// Saves a group to disk in the given filename
void SaveGroup(char *filename, group *g) {
  CFILE *ifile;
  int i;

  ifile = cfopen(filename, "wb");

  if (!ifile)
    return;

  // Write tag & version number
  cf_WriteBytes((uint8_t *)GROUP_FILE_TAG, 4, ifile);
  cf_WriteInt(ifile, GROUP_FILE_VERSION);
  cf_WriteInt(ifile, LEVEL_FILE_VERSION);

  // Write the current list of textures
  WriteTextureList(ifile);

  // Write group info
  cf_WriteInt(ifile, g->nrooms);
  cf_WriteInt(ifile, g->attachroom);
  cf_WriteInt(ifile, g->attachface);
  cf_WriteInt(ifile, g->nobjects);
  cf_WriteInt(ifile, g->ndoors);
  cf_WriteInt(ifile, g->ntriggers);

  // Write rooms
  for (i = 0; i < g->nrooms; i++)
    WriteRoom(ifile, &g->rooms[i]);

  // Write objects
  for (i = 0; i < g->nobjects; i++)
    WriteGroupObject(ifile, &g->objects[i]);

  // Write triggers
  for (i = 0; i < g->ntriggers; i++)
    WriteGroupTrigger(ifile, &g->triggers[i]);

  // Close the file
  cfclose(ifile);
}

// Reads an object for a group
void ReadGroupObject(CFILE *ifile, object *objp) {
  objp->type = cf_ReadByte(ifile);
  objp->id = cf_ReadShort(ifile);
  objp->flags = cf_ReadInt(ifile);

  if (objp->type == OBJ_DOOR)
    objp->shields = cf_ReadShort(ifile);

  objp->roomnum = cf_ReadInt(ifile);
  cf_ReadVector(ifile, &objp->pos);
  cf_ReadMatrix(ifile, &objp->orient);

  objp->contains_type = cf_ReadByte(ifile);
  objp->contains_id = cf_ReadByte(ifile);
  objp->contains_count = cf_ReadByte(ifile);

  objp->lifeleft = cf_ReadFloat(ifile);
}

void ReadGroupTrigger(CFILE *ifile, trigger *tp) {
  tp->roomnum = cf_ReadShort(ifile);
  tp->facenum = cf_ReadShort(ifile);
  tp->flags = cf_ReadShort(ifile);
  tp->activator = cf_ReadShort(ifile);
}

// Loads a group from disk
group *LoadGroup(char *filename) {
  CFILE *ifile;
  char tag[4];
  int version, level_version;
  group *g;
  int i;

  ifile = cfopen(filename, "rb");

  if (!ifile)
    return NULL;

  // Read & check tag
  cf_ReadBytes((uint8_t *)tag, 4, ifile);
  if (strncmp(tag, GROUP_FILE_TAG, 4)) {
    cfclose(ifile);
    return NULL;
  }

  // Read & check version number
  version = cf_ReadInt(ifile);
  if (version > GROUP_FILE_VERSION) {
    cfclose(ifile);
    return NULL;
  }

  // Check for out-of-date groups
  if (version < 2) {
    OutrageMessageBox("Sorry - segment groups no longer supported.");
    cfclose(ifile);
    return NULL;
  }

  // Read & check level file version number
  level_version = cf_ReadInt(ifile);
  if (level_version > LEVEL_FILE_VERSION) {
    cfclose(ifile);
    return NULL;
  }

  // Read the textures & build xlate table
  ReadTextureList(ifile);

  // Allocate group
  g = (group *)mem_malloc(sizeof(*g));

  // Read group info
  g->nrooms = cf_ReadInt(ifile);
  g->attachroom = cf_ReadInt(ifile);
  g->attachface = cf_ReadInt(ifile);

  // Read object, door, & trigger info
  if (version >= 3) {
    g->nobjects = cf_ReadInt(ifile);
    g->ndoors = cf_ReadInt(ifile);
    g->ntriggers = cf_ReadInt(ifile);
  } else
    g->nobjects = g->ndoors = g->ntriggers = 0;

  // Allocate room and vertex arrays
  g->rooms = (room *)mem_malloc(sizeof(*g->rooms) * g->nrooms);

  // Read rooms
  for (i = 0; i < g->nrooms; i++) {
    g->rooms[i].used = 0; // ReadRoom() wants the used flag to be clear
    ReadRoom(ifile, &g->rooms[i], level_version);
  }

  // Read objects & triggers
  g->triggers = NULL;
  g->objects = NULL;
  if (version >= 3) {

    // Allocate objects array
    if (g->nobjects)
      g->objects = (object *)mem_malloc(sizeof(*g->objects) * g->nobjects);

    // Allocate triggers array
    if (g->ntriggers)
      g->triggers = (trigger *)mem_malloc(sizeof(*g->triggers) * g->ntriggers);

    // Read objects
    for (i = 0; i < g->nobjects; i++)
      ReadGroupObject(ifile, &g->objects[i]);

    // Read triggers
    for (i = 0; i < g->ntriggers; i++)
      ReadGroupTrigger(ifile, &g->triggers[i]);
  }

  // Close the file
  cfclose(ifile);

  return g;
}