CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Tools/MaxComponent/plClimbComponent.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"
// max includes
#include "plPickNode.h"
#include "resource.h"

// local
#include "plClimbComponent.h"
#include "plPhysicalComponents.h"	// so we can pick terrains
#include "plComponentReg.h"

// other
#include "../MaxMain/plMaxNode.h"
#include "../plMessage/plClimbMsg.h"
#include "../plPhysical/plCollisionDetector.h"
#include "../MaxMain/plPhysicalProps.h"
#include "../plPhysical/plSimDefs.h"
#include "../pnSceneObject/plSceneObject.h"

// stl
#include <map>

/////////////////////////////////////////////////////////////////
//
// THE DUMMY
//
/////////////////////////////////////////////////////////////////
void DummyCodeIncludeFuncClimbTrigger() {}

/////////////////////////////////////////////////////////////////
//
// SOME ENUMS
//
/////////////////////////////////////////////////////////////////
// CLIMBCOMMANDS
enum Commands
{
	kMount				= 0,
	kEnableDismount		= 1,
	kDisableDismount	= 2,
	kEnableClimb		= 3,
	kDisableClimb		= 4,
	kFallOff			= 5,
	kRelease			= 6,
	kMaxCommands		= 7
};

// these synchronized ^^^^VVVVV
const char * fCommandStrs[] =
{
	"Start Climbing",
	"Enable Dismount",
	"Disable Dismount",
	"Enable Climb",
	"Disable Climb",
	"Fall Off",
	"Let Go"
};

enum Directions
{
	kUp		= 0,
	kDown	= 1,
	kLeft	= 2,
	kRight  = 3,
	kMaxDirections
};

const char * fDirectionStrs[] =
{
	"Up",
	"Down",
	"Left",
	"Right"
};


/////////////////////////////////////////////////////////////////
//
// CLASS DESCRIPTOR AND PARAM BLOCK
//
/////////////////////////////////////////////////////////////////

// CLASS DESCRIPTOR
CLASS_DESC(plClimbTriggerComponent, gClimbTriggerDesc, "Avatar ClimbTrigger",  "AvatarClimbTrigger", COMP_TYPE_AVATAR, CLIMB_TRIGGER_COMPONENT_CLASS_ID)

// FORWARD REFERENCE OT THE COMPONENT DIALOG PROC
static plClimbTriggerComponentProc gClimbTriggerComponentProc;

// PARAM BLOCK
ParamBlockDesc2 gClimbTriggerBk
(	

	plComponent::kBlkComp, _T("ClimbTrigger"), 0, &gClimbTriggerDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	//Roll out
	IDD_COMP_CLIMB_TRIGGER, IDS_COMP_CLIMB_TRIGGER, 0, 0, &gClimbTriggerComponentProc,

	plClimbTriggerComponent::kCommand, _T("Command"),	TYPE_INT, 0, 0,
		p_default, kMount,
		end,

	plClimbTriggerComponent::kDirection, _T("Direction"),	TYPE_INT, 0, 0,
		p_default, kUp,
		end,

	plClimbTriggerComponent::kWallPicker, _T("WallPicker"),	TYPE_INODE,		0, 0,
		end,

	end
);

/////////////////////////////////////////////////////////////////
//
// PLCLIMBTRIGGER IMPLEMENTATION
//
/////////////////////////////////////////////////////////////////

