khanat-opennel-code/code/ryzom/client/src/r2/tool_create_entity.cpp

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "stdpch.h"
//
#include "editor.h"
#include "tool_create_entity.h"
//
#include "nel/misc/vectord.h"
#include "nel/misc/i18n.h"
//
#include "../client_sheets/character_sheet.h"
//
#include "../entity_cl.h"
#include "../player_r2_cl.h"
#include "../sheet_manager.h"
#include "../interface_v3/lua_ihm.h"
#include "../cdb_leaf.h"
#include "../interface_v3/interface_manager.h"
#include "dmc/palette.h"
#include "displayer_visual.h"
#include "r2_config.h"
#include "verbose_clock.h"
#include "entity_sorter.h"
//
#include "../interface_v3/ctrl_base_button.h"
//
#include "game_share/player_visual_properties.h"
#include "game_share/visual_slot_manager.h"

using namespace NLPACS;
using namespace NLMISC;
using namespace std;

namespace R2
{

// ***************************************************************
CToolCreateEntity::~CToolCreateEntity()
{
	clearArray();
}

// ***************************************************************
void CToolCreateEntity::cancel()
{
	CToolChoosePos::cancel();
	clearArray();
}

// ***************************************************************
CToolCreateEntity::CToolCreateEntity(uint ghostSlot, const std::string &paletteId, bool arrayMode) : CToolChoosePos(ghostSlot)
{
	_PaletteId = paletteId;
	if (!arrayMode)
	{
		enableMultiPos();
	}
	_CreateState = CreateSingle;
	_ArrayOrigin.set(0.f, 0.f, 0.f);
	_ArrayEnd.set(0.f, 0.f, 0.f);
	_ArrayDefaultAngle = 0.f;
	if (arrayMode)
	{
		CObject *paletteNode = getEditor().getDMC().getPaletteElement(paletteId);
		if (paletteNode)
		{
			std::string sheetClient = getString(paletteNode, "SheetClient");
			if (isBotObjectSheet(CSheetId(sheetClient)))
			{
				_CreateState = ChooseArrayOrigin;
			}
		}
	}
	_ArrayWantedAction = ArrayActionNone;
}

// ***************************************************************
void CToolCreateEntity::updateInvalidCursorOnUI()
{
	//H_AUTO(R2_CToolCreateEntity_updateInvalidCursorOnUI)
	// set the default cursor unless the mouse is on the palette
	const std::vector<CInterfaceGroup *> &groups = getUI().getGroupsUnderPointer();
	for(uint k = 0; k < groups.size(); ++k)
	{
		if (groups[k]->getId() == "ui:interface:r2ed_palette") // hardcoded for now ...
		{
			setMouseCursor(_CursValid);
			return;
		}
	}
	setMouseCursor(DEFAULT_CURSOR);
}

// ***************************************************************
void CToolCreateEntity::commit(const NLMISC::CVector &createPosition, float createAngle)
{
	//H_AUTO(R2_CToolCreateEntity_commit)
	if (_CreateState == ChooseArrayOrigin)
	{
		if (!getEditor().verifyRoomLeft(0, 1))
		{

			getUI().executeLuaScript("r2:checkStaticQuota(1)");
			return;
		}
		setContextHelp(CI18N::get("uiR2EDDrawArrayContextHelp"));
		_CreateState = DrawArray;
		_ArrayDefaultAngle = createAngle;
		_ArrayOrigin = createPosition;
		_ArrayEnd = createPosition;
		updateArray(getGhost());
		removeGhostSlot();
		return;
	}

	CEntityCL *ghost = getGhost();
	if (!ghost) return;

	cloneEntityIntoScenario(ghost,
							createPosition,
							createAngle,
							true, /* new action */
							false /* create ghost */);

	if (isMultiPos() && isShiftDown())
	{
		// prevent newly created ghost to be removed twice ...
		removeGhostSlot();
		// re set this tool to generate a new entity look
		getUI().runActionHandler("r2ed_create_entity", NULL, "PaletteId=" + _PaletteId);
	}
}

// ***************************************************************
bool CToolCreateEntity::isBotObjectSheet(const NLMISC::CSheetId &sheetId) const
{
	//H_AUTO(R2_CToolCreateEntity_isBotObjectSheet)
	const CCharacterSheet *charSheet = dynamic_cast<const CCharacterSheet *>(SheetMngr.get(sheetId));
	if (charSheet)
	{
		std::string botobjectsPaletteRoot = "palette.entities.botobjects";
		return (_PaletteId.substr(0, botobjectsPaletteRoot.size()) == botobjectsPaletteRoot);
	}
	return false;
}


// ***************************************************************
std::string CToolCreateEntity::cloneEntityIntoScenario(CEntityCL *clonee,
												const NLMISC::CVector &createPosition,
												float createAngle,
												bool  newAction,
												bool  createGhost
											   )
{
	//H_AUTO(R2_CToolCreateEntity_cloneEntityIntoScenario)
	if (!clonee) return "";
	std::string instanceId;
	bool isBotObject = isBotObjectSheet(clonee->sheetId());

	if (!getEditor().verifyRoomLeft(isBotObject ? 0 : 1, isBotObject ? 1 : 0)) { return ""; }

	std::string className;
	// if class is given in the palette node, then use it. Default to 'Npc' else
	CObject *paletteNode = getDMC().getPaletteElement(_PaletteId);
	if (paletteNode && paletteNode->findIndex("Class") != -1)
	{
		className = getString(paletteNode, "Class");
	}
	if (className.empty())
	{
		className = "Npc";
	}

	ucstring readableName;
	// retrieve name from the palette id
	CLuaState &ls = getEditor().getLua();
	getEditor().getEnv()["PaletteIdToTranslation"][_PaletteId].push();
	if (ls.isString(-1))
	{
		readableName.fromUtf8(ls.toString(-1));
	}
	if (readableName.empty())
	{
		// if no name found then give a default one
		readableName = CI18N::get(isBotObject ? "uiR2EDNameBotObject" : "uiR2EDNameNPC");
	}

	// except for creatures, posfix the name with a number
	std::string creaturePaletteRoot = "palette.entities.creatures";
	if (_PaletteId.substr(0, creaturePaletteRoot.size()) != creaturePaletteRoot)
	{
		readableName = getEditor().genInstanceName(readableName);
	}
	else
	{
		className = "NpcCreature";

		// is Plant
		std::string sheetClient = getString(paletteNode, "SheetClient");
		getEditor().getLua().push(sheetClient);
		if (getEditor().getEnv().callMethodByNameNoThrow("isNPCPlant", 1, 1))
		{
			CLuaObject result(getEditor().getLua());
			bool isPlant = result.toBoolean();
			if (isPlant)
				className = "NpcPlant";
		}
	}

	if (newAction)
	{
		getDMC().newAction(NLMISC::CI18N::get("uiR2EDCreateAction") + readableName);
	}
	// send network commands to create entity on server
	std::auto_ptr<CObject> desc(getDMC().newComponent(className));

	if (desc.get())
	{
		// TMP FIX : if the created entity is a custom npc, then retrieve look from the clonee visual properties
		if (className == "NpcCustom")
		{
			SPropVisualA vA;
			SPropVisualB vB;
			SPropVisualC vC;
			const string propNameA = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPA);
			const string propNameB = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPB);
			const string propNameC = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPC);
			CCDBNodeLeaf *leafA = CInterfaceManager::getInstance()->getDbProp(propNameA);
			CCDBNodeLeaf *leafB = CInterfaceManager::getInstance()->getDbProp(propNameB);
			CCDBNodeLeaf *leafC = CInterfaceManager::getInstance()->getDbProp(propNameC);
			if (!leafA)
			{
				nlwarning("Can't find DB leaf %s", propNameA.c_str());
				return "";
			}
			if (!leafB)
			{
				nlwarning("Can't find DB leaf %s", propNameB.c_str());
				return "";
			}
			if (!leafC)
			{
				nlwarning("Can't find DB leaf %s", propNameC.c_str());
				return "";
			}

