CWE-ou-minkata/Sources/Tools/MaxComponent/plInventoryObjComponent.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "HeadSpin.h"
#include "plInventoryObjComponent.h"                            //Inventory Dependencies

#include "resource.h"                                           //Resource Dependencies
#include "hsResMgr.h"                       // Ibid
    
#include "plComponent.h"                                        //Component Dependencies
#include "plComponentReg.h"                                     // Ibid
#include "pnSceneObject/plSceneObject.h"                     // Ibid
#include "pnKeyedObject/hsKeyedObject.h"                     // Ibid
#include "MaxMain/plMaxNode.h"                               // Ibid
#include "plResponderComponent.h"


#include "plPhysical/plCollisionDetector.h"                     //Modifiers Dependencies
#include "plModifier/plLogicModifier.h"                         // Ibid
#include "plModifier/plAxisAnimModifier.h"                      // Ibid
#include "pnModifier/plConditionalObject.h"                     // Ibid
#include "plPhysical/plPickingDetector.h"                       // Ibid
#include "pfConditional/plActivatorConditionalObject.h"         // Ibid
#include "pfConditional/plFacingConditionalObject.h"            // Ibid
#include "pfConditional/plObjectInBoxConditionalObject.h"       // Ibid

#include "pnMessage/plObjRefMsg.h"                           //Message Dependencies
#include "pnMessage/plNotifyMsg.h"                           // Ibid
#include "pnMessage/plCursorChangeMsg.h"                     // Ibid


#include "MaxConvert/plConvert.h"


//
//  DummyCodeIncludeFuncInventStuff Function.
//      Necessary to keep the compiler from throwing away this file.
//      No functions within are inherently called otherwise....
//
//


void DummyCodeIncludeFuncInventStuff() {}




CLASS_DESC(plInventoryObjComponent, gInventoryObjDesc, "(ex)InventoryObj",  "(ex)InventoryObj", COMP_TYPE_LOGIC, INVENTORYOBJCOMP_CID)


enum
{
    kClickDragDirectional,
    kClickDragDegrees,
    kClickDragUseProxy,
    kClickDragProxy,
    kClickDragUseRegion,
    kClickDragProxyRegion,
    kClickDragUseX,
    kClickDragUseY,
    kClickDragAnimX,
    kClickDragAnimY,
    kClickDragUseLoopX,
    kClickDragUseLoopY,
    kClickDragLoopAnimX,
    kClickDragLoopAnimY,
    kAgeSpecificCheckBx,        //Added in v1
    kRespawnAfterLostCheckBx,   //Added in v1
    kConsumableCheckbx,         //Added in v1
    kLifeSpan                   //Added in v1
};


class plInventoryObjComponentProc;
extern plInventoryObjComponentProc gInventoryObjComponentProc;

ParamBlockDesc2 gInventoryObjBlock
(
    plComponent::kBlkComp, _T("ClickDragComp"), 0, &gInventoryObjDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_INV_OBJECT, IDS_COMP_INV_OBJECTS, 0, 0, NULL, //&gInventoryObjComponentProc,

    kAgeSpecificCheckBx,  _T("AgeSpecificObject"), TYPE_BOOL,       0, 0,
        p_default,  FALSE,
        p_enable_ctrls, 1, kRespawnAfterLostCheckBx,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_INV_OBJECT_ITINERANTBOOL,
        end,

    kRespawnAfterLostCheckBx,  _T("RespawnAtSPObject"), TYPE_BOOL,      0, 0,
        p_default,  FALSE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_INV_OBJECT_RESPAWNBOOL,
        end,
    
    kConsumableCheckbx , _T("TemporaryObject"), TYPE_BOOL,      0, 0,
        p_default,  FALSE,
        p_enable_ctrls, 1, kLifeSpan,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_INV_OBJECT_CONSUMABLE,
        end,    

    kLifeSpan,  _T("LifeSpan"), TYPE_FLOAT,     P_ANIMATABLE, 0,    
        p_default, 0.0,
        p_range, 0.0, 100000.0,
        p_ui,   TYPE_SPINNER,   EDITTYPE_POS_FLOAT, 
        IDC_COMP_INV_OBJECT_LIFE_EDIT, IDC_COMP_INV_OBJECT_LIFE_SPIN, 1.0f,
        end,



    end
);