// CTOR
plClimbTriggerComponent::plClimbTriggerComponent()
{
	fClassDesc = &gClimbTriggerDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

extern const plArmatureMod * FindArmatureMod(const plSceneObject *obj);

// CONVERT
hsBool plClimbTriggerComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
	plClimbMsg::Command enterCommand;		// when entering the region
	plClimbMsg::Command exitCommand;		// run this command when exiting the region
	hsBool enterStatus = false;
	hsBool exitStatus = false;
	plClimbMsg::Direction direction;		// direction is assumed the same for both enter and exit commands
											// i.e. enable up, disable up

	int iCommand = fCompPB->GetInt(plClimbTriggerComponent::kCommand);
	int iDirection = fCompPB->GetInt(plClimbTriggerComponent::kDirection);

	switch(iCommand)
	{
	case kMount:
		enterCommand = plClimbMsg::kStartClimbing;
		exitCommand = plClimbMsg::kNoCommand;
		break;
	case kEnableClimb:
		enterCommand = plClimbMsg::kEnableClimb;
		enterStatus = true;
		exitCommand = plClimbMsg::kEnableClimb;
		exitStatus = false;
		break;
	case kDisableClimb:
		enterCommand = plClimbMsg::kEnableClimb;
		enterStatus = false;
		exitCommand = plClimbMsg::kEnableClimb;
		exitStatus = true;
		break;
	case kEnableDismount:
		enterCommand = plClimbMsg::kEnableDismount;
		enterStatus = true;
		exitCommand = plClimbMsg::kEnableDismount;
		exitStatus = false;
		break;
	case kDisableDismount:
		enterCommand = plClimbMsg::kEnableDismount;
		enterStatus = false;
		exitCommand = plClimbMsg::kEnableDismount;
		exitStatus = true;
		break;
	case kFallOff:
		enterCommand = plClimbMsg::kFallOff;
		exitCommand = plClimbMsg::kNoCommand;
		break;
	case kRelease:
		enterCommand = plClimbMsg::kRelease;
		exitCommand = plClimbMsg::kNoCommand;
		break;
	}

	switch(iDirection)
	{
	case kUp:
		direction = plClimbMsg::kUp;
		break;
	case kDown:
		direction = plClimbMsg::kDown;
		break;
	case kLeft:
		direction = plClimbMsg::kLeft;
		break;
	case kRight:
		direction = plClimbMsg::kRight;
		break;
	}

	plKey nilKey = nil;
	plKey target = node->GetSceneObject()->GetKey();
	plClimbMsg *enterMsg = nil;
	if(enterCommand != plClimbMsg::kNoCommand)
	{
		enterMsg = TRACKED_NEW plClimbMsg(nilKey, nilKey, enterCommand, direction, enterStatus, target);
		enterMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
		enterMsg->SetBCastFlag(plMessage::kNetPropagate);
		enterMsg->SetBCastFlag(plMessage::kNetForce);
	}

	plClimbMsg *exitMsg = nil;
	if(exitCommand != nil)
	{
		exitMsg = TRACKED_NEW plClimbMsg(nilKey, nilKey, exitCommand, direction, exitStatus, target);
		exitMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
		exitMsg->SetBCastFlag(plMessage::kNetPropagate);
		exitMsg->SetBCastFlag(plMessage::kNetForce);
	}

	plSimpleRegionSensor *sensMod = TRACKED_NEW plSimpleRegionSensor(enterMsg, exitMsg);
	node->AddModifier(sensMod, IGetUniqueName(node));
	
	return true;
}

hsBool plClimbTriggerComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
 	node->SetForceLocal(true);
	node->SetDrawable(false);

	plPhysicalProps *props = node->GetPhysicalProps();

	// only if movable will it have mass (then it will keep track of movements in PhysX)
	if ( node->IsMovable() || node->IsTMAnimatedRecur() )
 		props->SetMass(1.0, node, pErrMsg);
 	props->SetFriction(0.0, node, pErrMsg);
 	props->SetRestitution(0.0, node, pErrMsg);
	props->SetBoundsType(plSimDefs::kExplicitBounds, node, pErrMsg);
	props->SetGroup(plSimDefs::kGroupDetector, node, pErrMsg);
	props->SetReportGroup(1<<plSimDefs::kGroupAvatar, node, pErrMsg);
//	props->SetPinned(true, node, pErrMsg);

	return true;
}


