Ticket #96: progress_1_96_IV.patch

source/tools/atlas/AtlasUI/ScenarioEditor/Tools/PlaceObject.cpp

@@ -49 +49 @@
             + (m_ScreenPos.type1.y-m_Target.type1.y)*(m_ScreenPos.type1.y-m_Target.type1.y);
         bool useTarget = (dragDistSq >= 16*16);
         if (preview)
-            POST_MESSAGE(ObjectPreview, ((std::wstring)m_ObjectID.wc_str(), GetScenarioEditor().GetObjectSettings().GetSettings(), m_ObjPos, useTarget, m_Target, g_DefaultAngle, m_ActorSeed));
+            POST_MESSAGE(ObjectPreview, ((std::wstring)m_ObjectID.wc_str(), GetScenarioEditor().GetObjectSettings().GetSettings(), m_ObjPos, useTarget, m_Target, g_DefaultAngle, m_ActorSeed, true));
         else
         {
             POST_COMMAND(CreateObject, ((std::wstring)m_ObjectID.wc_str(), GetScenarioEditor().GetObjectSettings().GetSettings(), m_ObjPos, useTarget, m_Target, g_DefaultAngle, m_ActorSeed));

source/tools/atlas/AtlasUI/ScenarioEditor/Tools/TransformObject.cpp

@@ -23 +23 @@
 #include "Common/MiscState.h"
 #include "Common/ObjectSettings.h"
 #include "GameInterface/Messages.h"
+#include <wx/clipbrd.h>
+#include <wx/xml/xml.h>
+#include <wx/sstream.h>
 
 using AtlasMessage::Position;
 
@@ -33 +36 @@
     int m_dx, m_dy;
     AtlasMessage::ObjectID m_lastSelected;
     wxPoint m_startPoint;
+    Position m_entPosition;
 
     // TODO: If we don't plan to change hotkeys, just replace with evt.ShiftDown(), etc.
     static const wxKeyCode SELECTION_ADD_HOTKEY = WXK_SHIFT;
@@ -52 +56 @@
         POST_MESSAGE(SetSelectionPreview, (g_SelectedObjects));
     }
 
+    void OnPasteStart()
+    {
+        //PASTE
+        wxString entities;
+        if (wxTheClipboard->Open())
+        {
+            if (wxTheClipboard->IsSupported(wxDF_TEXT))
+            {
+                wxTextDataObject data;
+                wxTheClipboard->GetData(data);
+                entities = data.GetText();
+            }
+            wxTheClipboard->Close();
+        }
+        else 
+        {
+            //TODO: Show something when the clipboard couldnt open
+        }
+        
+        //First do we need to check if it is a correct xml string
+        wxInputStream* is = new wxStringInputStream(entities);
+        wxXmlDocument doc;
+        if (!doc.Load(*is))
+            return;
 
+        // Entities, Entity(1.*)
+        wxXmlNode* root = doc.GetRoot();
+        if (root->GetName() != wxT("Entities"))
+            return;
+
+        //  Template, position,orientation
+        const wxXmlNode* child = root->GetChildren();
+
+        while (child)
+        {
+            if (child->GetName() != wxT("Entity"))
+                return;
+
+            //TODO Validate all attributes
+            child = child->GetNext();
+        }
+        
+        //Update selectedObjects??
+        g_SelectedObjects.empty();
+        POST_MESSAGE(SetSelectionPreview, (g_SelectedObjects));
+
+        // is the source code get here now you can add the objects to scene(preview)
+        // store id to move 
+        child = root->GetChildren();
+        
+        while (child)
+        {
+            wxString templateName;
+            Position entityPos;
+            double orientation = 0;
+
+            const wxXmlNode* xmlData = child->GetChildren();
+            
+            while (xmlData)
+            {
+                if (xmlData->GetName() == wxT("Template"))
+                    templateName = xmlData->GetNodeContent();
+                else if (xmlData->GetName() == wxT("Position"))
+                {
+                    wxString x, z;
+                    xmlData->GetAttribute(wxT("x"), &x);
+                    xmlData->GetAttribute(wxT("z"), &z);
+                
+                    double aux,aux2;
+                    x.ToDouble(&aux);
+                    z.ToDouble(&aux2);
+
+                    entityPos = Position(aux, 0, aux2);
+                }
+                else if (xmlData->GetName() == wxT("Orientation"))
+                {
+                    wxString y;
+                    xmlData->GetAttribute(wxT("y"), &y);
+                    y.ToDouble(&orientation);
+                }
+
+                xmlData = xmlData->GetNext();
+            }
+
+            POST_MESSAGE(ObjectPreview, ((std::wstring)templateName.c_str(), GetScenarioEditor().GetObjectSettings().GetSettings(), entityPos, false, Position(), orientation, 0, false));
+
+            child = child->GetNext();
+        }
+
+        //Set state paste for preview the new objects
+        this->SetState(&Pasting);
+    }
+
+    void OnMovingPaste()
+    {
+        //Move the preview(s) object(s)
+        POST_MESSAGE(MoveObjectPreview, ((m_entPosition)));
+    }
+
+    void OnPasteEnd(bool canceled)
+    {
+        if (canceled)
+            //delete previews objects
+            POST_MESSAGE(ObjectPreview, (_T(""), GetScenarioEditor().GetObjectSettings().GetSettings(), Position(), false, Position(), 0, 0, true));
+        else
+        {
+            //Create new Objects and delete preview objects
+            POST_MESSAGE(ObjectPreviewToEntity, ());
+
+            AtlasMessage::qGetCurrentSelection currentSelection;
+            currentSelection.Post();
+
+            g_SelectedObjects = *currentSelection.ids;
+        }
+        
+
+        //when all is done set default state
+        this->SetState(&Waiting);
+    }
+
     // TODO: keys to rotate/move object?
 
     struct sWaiting : public State