			vA.PropertyA = leafA->getValue64();
			vB.PropertyB = leafB->getValue64();
			vC.PropertyC = leafC->getValue64();
			nlassert(desc->isTable());
			CObjectTable *props = (CObjectTable *) desc.get();

			props->set("GabaritHeight",     (double)vC.PropertySubData.CharacterHeight);
			props->set("GabaritTorsoWidth", (double)vC.PropertySubData.TorsoWidth);
			props->set("GabaritArmsWidth",  (double)vC.PropertySubData.ArmsWidth);
			props->set("GabaritLegsWidth",  (double)vC.PropertySubData.LegsWidth);
			props->set("GabaritBreastSize", (double)vC.PropertySubData.BreastSize);

			props->set("HairColor", (double)vA.PropertySubData.HatColor);
			props->set("Tattoo",    (double)vC.PropertySubData.Tattoo);
			props->set("EyesColor", (double)vC.PropertySubData.EyesColor);

			props->set("MorphTarget1", (double)vC.PropertySubData.MorphTarget1);
			props->set("MorphTarget2", (double)vC.PropertySubData.MorphTarget2);
			props->set("MorphTarget3", (double)vC.PropertySubData.MorphTarget3);
			props->set("MorphTarget4", (double)vC.PropertySubData.MorphTarget4);
			props->set("MorphTarget5", (double)vC.PropertySubData.MorphTarget5);
			props->set("MorphTarget6", (double)vC.PropertySubData.MorphTarget6);
			props->set("MorphTarget7", (double)vC.PropertySubData.MorphTarget7);
			props->set("MorphTarget8", (double)vC.PropertySubData.MorphTarget8);