plInventoryObjComponent::plInventoryObjComponent()
{
    fClassDesc = &gInventoryObjDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

const plInventoryObjComponent::LogicKeys& plInventoryObjComponent::GetLogicKeys()
{
    return fLogicModKeys;
}

// Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plInventoryObjComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
    fLogicModKeys.clear();
    fReceivers.Reset();
    return true;
}

plKey plInventoryObjComponent::GetLogicKey(plMaxNode* node)
{
    LogicKeys::const_iterator it;
    
    for (it = fLogicModKeys.begin(); it != fLogicModKeys.end(); it++)
    {
        if (node == it->first)
            return(it->second);
    }
    return nil;
}


hsBool plInventoryObjComponent::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{
    plLocation loc = node->GetLocation();
    plSceneObject *obj = node->GetSceneObject();

    // Create and register the ClickDrag's logic component
    plLogicModifier *logic = TRACKED_NEW plLogicModifier;
    char tmpName[256];
    sprintf(tmpName, "%s_%s_LogicModifier", obj->GetKeyName(), GetINode()->GetName());
    plKey logicKey = hsgResMgr::ResMgr()->NewKey(tmpName, logic, node->GetLocation());
    hsgResMgr::ResMgr()->AddViaNotify(logicKey, TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);

    fLogicModKeys[node] = logicKey;



return true;
}

void plInventoryObjComponent::AddReceiverKey(plKey key, plMaxNode* node)
{
    fReceivers.Append(key);
}

hsBool plInventoryObjComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
    return true;
}

#include "plNoteTrackDlgComp.h"

class plInventoryObjComponentProc : public ParamMap2UserDlgProc
{
protected:
    plComponentNoteTrackDlg fNoteTrackDlgX;
    plComponentNoteTrackDlg fNoteTrackDlgY;
    IParamBlock2 *fPB;

public:
    BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        switch (msg)
        {
        case WM_INITDIALOG:
//          fPB = map->GetParamBlock();
/*          
//          fNoteTrackDlgX.Init(GetDlgItem(hWnd, IDC_COMP_CLICK_DRAG_ANIMX),
//                              nil,
///                             kClickDragAnimX,
/                               nil,
                                fPB,
                                fPB->GetOwner());

            fNoteTrackDlgX.Load();

            EnableWindow(GetDlgItem(hWnd, IDC_COMP_CLICK_DRAG_ANIMX), true);
            
            fNoteTrackDlgY.Init(GetDlgItem(hWnd, IDC_COMP_CLICK_DRAG_ANIM_Y),
                                nil,
                                kClickDragAnimY,
                                nil,
                                fPB,
                                fPB->GetOwner());

            fNoteTrackDlgY.Load();

            EnableWindow(GetDlgItem(hWnd, IDC_COMP_CLICK_DRAG_ANIM_Y), true);
*/
        return TRUE;
/*
        case WM_COMMAND:
            if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_COMP_CLICK_DRAG_ANIMX)
            {
                fNoteTrackDlgX.AnimChanged();
                return TRUE;
            }
            if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_COMP_CLICK_DRAG_ANIM_Y)
            {
                fNoteTrackDlgY.AnimChanged();
                return TRUE;
            }
            break;
            */
        }

        return false;   
    }

    void DeleteThis()
    {
//      fNoteTrackDlgX.DeleteCache();
//      fNoteTrackDlgY.DeleteCache();
    }
};
static plInventoryObjComponentProc gInventoryObjComponentProc;