@@ -167 +290 @@
                 obj->GetScenarioEditor().GetObjectSettings().NotifyObservers();
                 return true;
             }
-            else
-                return false;
+            else if (evt.GetModifiers() == wxMOD_CONTROL)
+            {
+                if (!g_SelectedObjects.empty())
+                {
+                    if (evt.GetKeyCode() == 'C')
+                    {
+                        //COPY current selections
+                        AtlasMessage::qGetObjectMapSettings info(g_SelectedObjects);
+                        info.Post();
+
+                        //In xmldata is the configuration
+                        //now send to clipboard
+                        if (wxTheClipboard->Open())
+                        {
+                            wxString text(info.xmldata.c_str());
+                            wxTheClipboard->SetData(new wxTextDataObject(text));
+                            wxTheClipboard->Close();
+                        }
+                        else
+                        {
+                            //TODO: Say something about couldnt open clipboard
+                        }
+                        return true;
+                    }
+                }
+                else if (evt.GetKeyCode() == 'V')
+                {
+                    obj->OnPasteStart();
+                    return true;
+                }
+            }
+            
+            return false;
         }
     }
     Waiting;
@@ -335 +489 @@
         }
     }
     SelectSimilar;
+
+    struct sPasting : public State
+    {
+        bool OnMouse(TransformObject* obj, wxMouseEvent& evt)
+        {
+            if (evt.Moving())
+            {
+                //Move the object
+                obj->m_entPosition = Position(evt.GetPosition());
+                obj->OnMovingPaste();
+                return true;
+            } 
+            else if (evt.LeftDown())
+            {
+                //Place the object and update 
+                obj->OnPasteEnd(false);
+                return true;
+            }
+            else
+                return false;
+        }
+        bool OnKey(TransformObject* obj, wxKeyEvent& evt, KeyEventType type)
+        {
+            if (type == KEY_CHAR && evt.GetKeyCode() == WXK_ESCAPE)
+            {
+                obj->OnPasteEnd(true);
+                return true;
+            }
+            else
+                return false;
+        }
+    }
+    Pasting;
 };
 
 IMPLEMENT_DYNAMIC_CLASS(TransformObject, StateDrivenTool<TransformObject>);

source/tools/atlas/GameInterface/Handlers/ObjectHandlers.cpp

@@ -49 +49 @@
 #include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/components/ICmpVisual.h"
 #include "simulation2/helpers/Selection.h"
+#include "ps/XML/XMLWriter.h"
 
-
 namespace AtlasMessage {
 
 namespace
@@ -218 +218 @@
     msg->settings = settings;
 }
 