/////////////////////////////////////////////////////////////////
//
// DIALOG PROC IMPLEMENTATION
//
/////////////////////////////////////////////////////////////////
BOOL plClimbTriggerComponentProc::DlgProc(TimeValue t, IParamMap2 *pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	IParamBlock2 *pb = pm->GetParamBlock();
	HWND hCommandMenu = GetDlgItem(hWnd, IDC_COMP_CLIMB_COMMAND);
	HWND hDirectionMenu = GetDlgItem(hWnd, IDC_COMP_CLIMB_DIRECTION);
	HWND hPick = GetDlgItem(hWnd, IDC_COMP_WALL_PICK);
	INode *curPick = nil;
	int curSurface = 0;

	switch (msg)
	{
	case WM_INITDIALOG:
		{
			int i = 0;
			// fill out the command menu
			for (i = 0; i < kMaxCommands; i++)
				ComboBox_AddString(hCommandMenu, fCommandStrs[i]);
			// reflect the current selection
			ComboBox_SetCurSel(hCommandMenu, pb->GetInt(ParamID(plClimbTriggerComponent::kCommand)));

			// fill out the direction menu
			for (i = 0; i < kMaxDirections; i++)
				ComboBox_AddString(hDirectionMenu, fDirectionStrs[i]);
			// reflect the current selection
			ComboBox_SetCurSel(hDirectionMenu, pb->GetInt(ParamID(plClimbTriggerComponent::kDirection)));

			// show the name of the currently picked item
			curPick = pb->GetINode(ParamID(plClimbTriggerComponent::kWallPicker));
			Button_SetText(hPick, (curPick == nil ? "None" : curPick->GetName()));
		}
		return TRUE;
		break;


	case WM_COMMAND:
		if (HIWORD(wParam) == BN_CLICKED)
		{
			if (LOWORD(wParam) == IDC_COMP_WALL_PICK)
			{
				// we're picking a new climbing wall
				std::vector<Class_ID> pickableClasses;
				pickableClasses.push_back(PHYSICS_TERRAIN_CID);		// allow picking terrains
				pickableClasses.push_back(PHYS_CLIMBABLE_CID);		// and climbables
				if (plPick::NodeRefKludge(pb, plClimbTriggerComponent::kWallPicker, &pickableClasses, true, false))			
				{
					curPick = pb->GetINode(ParamID(plClimbTriggerComponent::kWallPicker));
					Button_SetText(hPick, (curPick == nil ? "None" : curPick->GetName()));
				}
			
				return TRUE;
			}
		}
		else if (LOWORD(wParam) == IDC_COMP_CLIMB_COMMAND)
		{
			HWND hSurface = GetDlgItem(hWnd, IDC_COMP_CLIMB_COMMAND);
			curSurface = ComboBox_GetCurSel(hSurface);
			pb->SetValue(ParamID(plClimbTriggerComponent::kCommand), 0, curSurface);
		}
		else if (LOWORD(wParam) == IDC_COMP_CLIMB_DIRECTION)
		{
			HWND hSurface = GetDlgItem(hWnd, IDC_COMP_CLIMB_DIRECTION);
			curSurface = ComboBox_GetCurSel(hSurface);
			pb->SetValue(ParamID(plClimbTriggerComponent::kDirection), 0, curSurface);
		}
	}

	return FALSE;
}




/////////////////////////////////////////////////////////////////////////////////////////
//
//	CLIMB BLOCKER COMPONENT
//
/////////////////////////////////////////////////////////////////////////////////////////

//Class that accesses the paramblock below.
class plClimbBlockerComponent : public plComponent
{
public:
	plClimbBlockerComponent();

	// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
	// of properties on the MaxNode, as it's still indeterminant.
	hsBool SetupProperties(plMaxNode *pNode, plErrorMsg *pErrMsg);
	hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};

//Max desc stuff necessary below.
CLASS_DESC(plClimbBlockerComponent, gClimbBlockDesc, "Climb Blocker",  "ClimbBlocker", COMP_TYPE_AVATAR, Class_ID(0x170000ac, 0x3cee02c5))

ParamBlockDesc2 gClimbBlockBk
(
	plComponent::kBlkComp, _T("Climb Blocker"), 0, &gClimbBlockDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

	IDD_COMP_CLIMB_BLOCK, IDS_COMP_CLIMB_BLOCKER, 0, 0, NULL,

	end
);

plClimbBlockerComponent::plClimbBlockerComponent()
{
	fClassDesc = &gClimbBlockDesc;
	fClassDesc->MakeAutoParamBlocks(this);
}

// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plClimbBlockerComponent::SetupProperties(plMaxNode *node,  plErrorMsg *errMsg)
{
	node->SetDrawable(false);

	plPhysicalProps *props = node->GetPhysicalProps();

// 	props->SetMass(0.0, node, errMsg);
// 	props->SetFriction(0.0, node, errMsg);
// 	props->SetRestitution(0.0, node, errMsg);
	props->SetBoundsType(plSimDefs::kExplicitBounds, node, errMsg);
//	props->SetPinned(true, node, errMsg);
	props->SetLOSBlockCustom(true, node, errMsg);

	return true;
}

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