C4MaterialMap Class Reference

#include <C4Material.h>

Collaboration diagram for C4MaterialMap:

Public Member Functions
	C4MaterialMap ()
	~C4MaterialMap ()
void	Default ()
void	Clear ()
int32_t	Load (C4Group &hGroup)
bool	HasMaterials (C4Group &hGroup) const
int32_t	Get (const char *szMaterial)
bool	SaveEnumeration (C4Group &hGroup)
bool	LoadEnumeration (C4Group &hGroup)
C4MaterialReaction *	GetReactionUnsafe (int32_t iPXSMat, int32_t iLandscapeMat)
C4MaterialReaction *	GetReaction (int32_t iPXSMat, int32_t iLandscapeMat)
void	UpdateScriptPointers ()
bool	CrossMapMaterials (const char *szEarthMaterial)

Static Public Member Functions
static bool	mrfConvert (C4MaterialReaction *pReaction, int32_t &iX, int32_t &iY, int32_t iLSPosX, int32_t iLSPosY, C4Real &fXDir, C4Real &fYDir, int32_t &iPxsMat, int32_t iLsMat, MaterialInteractionEvent evEvent, bool *pfPosChanged)
static bool	mrfPoof (C4MaterialReaction *pReaction, int32_t &iX, int32_t &iY, int32_t iLSPosX, int32_t iLSPosY, C4Real &fXDir, C4Real &fYDir, int32_t &iPxsMat, int32_t iLsMat, MaterialInteractionEvent evEvent, bool *pfPosChanged)
static bool	mrfCorrode (C4MaterialReaction *pReaction, int32_t &iX, int32_t &iY, int32_t iLSPosX, int32_t iLSPosY, C4Real &fXDir, C4Real &fYDir, int32_t &iPxsMat, int32_t iLsMat, MaterialInteractionEvent evEvent, bool *pfPosChanged)
static bool	mrfIncinerate (C4MaterialReaction *pReaction, int32_t &iX, int32_t &iY, int32_t iLSPosX, int32_t iLSPosY, C4Real &fXDir, C4Real &fYDir, int32_t &iPxsMat, int32_t iLsMat, MaterialInteractionEvent evEvent, bool *pfPosChanged)
static bool	mrfInsert (C4MaterialReaction *pReaction, int32_t &iX, int32_t &iY, int32_t iLSPosX, int32_t iLSPosY, C4Real &fXDir, C4Real &fYDir, int32_t &iPxsMat, int32_t iLsMat, MaterialInteractionEvent evEvent, bool *pfPosChanged)
static bool	mrfScript (C4MaterialReaction *pReaction, int32_t &iX, int32_t &iY, int32_t iLSPosX, int32_t iLSPosY, C4Real &fXDir, C4Real &fYDir, int32_t &iPxsMat, int32_t iLsMat, MaterialInteractionEvent evEvent, bool *pfPosChanged)

Public Attributes
int32_t	Num
C4Material *	Map
C4MaterialReaction **	ppReactionMap
int32_t	max_shape_width
int32_t	max_shape_height
C4MaterialReaction	DefReactConvert
C4MaterialReaction	DefReactPoof
C4MaterialReaction	DefReactCorrode
C4MaterialReaction	DefReactIncinerate
C4MaterialReaction	DefReactInsert

Protected Member Functions
void	SetMatReaction (int32_t iPXSMat, int32_t iLSMat, C4MaterialReaction *pReact)
bool	SortEnumeration (int32_t iMat, const char *szMatName)

Detailed Description

Definition at line 162 of file C4Material.h.

Constructor & Destructor Documentation

C4MaterialMap()

C4MaterialMap::C4MaterialMap

(

)

Definition at line 302 of file C4Material.cpp.

                             : DefReactConvert(&mrfConvert), DefReactPoof(&mrfPoof), DefReactCorrode(&mrfCorrode), DefReactIncinerate(&mrfIncinerate), DefReactInsert(&mrfInsert)
{
    Default();
}

References Default().

Here is the call graph for this function:

~C4MaterialMap()

C4MaterialMap::~C4MaterialMap

(

)

Definition at line 308 of file C4Material.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

Clear()

void C4MaterialMap::Clear

(

)

Definition at line 313 of file C4Material.cpp.

{
    delete [] Map; Map=nullptr; Num=0;
    delete [] ppReactionMap; ppReactionMap = nullptr;
}

References Map, Num, and ppReactionMap.

Referenced by c4_material_map_handle_new(), C4Game::Clear(), C4Game::InitMaterialTexture(), and ~C4MaterialMap().

Here is the caller graph for this function:

CrossMapMaterials()

bool C4MaterialMap::CrossMapMaterials

(

const char *

szEarthMaterial

)

Definition at line 375 of file C4Material.cpp.