			props->set("Sex", (double)vA.PropertySubData.Sex);

			CVisualSlotManager * vsManager = CVisualSlotManager::getInstance();
			NLMISC::CSheetId * sheetId = NULL;

			if(vA.PropertySubData.HatModel == 0)
			{
				props->set("HatModel", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.HatModel, SLOTTYPE::HEAD_SLOT);
				if (sheetId)
				{
					props->set("HairType",  (double)sheetId->asInt());
				}
			}

			if(vA.PropertySubData.JacketModel == 0)
			{
				props->set("JacketModel", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.JacketModel, SLOTTYPE::CHEST_SLOT);
				if (sheetId)
				{
					props->set("JacketModel",  (double)sheetId->asInt());
				}
			}

			if(vA.PropertySubData.TrouserModel == 0)
			{
				props->set("TrouserModel", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.TrouserModel, SLOTTYPE::LEGS_SLOT);
				if (sheetId)
				{
					props->set("TrouserModel",  (double)sheetId->asInt());
				}
			}

			if(vB.PropertySubData.FeetModel == 0)
			{
				props->set("FeetModel", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vB.PropertySubData.FeetModel, SLOTTYPE::FEET_SLOT);
				if (sheetId)
				{
					props->set("FeetModel",  (double)sheetId->asInt());
				}
			}

			if(vB.PropertySubData.HandsModel == 0)
			{
				props->set("HandsModel", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vB.PropertySubData.HandsModel, SLOTTYPE::HANDS_SLOT);
				if (sheetId)
				{
					props->set("HandsModel",  (double)sheetId->asInt());
				}
			}

			if(vA.PropertySubData.ArmModel == 0)
			{
				props->set("ArmModel", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.ArmModel, SLOTTYPE::ARMS_SLOT);
				if (sheetId)
				{
					props->set("ArmModel",  (double)sheetId->asInt());
				}
			}

			double weaponRH=0, weaponLH=0;
			if(vA.PropertySubData.WeaponRightHand == 0)
			{
				props->set("WeaponRightHand", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.WeaponRightHand, SLOTTYPE::RIGHT_HAND_SLOT);
				if (sheetId)
				{
					weaponRH = (double)sheetId->asInt();
				}
				props->set("WeaponRightHand",  weaponRH);
			}

