Beispiel #1
0
static int deactivatePlat(thinker_t *th, void *context)
{
    plat_t *plat = (plat_t *) th;
    deactivateplatparams_t *params = (deactivateplatparams_t *) context;

#if __JHEXEN__
    // For THE one with the tag.
    if(plat->tag == params->tag)
    {
        // Destroy it.
        stopPlat(plat);
        params->count++;
        return true; // Stop iteration.
    }
#else
    // For one with the tag and not in stasis.
    if(plat->tag == (int) params->tag && !Thinker_InStasis(&plat->thinker))
    {
        // Put it in stasis.
        plat->oldState = plat->state;
        Thinker_SetStasis(&plat->thinker, true);
        params->count++;
    }
#endif

    return false; // Continue iteration.
}
Beispiel #2
0
static int activatePlat(thinker_t *th, void *context)
{
    plat_t *plat = (plat_t *) th;
    activateplatparams_t *params = (activateplatparams_t *) context;

    if(plat->tag == (int) params->tag && Thinker_InStasis(&plat->thinker))
    {
        plat->state = plat->oldState;
        Thinker_SetStasis(&plat->thinker, false);
        params->count++;
    }

    return false; // Contiue iteration.
}
Beispiel #3
0
static int SV_ReadPlat(plat_t *plat)
{
/* Original Heretic format:
typedef struct {
    thinker_t   thinker;        // was 12 bytes
    Sector     *sector;
    fixed_t     speed;
    fixed_t     low;
    fixed_t     high;
    int         wait;
    int         count;
    platstate_e     status;         // was 32bit int
    platstate_e     oldStatus;      // was 32bit int
    boolean     crush;
    int         tag;
    plattype_e  type;           // was 32bit int
} v13_plat_t;
*/
    byte temp[SIZEOF_V13_THINKER_T];
    // Padding at the start (an old thinker_t struct)
    Reader_Read(svReader, &temp, SIZEOF_V13_THINKER_T);

    // Start of used data members.
    // A 32bit pointer to sector, serialized.
    plat->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));
    if(!plat->sector)
        Con_Error("tc_plat: bad sector number\n");

    plat->speed = FIX2FLT(Reader_ReadInt32(svReader));
    plat->low = FIX2FLT(Reader_ReadInt32(svReader));
    plat->high = FIX2FLT(Reader_ReadInt32(svReader));
    plat->wait = Reader_ReadInt32(svReader);
    plat->count = Reader_ReadInt32(svReader);
    plat->state = Reader_ReadInt32(svReader);
    plat->oldState = Reader_ReadInt32(svReader);
    plat->crush = Reader_ReadInt32(svReader);
    plat->tag = Reader_ReadInt32(svReader);
    plat->type = Reader_ReadInt32(svReader);

    plat->thinker.function = T_PlatRaise;
    if(!(temp + V13_THINKER_T_FUNC_OFFSET))
        Thinker_SetStasis(&plat->thinker, true);

    P_ToXSector(plat->sector)->specialData = T_PlatRaise;
    return true; // Add this thinker.
}
Beispiel #4
0
static int SV_ReadCeiling(ceiling_t *ceiling)
{
/* Original Heretic format:
typedef struct {
    thinker_t thinker; ///< 12 bytes
    ceilingtype_e type; ///< 32bit int
    Sector* sector;
    fixed_t bottomheight, topheight;
    fixed_t speed;
    boolean crush;
    int direction; /// 1= up, 0= waiting, -1= down
    int tag'
    int olddirection;
} v13_ceiling_t;
*/
    byte temp[SIZEOF_V13_THINKER_T];

    // Padding at the start (an old thinker_t struct)
    Reader_Read(svReader, &temp, SIZEOF_V13_THINKER_T);

    // Start of used data members.
    ceiling->type = Reader_ReadInt32(svReader);

    // A 32bit pointer to sector, serialized.
    ceiling->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));
    if(!ceiling->sector)
        Con_Error("tc_ceiling: bad sector number\n");

    ceiling->bottomHeight = FIX2FLT(Reader_ReadInt32(svReader));
    ceiling->topHeight    = FIX2FLT(Reader_ReadInt32(svReader));
    ceiling->speed        = FIX2FLT(Reader_ReadInt32(svReader));
    ceiling->crush        = Reader_ReadInt32(svReader);
    ceiling->state        = (Reader_ReadInt32(svReader) == -1? CS_DOWN : CS_UP);
    ceiling->tag          = Reader_ReadInt32(svReader);
    ceiling->oldState     = (Reader_ReadInt32(svReader) == -1? CS_DOWN : CS_UP);

    ceiling->thinker.function = T_MoveCeiling;
    if(!(temp + V13_THINKER_T_FUNC_OFFSET))
        Thinker_SetStasis(&ceiling->thinker, true);

    P_ToXSector(ceiling->sector)->specialData = T_MoveCeiling;
    return true; // Add this thinker.
}
Beispiel #5
0
int plat_t::read(MapStateReader *msr)
{
    Reader *reader = msr->reader();
    int mapVersion = msr->mapVersion();

#if __JHEXEN__
    if(mapVersion >= 4)
#else
    if(mapVersion >= 5)
#endif
    {   // Note: the thinker class byte has already been read.
        /*int ver =*/ Reader_ReadByte(reader); // version byte.

        thinker.function = T_PlatRaise;

#if !__JHEXEN__
        // Should we put this into stasis?
        if(mapVersion == 5)
        {
            if(!Reader_ReadByte(reader))
                Thinker_SetStasis(&thinker, true);
        }
#endif

        type      = plattype_e(Reader_ReadByte(reader));
        sector    = (Sector *)P_ToPtr(DMU_SECTOR, Reader_ReadInt32(reader));
        DENG_ASSERT(sector != 0);
        speed     = FIX2FLT(Reader_ReadInt32(reader));
        low       = (float) Reader_ReadInt16(reader);
        high      = (float) Reader_ReadInt16(reader);
        wait      = Reader_ReadInt32(reader);
        count     = Reader_ReadInt32(reader);
        state     = platstate_e(Reader_ReadByte(reader));
        oldState  = platstate_e(Reader_ReadByte(reader));
        crush     = (dd_bool) Reader_ReadByte(reader);
        tag       = Reader_ReadInt32(reader);
    }
    else
    {
        // Its in the old format which serialized plat_t
        // Padding at the start (an old thinker_t struct)
        int32_t junk[4]; // sizeof thinker_t
        Reader_Read(reader, (byte *)junk, 16);

        // Start of used data members.
        // A 32bit pointer to sector, serialized.
        sector    = (Sector *)P_ToPtr(DMU_SECTOR, (int) Reader_ReadInt32(reader));
        DENG_ASSERT(sector != 0);

        speed     = FIX2FLT((fixed_t) Reader_ReadInt32(reader));
        low       = FIX2FLT((fixed_t) Reader_ReadInt32(reader));
        high      = FIX2FLT((fixed_t) Reader_ReadInt32(reader));

        wait      = Reader_ReadInt32(reader);
        count     = Reader_ReadInt32(reader);
        state     = platstate_e(Reader_ReadInt32(reader));
        oldState  = platstate_e(Reader_ReadInt32(reader));
        crush     = Reader_ReadInt32(reader);
        tag       = Reader_ReadInt32(reader);
        type      = plattype_e(Reader_ReadInt32(reader));

        thinker.function = T_PlatRaise;
#if !__JHEXEN__
        if(junk[2] == 0)
        {
            Thinker_SetStasis(&thinker, true);
        }
#endif
    }

    P_ToXSector(sector)->specialData = this;

    return true; // Add this thinker.
}