{
    // Check material number
    if (::MaterialMap.Num>C4MaxMaterial)
        { LogFatal(LoadResStr("IDS_PRC_TOOMANYMATS")); return false; }
    // build reaction function map
    delete [] ppReactionMap;
    typedef C4MaterialReaction * C4MaterialReactionPtr;
    ppReactionMap = new C4MaterialReactionPtr[(Num+1)*(Num+1)];
    for (int32_t iMatPXS=-1; iMatPXS<Num; iMatPXS++)
    {
        C4Material *pMatPXS = (iMatPXS+1) ? Map+iMatPXS : nullptr;
        for (int32_t iMatLS=-1; iMatLS<Num; iMatLS++)
        {
            C4MaterialReaction *pReaction = nullptr;
            C4Material *pMatLS  = ( iMatLS+1) ? Map+ iMatLS : nullptr;
            // natural stuff: material conversion here?
            if (pMatPXS && pMatPXS->sInMatConvert.getLength() && SEqualNoCase(pMatPXS->sInMatConvert.getData(), pMatLS ? pMatLS->Name : C4TLS_MatSky))
                pReaction = &DefReactConvert;
            // non-sky reactions
            else if (pMatPXS && pMatLS)
            {
                // incindiary vs extinguisher
                if ((pMatPXS->Incendiary && pMatLS->Extinguisher) || (pMatPXS->Extinguisher && pMatLS->Incendiary))
                    pReaction = &DefReactPoof;
                // incindiary vs inflammable
                else if ((pMatPXS->Incendiary && pMatLS->Inflammable) || (pMatPXS->Inflammable && pMatLS->Incendiary))
                    pReaction = &DefReactIncinerate;
                // corrosive vs corrode
                else if (pMatPXS->Corrosive && pMatLS->Corrode)
                    pReaction = &DefReactCorrode;
                // liquid hitting liquid or solid: Material insertion
                else if (DensityLiquid(MatDensity(iMatPXS)) && DensitySemiSolid(MatDensity(iMatLS)))
                    pReaction = &DefReactInsert;
                // solid hitting solid: Material insertion
                else if (DensitySolid(MatDensity(iMatPXS)) && DensitySolid(MatDensity(iMatLS)))
                    pReaction = &DefReactInsert;
            }
            // assign the function; or nullptr for no reaction
            SetMatReaction(iMatPXS, iMatLS, pReaction);
        }
    }
    // reset max shape size
    max_shape_width=max_shape_height=0;
    // material-specific initialization
    int32_t cnt;
    for (cnt=0; cnt<Num; cnt++)
    {
        C4Material *pMat = Map+cnt;
        const char *szTextureOverlay = nullptr;
        // newgfx: init pattern
        if (Map[cnt].sTextureOverlay.getLength())
            if (::TextureMap.GetTexture(Map[cnt].sTextureOverlay.getLength()))
            {
                szTextureOverlay = Map[cnt].sTextureOverlay.getData();
                // backwards compatibility: if a pattern was specified although the no-pattern flag was set, overwrite that flag
                if (Map[cnt].OverlayType & C4MatOv_None)
                {
                    DebugLogF("Error in overlay of material %s: Flag C4MatOv_None ignored because a custom overlay (%s) was specified!", Map[cnt].Name, szTextureOverlay);
                    Map[cnt].OverlayType &= ~C4MatOv_None;
                }
            }
        // default to first texture in texture map
        int iTexMapIx;
        if (!szTextureOverlay && (iTexMapIx = ::TextureMap.GetIndex(Map[cnt].Name, nullptr, false)))
            szTextureOverlay = TextureMap.GetEntry(iTexMapIx)->GetTextureName();
        // default to smooth
        if (!szTextureOverlay)
            szTextureOverlay = "none";
        // search/create entry in texmap
        Map[cnt].DefaultMatTex = ::TextureMap.GetIndex(Map[cnt].Name, szTextureOverlay, true,
                                 FormatString("DefaultMatTex of mat %s", Map[cnt].Name).getData());
        // init PXS facet
        C4Surface * sfcTexture;
        C4Texture * Texture;
        if (Map[cnt].sPXSGfx.getLength())
            if ((Texture=::TextureMap.GetTexture(Map[cnt].sPXSGfx.getData())))
                if ((sfcTexture=Texture->Surface32))
                    Map[cnt].PXSFace.Set(sfcTexture, Map[cnt].PXSGfxRt.x, Map[cnt].PXSGfxRt.y, Map[cnt].PXSGfxRt.Wdt, Map[cnt].PXSGfxRt.Hgt);
        // evaluate reactions for that material
        for (auto & iRCnt : pMat->CustomReactionList)
        {
            C4MaterialReaction *pReact = &iRCnt;
            if (pReact->sConvertMat.getLength()) pReact->iConvertMat = Get(pReact->sConvertMat.getData()); else pReact->iConvertMat = -1;
            // evaluate target spec
            int32_t tmat;
            if (MatValid(tmat=Get(pReact->TargetSpec.getData())))
            {
                // single material target
                if (pReact->fInverseSpec)
                    for (int32_t cnt2=-1; cnt2<Num; cnt2++) {
                        if (cnt2!=tmat)
                            SetMatReaction(cnt, cnt2, pReact);
                        else
                            SetMatReaction(cnt, tmat, pReact);
                    }
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "All"))
            {
                // add to all materials, including sky
                if (!pReact->fInverseSpec) for (int32_t cnt2=-1; cnt2<Num; cnt2++) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Solid"))
            {
                // add to all solid materials
                if (pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (DensitySolid(Map[cnt2].Density) != pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "SemiSolid"))
            {
                // add to all semisolid materials
                if (pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (DensitySemiSolid(Map[cnt2].Density) != pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Background"))
            {
                // add to all BG materials, including sky
                if (!pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (!Map[cnt2].Density != pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Sky"))
            {
                // add to sky
                if (!pReact->fInverseSpec)
                    SetMatReaction(cnt, -1, pReact);
                else
                    for (int32_t cnt2=0; cnt2<Num; cnt2++) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Incendiary") || SEqualNoCase(pReact->TargetSpec.getData(), "Incindiary"))
            {
                // add to all incendiary materials
                if (pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (!Map[cnt2].Incendiary == pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Extinguisher"))
            {
                // add to all incendiary materials
                if (pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (!Map[cnt2].Extinguisher == pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Inflammable"))
            {
                // add to all incendiary materials
                if (pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (!Map[cnt2].Inflammable == pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Corrosive"))
            {
                // add to all incendiary materials
                if (pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (!Map[cnt2].Corrosive == pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
            else if (SEqualNoCase(pReact->TargetSpec.getData(), "Corrode"))
            {
                // add to all incendiary materials
                if (pReact->fInverseSpec) SetMatReaction(cnt, -1, pReact);
                for (int32_t cnt2=0; cnt2<Num; cnt2++) if (!Map[cnt2].Corrode == pReact->fInverseSpec) SetMatReaction(cnt, cnt2, pReact);
            }
        }
    }
    // second loop (DefaultMatTex is needed by GetIndexMatTex)
    for (cnt=0; cnt<Num; cnt++)
    {
        if (Map[cnt].sBlastShiftTo.getLength())
            Map[cnt].BlastShiftTo=::TextureMap.GetIndexMatTex(Map[cnt].sBlastShiftTo.getData(), nullptr, true, FormatString("BlastShiftTo of mat %s", Map[cnt].Name).getData());
        if (Map[cnt].sInMatConvertTo.getLength())
            Map[cnt].InMatConvertTo=Get(Map[cnt].sInMatConvertTo.getData());
        if (Map[cnt].sBelowTempConvertTo.getLength())
            Map[cnt].BelowTempConvertTo=::TextureMap.GetIndexMatTex(Map[cnt].sBelowTempConvertTo.getData(), nullptr, true, FormatString("BelowTempConvertTo of mat %s", Map[cnt].Name).getData());
        if (Map[cnt].sAboveTempConvertTo.getLength())
            Map[cnt].AboveTempConvertTo=::TextureMap.GetIndexMatTex(Map[cnt].sAboveTempConvertTo.getData(), nullptr, true, FormatString("AboveTempConvertTo of mat %s", Map[cnt].Name).getData());
    }
 
    // Get hardcoded system material indices
    const C4TexMapEntry* earth_entry = ::TextureMap.GetEntry(::TextureMap.GetIndexMatTex(szEarthMaterial));
    if(!earth_entry)
        { LogFatal(FormatString(R"(Earth material "%s" not found!)", szEarthMaterial).getData()); return false; }
 
    MVehic     = Get("Vehicle");     MCVehic     = Mat2PixColDefault(MVehic);
    MHalfVehic = Get("HalfVehicle"); MCHalfVehic = Mat2PixColDefault(MHalfVehic);
    MTunnel    = Get("Tunnel");
    MWater     = Get("Water");
    MEarth     = Get(earth_entry->GetMaterialName());
 
    if ((MVehic==MNone) || (MTunnel==MNone))
        { LogFatal(LoadResStr("IDS_PRC_NOSYSMATS")); return false; }
 
    return true;
}

References C4Material::AboveTempConvertTo, C4Material::BelowTempConvertTo, C4Material::BlastShiftTo, C4MatOv_None, C4MaxMaterial, C4TLS_MatSky, C4MaterialCore::Corrode, C4MaterialCore::Corrosive, C4MaterialCore::CustomReactionList, DebugLogF(), C4Material::DefaultMatTex, DefReactConvert, DefReactCorrode, DefReactIncinerate, DefReactInsert, DefReactPoof, DensityLiquid(), DensitySemiSolid(), DensitySolid(), C4MaterialCore::Extinguisher, C4MaterialReaction::fInverseSpec, FormatString(), Get(), StdStrBuf::getData(), C4TextureMap::GetEntry(), C4TextureMap::GetIndex(), C4TextureMap::GetIndexMatTex(), StdStrBuf::getLength(), C4TexMapEntry::GetMaterialName(), C4TextureMap::GetTexture(), C4TexMapEntry::GetTextureName(), C4Rect::Hgt, C4MaterialReaction::iConvertMat, C4MaterialCore::Incendiary, C4MaterialCore::Inflammable, C4Material::InMatConvertTo, LoadResStr(), LogFatal(), Map, Mat2PixColDefault(), MatDensity(), MaterialMap, MatValid(), max_shape_height, max_shape_width, MCHalfVehic, MCVehic, MEarth, MHalfVehic, MNone, MTunnel, MVehic, MWater, C4MaterialCore::Name, Num, C4MaterialCore::OverlayType, ppReactionMap, C4Material::PXSFace, C4MaterialCore::PXSGfxRt, C4MaterialReaction::sConvertMat, SEqualNoCase(), C4Facet::Set(), SetMatReaction(), C4MaterialCore::sInMatConvert, C4MaterialCore::sPXSGfx, C4MaterialCore::sTextureOverlay, C4Texture::Surface32, C4MaterialReaction::TargetSpec, TextureMap, C4Rect::Wdt, and C4Rect::y.

Referenced by C4Game::InitMaterialTexture().

Here is the call graph for this function:

Here is the caller graph for this function:

Default()

void C4MaterialMap::Default

(

)

Definition at line 641 of file C4Material.cpp.

{
    Num=0;
    Map=nullptr;
    ppReactionMap=nullptr;
    max_shape_width=max_shape_height=0;
}

References Map, max_shape_height, max_shape_width, Num, and ppReactionMap.

Referenced by C4MaterialMap(), and C4Game::Default().

Here is the caller graph for this function:

Get()

int32_t C4MaterialMap::Get

(

const char *

szMaterial

)

Definition at line 365 of file C4Material.cpp.

{
    int32_t cnt;
    for (cnt=0; cnt<Num; cnt++)
        if (SEqualNoCase(szMaterial,Map[cnt].Name))
            return cnt;
    return MNone;
}

References Map, MNone, Num, and SEqualNoCase().

Referenced by CrossMapMaterials(), C4Landscape::DrawChunks(), C4TextureMap::GetIndexMatTex(), C4TexMapEntry::Init(), Load(), C4MCOverlay::SetField(), and C4ToolsDlg::SetTexture().

Here is the call graph for this function:

Here is the caller graph for this function:

GetReaction()

C4MaterialReaction * C4MaterialMap::GetReaction	(	int32_t	iPXSMat,
		int32_t	iLandscapeMat
	)

Definition at line 649 of file C4Material.cpp.

{
    // safety
    if (!ppReactionMap) return nullptr;
    if (!Inside<int32_t>(iPXSMat, -1, Num-1)) return nullptr;
    if (!Inside<int32_t>(iLandscapeMat, -1, Num-1)) return nullptr;
    // values OK; get func!
    return GetReactionUnsafe(iPXSMat, iLandscapeMat);
}

References GetReactionUnsafe(), Num, and ppReactionMap.

Here is the call graph for this function:

GetReactionUnsafe()

C4MaterialReaction* C4MaterialMap::GetReactionUnsafe ( int32_t  iPXSMat, int32_t  iLandscapeMat  )

inline

Definition at line 191 of file C4Material.h.

    {
        assert(ppReactionMap); assert(Inside<int32_t>(iPXSMat,-1,Num-1)); assert(Inside<int32_t>(iLandscapeMat,-1,Num-1));
        return ppReactionMap[(iLandscapeMat+1)*(Num+1) + iPXSMat+1];
    }

References Num, and ppReactionMap.

Referenced by C4MassMover::Corrosion(), C4PXS::Execute(), GetReaction(), and C4Landscape::InsertMaterial().

Here is the caller graph for this function:

HasMaterials()

bool C4MaterialMap::HasMaterials

(

C4Group &

hGroup

)

const

Definition at line 360 of file C4Material.cpp.

{
    return !!hGroup.EntryCount(C4CFN_MaterialFiles);
}

References C4CFN_MaterialFiles, and C4Group::EntryCount().

Here is the call graph for this function:

Load()

int32_t C4MaterialMap::Load

(

C4Group &

hGroup

)

Definition at line 319 of file C4Material.cpp.

{
    char entryname[256+1];
 
    // Determine number of materials in files
    int32_t mat_num=hGroup.EntryCount(C4CFN_MaterialFiles);
 
    // Allocate new map
    C4Material *pNewMap = new C4Material [mat_num + Num];
    if (!pNewMap) return 0;
 
    // Load material cores to map
    hGroup.ResetSearch(); int32_t cnt=0;
    while (hGroup.FindNextEntry(C4CFN_MaterialFiles,entryname))
    {
        if (cnt >= mat_num) {
            Log("Internal Error: More materials loaded than expected. Make sure your material file names are unique (ignoring case).");
            break;
        }
        // Load mat
        if (!pNewMap[cnt].Load(hGroup,entryname))
            { delete [] pNewMap; return 0; }
        // A new material?
        if (Get(pNewMap[cnt].Name) == MNone)
            cnt++;
    }
 
    // Take over old materials.
    for (int32_t i = 0; i < Num; i++)
    {
        pNewMap[cnt+i] = Map[i];
    }
    delete [] Map;
    Map = pNewMap;
 
    // set material number
    Num+=cnt;
 
    return cnt;
}

References C4CFN_MaterialFiles, C4Group::EntryCount(), C4Group::FindNextEntry(), Get(), Log(), Map, MNone, Num, and C4Group::ResetSearch().

Referenced by C4Game::InitMaterialTexture().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadEnumeration()

bool C4MaterialMap::LoadEnumeration

(

C4Group &

hGroup

)

Definition at line 587 of file C4Material.cpp.

{
    // Load enumeration map (from savegame), succeed if not present
    StdStrBuf mapbuf;
    if (!hGroup.LoadEntryString(C4CFN_MatMap, &mapbuf)) return true;
 
    // Sort material array by enumeration map, fail if some missing
    const char *csearch;
    char cmatname[C4M_MaxName+1];
    int32_t cmat=0;
    if (!(csearch = SSearch(mapbuf.getData(),"[Enumeration]"))) { return false; }
    csearch=SAdvanceSpace(csearch);
    while (IsIdentifier(*csearch))
    {
        SCopyIdentifier(csearch,cmatname,C4M_MaxName);
        if (!SortEnumeration(cmat,cmatname))
        {
            // Output error message!
            return false;
        }
        cmat++;
        csearch+=SLen(cmatname);
        csearch=SAdvanceSpace(csearch);
    }
 
    return true;
}

References C4CFN_MatMap, C4M_MaxName, StdStrBuf::getData(), IsIdentifier(), C4Group::LoadEntryString(), SAdvanceSpace(), SCopyIdentifier(), SLen(), SortEnumeration(), and SSearch().

Referenced by C4Game::InitMaterialTexture().

Here is the call graph for this function:

Here is the caller graph for this function:

mrfConvert()

bool C4MaterialMap::mrfConvert ( C4MaterialReaction *  pReaction, int32_t &  iX, int32_t &  iY, int32_t  iLSPosX, int32_t  iLSPosY, C4Real &  fXDir, C4Real &  fYDir, int32_t &  iPxsMat, int32_t  iLsMat, MaterialInteractionEvent  evEvent, bool *  pfPosChanged  )

static

Definition at line 753 of file C4Material.cpp.

{
    if (pReaction->fUserDefined) if (!mrfUserCheck(pReaction, iX, iY, iLSPosX, iLSPosY, fXDir, fYDir, iPxsMat, iLsMat, evEvent, pfPosChanged)) return false;
    switch (evEvent)
    {
    case meePXSMove: // PXS movement
        // for hardcoded stuff: only InMatConvert is Snow in Water, which does not have any collision proc
        if (!pReaction->fUserDefined) break;
        // user-defined conversions may also convert upon hitting materials
 
    case meePXSPos: // PXS check before movement
    {
        // Check depth
        int32_t iDepth = pReaction->fUserDefined ? pReaction->iDepth : ::MaterialMap.Map[iPxsMat].InMatConvertDepth;
        if (!iDepth || GBackMat(iX, iY - iDepth) == iLsMat)
        {
            // Convert
            iPxsMat = pReaction->fUserDefined ? pReaction->iConvertMat : ::MaterialMap.Map[iPxsMat].InMatConvertTo;
            if (!MatValid(iPxsMat))
                // Convert failure (target mat not be loaded, or target may be C4TLS_MatSky): Kill Pix
                return true;
            // stop movement after conversion
            fXDir = fYDir = 0;
            if (pfPosChanged) *pfPosChanged = true;
        }
    }
    break;
 
    case meeMassMove: // MassMover-movement
        // Conversion-transfer to PXS
        ::PXS.Create(iPxsMat,itofix(iX),itofix(iY));
        return true;
    }
    // not handled
    return false;
}

References C4PXSSystem::Create(), C4MaterialReaction::fUserDefined, GBackMat(), C4MaterialReaction::iConvertMat, C4MaterialReaction::iDepth, C4MaterialCore::InMatConvertDepth, C4Material::InMatConvertTo, itofix(), Map, MaterialMap, MatValid(), meeMassMove, meePXSMove, meePXSPos, mrfUserCheck(), and PXS.

Here is the call graph for this function:

mrfCorrode()

bool C4MaterialMap::mrfCorrode ( C4MaterialReaction *  pReaction, int32_t &  iX, int32_t &  iY, int32_t  iLSPosX, int32_t  iLSPosY, C4Real &  fXDir, C4Real &  fYDir, int32_t &  iPxsMat, int32_t  iLsMat, MaterialInteractionEvent  evEvent, bool *  pfPosChanged  )

static

Definition at line 819 of file C4Material.cpp.

{
    if (pReaction->fUserDefined) if (!mrfUserCheck(pReaction, iX, iY, iLSPosX, iLSPosY, fXDir, fYDir, iPxsMat, iLsMat, evEvent, pfPosChanged)) return false;
    switch (evEvent)
    {
    case meePXSPos: // PXS check before movement
        // No corrosion - it would make acid incredibly effective
        break;
    case meeMassMove: // MassMover-movement
    {
        // evaluate corrosion percentage
        bool fDoCorrode; int d100 = Random(100);
        if (pReaction->fUserDefined)
            fDoCorrode = (d100 < pReaction->iCorrosionRate);
        else
            fDoCorrode = (d100 < ::MaterialMap.Map[iPxsMat].Corrosive) && (d100 < ::MaterialMap.Map[iLsMat].Corrode);
        if (fDoCorrode)
        {
            ::Landscape.ClearPix(iLSPosX,iLSPosY);
            //::Landscape.CheckInstabilityRange(iLSPosX,iLSPosY); - more correct, but makes acid too effective as well
            if (!Random(5))
            {
                Smoke(iX, iY, 3 + Random(3));
            }
            if (!Random(20)) StartSoundEffectAt("Liquids::Corrode", iX, iY);
            return true;
        }
    }
    break;
 
    case meePXSMove: // PXS movement
    {
        // corrodes to corrosives are always same density proc; so do insertion check first
        if (!pReaction->fUserDefined)
            if (!mrfInsertCheck(iX, iY, fXDir, fYDir, iPxsMat, iLsMat, pfPosChanged))
                // either splash or slide prevented interaction
                return false;
        // evaluate corrosion percentage
        bool fDoCorrode; int d100 = Random(100);
        if (pReaction->fUserDefined)
            fDoCorrode = (d100 < pReaction->iCorrosionRate);
        else
            fDoCorrode = (d100 < ::MaterialMap.Map[iPxsMat].Corrosive) && (d100 < ::MaterialMap.Map[iLsMat].Corrode);
        if (fDoCorrode)
        {
            ::Landscape.ClearPix(iLSPosX,iLSPosY);
            ::Landscape.CheckInstabilityRange(iLSPosX,iLSPosY);
            if (!Random(5))
            {
                Smoke(iX,iY,3+Random(3));
            }
            if (!Random(20)) StartSoundEffectAt("Liquids::Corrode", iX, iY);
            return true;
        }
        // Else: dead. Insert material here
        ::Landscape.InsertMaterial(iPxsMat,&iX,&iY);
        return true;
    }
    }
    // not handled
    return false;
}

References C4Landscape::ClearPix(), C4MaterialCore::Corrode, C4MaterialCore::Corrosive, C4MaterialReaction::fUserDefined, C4MaterialReaction::iCorrosionRate, Landscape, Map, MaterialMap, meeMassMove, meePXSPos, mrfUserCheck(), and Random().

Here is the call graph for this function:

mrfIncinerate()

bool C4MaterialMap::mrfIncinerate ( C4MaterialReaction *  pReaction, int32_t &  iX, int32_t &  iY, int32_t  iLSPosX, int32_t  iLSPosY, C4Real &  fXDir, C4Real &  fYDir, int32_t &  iPxsMat, int32_t  iLsMat, MaterialInteractionEvent  evEvent, bool *  pfPosChanged  )

static

Definition at line 882 of file C4Material.cpp.

{
    // not available as user reaction
    assert(!pReaction->fUserDefined);
    switch (evEvent)
    {
    case meeMassMove: // MassMover-movement
    case meePXSPos: // PXS check before movement
        if (::Landscape.Incinerate(iX, iY, NO_OWNER)) return true;
        break;
 
    case meePXSMove: // PXS movement
        // incinerate to inflammables are always same density proc; so do insertion check first
        if (!mrfInsertCheck(iX, iY, fXDir, fYDir, iPxsMat, iLsMat, pfPosChanged))
            // either splash or slide prevented interaction
            return false;
        // evaluate inflammation (should always succeed)
        if (::Landscape.Incinerate(iX, iY, NO_OWNER)) return true;
        // Else: dead. Insert material here
        ::Landscape.InsertMaterial(iPxsMat,&iX,&iY);
        return true;
    }
    // not handled
    return false;
}

References C4MaterialReaction::fUserDefined, C4Landscape::Incinerate(), C4Landscape::InsertMaterial(), Landscape, meeMassMove, meePXSMove, meePXSPos, mrfInsertCheck(), and NO_OWNER.

Here is the call graph for this function:

mrfInsert()

bool C4MaterialMap::mrfInsert ( C4MaterialReaction *  pReaction, int32_t &  iX, int32_t &  iY, int32_t  iLSPosX, int32_t  iLSPosY, C4Real &  fXDir, C4Real &  fYDir, int32_t &  iPxsMat, int32_t  iLsMat, MaterialInteractionEvent  evEvent, bool *  pfPosChanged  )

static

Definition at line 908 of file C4Material.cpp.

{
    if (pReaction->fUserDefined) if (!mrfUserCheck(pReaction, iX, iY, iLSPosX, iLSPosY, fXDir, fYDir, iPxsMat, iLsMat, evEvent, pfPosChanged)) return false;
    switch (evEvent)
    {
    case meePXSPos: // PXS check before movement
        break;
 
    case meePXSMove: // PXS movement
    {
        // check for bounce/slide
        if (!pReaction->fUserDefined)
            if (!mrfInsertCheck(iX, iY, fXDir, fYDir, iPxsMat, iLsMat, pfPosChanged))
                // continue existing
                return false;
        // Else: dead. Insert material here
        ::Landscape.InsertMaterial(iPxsMat,&iX,&iY);
        return true;
    }
 
    case meeMassMove: // MassMover-movement
        break;
    }
    // not handled
    return false;
}

References C4MaterialReaction::fUserDefined, C4Landscape::InsertMaterial(), Landscape, meeMassMove, meePXSMove, meePXSPos, mrfInsertCheck(), and mrfUserCheck().

Here is the call graph for this function:

mrfPoof()

bool C4MaterialMap::mrfPoof ( C4MaterialReaction *  pReaction, int32_t &  iX, int32_t &  iY, int32_t  iLSPosX, int32_t  iLSPosY, C4Real &  fXDir, C4Real &  fYDir, int32_t &  iPxsMat, int32_t  iLsMat, MaterialInteractionEvent  evEvent, bool *  pfPosChanged  )

static

Definition at line 790 of file C4Material.cpp.

{
    if (pReaction->fUserDefined) if (!mrfUserCheck(pReaction, iX, iY, iLSPosX, iLSPosY, fXDir, fYDir, iPxsMat, iLsMat, evEvent, pfPosChanged)) return false;
    switch (evEvent)
    {
    case meeMassMove: // MassMover-movement
    case meePXSPos: // PXS check before movement: Kill both landscape and PXS mat
        ::Landscape.ExtractMaterial(iLSPosX,iLSPosY,false);
        if (!Random(3)) Smoke(iX,iY,3);
        if (!Random(3)) StartSoundEffectAt("Liquids::Pshshsh", iX, iY);
        return true;
 
    case meePXSMove: // PXS movement
        // incindiary/extinguisher/corrosives are always same density proc; so do insertion check first
        // Do not allow sliding though (e.g. water on lava).
        if (!pReaction->fUserDefined)
            if (!mrfInsertCheck(iX, iY, fXDir, fYDir, iPxsMat, iLsMat, pfPosChanged, true))
                // either splash or slide prevented interaction
                return false;
        // Always kill both landscape and PXS mat
        ::Landscape.ExtractMaterial(iLSPosX,iLSPosY,false);
        if (!Random(3)) Smoke(iX,iY,3);
        if (!Random(3)) StartSoundEffectAt("Liquids::Pshshsh", iX, iY);
        return true;
    }
    // not handled
    return false;
}

References C4Landscape::ExtractMaterial(), C4MaterialReaction::fUserDefined, Landscape, meeMassMove, meePXSPos, mrfUserCheck(), and Random().

Here is the call graph for this function:

mrfScript()

bool C4MaterialMap::mrfScript ( C4MaterialReaction *  pReaction, int32_t &  iX, int32_t &  iY, int32_t  iLSPosX, int32_t  iLSPosY, C4Real &  fXDir, C4Real &  fYDir, int32_t &  iPxsMat, int32_t  iLsMat, MaterialInteractionEvent  evEvent, bool *  pfPosChanged  )

static

Definition at line 935 of file C4Material.cpp.

{
    // do generic checks for user-defined reactions
    if (!mrfUserCheck(pReaction, iX, iY, iLSPosX, iLSPosY, fXDir, fYDir, iPxsMat, iLsMat, evEvent, pfPosChanged))
        return false;
 
    // check script func
    if (!pReaction->pScriptFunc) return false;
    // OK - let's call it!
    //                      0           1           2                3                        4                           5                      6               7              8
    int32_t iXDir1, iYDir1, iXDir2, iYDir2;
    C4AulParSet pars(iX, iY, iLSPosX, iLSPosY, iXDir1 = fixtoi(fXDir, 100), iYDir1 = fixtoi(fYDir, 100), iPxsMat, iLsMat, int(evEvent));
    if (!!pReaction->pScriptFunc->Exec(nullptr, &pars, false))
    {
        // PXS shall be killed!
        return true;
    }
    // PXS shall exist further: write back parameters
    iPxsMat = pars[6].getInt();
    int32_t iX2 = pars[0].getInt(), iY2 = pars[1].getInt();
    iXDir2 = pars[4].getInt(); iYDir2 = pars[5].getInt();
    if (iX!=iX2 || iY!=iY2 || iXDir1!=iXDir2 || iYDir1!=iYDir2)
    {
        // changes to pos/speed detected
        if (pfPosChanged) *pfPosChanged = true;
        iX=iX2; iY=iY2;
        fXDir = C4REAL100(iXDir2);
        fYDir = C4REAL100(iYDir2);
    }
    // OK; done
    return false;
}

References C4REAL100(), C4AulFunc::Exec(), fixtoi(), mrfUserCheck(), and C4MaterialReaction::pScriptFunc.

Referenced by C4MaterialReaction::ResolveScriptFuncs().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveEnumeration()

bool C4MaterialMap::SaveEnumeration

(

C4Group &

hGroup

)

Definition at line 574 of file C4Material.cpp.

{
    char *mapbuf = new char [1000];
    mapbuf[0]=0;
    SAppend("[Enumeration]",mapbuf); SAppend("\n",mapbuf);
    for (int32_t cnt=0; cnt<Num; cnt++)
    {
        SAppend(Map[cnt].Name,mapbuf);
        SAppend("\n",mapbuf);
    }
    return hGroup.Add(C4CFN_MatMap,mapbuf,SLen(mapbuf),false,true);
}

References C4Group::Add(), C4CFN_MatMap, Map, Num, SAppend(), and SLen().

Here is the call graph for this function:

SetMatReaction()

void C4MaterialMap::SetMatReaction ( int32_t  iPXSMat, int32_t  iLSMat, C4MaterialReaction *  pReact  )

protected

Definition at line 566 of file C4Material.cpp.

{
    // evaluate reaction swap
    if (pReact && pReact->fReverse) std::swap(iPXSMat, iLSMat);
    // set it
    ppReactionMap[(iLSMat+1)*(Num+1) + iPXSMat+1] = pReact;
}

References C4MaterialReaction::fReverse, Num, and ppReactionMap.

Referenced by CrossMapMaterials().

Here is the caller graph for this function:

SortEnumeration()

bool C4MaterialMap::SortEnumeration ( int32_t  iMat, const char *  szMatName  )

protected

Definition at line 615 of file C4Material.cpp.

{
 
    // Not enough materials loaded
    if (iMat>=Num) return false;
 
    // Find requested mat
    int32_t cmat;
    for (cmat=iMat; cmat<Num; cmat++)
        if (SEqual(szMatName,Map[cmat].Name))
            break;
    // Not found
    if (cmat>=Num) return false;
 
    // already the same?
    if (cmat == iMat) return true;
 
    // Move requested mat to indexed position
    C4Material mswap;
    mswap = Map[iMat];
    Map[iMat] = Map[cmat];
    Map[cmat] = mswap;
 
    return true;
}

References Map, Num, and SEqual().

Referenced by LoadEnumeration().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateScriptPointers()

void C4MaterialMap::UpdateScriptPointers

(

)

Definition at line 968 of file C4Material.cpp.

{
    // update in all materials
    for (int32_t i=0; i<Num; ++i) Map[i].UpdateScriptPointers();
}

References Map, and Num.

Referenced by C4Game::InitMaterialTexture(), C4Game::LinkScriptEngine(), and C4Game::ReLinkScriptEngine().

Here is the caller graph for this function:

Member Data Documentation

DefReactConvert

C4MaterialReaction C4MaterialMap::DefReactConvert

Definition at line 173 of file C4Material.h.

Referenced by CrossMapMaterials().

DefReactCorrode

C4MaterialReaction C4MaterialMap::DefReactCorrode

Definition at line 173 of file C4Material.h.

Referenced by CrossMapMaterials().

DefReactIncinerate

C4MaterialReaction C4MaterialMap::DefReactIncinerate

Definition at line 173 of file C4Material.h.

Referenced by CrossMapMaterials().

DefReactInsert

C4MaterialReaction C4MaterialMap::DefReactInsert

Definition at line 173 of file C4Material.h.

Referenced by CrossMapMaterials().

DefReactPoof

C4MaterialReaction C4MaterialMap::DefReactPoof

Definition at line 173 of file C4Material.h.

Referenced by CrossMapMaterials().

Map

C4Material* C4MaterialMap::Map

Definition at line 169 of file C4Material.h.

Referenced by C4Landscape::_SetPix2(), C4EditCursor::ApplyToolPicker(), C4Landscape::P::BlastFreePix(), C4Landscape::P::BlastMaterial2Objects(), C4Landscape::CheckInstability(), Clear(), CrossMapMaterials(), Default(), C4Landscape::P::DigFreePix(), C4Landscape::P::DigFreePixNoInstability(), C4Landscape::P::DigMaterial2Objects(), C4Landscape::P::DoScan(), C4PXSSystem::Draw(), C4Landscape::DrawChunks(), C4MCOverlay::Evaluate(), C4Object::ExecLife(), C4MassMover::Execute(), C4PXS::Execute(), C4Landscape::P::ExecuteScan(), C4Landscape::FindMatTop(), Get(), C4TextureMap::GetIndexMatTex(), C4Landscape::Incinerate(), C4TexMapEntry::Init(), C4Landscape::InsertMaterial(), Load(), Mat2PixColDefault(), MatDensity(), MatDigFree(), MatPlacement(), mrfConvert(), mrfCorrode(), mrfInsertCheck(), C4Landscape::RemoveUnusedTexMapEntries(), SaveEnumeration(), C4ToolsDlg::SetTexture(), C4Landscape::P::ShakeFreePix(), SortEnumeration(), C4Landscape::P::UpdateMatCnt(), C4Landscape::UpdatePixMaps(), UpdateScriptPointers(), and C4EditCursor::UpdateStatusBar().

max_shape_height

int32_t C4MaterialMap::max_shape_height

Definition at line 171 of file C4Material.h.

Referenced by CrossMapMaterials(), Default(), and C4Landscape::P::MapToSurface().

max_shape_width

int32_t C4MaterialMap::max_shape_width

Definition at line 171 of file C4Material.h.

Referenced by CrossMapMaterials(), Default(), and C4Landscape::P::MapToSurface().

Num

int32_t C4MaterialMap::Num

Definition at line 168 of file C4Material.h.

Referenced by C4Landscape::P::BlastMaterial2Objects(), Clear(), CrossMapMaterials(), Default(), C4Landscape::P::DigMaterial2Objects(), C4MCOverlay::Evaluate(), C4Landscape::P::ExecuteScan(), Get(), C4Landscape::P::GetBridgeMatConversion(), GetReaction(), GetReactionUnsafe(), Load(), MatValid(), C4Landscape::RemoveUnusedTexMapEntries(), SaveEnumeration(), SetMatReaction(), SortEnumeration(), and UpdateScriptPointers().

ppReactionMap

C4MaterialReaction** C4MaterialMap::ppReactionMap

Definition at line 170 of file C4Material.h.

Referenced by Clear(), CrossMapMaterials(), Default(), GetReaction(), GetReactionUnsafe(), and SetMatReaction().

---

The documentation for this class was generated from the following files:

• C4Material.h
• C4Material.cpp