			if(vA.PropertySubData.WeaponLeftHand == 0)
			{
				props->set("WeaponLeftHand", 0);
			}
			else
			{
				sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.WeaponLeftHand, SLOTTYPE::LEFT_HAND_SLOT);
				if (sheetId)
				{
					weaponLH = (double)sheetId->asInt();
				}
				props->set("WeaponLeftHand",  weaponLH);
			}

			props->set("JacketColor", (double)vA.PropertySubData.JacketColor);
			props->set("TrouserColor", (double)vA.PropertySubData.TrouserColor);
			props->set("FeetColor", (double)vB.PropertySubData.FeetColor);
			props->set("HandsColor", (double)vB.PropertySubData.HandsColor);
			props->set("ArmColor", (double)vA.PropertySubData.ArmColor);

			CPlayerR2CL * player = (CPlayerR2CL*)dynamic_cast<CPlayerR2CL*>(clonee);
			if(player != NULL)
			{
				std::string race, gender, sheetClient;
				switch(player->people())
				{
				case EGSPD::CPeople::Fyros:
					sheetClient = "basic_fyros_";
					race = "Fyros";
					break;

				case EGSPD::CPeople::Matis:
					sheetClient = "basic_matis_";
					race = "Matis";
					break;

				case EGSPD::CPeople::Tryker:
					sheetClient = "basic_tryker_";
					race = "Tryker";
					break;

				case EGSPD::CPeople::Zorai:
					sheetClient = "basic_zorai_";
					race = "Zorai";
					break;

				default:
					nlwarning("CToolCreateEntity::commit unknown people");
				}
				switch(player->getGender())
				{
				case GSGENDER::female:
					sheetClient = sheetClient+"female.creature";
					gender = "female";
					break;

				case GSGENDER::male:
					sheetClient = sheetClient+"male.creature";
					gender = "male";
					break;

				default:
					nlwarning("CToolCreateEntity::commit unknown gender");
				}

				props->set("SheetClient", sheetClient);

				// random name
				getEditor().getLua().push(race);
				getEditor().getLua().push(gender);
				if (getEditor().getEnv().callMethodByNameNoThrow("randomNPCName", 2, 1))
				{
					CLuaObject result(getEditor().getLua());
					std::string name = result.toString();
					props->set("Name", name);
				}
			}

			getEditor().getLua().push(getString(paletteNode, "Equipment"));
			getEditor().getLua().push(weaponRH);
			getEditor().getLua().push(weaponLH);
			getEditor().getLua().push(getString(paletteNode, "Sheet"));
			getEditor().getLua().push(getString(paletteNode, "SheetModel"));
			if (getEditor().getEnv().callMethodByNameNoThrow("searchSheet", 5, 1))
			{
				CLuaObject result(getEditor().getLua());
				std::string sheet = result.toString();
				props->set("Sheet", sheet);
			}
			else
			{
				nlwarning("SearchSheet failed : Palette Id = %s", _PaletteId.c_str());
				return "";
			}
		}
		else
		{
			desc->set("Name", readableName.toUtf8());
		}

		desc->set("Base", _PaletteId);
		desc->setObject("Position", buildVector(CVectorD(createPosition)));
		desc->set("Angle", createAngle);
		//desc->set("Name", readableName.toUtf8());

		instanceId = getString(desc.get(), "InstanceId");
		if (!instanceId.empty())
		{
			if (!createGhost)
			{
				// selection asked when instance is created
				getEditor().setCookie(instanceId, "Select", true);
			}
			else
			{
				getEditor().setCookie(instanceId, "GhostDuplicate", true);
			}
		}

		// send creation command
		// tmp : static npc counter
		// add in component list of default feature
		if (getEditor().getDefaultFeature())
		{
			std::string targetInstanceId;
			// if object is a bot object, it is considered to be permanent content
			// and should be created in the base act
			CInstance *targetAct =  isBotObject ? getEditor().getBaseAct() : getEditor().getCurrentAct();
			if (!targetAct)
			{
				nlwarning("Can't find act when creating an entity");
			}
			else
			{
				if (_AutoGroup.getGroupingCandidate())
				{
					nlassert(!createGhost); // either autogroup or arraymode, both at the same time not supported
					_AutoGroup.group(desc.get(), createPosition);
				}
				else
				{
					// create standalone
					desc->setGhost(createGhost);
					getDMC().requestInsertNode(getEditor().getDefaultFeature(targetAct)->getId(),
											   "Components",
											   -1,
											   "",
											   desc.get());
				}
			}
		}
	}
	return instanceId;
}

// ***************************************************************
void CToolCreateEntity::onActivate()
{
	//H_AUTO(R2_CToolCreateEntity_onActivate)
	setContextHelp(CI18N::get("uiR2EDToolCreateEntity"));
}

