ryzom/client/src/r2/tool_create_entity.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdpch.h"
  21 //
  22 #include "editor.h"
  23 #include "tool_create_entity.h"
  24 //
  25 #include "nel/misc/vectord.h"
  26 #include "nel/misc/i18n.h"
  27 //
  28 #include "../client_sheets/character_sheet.h"
  29 //
  30 #include "../entity_cl.h"
  31 #include "../player_r2_cl.h"
  32 #include "../sheet_manager.h"
  33 #include "nel/gui/lua_ihm.h"
  34 #include "nel/misc/cdb_leaf.h"
  35 #include "../interface_v3/interface_manager.h"
  36 #include "dmc/palette.h"
  37 #include "displayer_visual.h"
  38 #include "r2_config.h"
  39 #include "verbose_clock.h"
  40 #include "entity_sorter.h"
  41 //
  42 #include "nel/gui/ctrl_base_button.h"
  43 //
  44 #include "game_share/player_visual_properties.h"
  45 #include "game_share/visual_slot_manager.h"
  46
  47 #ifdef DEBUG_NEW
  48 #define new DEBUG_NEW
  49 #endif
  50
  51 using namespace NLPACS;
  52 using namespace NLMISC;
  53 using namespace std;
  54
  55 namespace R2
  56 {
  57
  58 // ***************************************************************
  59 CToolCreateEntity::~CToolCreateEntity()
  60 {
  61         clearArray();
  62 }
  63
  64 // ***************************************************************
  65 void CToolCreateEntity::cancel()
  66 {
  67         CToolChoosePos::cancel();
  68         clearArray();
  69 }
  70
  71 // ***************************************************************
  72 CToolCreateEntity::CToolCreateEntity(uint ghostSlot, const std::string &paletteId, bool arrayMode) : CToolChoosePos(ghostSlot)
  73 {
  74         _PaletteId = paletteId;
  75         if (!arrayMode)
  76         {
  77                 enableMultiPos();
  78         }
  79         _CreateState = CreateSingle;
  80         _ArrayOrigin.set(0.f, 0.f, 0.f);
  81         _ArrayEnd.set(0.f, 0.f, 0.f);
  82         _ArrayDefaultAngle = 0.f;
  83         if (arrayMode)
  84         {
  85                 CObject *paletteNode = getEditor().getDMC().getPaletteElement(paletteId);
  86                 if (paletteNode)
  87                 {
  88                         std::string sheetClient = getString(paletteNode, "SheetClient");
  89                         if (isBotObjectSheet(CSheetId(sheetClient)))
  90                         {
  91                                 _CreateState = ChooseArrayOrigin;
  92                         }
  93                 }
  94         }
  95         _ArrayWantedAction = ArrayActionNone;
  96 }
  97
  98 // ***************************************************************
  99 void CToolCreateEntity::updateInvalidCursorOnUI()
 100 {
 101         //H_AUTO(R2_CToolCreateEntity_updateInvalidCursorOnUI)
 102         // set the default cursor unless the mouse is on the palette
 103         const std::vector<CInterfaceGroup *> &groups = CWidgetManager::getInstance()->getGroupsUnderPointer();
 104         for(uint k = 0; k < groups.size(); ++k)
 105         {
 106                 if (groups[k]->getId() == "ui:interface:r2ed_palette") // hardcoded for now ...
 107                 {
 108                         setMouseCursor(_CursValid);
 109                         return;
 110                 }
 111         }
 112         setMouseCursor(DEFAULT_CURSOR);
 113 }
 114
 115 // ***************************************************************
 116 void CToolCreateEntity::commit(const NLMISC::CVector &createPosition, float createAngle)
 117 {
 118         //H_AUTO(R2_CToolCreateEntity_commit)
 119         if (_CreateState == ChooseArrayOrigin)
 120         {
 121                 if (!getEditor().verifyRoomLeft(0, 1))
 122                 {
 123
 124                         CLuaManager::getInstance().executeLuaScript("r2:checkStaticQuota(1)");
 125                         return;
 126                 }
 127                 setContextHelp(CI18N::get("uiR2EDDrawArrayContextHelp"));
 128                 _CreateState = DrawArray;
 129                 _ArrayDefaultAngle = createAngle;
 130                 _ArrayOrigin = createPosition;
 131                 _ArrayEnd = createPosition;
 132                 updateArray(getGhost());
 133                 removeGhostSlot();
 134                 return;
 135         }
 136
 137         CEntityCL *ghost = getGhost();
 138         if (!ghost) return;
 139
 140         cloneEntityIntoScenario(ghost,
 141                                                         createPosition,
 142                                                         createAngle,
 143                                                         true, /* new action */
 144                                                         false /* create ghost */);
 145
 146         if (isMultiPos() && isShiftDown())
 147         {
 148                 // prevent newly created ghost to be removed twice ...
 149                 removeGhostSlot();
 150                 // re set this tool to generate a new entity look
 151                 CAHManager::getInstance()->runActionHandler("r2ed_create_entity", NULL, "PaletteId=" + _PaletteId);
 152         }
 153 }
 154
 155 // ***************************************************************
 156 bool CToolCreateEntity::isBotObjectSheet(const NLMISC::CSheetId &sheetId) const
 157 {
 158         //H_AUTO(R2_CToolCreateEntity_isBotObjectSheet)
 159         const CCharacterSheet *charSheet = dynamic_cast<const CCharacterSheet *>(SheetMngr.get(sheetId));
 160         if (charSheet)
 161         {
 162                 std::string botobjectsPaletteRoot = "palette.entities.botobjects";
 163                 return (_PaletteId.substr(0, botobjectsPaletteRoot.size()) == botobjectsPaletteRoot);
 164         }
 165         return false;
 166 }
 167
 168
 169 // ***************************************************************
 170 std::string CToolCreateEntity::cloneEntityIntoScenario(CEntityCL *clonee,
 171                                                                                                 const NLMISC::CVector &createPosition,
 172                                                                                                 float createAngle,
 173                                                                                                 bool  newAction,
 174                                                                                                 bool  createGhost
 175                                                                                            )
 176 {
 177         //H_AUTO(R2_CToolCreateEntity_cloneEntityIntoScenario)
 178         if (!clonee) return "";
 179         std::string instanceId;
 180         bool isBotObject = isBotObjectSheet(clonee->sheetId());
 181
 182         if (!getEditor().verifyRoomLeft(isBotObject ? 0 : 1, isBotObject ? 1 : 0)) { return ""; }
 183
 184         std::string className;
 185         // if class is given in the palette node, then use it. Default to 'Npc' else
 186         CObject *paletteNode = getDMC().getPaletteElement(_PaletteId);
 187         if (paletteNode && paletteNode->findIndex("Class") != -1)
 188         {
 189                 className = getString(paletteNode, "Class");
 190         }
 191         if (className.empty())
 192         {
 193                 className = "Npc";
 194         }
 195
 196         ucstring readableName;
 197         // retrieve name from the palette id
 198         CLuaState &ls = getEditor().getLua();
 199         getEditor().getEnv()["PaletteIdToTranslation"][_PaletteId].push();
 200         if (ls.isString(-1))
 201         {
 202                 readableName.fromUtf8(ls.toString(-1));
 203         }
 204         if (readableName.empty())
 205         {
 206                 // if no name found then give a default one
 207                 readableName = CI18N::get(isBotObject ? "uiR2EDNameBotObject" : "uiR2EDNameNPC");
 208         }
 209
 210         // except for creatures, posfix the name with a number
 211         std::string creaturePaletteRoot = "palette.entities.creatures";
 212         if (_PaletteId.substr(0, creaturePaletteRoot.size()) != creaturePaletteRoot)
 213         {
 214                 readableName = getEditor().genInstanceName(readableName);
 215         }
 216         else
 217         {
 218                 className = "NpcCreature";
 219
 220                 // is Plant
 221                 std::string sheetClient = getString(paletteNode, "SheetClient");
 222                 getEditor().getLua().push(sheetClient);
 223                 if (getEditor().getEnv().callMethodByNameNoThrow("isNPCPlant", 1, 1))
 224                 {
 225                         CLuaObject result(getEditor().getLua());
 226                         bool isPlant = result.toBoolean();
 227                         if (isPlant)
 228                                 className = "NpcPlant";
 229                 }
 230         }
 231
 232         if (newAction)
 233         {
 234                 getDMC().newAction(NLMISC::CI18N::get("uiR2EDCreateAction") + readableName);
 235         }
 236         // send network commands to create entity on server
 237         CUniquePtr<CObject> desc(getDMC().newComponent(className));
 238
 239         if (desc.get())
 240         {
 241                 // TMP FIX : if the created entity is a custom npc, then retrieve look from the clonee visual properties
 242                 if (className == "NpcCustom")
 243                 {
 244                         SPropVisualA vA;
 245                         SPropVisualB vB;
 246                         SPropVisualC vC;
 247                         const string propNameA = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPA);
 248                         const string propNameB = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPB);
 249                         const string propNameC = toString("SERVER:Entities:E%d:P%d", clonee->slot(), CLFECOMMON::PROPERTY_VPC);
 250                         CCDBNodeLeaf *leafA = NLGUI::CDBManager::getInstance()->getDbProp(propNameA);
 251                         CCDBNodeLeaf *leafB = NLGUI::CDBManager::getInstance()->getDbProp(propNameB);
 252                         CCDBNodeLeaf *leafC = NLGUI::CDBManager::getInstance()->getDbProp(propNameC);
 253                         if (!leafA)
 254                         {
 255                                 nlwarning("Can't find DB leaf %s", propNameA.c_str());
 256                                 return "";
 257                         }
 258                         if (!leafB)
 259                         {
 260                                 nlwarning("Can't find DB leaf %s", propNameB.c_str());
 261                                 return "";
 262                         }
 263                         if (!leafC)
 264                         {
 265                                 nlwarning("Can't find DB leaf %s", propNameC.c_str());
 266                                 return "";
 267                         }
 268
 269                         vA.PropertyA = leafA->getValue64();
 270                         vB.PropertyB = leafB->getValue64();
 271                         vC.PropertyC = leafC->getValue64();
 272                         nlassert(desc->isTable());
 273                         CObjectTable *props = (CObjectTable *) desc.get();
 274
 275                         props->set("GabaritHeight",     (double)vC.PropertySubData.CharacterHeight);
 276                         props->set("GabaritTorsoWidth", (double)vC.PropertySubData.TorsoWidth);
 277                         props->set("GabaritArmsWidth",  (double)vC.PropertySubData.ArmsWidth);
 278                         props->set("GabaritLegsWidth",  (double)vC.PropertySubData.LegsWidth);
 279                         props->set("GabaritBreastSize", (double)vC.PropertySubData.BreastSize);
 280
 281                         props->set("HairColor", (double)vA.PropertySubData.HatColor);
 282                         props->set("Tattoo",    (double)vC.PropertySubData.Tattoo);
 283                         props->set("EyesColor", (double)vC.PropertySubData.EyesColor);
 284
 285                         props->set("MorphTarget1", (double)vC.PropertySubData.MorphTarget1);
 286                         props->set("MorphTarget2", (double)vC.PropertySubData.MorphTarget2);
 287                         props->set("MorphTarget3", (double)vC.PropertySubData.MorphTarget3);
 288                         props->set("MorphTarget4", (double)vC.PropertySubData.MorphTarget4);
 289                         props->set("MorphTarget5", (double)vC.PropertySubData.MorphTarget5);
 290                         props->set("MorphTarget6", (double)vC.PropertySubData.MorphTarget6);
 291                         props->set("MorphTarget7", (double)vC.PropertySubData.MorphTarget7);
 292                         props->set("MorphTarget8", (double)vC.PropertySubData.MorphTarget8);
 293
 294                         props->set("Sex", (double)vA.PropertySubData.Sex);
 295
 296                         CVisualSlotManager * vsManager = CVisualSlotManager::getInstance();
 297                         NLMISC::CSheetId * sheetId = NULL;
 298
 299                         if(vA.PropertySubData.HatModel == 0)
 300                         {
 301                                 props->set("HatModel", 0);
 302                         }
 303                         else
 304                         {
 305                                 sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.HatModel, SLOTTYPE::HEAD_SLOT);
 306                                 if (sheetId)
 307                                 {
 308                                         props->set("HairType",  (double)sheetId->asInt());
 309                                 }
 310                         }
 311
 312                         if(vA.PropertySubData.JacketModel == 0)
 313                         {
 314                                 props->set("JacketModel", 0);
 315                         }
 316                         else
 317                         {
 318                                 sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.JacketModel, SLOTTYPE::CHEST_SLOT);
 319                                 if (sheetId)
 320                                 {
 321                                         props->set("JacketModel",  (double)sheetId->asInt());
 322                                 }
 323                         }
 324
 325                         if(vA.PropertySubData.TrouserModel == 0)
 326                         {
 327                                 props->set("TrouserModel", 0);
 328                         }
 329                         else
 330                         {
 331                                 sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.TrouserModel, SLOTTYPE::LEGS_SLOT);
 332                                 if (sheetId)
 333                                 {
 334                                         props->set("TrouserModel",  (double)sheetId->asInt());
 335                                 }
 336                         }
 337
 338                         if(vB.PropertySubData.FeetModel == 0)
 339                         {
 340                                 props->set("FeetModel", 0);
 341                         }
 342                         else
 343                         {
 344                                 sheetId = vsManager->index2Sheet((uint32)vB.PropertySubData.FeetModel, SLOTTYPE::FEET_SLOT);
 345                                 if (sheetId)
 346                                 {
 347                                         props->set("FeetModel",  (double)sheetId->asInt());
 348                                 }
 349                         }
 350
 351                         if(vB.PropertySubData.HandsModel == 0)
 352                         {
 353                                 props->set("HandsModel", 0);
 354                         }
 355                         else
 356                         {
 357                                 sheetId = vsManager->index2Sheet((uint32)vB.PropertySubData.HandsModel, SLOTTYPE::HANDS_SLOT);
 358                                 if (sheetId)
 359                                 {
 360                                         props->set("HandsModel",  (double)sheetId->asInt());
 361                                 }
 362                         }
 363
 364                         if(vA.PropertySubData.ArmModel == 0)
 365                         {
 366                                 props->set("ArmModel", 0);
 367                         }
 368                         else
 369                         {
 370                                 sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.ArmModel, SLOTTYPE::ARMS_SLOT);
 371                                 if (sheetId)
 372                                 {
 373                                         props->set("ArmModel",  (double)sheetId->asInt());
 374                                 }
 375                         }
 376
 377                         double weaponRH=0, weaponLH=0;
 378                         if(vA.PropertySubData.WeaponRightHand == 0)
 379                         {
 380                                 props->set("WeaponRightHand", 0);
 381                         }
 382                         else
 383                         {
 384                                 sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.WeaponRightHand, SLOTTYPE::RIGHT_HAND_SLOT);
 385                                 if (sheetId)
 386                                 {
 387                                         weaponRH = (double)sheetId->asInt();
 388                                 }
 389                                 props->set("WeaponRightHand",  weaponRH);
 390                         }
 391
 392                         if(vA.PropertySubData.WeaponLeftHand == 0)
 393                         {
 394                                 props->set("WeaponLeftHand", 0);
 395                         }
 396                         else
 397                         {
 398                                 sheetId = vsManager->index2Sheet((uint32)vA.PropertySubData.WeaponLeftHand, SLOTTYPE::LEFT_HAND_SLOT);
 399                                 if (sheetId)
 400                                 {
 401                                         weaponLH = (double)sheetId->asInt();
 402                                 }
 403                                 props->set("WeaponLeftHand",  weaponLH);
 404                         }
 405
 406                         props->set("JacketColor", (double)vA.PropertySubData.JacketColor);
 407                         props->set("TrouserColor", (double)vA.PropertySubData.TrouserColor);
 408                         props->set("FeetColor", (double)vB.PropertySubData.FeetColor);
 409                         props->set("HandsColor", (double)vB.PropertySubData.HandsColor);
 410                         props->set("ArmColor", (double)vA.PropertySubData.ArmColor);
 411
 412                         CPlayerR2CL * player = (CPlayerR2CL*)dynamic_cast<CPlayerR2CL*>(clonee);
 413                         if(player != NULL)
 414                         {
 415                                 std::string race, gender, sheetClient;
 416                                 switch(player->people())
 417                                 {
 418                                 case EGSPD::CPeople::Fyros:
 419                                         sheetClient = "basic_fyros_";
 420                                         race = "Fyros";
 421                                         break;
 422
 423                                 case EGSPD::CPeople::Matis:
 424                                         sheetClient = "basic_matis_";
 425                                         race = "Matis";
 426                                         break;
 427
 428                                 case EGSPD::CPeople::Tryker:
 429                                         sheetClient = "basic_tryker_";
 430                                         race = "Tryker";
 431                                         break;
 432
 433                                 case EGSPD::CPeople::Zorai:
 434                                         sheetClient = "basic_zorai_";
 435                                         race = "Zorai";
 436                                         break;
 437
 438                                 default:
 439                                         nlwarning("CToolCreateEntity::commit unknown people");
 440                                 }
 441                                 switch(player->getGender())
 442                                 {
 443                                 case GSGENDER::female:
 444                                         sheetClient = sheetClient+"female.creature";
 445                                         gender = "female";
 446                                         break;
 447
 448                                 case GSGENDER::male:
 449                                         sheetClient = sheetClient+"male.creature";
 450                                         gender = "male";
 451                                         break;
 452
 453                                 default:
 454                                         nlwarning("CToolCreateEntity::commit unknown gender");
 455                                 }
 456
 457                                 props->set("SheetClient", sheetClient);
 458
 459                                 // random name
 460                                 getEditor().getLua().push(race);
 461                                 getEditor().getLua().push(gender);
 462                                 if (getEditor().getEnv().callMethodByNameNoThrow("randomNPCName", 2, 1))
 463                                 {
 464                                         CLuaObject result(getEditor().getLua());
 465                                         std::string name = result.toString();
 466                                         props->set("Name", name);
 467                                 }
 468                         }
 469
 470                         getEditor().getLua().push(getString(paletteNode, "Equipment"));
 471                         getEditor().getLua().push(weaponRH);
 472                         getEditor().getLua().push(weaponLH);
 473                         getEditor().getLua().push(getString(paletteNode, "Sheet"));
 474                         getEditor().getLua().push(getString(paletteNode, "SheetModel"));
 475                         if (getEditor().getEnv().callMethodByNameNoThrow("searchSheet", 5, 1))
 476                         {
 477                                 CLuaObject result(getEditor().getLua());
 478                                 std::string sheet = result.toString();
 479                                 props->set("Sheet", sheet);
 480                         }
 481                         else
 482                         {
 483                                 nlwarning("SearchSheet failed : Palette Id = %s", _PaletteId.c_str());
 484                                 return "";
 485                         }
 486                 }
 487                 else
 488                 {
 489                         desc->set("Name", readableName.toUtf8());
 490                 }
 491
 492                 desc->set("Base", _PaletteId);
 493                 desc->setObject("Position", buildVector(CVectorD(createPosition)));
 494                 desc->set("Angle", createAngle);
 495                 //desc->set("Name", readableName.toUtf8());
 496
 497                 instanceId = getString(desc.get(), "InstanceId");
 498                 if (!instanceId.empty())
 499                 {
 500                         if (!createGhost)
 501                         {
 502                                 // selection asked when instance is created
 503                                 getEditor().setCookie(instanceId, "Select", true);
 504                         }
 505                         else
 506                         {
 507                                 getEditor().setCookie(instanceId, "GhostDuplicate", true);
 508                         }
 509                 }
 510
 511                 // send creation command
 512                 // tmp : static npc counter
 513                 // add in component list of default feature
 514                 if (getEditor().getDefaultFeature())
 515                 {
 516                         std::string targetInstanceId;
 517                         // if object is a bot object, it is considered to be permanent content
 518                         // and should be created in the base act
 519                         CInstance *targetAct =  isBotObject ? getEditor().getBaseAct() : getEditor().getCurrentAct();
 520                         if (!targetAct)
 521                         {
 522                                 nlwarning("Can't find act when creating an entity");
 523                         }
 524                         else
 525                         {
 526                                 if (_AutoGroup.getGroupingCandidate())
 527                                 {
 528                                         nlassert(!createGhost); // either autogroup or arraymode, both at the same time not supported
 529                                         _AutoGroup.group(desc.get(), createPosition);
 530                                 }
 531                                 else
 532                                 {
 533                                         // create standalone
 534                                         desc->setGhost(createGhost);
 535                                         getDMC().requestInsertNode(getEditor().getDefaultFeature(targetAct)->getId(),
 536                                                                                            "Components",
 537                                                                                            -1,
 538                                                                                            "",
 539                                                                                            desc.get());
 540                                 }
 541                         }
 542                 }
 543         }
 544         return instanceId;
 545 }
 546
 547 // ***************************************************************
 548 void CToolCreateEntity::onActivate()
 549 {
 550         //H_AUTO(R2_CToolCreateEntity_onActivate)
 551         setContextHelp(CI18N::get("uiR2EDToolCreateEntity"));
 552 }
 553
 554 // ***************************************************************
 555 void CToolCreateEntity::updateBeforeRender()
 556 {
 557         //H_AUTO(R2_CToolCreateEntity_updateBeforeRender)
 558         if (_CreateState != DrawArray)
 559         {
 560                 CToolChoosePos::updateBeforeRender();
 561                 _AutoGroup.update(_CreatePosition, _PaletteId, _Valid && !isCtrlDown());
 562                 setContextHelp(CI18N::get(_AutoGroup.getGroupingCandidate() ? "uiR2EDToolCreateEntityAutoGroup" : "uiR2EDToolCreateEntity"));
 563                 return;
 564         }
 565         setContextHelp(CI18N::get("uiR2EDDrawArrayContextHelp"));
 566         // update for array mode
 567         bool valid = true;
 568         sint32 mouseX,  mouseY;
 569         getMousePos(mouseX,  mouseY);
 570         if (!isInScreen(mouseX,  mouseY) || (isMouseOnUI() && !isMouseOnWorldMap()))
 571         {
 572                 valid = false;
 573                 _ArrayEnd = _ArrayOrigin;
 574         }
 575         //
 576         CTool::CWorldViewRay worldViewRay;
 577         computeWorldViewRay(mouseX,  mouseY,  worldViewRay);
 578         //
 579         CVector entityPos; // the pos where the ghost will be shown
 580         CVector inter;     // intersection of view ray with landscape
 581         _ValidArray = true;
 582         TRayIntersectionType rayIntersectionType = computeLandscapeRayIntersection(worldViewRay,  inter);
 583         switch(rayIntersectionType)
 584         {
 585                 case NoIntersection:
 586                         _ValidArray  = false;
 587                         _ArrayEnd = _ArrayOrigin;
 588                 break;
 589                 case ValidPacsPos:
 590                 case InvalidPacsPos:
 591                         _ArrayEnd = inter;
 592                 break;
 593         }
 594         for (uint k = 0; valid && k < _ArrayElements.size(); ++k)
 595         {
 596                 if (_ArrayElements[k])
 597                 {
 598                         if (_ArrayElements[k]->getDisplayFlag(CDisplayerVisual::FlagBadPos))
 599                         {
 600                                 _ValidArray  = false;
 601                         }
 602                 }
 603         }
 604         CGroupMap *worldMap = getWorldMap();
 605         if (worldMap) worldMap->setSelectionAxis(_ValidArray);
 606         setMouseCursor(_ValidArray ? _CursValid : _CursInvalid);
 607 }
 608
 609 // ***************************************************************
 610 void CToolCreateEntity::updateAfterRender()
 611 {
 612         //H_AUTO(R2_CToolCreateEntity_updateAfterRender)
 613         if (_CreateState != DrawArray)
 614         {
 615                 CToolChoosePos::updateAfterRender();
 616                 return;
 617         }
 618         switch(_ArrayWantedAction)
 619         {
 620                 case ArrayActionNone:
 621                 break;
 622                 case ArrayActionValidate:
 623                 {
 624                         commitArray();
 625                         CTool::TSmartPtr hold(this);
 626                         CAHManager::getInstance()->runActionHandler("r2ed_create_entity", NULL, "PaletteId="+_PaletteId);
 627                         return;
 628                 }
 629                 break;
 630                 case ArrayActionCancel:
 631                 {
 632                         CTool::TSmartPtr hold(this);
 633                         cancel();
 634                         getEditor().setCurrentTool(NULL);
 635                         return;
 636                 }
 637                 break;
 638         }
 639         updateArray(NULL);
 640 }
 641
 642
 643 // ***************************************************************
 644 bool CToolCreateEntity::onMouseLeftButtonClicked()
 645 {
 646         //H_AUTO(R2_CToolCreateEntity_onMouseLeftButtonClicked)
 647         if (_CreateState != DrawArray)
 648         {
 649                 return CToolChoosePos::onMouseLeftButtonClicked();
 650         }
 651         if (_ValidArray)
 652         {
 653                 _ArrayWantedAction = ArrayActionValidate;
 654         }
 655         return true;
 656 }
 657
 658 // ***************************************************************
 659 bool CToolCreateEntity::onMouseRightButtonClicked()
 660 {
 661         //H_AUTO(R2_CToolCreateEntity_onMouseRightButtonClicked)
 662         if (_CreateState != DrawArray)
 663         {
 664                 return CToolChoosePos::onMouseRightButtonClicked();
 665         }
 666         _ArrayWantedAction = ArrayActionCancel;
 667         return true;
 668 }
 669
 670 // ***************************************************************
 671 void CToolCreateEntity::clearArray()
 672 {
 673         //H_AUTO(R2_CToolCreateEntity_clearArray)
 674         for (uint k = 0; k < _ArrayElements.size(); ++k)
 675         {
 676                 if (_ArrayElements[k])
 677                 {
 678                         getEditor().getDMC().requestEraseNode(_ArrayElements[k]->getDisplayedInstance()->getId(), "", -1);
 679                 }
 680         }
 681 }
 682
 683 // ***************************************************************
 684 void CToolCreateEntity::updateArray(CEntityCL *clonee)
 685 {
 686         //H_AUTO(R2_CToolCreateEntity_updateArray)
 687         if (!clonee)
 688         {
 689                 nlassert(!_ArrayElements.empty());
 690                 nlassert(_ArrayElements[0] != NULL);
 691                 clonee = _ArrayElements[0]->getEntity();
 692                 if (!clonee)
 693                 {
 694                         return;
 695                 }
 696         }
 697
 698         CVector extent = _ArrayEnd - _ArrayOrigin;
 699         uint arraySize = 1;
 700         float arrayStepLength = 1.f;
 701         if (!_ArrayElements.empty() && _ArrayElements[0])
 702         {
 703                 arrayStepLength = 2.f * _ArrayElements[0]->getSelectionDecalRadius();
 704                 arraySize = (uint) floorf(extent.norm() / arrayStepLength) + 1;
 705                 arraySize = std::min(arraySize, (uint) 16);
 706         }
 707         while (!getEditor().verifyRoomLeft(0, arraySize))
 708         {
 709                 -- arraySize;
 710                 if (arraySize == 0)
 711                 {
 712                         TSmartPtr hold(this);
 713                         cancel();
 714                         return;
 715                 }
 716         }
 717         _ArrayElements.resize(std::max(arraySize, uint(_ArrayElements.size())));
 718         CVector delta = arrayStepLength * extent.normed();
 719         float angle = _ArrayDefaultAngle;
 720         if (arraySize > 1)
 721         {
 722                 angle = - (float) atan2(extent.x, extent.y);
 723         }
 724         bool newEntityCreated = false;
 725         uint numCreatedEntity = 0;
 726         for (uint k = 0; k < _ArrayElements.size(); ++k)
 727         {
 728                 CVector pos = _ArrayOrigin + (float) k * delta;
 729                 if (!_ArrayElements[k])
 730                 {
 731                         if (k < arraySize)
 732                         {
 733                                 nlwarning("NEW ENTITY");
 734                                 // create new element
 735                                 std::string instanceId = cloneEntityIntoScenario(clonee,
 736                                                                                                                                  pos,
 737                                                                                                                                  angle,
 738                                                                                                                                  false, /*new action*/
 739                                                                                                                                  true /*create ghost*/);
 740                                 CInstance *inst = getEditor().getInstanceFromId(instanceId);
 741                                 if (inst)
 742                                 {
 743                                         _ArrayElements[k] = dynamic_cast<CDisplayerVisualEntity *>(inst->getDisplayerVisual());
 744                                         if (_ArrayElements[k])
 745                                         {
 746                                                 _ArrayElements[k]->setDisplayMode(CDisplayerVisual::DisplayModeArray);
 747                                         }
 748                                 }
 749                                 newEntityCreated = true;
 750                                 ++ numCreatedEntity;
 751                         }
 752                 }
 753
 754                 if (_ArrayElements[k])
 755                 {
 756                         bool active = k < arraySize;
 757                         // do a kind of 'reserve' on the list of entities : don't delete entities in excess, but hide them instead
 758                         if (active != _ArrayElements[k]->getActive())
 759                         {
 760                                 _ArrayElements[k]->setActive(active);
 761                                 if (active)
 762                                 {
 763                                         newEntityCreated = true;
 764                                         _ArrayElements[k]->setDisplayMode(CDisplayerVisual::DisplayModeArray);
 765                                 }
 766                         }
 767                         if (active)
 768                         {
 769                                 // update pos & angle
 770                                 TInstanceId     instanceId = _ArrayElements[k]->getDisplayedInstance()->getId();
 771                                 CVector worldPos = _ArrayElements[k]->getWorldPos();
 772                                 if (pos != worldPos)
 773                                 {
 774                                         CObject *newPos = buildVector(pos, _ArrayElements[k]->getDisplayedInstance()->getPosInstanceId());
 775                                         getEditor().getDMC().requestSetNode(instanceId, "Position", newPos);
 776                                         delete newPos;
 777                                 }
 778                                 if (angle != _ArrayElements[k]->getAngle())
 779                                 {
 780                                         CObjectNumber *angleObject = new CObjectNumber(angle);
 781                                         getEditor().getDMC().requestSetNode(instanceId, "Angle", angleObject);
 782                                         delete angleObject;
 783                                 }
 784                         }
 785                 }
 786         }
 787         if (newEntityCreated)
 788         {
 789                 nlwarning("Num created entity = %d", numCreatedEntity);
 790                 getEditor().getEntitySorter()->clipEntitiesByDist();
 791         }
 792 }
 793
 794 // ***************************************************************
 795 void CToolCreateEntity::commitArray()
 796 {
 797         //H_AUTO(R2_CToolCreateEntity_commitArray)
 798         for (uint k = 0; k < _ArrayElements.size(); ++k)
 799         {
 800                 if (_ArrayElements[k])
 801                 {
 802                         cloneEntityIntoScenario(_ArrayElements[k]->getEntity(),
 803                                                                         _ArrayElements[k]->getWorldPos(),
 804                                                                         _ArrayElements[k]->getAngle(),
 805                                                                         k == 0, /*new action*/
 806                                                                         false /*create ghost*/);
 807                 }
 808         }
 809         clearArray();
 810         getEditor().getDMC().flushActions();
 811 }
 812
 813 // ***************************************************************
 814 bool CToolCreateEntity::stopAfterCommit() const
 815 {
 816         //H_AUTO(R2_CToolCreateEntity_stopAfterCommit)
 817         return _CreateState == CreateSingle;
 818 }
 819
 820
 821
 822 // ***************************************************************
 823 class CAHR2EDToggleDrawArray : public IActionHandler
 824 {
 825         virtual void execute(CCtrlBase *pCaller, const std::string &/* sParams */)
 826         {
 827                 CInterfaceManager *im = CInterfaceManager::getInstance();
 828                 CCtrlBaseButton *but = dynamic_cast<CCtrlBaseButton *>(pCaller);
 829                 if (but)
 830                 {
 831                         NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:R2_DRAW_ARRAY")->setValueBool(but->getPushed());
 832                         CToolCreateEntity *tce = dynamic_cast<CToolCreateEntity *>(getEditor().getCurrentTool());
 833                         if (tce)
 834                         {
 835                                 CAHManager::getInstance()->runActionHandler("r2ed_create_entity", NULL, "PaletteId=" + tce->getPaletteId());
 836                         }
 837                 }
 838         }
 839 };
 840 REGISTER_ACTION_HANDLER(CAHR2EDToggleDrawArray, "r2ed_toggle_draw_array");
 841
 842
 843
 844
 845 } // R2