+QUERYHANDLER(GetObjectMapSettings)
+{
+    std::vector<entity_id_t> ids = *msg->ids;
+    
+    CmpPtr<ICmpTemplateManager> cmpTemplateManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+    ENSURE(cmpTemplateManager);
+    
+    XML_Start();
+    {
+        XML_Element("Entities");
+        {
+            for (size_t i = 0; i < ids.size(); i++)
+            {
+                entity_id_t id = (entity_id_t)ids[i];
+                XML_Element("Entity");
+                {
+                    //Template name
+                    XML_Setting("Template", cmpTemplateManager->GetCurrentTemplateName(id));
+                    
+                    //Player
+                    CmpPtr<ICmpOwnership> cmpOwnership(*g_Game->GetSimulation2(), id);
+                    if (cmpOwnership)
+                        XML_Setting("Player", (int)cmpOwnership->GetOwner());
+                    
+                    //Adding position to make some relative position later
+                    CmpPtr<ICmpPosition> cmpPosition(*g_Game->GetSimulation2(), id);
+                    if (cmpPosition)
+                    {
+                        CFixedVector3D pos = cmpPosition->GetPosition();
+                        CFixedVector3D rot = cmpPosition->GetRotation();
+                        {
+                            XML_Element("Position");
+                            XML_Attribute("x", pos.X);
+                            XML_Attribute("z", pos.Z);
+                            // TODO: height offset etc
+                        }
+                        {
+                            XML_Element("Orientation");
+                            XML_Attribute("y", rot.Y);
+                                                        // TODO: X, Z maybe
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    const CStr& data = XML_GetOutput();
+    msg->xmldata = std::wstring(data.begin(), data.end());
+}
+
+
 BEGIN_COMMAND(SetObjectSettings)
 {
     player_id_t m_PlayerOld, m_PlayerNew;
@@ -283 +335 @@
 
 static CStrW g_PreviewUnitName;
 static entity_id_t g_PreviewEntityID = INVALID_ENTITY;
+static std::vector<entity_id_t> g_PreviewEntitiesID;
 
 static CVector3D GetUnitPos(const Position& pos, bool floating)
 {
@@ -311 +364 @@
     return vec;
 }
 
+QUERYHANDLER(GetCurrentSelection)
+{
+    msg->ids = g_Selection;
+}
+
+MESSAGEHANDLER(ObjectPreviewToEntity)
+{
+    UNUSED2(msg);
+
+    if (g_PreviewEntitiesID.size() == 0)
+        return;
+
+    CmpPtr<ICmpTemplateManager> cmpTemplateManager(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+    ENSURE(cmpTemplateManager);
+
+    PlayerColorMap playerColor;
+
+    //I need to re create the objects finally delete preview objects
+    std::vector<entity_id_t>::const_iterator i;
+    for (i = g_PreviewEntitiesID.begin(); i != g_PreviewEntitiesID.end(); i++)
+    {
+        //Get template
+        entity_id_t ent = *i;
+        std::string templateName = cmpTemplateManager->GetCurrentTemplateName(ent);
+        std::wstring wTemplateName(templateName.begin() + 8, templateName.end());
+        //Create new entity
+        entity_id_t new_ent = g_Game->GetSimulation2()->AddEntity(wTemplateName);
+        if (new_ent == INVALID_ENTITY)
+            continue;
+
+        //get position, get rotation
+        CmpPtr<ICmpPosition> cmpPositionNew(*g_Game->GetSimulation2(), new_ent);
+        CmpPtr<ICmpPosition> cmpPositionOld(*g_Game->GetSimulation2(), ent);
+
+        if (cmpPositionNew && cmpPositionOld)
+        {
+            CVector3D pos = cmpPositionOld->GetPosition();
+            cmpPositionNew->JumpTo(entity_pos_t::FromFloat(pos.X), entity_pos_t::FromFloat(pos.Z));
+
+            //now rotate
+            CFixedVector3D rotation = cmpPositionOld->GetRotation();
+            cmpPositionNew->SetYRotation(rotation.Y);
+        }
+
+        //get owner
+        CmpPtr<ICmpOwnership> cmpOwnershipNew(*g_Game->GetSimulation2(), new_ent);
+        CmpPtr<ICmpOwnership> cmpOwnershipOld(*g_Game->GetSimulation2(), ent);
+        if (cmpOwnershipNew && cmpOwnershipOld)
+            cmpOwnershipNew->SetOwner(cmpOwnershipOld->GetOwner());
+
+        //getVisual
+        CmpPtr<ICmpVisual> cmpVisualNew(*g_Game->GetSimulation2(), new_ent);
+        CmpPtr<ICmpVisual> cmpVisualOld(*g_Game->GetSimulation2(), ent);
+        if (cmpVisualNew && cmpVisualOld)
+            cmpVisualNew->SetActorSeed(cmpVisualOld->GetActorSeed());
+
+        //Update g_selectedObject and higligth
+        g_Selection.push_back(new_ent);
+        CmpPtr<ICmpSelectable> cmpSelectable(*g_Game->GetSimulation2(), new_ent);
+        if (cmpSelectable)
+            cmpSelectable->SetSelectionHighlight(GetOwnerPlayerColor(playerColor, new_ent), true);
+
+        g_Game->GetSimulation2()->DestroyEntity(ent);
+    }
+    g_PreviewEntitiesID.clear();
+
+}
+
+MESSAGEHANDLER(MoveObjectPreview)
+{
+    if (g_PreviewEntitiesID.size()==0)
+        return;
+
+    //TODO:Change pivot 
+    entity_id_t referenceEntity = *g_PreviewEntitiesID.begin();
+
+    // All selected objects move relative to a pivot object,
+    //  so get its position and whether it's floating
+    CFixedVector3D referencePos;
+    
+    CmpPtr<ICmpPosition> cmpPosition(*g_Game->GetSimulation2(), referenceEntity);
+    if (cmpPosition && cmpPosition->IsInWorld())
+        referencePos = cmpPosition->GetPosition();
+        
+
+    // Calculate directional vector of movement for pivot object,
+    //  we apply the same movement to all objects
+    CVector3D targetPos = GetUnitPos(msg->pos, true);
+    CFixedVector3D fTargetPos(entity_pos_t::FromFloat(targetPos.X), entity_pos_t::FromFloat(targetPos.Y), entity_pos_t::FromFloat(targetPos.Z));
+    CFixedVector3D dir = fTargetPos - referencePos;
+
+    for (size_t i = 0; i < g_PreviewEntitiesID.size(); ++i)
+    {
+        entity_id_t id = (entity_id_t)g_PreviewEntitiesID[i];
+        CFixedVector3D posFinal;
+        CmpPtr<ICmpPosition> cmpPosition(*g_Game->GetSimulation2(), id);
+        if (cmpPosition && cmpPosition->IsInWorld())
+        {
+            // Calculate this object's position
+            CFixedVector3D posFixed = cmpPosition->GetPosition();
+            posFinal = posFixed + dir;
+        }
+        cmpPosition->JumpTo(posFinal.X, posFinal.Z);
+    }
+}
+
 MESSAGEHANDLER(ObjectPreview)
 {
     // If the selection has changed...
-    if (*msg->id != g_PreviewUnitName)
+    if (*msg->id != g_PreviewUnitName || (!msg->cleanObjectPreviews))
     {
         // Delete old entity
-        if (g_PreviewEntityID != INVALID_ENTITY)
-            g_Game->GetSimulation2()->DestroyEntity(g_PreviewEntityID);
+        if (g_PreviewEntityID != INVALID_ENTITY && msg->cleanObjectPreviews)
+        {
+            //Time to delete all preview objects
+            if (g_PreviewEntitiesID.size() > 0)
+            {
+                std::vector<entity_id_t>::const_iterator i;
+                for (i = g_PreviewEntitiesID.begin(); i != g_PreviewEntitiesID.end(); i++)
+                {
+                    g_Game->GetSimulation2()->DestroyEntity(*i);
+                }
+                g_PreviewEntitiesID.clear();
+            }
+        }
 
         // Create the new entity
         if ((*msg->id).empty())
             g_PreviewEntityID = INVALID_ENTITY;
         else
+        {
             g_PreviewEntityID = g_Game->GetSimulation2()->AddLocalEntity(L"preview|" + *msg->id);
+            g_PreviewEntitiesID.push_back(g_PreviewEntityID);
+        }
+        
 
         g_PreviewUnitName = *msg->id;
     }

source/tools/atlas/GameInterface/Messages.h

@@ -334 +334 @@
 SHAREABLE_STRUCT(sObjectSettings);
 #endif
 
+// transform de local entity to a real entity
+MESSAGE(ObjectPreviewToEntity,);
+
+//Query for get selected objects
+QUERY(GetCurrentSelection,
+    , //No inputs
+    ((std::vector<ObjectID>, ids))
+    );
+
+// Moving Preview(s) object together, default is using the firs element in vector
+MESSAGE(MoveObjectPreview,
+        ((Position,pos))
+        );
+
 // Preview object in the game world - creates a temporary unit at the given
 // position, and removes it when the preview is next changed
 MESSAGE(ObjectPreview,
@@ -344 +358 @@
         ((Position, target))
         ((float, angle))
         ((unsigned int, actorseed))
+        ((bool, cleanObjectPreviews))
         );
 
 COMMAND(CreateObject, NOMERGE,
@@ -590 +605 @@
         ((sObjectSettings, settings))
         );
 
+QUERY(GetObjectMapSettings,
+        ((std::vector<ObjectID>, ids))
+        ,
+        ((std::wstring, xmldata))
+        );
+
+
 QUERY(GetPlayerObjects,
         ((int, player))
         ,