mail[Wesnoth-commits] r20653 - in /trunk/src/editor: editor.cpp editor.hpp


Others Months | Index by Date | Thread Index
>>   [Date Prev] [Date Next] [Thread Prev] [Thread Next]

Header


Content

Posted by alinktomine on September 22, 2007 - 01:55:
Author: alink
Date: Sat Sep 22 01:54:56 2007
New Revision: 20653

URL: http://svn.gna.org/viewcvs/wesnoth?rev=20653&view=rev
Log:
- Fix a bug with the drag-move in editor (collision between read and write
if source and destination areas are not disjoint)
- Introduce a map_buffer type to handle this kind of operations and simplify
the clipboard functions
- Simplify the arithmetic operations about cartesian/hexagonal translations

Modified:
    trunk/src/editor/editor.cpp
    trunk/src/editor/editor.hpp

Modified: trunk/src/editor/editor.cpp
URL: 
http://svn.gna.org/viewcvs/wesnoth/trunk/src/editor/editor.cpp?rev=20653&r1=20652&r2=20653&view=diff
==============================================================================
--- trunk/src/editor/editor.cpp (original)
+++ trunk/src/editor/editor.cpp Sat Sep 22 01:54:56 2007
@@ -633,56 +633,23 @@
 
 void map_editor::edit_fill_selection() {
        map_undo_action undo_action;
-       for (std::set<gamemap::location>::const_iterator it = 
selected_hexes_.begin();
-                it != selected_hexes_.end(); it++) {
-               if (map_.on_board(*it)) {
-                       undo_action.add_terrain(map_.get_terrain(*it), 
palette_.selected_fg_terrain(), *it);
-                       map_.set_terrain(*it, palette_.selected_fg_terrain());
-               }
-       }
-       terrain_changed(selected_hexes_);
+       perform_fill_selection(undo_action);
        save_undo_action(undo_action);
 }
 
 void map_editor::edit_cut() {
-       clipboard_.clear();
-       insert_selection_in_clipboard();
+       edit_copy();
        edit_fill_selection();
 }
 
 void map_editor::edit_copy() {
-       clipboard_.clear();
+       clear_buffer(clipboard_);
        insert_selection_in_clipboard();
 }
 
 void map_editor::perform_paste() {
        map_undo_action undo_action;
-       std::set<gamemap::location> filled;
-       gamemap::location start_hex = selected_hex_;
-       clear_highlighted_hexes_in_gui();
-       for (std::vector<clipboard_item>::const_iterator it = 
clipboard_.begin();
-                it != clipboard_.end(); it++) {
-               gamemap::location l(clipboard_offset_loc_.x + (*it).x_offset,
-                                                       
clipboard_offset_loc_.y + (*it).y_offset);
-               const int x_offset = start_hex.x - clipboard_offset_loc_.x;
-               const int y_offset = start_hex.y - clipboard_offset_loc_.y;
-               gamemap::location target = get_hex_with_offset(l, x_offset, 
y_offset);
-               if (map_.on_board(target)) {
-                       undo_action.add_terrain(map_.get_terrain(target), 
(*it).terrain, target);
-                       map_.set_terrain(target, (*it).terrain);
-                       const int start_side = (*it).starting_side;
-                       if (start_side != -1) {
-                               undo_action.add_starting_location(start_side, 
start_side,
-                                       map_.starting_position(start_side), 
target);
-                               map_.set_starting_position(start_side, 
target);
-                       }
-                       filled.insert(target);
-                       gui_.add_highlighted_loc(target);
-               }
-       }
-       undo_action.set_selection(selected_hexes_, filled);
-       terrain_changed(filled);
-       selected_hexes_ = filled;
+       paste_buffer(clipboard_, selected_hex_, undo_action);
        save_undo_action(undo_action);
 }
 
@@ -786,28 +753,76 @@
        return command_executor::get_action_state(command);
 }
 