// ***************************************************************
void CToolCreateEntity::updateBeforeRender()
{
	//H_AUTO(R2_CToolCreateEntity_updateBeforeRender)
	if (_CreateState != DrawArray)
	{
		CToolChoosePos::updateBeforeRender();
		_AutoGroup.update(_CreatePosition, _PaletteId, _Valid && !isCtrlDown());
		setContextHelp(CI18N::get(_AutoGroup.getGroupingCandidate() ? "uiR2EDToolCreateEntityAutoGroup" : "uiR2EDToolCreateEntity"));
		return;
	}
	setContextHelp(CI18N::get("uiR2EDDrawArrayContextHelp"));
	// update for array mode
	bool valid = true;
	sint32 mouseX,  mouseY;
	getMousePos(mouseX,  mouseY);
	if (!isInScreen(mouseX,  mouseY) || (isMouseOnUI() && !isMouseOnWorldMap()))
	{
		valid = false;
		_ArrayEnd = _ArrayOrigin;
	}
	//
	CTool::CWorldViewRay worldViewRay;
	computeWorldViewRay(mouseX,  mouseY,  worldViewRay);
	//
	CVector entityPos; // the pos where the ghost will be shown
	CVector inter;     // intersection of view ray with landscape
	_ValidArray = true;
	TRayIntersectionType rayIntersectionType = computeLandscapeRayIntersection(worldViewRay,  inter);
	switch(rayIntersectionType)
	{
		case NoIntersection:
			_ValidArray  = false;
			_ArrayEnd = _ArrayOrigin;
		break;
		case ValidPacsPos:
		case InvalidPacsPos:
			_ArrayEnd = inter;
		break;
	}
	for (uint k = 0; valid && k < _ArrayElements.size(); ++k)
	{
		if (_ArrayElements[k])
		{
			if (_ArrayElements[k]->getDisplayFlag(CDisplayerVisual::FlagBadPos))
			{
				_ValidArray  = false;
			}
		}
	}
	CGroupMap *worldMap = getWorldMap();
	if (worldMap) worldMap->setSelectionAxis(_ValidArray);
	setMouseCursor(_ValidArray ? _CursValid.c_str() : _CursInvalid.c_str());
}

// ***************************************************************
void CToolCreateEntity::updateAfterRender()
{
	//H_AUTO(R2_CToolCreateEntity_updateAfterRender)
	if (_CreateState != DrawArray)
	{
		CToolChoosePos::updateAfterRender();
		return;
	}
	switch(_ArrayWantedAction)
	{
		case ArrayActionNone:
		break;
		case ArrayActionValidate:
		{
			commitArray();
			CTool::TSmartPtr hold(this);
			getUI().runActionHandler("r2ed_create_entity", NULL, "PaletteId="+_PaletteId);
			return;
		}
		break;
		case ArrayActionCancel:
		{
			CTool::TSmartPtr hold(this);
			cancel();
			getEditor().setCurrentTool(NULL);
			return;
		}
		break;
	}
	updateArray(NULL);
}


// ***************************************************************
bool CToolCreateEntity::onMouseLeftButtonClicked()
{
	//H_AUTO(R2_CToolCreateEntity_onMouseLeftButtonClicked)
	if (_CreateState != DrawArray)
	{
		return CToolChoosePos::onMouseLeftButtonClicked();
	}
	if (_ValidArray)
	{
		_ArrayWantedAction = ArrayActionValidate;
	}
	return true;
}

// ***************************************************************
bool CToolCreateEntity::onMouseRightButtonClicked()
{
	//H_AUTO(R2_CToolCreateEntity_onMouseRightButtonClicked)
	if (_CreateState != DrawArray)
	{
		return CToolChoosePos::onMouseRightButtonClicked();
	}
	_ArrayWantedAction = ArrayActionCancel;
	return true;
}

// ***************************************************************
void CToolCreateEntity::clearArray()
{
	//H_AUTO(R2_CToolCreateEntity_clearArray)
	for (uint k = 0; k < _ArrayElements.size(); ++k)
	{
		if (_ArrayElements[k])
		{
			getEditor().getDMC().requestEraseNode(_ArrayElements[k]->getDisplayedInstance()->getId(), "", -1);
		}
	}
}

