Maraiah/src/marathon/map.rs

use crate::{durandal::{bin::*, err::*, fixed::*,
                       text::mac_roman_conv},
            marathon::xfer::TransferMode};
use bitflags::bitflags;
use serde::Serialize;
use std::fmt;

pub fn read_minf(b: &[u8]) -> ResultS<Minf>
{
   let env_code = c_u16b(b, 0)?;
   let physi_id = c_u16b(b, 2)?;
   let music_id = c_u16b(b, 4)?;
   let msn_flag = c_u16b(b, 6)?;
   let env_flag = c_u16b(b, 8)?;
   let levelnam = mac_roman_conv(c_data(b, 18..84)?);
   let ent_flag = c_u32b(b, 84)?;
   let msn_flag = ok!(MsnFlags::from_bits(msn_flag), "bad MsnFlags")?;
   let env_flag = ok!(EnvFlags::from_bits(env_flag), "bad EnvFlags")?;
   let ent_flag = ok!(EntFlags::from_bits(ent_flag), "bad EntFlags")?;
   Ok(Minf{env_code, physi_id, music_id, msn_flag, env_flag, ent_flag,
           levelnam})
}

pub fn read_sidetex(b: &[u8]) -> ResultS<SideTex>
{
   let offs   = read_point(c_data(b, 0..4)?)?;
   let tex_id = c_u16b(b, 4)?;
   let tex_id = ObjID::from_repr(tex_id);
   Ok(SideTex{offs, tex_id})
}

pub fn read_point(b: &[u8]) -> ResultS<Point>
{
   let x = c_u16b(b, 0)?;
   let y = c_u16b(b, 2)?;
   let x = Unit::from_bits(x);
   let y = Unit::from_bits(y);
   Ok(Point{x, y})
}

pub fn read_epnt(b: &[u8]) -> ResultS<(Point, usize)>
{
   Ok((read_point(c_data(b, 6..10)?)?, 16))
}

pub fn read_pnts(b: &[u8]) -> ResultS<(Point, usize)>
{
   Ok((read_point(b)?, 4))
}

pub fn read_lins(b: &[u8]) -> ResultS<(Line, usize)>
{
   let pnt_beg = c_u16b(b, 0)?;
   let pnt_end = c_u16b(b, 2)?;
   let flags   = c_u16b(b, 4)?;
   let length  = c_u16b(b, 6)?;
   let adj_hi  = c_u16b(b, 8)?;
   let adj_lo  = c_u16b(b, 10)?;
   let side_fr = c_u16b(b, 12)?;
   let side_bk = c_u16b(b, 14)?;
   let poly_fr = c_u16b(b, 16)?;
   let poly_bk = c_u16b(b, 18)?;
   let flags   = ok!(LineFlags::from_bits(flags), "bad LineFlags")?;
   let length  = Unit::from_bits(length);
   let adj_hi  = Unit::from_bits(adj_hi);
   let adj_lo  = Unit::from_bits(adj_lo);
   let side_fr = ObjID::from_repr(side_fr);
   let side_bk = ObjID::from_repr(side_bk);
   let poly_fr = ObjID::from_repr(poly_fr);
   let poly_bk = ObjID::from_repr(poly_bk);
   Ok((Line{flags, length, adj_hi, adj_lo, pnt_beg, pnt_end, side_fr,
            side_bk, poly_fr, poly_bk}, 32))
}

pub fn read_sids(b: &[u8]) -> ResultS<(Side, usize)>
{
   let stype    = c_u16b(b, 0)?;
   let flags    = c_u16b(b, 2)?;
   let tex_pri  = read_sidetex(c_data(b, 4..10)?)?;
   let tex_sec  = read_sidetex(c_data(b, 10..16)?)?;
   let tex_tra  = read_sidetex(c_data(b, 16..22)?)?;
   let ex_tleft = read_point(c_data(b, 22..26)?)?;
   let ex_trigh = read_point(c_data(b, 26..30)?)?;
   let ex_bleft = read_point(c_data(b, 30..34)?)?;
   let ex_brigh = read_point(c_data(b, 34..38)?)?;
   let paneltyp = c_u16b(b, 38)?;
   let paneldat = c_i16b(b, 40)?;
   let xfer_pri = c_u16b(b, 42)?;
   let xfer_sec = c_u16b(b, 44)?;
   let xfer_tra = c_u16b(b, 46)?;
   let shade    = c_u32b(b, 48)?;
   let flags    = ok!(SideFlags::from_bits(flags), "bad SideFlags")?;
   let xfer_pri = TransferMode::from_repr(xfer_pri)?;
   let xfer_sec = TransferMode::from_repr(xfer_sec)?;
   let xfer_tra = TransferMode::from_repr(xfer_tra)?;
   let shade    = Fixed::from_bits(shade);
   Ok((Side{stype, flags, tex_pri, tex_sec, tex_tra, ex_tleft, ex_trigh,
            ex_bleft, ex_brigh, paneltyp, paneldat, xfer_pri, xfer_sec,
            xfer_tra, shade}, 64))
}