+void map_editor::copy_buffer(map_buffer& buffer, const 
std::set<gamemap::location> &locs, const gamemap::location &origin)
+{
+       std::set<gamemap::location>::const_iterator it;
+       for (it = locs.begin(); it != locs.end(); it++) {
+               t_translation::t_letter terrain = map_.get_terrain(*it);
+               buffer.push_back(buffer_item(*it-origin, terrain, 
starting_side_at(map_, *it)));
+       }
+}
+
+void map_editor::paste_buffer(const map_buffer &buffer, const 
gamemap::location &loc, map_undo_action &undo_action)
+{
+       std::set<gamemap::location> filled;
+       std::vector<buffer_item>::const_iterator it;
+       for (it = buffer.begin(); it != buffer.end(); it++) {
+               //the addition of locations is not commutative !
+               gamemap::location target = it->offset + loc;
+
+               if (map_.on_board(target)) {
+                       undo_action.add_terrain(map_.get_terrain(target), 
it->terrain, target);
+                       map_.set_terrain(target, it->terrain);
+                       const int start_side = it->starting_side;
+                       if (start_side != -1) {
+                               undo_action.add_starting_location(start_side, 
start_side,
+                                       map_.starting_position(start_side), 
target);
+                               map_.set_starting_position(start_side, 
target);
+                       }
+                       filled.insert(target);
+               }
+       }
+
+       terrain_changed(filled);
+       undo_action.set_selection(selected_hexes_, filled);
+       selected_hexes_ = filled;
+       highlight_selected_hexes(true);
+}
+
 void map_editor::insert_selection_in_clipboard() {
-       if (selected_hexes_.empty()) {
-               return;
-       }
-       gamemap::location offset_hex = *(selected_hexes_.begin());
+
+       // Find the hex that is closest to the selected one,
+       // use this as origin
+       gamemap::location origin(1000,1000);
        std::set<gamemap::location>::const_iterator it;
-       // Find the hex that is closest to the selected one,
-       // use this as the one to calculate the offset from.
        for (it = selected_hexes_.begin(); it != selected_hexes_.end(); it++) 
{
                if (distance_between(selected_hex_, *it) <
-                       distance_between(selected_hex_, offset_hex)) {
-                       offset_hex = *it;
-               }
-       }
-       clipboard_offset_loc_ = offset_hex;
+                       distance_between(selected_hex_, origin)) {
+                       origin = *it;
+               }
+       }
+
+       copy_buffer(clipboard_, selected_hexes_, origin);
+}
+
+void map_editor::perform_fill_selection(map_undo_action &undo_action) {
+       std::set<gamemap::location>::const_iterator it;
        for (it = selected_hexes_.begin(); it != selected_hexes_.end(); it++) 
{
-               const int x_offset = (*it).x - offset_hex.x;
-               const int y_offset = (*it).y - offset_hex.y;
-               t_translation::t_letter terrain = map_.get_terrain(*it);
-               clipboard_.push_back(clipboard_item(x_offset, y_offset, 
terrain,
-                                    starting_side_at(map_, *it)));
-       }
+               if (map_.on_board(*it)) {
+                       undo_action.add_terrain(map_.get_terrain(*it), 
palette_.selected_bg_terrain(), *it);
+                       map_.set_terrain(*it, palette_.selected_bg_terrain());
+               }
+       }
+       terrain_changed(selected_hexes_);
+}
+
+void map_editor::perform_selection_move() {
+       map_undo_action undo_action;
+       map_buffer buf;
+       copy_buffer(buf, selected_hexes_, selection_move_start_);
+       perform_fill_selection(undo_action);
+       paste_buffer(buf,selected_hex_, undo_action);
+       save_undo_action(undo_action);
 }
 
 
@@ -1042,15 +1057,6 @@
        from_scenario_ = from_scenario;
 }
 
-gamemap::location map_editor::get_hex_with_offset(const gamemap::location 
loc,
-                                                  const int x_offset, const 
int y_offset) {
-       gamemap::location new_loc(loc.x + x_offset, loc.y + y_offset);
-       if (new_loc.x % 2 != loc.x % 2 && is_odd(new_loc.x)) {
-               new_loc.y--;
-       }
-       return new_loc;
-}
-
 void map_editor::left_button_down(const int mousex, const int mousey) {
        const gamemap::location& minimap_loc = 
gui_.minimap_location_on(mousex,mousey);
        const gamemap::location hex = gui_.hex_clicked_on(mousex, mousey);
@@ -1101,14 +1107,12 @@
        }
        else if (l_button_held_func_ == MOVE_SELECTION) {
                reset_mouseover_overlay();
-               const int x_diff = hex.x - selection_move_start_.x;
-               const int y_diff = hex.y - selection_move_start_.y;
+               //(*it-selection_move_start_) + hex
                // No other selections should be active when doing this.
                gui_.clear_highlighted_locs();
-               for (std::set<gamemap::location>::const_iterator it = 
selected_hexes_.begin();
-                        it != selected_hexes_.end(); it++) {
-                       const gamemap::location hl_loc =
-                               get_hex_with_offset(*it, x_diff, y_diff);
+               std::set<gamemap::location>::const_iterator it;
+               for (it = selected_hexes_.begin(); it != 
selected_hexes_.end(); it++) {
+                       const gamemap::location hl_loc = 
(*it-selection_move_start_) + hex;
                        if (map_.on_board(hl_loc)) {
                                gui_.add_highlighted_loc(hl_loc);
                        }
@@ -1146,45 +1150,6 @@
                        }
                }
        }