// ***************************************************************
void CToolCreateEntity::updateArray(CEntityCL *clonee)
{
	//H_AUTO(R2_CToolCreateEntity_updateArray)
	if (!clonee)
	{
		nlassert(!_ArrayElements.empty());
		nlassert(_ArrayElements[0] != NULL);
		clonee = _ArrayElements[0]->getEntity();
		if (!clonee)
		{
			return;
		}
	}

	CVector extent = _ArrayEnd - _ArrayOrigin;
	uint arraySize = 1;
	float arrayStepLength = 1.f;
	if (!_ArrayElements.empty() && _ArrayElements[0])
	{
		arrayStepLength = 2.f * _ArrayElements[0]->getSelectionDecalRadius();
		arraySize = (uint) floorf(extent.norm() / arrayStepLength) + 1;
		arraySize = std::min(arraySize, (uint) 16);
	}
	while (!getEditor().verifyRoomLeft(0, arraySize))
	{
		-- arraySize;
		if (arraySize == 0)
		{
			TSmartPtr hold(this);
			cancel();
			return;
		}
	}
	_ArrayElements.resize(std::max(arraySize, uint(_ArrayElements.size())));
	CVector delta = arrayStepLength * extent.normed();
	float angle = _ArrayDefaultAngle;
	if (arraySize > 1)
	{
		angle = - (float) atan2(extent.x, extent.y);
	}
	bool newEntityCreated = false;
	uint numCreatedEntity = 0;
	for (uint k = 0; k < _ArrayElements.size(); ++k)
	{
		CVector pos = _ArrayOrigin + (float) k * delta;
		if (!_ArrayElements[k])
		{
			if (k < arraySize)
			{
				nlwarning("NEW ENTITY");
				// create new element
				std::string instanceId = cloneEntityIntoScenario(clonee,
																 pos,
																 angle,
																 false, /*new action*/
																 true /*create ghost*/);
				CInstance *inst = getEditor().getInstanceFromId(instanceId);
				if (inst)
				{
					_ArrayElements[k] = dynamic_cast<CDisplayerVisualEntity *>(inst->getDisplayerVisual());
					if (_ArrayElements[k])
					{
						_ArrayElements[k]->setDisplayMode(CDisplayerVisual::DisplayModeArray);
					}
				}
				newEntityCreated = true;
				++ numCreatedEntity;
			}
		}

		if (_ArrayElements[k])
		{
			bool active = k < arraySize;
			// do a kind of 'reserve' on the list of entities : don't delete entities in excess, but hide them instead
			if (active != _ArrayElements[k]->getActive())
			{
				_ArrayElements[k]->setActive(active);
				if (active)
				{
					newEntityCreated = true;
					_ArrayElements[k]->setDisplayMode(CDisplayerVisual::DisplayModeArray);
				}
			}
			if (active)
			{
				// update pos & angle
				TInstanceId	instanceId = _ArrayElements[k]->getDisplayedInstance()->getId();
				CVector worldPos = _ArrayElements[k]->getWorldPos();
				if (pos != worldPos)
				{
					CObject *newPos = buildVector(pos, _ArrayElements[k]->getDisplayedInstance()->getPosInstanceId());
					getEditor().getDMC().requestSetNode(instanceId, "Position", newPos);
					delete newPos;
				}
				if (angle != _ArrayElements[k]->getAngle())
				{
					CObjectNumber *angleObject = new CObjectNumber(angle);
					getEditor().getDMC().requestSetNode(instanceId, "Angle", angleObject);
					delete angleObject;
				}
			}
		}
	}
	if (newEntityCreated)
	{
		nlwarning("Num created entity = %d", numCreatedEntity);
		getEditor().getEntitySorter()->clipEntitiesByDist();
	}
}

// ***************************************************************
void CToolCreateEntity::commitArray()
{
	//H_AUTO(R2_CToolCreateEntity_commitArray)
	for (uint k = 0; k < _ArrayElements.size(); ++k)
	{
		if (_ArrayElements[k])
		{
			cloneEntityIntoScenario(_ArrayElements[k]->getEntity(),
									_ArrayElements[k]->getWorldPos(),
									_ArrayElements[k]->getAngle(),
									k == 0, /*new action*/
									false /*create ghost*/);
		}
	}
	clearArray();
	getEditor().getDMC().flushActions();
}

// ***************************************************************
bool CToolCreateEntity::stopAfterCommit() const
{
	//H_AUTO(R2_CToolCreateEntity_stopAfterCommit)
	return _CreateState == CreateSingle;
}



// ***************************************************************
class CAHR2EDToggleDrawArray : public IActionHandler
{
	virtual void execute(CCtrlBase *pCaller, const std::string &/* sParams */)
	{
		CInterfaceManager *im = CInterfaceManager::getInstance();
		CCtrlBaseButton *but = dynamic_cast<CCtrlBaseButton *>(pCaller);
		if (but)
		{
			im->getDbProp("UI:TEMP:R2_DRAW_ARRAY")->setValueBool(but->getPushed());
			CToolCreateEntity *tce = dynamic_cast<CToolCreateEntity *>(getEditor().getCurrentTool());
			if (tce)
			{
				im->runActionHandler("r2ed_create_entity", NULL, "PaletteId=" + tce->getPaletteId());
			}
		}
	}
};
REGISTER_ACTION_HANDLER(CAHR2EDToggleDrawArray, "r2ed_toggle_draw_array");




} // R2