#[derive(Serialize)]
pub struct Point
{
   x: Unit,
   y: Unit,
}

#[derive(Debug, Serialize)]
pub struct Line
{
   flags:   LineFlags,
   length:  Unit,
   adj_hi:  Unit,
   adj_lo:  Unit,
   pnt_beg: u16,
   pnt_end: u16,
   side_fr: ObjID,
   side_bk: ObjID,
   poly_fr: ObjID,
   poly_bk: ObjID,
}

#[derive(Debug, Serialize)]
pub struct SideTex
{
   offs:   Point,
   tex_id: ObjID,
}

#[derive(Debug, Serialize)]
pub struct Side
{
   stype:    u16,
   flags:    SideFlags,
   tex_pri:  SideTex,
   tex_sec:  SideTex,
   tex_tra:  SideTex,
   ex_tleft: Point,
   ex_trigh: Point,
   ex_bleft: Point,
   ex_brigh: Point,
   paneltyp: u16,
   paneldat: i16,
   xfer_pri: TransferMode,
   xfer_sec: TransferMode,
   xfer_tra: TransferMode,
   shade:    Fixed,
}

#[derive(Debug, Serialize)]
pub struct Minf
{
   env_code: u16,
   physi_id: u16,
   music_id: u16,
   msn_flag: MsnFlags,
   env_flag: EnvFlags,
   ent_flag: EntFlags,
   levelnam: String,
}

bitflags! {
   #[derive(Serialize)]
   pub struct LineFlags: u16
   {
      const TransSide   = 1 << 9;
      const ElevVar     = 1 << 10;
      const Elevation   = 1 << 11;
      const Landscape   = 1 << 12;
      const Transparent = 1 << 13;
      const Solid       = 1 << 14;
   }
}

bitflags! {
   #[derive(Serialize)]
   pub struct SideFlags: u16
   {
      const Status     = 1;
      const Panel      = 1 << 1;
      const Repair     = 1 << 2;
      const ItemUse    = 1 << 3;
      const Lighted    = 1 << 4;
      const CanDestroy = 1 << 5;
      const HitOnly    = 1 << 6;
      const ItemOpt    = 1 << 7;
   }
}

bitflags! {
   #[derive(Serialize)]
   pub struct EnvFlags: u16
   {
      const Vacuum     = 1;
      const Magnetic   = 1 << 1;
      const Rebellion  = 1 << 2;
      const LowGrav    = 1 << 3;
      const M1Glue     = 1 << 4;
      const LavaFloor  = 1 << 5;
      const Rebellion2 = 1 << 6;
      const Music      = 1 << 7;
      const TermPause  = 1 << 8;
      const M1Monster  = 1 << 9;
      const M1Weps     = 1 << 10;
      const NetPlay    = 1 << 13;
      const Solo       = 1 << 14;
   }
}

bitflags! {
   #[derive(Serialize)]
   pub struct EntFlags: u32
   {
      const Solo    = 1;
      const CoOp    = 1 << 1;
      const Carnage = 1 << 2;
      const KTMWTB  = 1 << 3;
      const KOTH    = 1 << 4;
      const Defense = 1 << 5;
      const Rugby   = 1 << 6;
      const CTF     = 1 << 7;
   }
}

bitflags! {
   #[derive(Serialize)]
   pub struct MsnFlags: u16
   {
      const Extermination = 1;
      const Exploration   = 1 << 1;
      const Retrieval     = 1 << 2;
      const Repair        = 1 << 3;
      const Rescue        = 1 << 4;
   }
}

impl fmt::Debug for Point
{
   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
   {
      write!(f, "({}, {})", self.x, self.y)
   }
}

// EOF