-}
-
-void map_editor::perform_selection_move() {
-       map_undo_action undo_action;
-       const int x_diff = selected_hex_.x - selection_move_start_.x;
-       const int y_diff = selected_hex_.y - selection_move_start_.y;
-       clear_highlighted_hexes_in_gui();
-       std::set<gamemap::location> new_selection;
-       // Transfer the terrain to the new position.
-       std::set<gamemap::location>::const_iterator it;
-       for(it = selected_hexes_.begin(); it != selected_hexes_.end(); it++) {
-               const gamemap::location hl_loc =
-                       get_hex_with_offset(*it, x_diff, y_diff);
-               if (map_.on_board(hl_loc)) {
-                       undo_action.add_terrain(map_.get_terrain(hl_loc), 
map_.get_terrain(*it), hl_loc);
-                       gui_.add_highlighted_loc(hl_loc);
-                       map_.set_terrain(hl_loc, map_.get_terrain(*it));
-                       const int start_side = starting_side_at(map_, *it);
-                       if (start_side != -1) {
-                               // Starting side at the old location that 
needs transfering.
-                               map_.set_starting_position(start_side, 
hl_loc);
-                               undo_action.add_starting_location(start_side, 
start_side, *it, hl_loc);
-                       }
-                       new_selection.insert(hl_loc);
-               }
-       }
-
-       // Fill the selection with the selected terrain.
-       for (it = selected_hexes_.begin(); it != selected_hexes_.end(); it++) 
{
-               if (map_.on_board(*it) && new_selection.find(*it) == 
new_selection.end()) {
-                       undo_action.add_terrain(map_.get_terrain(*it), 
palette_.selected_bg_terrain(), *it);
-                       map_.set_terrain(*it, palette_.selected_bg_terrain());
-               }
-       }
-       undo_action.set_selection(selected_hexes_, new_selection);
-       terrain_changed(selected_hexes_);
-       selected_hexes_ = new_selection;
-       terrain_changed(selected_hexes_);
-       save_undo_action(undo_action);
 }
 
 void map_editor::draw_terrain(const t_translation::t_letter terrain,

Modified: trunk/src/editor/editor.hpp
URL: 
http://svn.gna.org/viewcvs/wesnoth/trunk/src/editor/editor.hpp?rev=20653&r1=20652&r2=20653&view=diff
==============================================================================
--- trunk/src/editor/editor.hpp (original)
+++ trunk/src/editor/editor.hpp Sat Sep 22 01:54:56 2007
@@ -232,11 +232,8 @@
        /// Insert the currently selected locations in the clipboard.
        void insert_selection_in_clipboard();
 
-       /// Return the hex with the given offset from loc. Make calculations
-       /// so the result with have the same _appearance_ as when the offset
-       /// was calculated ,not the same representation.
-       gamemap::location get_hex_with_offset(const gamemap::location loc,
-                                                                             
    const int x_offset, const int y_offset);
+       /// Commit a selection filling.
+       void perform_fill_selection(map_undo_action &undo_action);
 
        /// Commit the movement of a selection.
        void perform_selection_move();
@@ -292,18 +289,25 @@
        // Load the tooltips for each button
        void load_tooltips(void);
 
-       /// An item in the clipboard. Consists of the copied terrain and an
+       /// An item in the buffer. Consists of the copied terrain and an
        /// offset. When pasting stuff, the offset is used to calculate
-       /// where to put the pasted hex when calculating from the one
-       /// selected when the paste takes place.
-       struct clipboard_item {
-               clipboard_item(int xo, int yo, t_translation::t_letter t, int 
start_side) :
-                       x_offset(xo), y_offset(yo), terrain(t),
-                       starting_side(start_side){}
-               int x_offset, y_offset;
+       /// where to put the pasted hex
+       struct buffer_item {
+               buffer_item(const gamemap::location &o, 
t_translation::t_letter t, int start_side) :
+                       offset(o), terrain(t), starting_side(start_side) {}
+               gamemap::location offset;
                t_translation::t_letter terrain;
                int starting_side;
        };
+
+       // map_buffer is used for clipboard and other map operations
+       typedef std::vector<buffer_item> map_buffer;
+
+       void copy_buffer(map_buffer& buffer, const 
std::set<gamemap::location> &locs,
+                        const gamemap::location &origin);
+       void paste_buffer(const map_buffer& buffer, const gamemap::location 
&loc,
+                       map_undo_action &undo_action);
+       void clear_buffer(map_buffer& buffer) {buffer.clear();};
 
        editor_display &gui_;
        editormap &map_;
@@ -331,8 +335,8 @@
        std::vector<gamemap::location> starting_positions_;
        std::set<gamemap::location> mouse_over_hexes_;
        std::set<gamemap::location> selected_hexes_;
-       std::vector<clipboard_item> clipboard_;
-       gamemap::location clipboard_offset_loc_;
+       map_buffer clipboard_;
+       
        LEFT_BUTTON_HELD_FUNC l_button_held_func_;
        gamemap::location selection_move_start_;
 




Related Messages


Powered by MHonArc, Updated Sat Sep 22 02:20:40 2007