[Mys-venture-commits] SF.net SVN: mys-venture:[78] trunk

[<kim...@us...>]

Revision: 78
          http://mys-venture.svn.sourceforge.net/mys-venture/?rev=78&view=rev
Author:   kimmovii
Date:     2010-07-28 13:17:23 +0000 (Wed, 28 Jul 2010)

Log Message:
-----------
Implemented MapColumn and MapLayer. Untested.

Modified Paths:
--------------
    trunk/design/game/technical_design.odt
    trunk/mysventure/include/sub_level/sub_gamelevels.h
    trunk/mysventure/mys-venture.pro

Added Paths:
-----------
    trunk/mysventure/include/sub_level/mapcolumn.h
    trunk/mysventure/include/sub_level/maplayer.h
    trunk/mysventure/source/sub_level/mapcolumn.cpp
    trunk/mysventure/source/sub_level/maplayer.cpp

Modified: trunk/design/game/technical_design.odt
===================================================================
(Binary files differ)

Added: trunk/mysventure/include/sub_level/mapcolumn.h
===================================================================
--- trunk/mysventure/include/sub_level/mapcolumn.h	                        (rev 0)
+++ trunk/mysventure/include/sub_level/mapcolumn.h	2010-07-28 13:17:23 UTC (rev 78)
@@ -0,0 +1,136 @@
+/*
+    Mys-venture is a 2D tile-based puzzle game.
+    Copyright (C) 2010 Kimmo Viitanen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*! \file
+Declaration for class MapColumn.
+*/
+
+#ifndef MAPCOLUMN_H
+#define MAPCOLUMN_H
+
+#include <QVector>
+
+#include "util/identification.h"
+
+
+namespace Sub_GameLevel
+{
+
+    /*! \brief
+    MapColumn represents a column of a map layer.
+    */
+    /*!
+    MapColumn is a container for Identification objects and
+    represents a single column on map layer.
+
+    The column can be initialized during construction by passing
+    the size of the column and the column data as a QVector to
+    the constructor.
+
+    The size of the column can be retrieved with either
+    getColumnSize() or getNumberOfRows(). The ID of the entity at a
+    position in the column can be retrieved with getEntity() and
+    a new entity can be set with setEntity().
+    */
+    class MapColumn
+    {
+    public:
+
+        /*! \brief
+        The default constructor.
+        */
+        MapColumn(unsigned int columnSize = 0,
+                  const QVector<Sub_GameUtility::Identification>& columnData =
+                  QVector<Sub_GameUtility::Identification>());
+
+        /*! \brief
+        Resizes the column to newSize elements.
+        */
+        void resize(unsigned int newSize);
+
+        /*! \brief
+        Returns the size of the column (the number of rows).
+        */
+        unsigned int getColumnSize() const;
+
+        /*! \brief
+        Returns the number of rows in column (the column size).
+        */
+        unsigned int getNumberOfRows() const;
+
+        /*! \brief
+        Returns the ID at position columnPos.
+        */
+        Sub_GameUtility::Identification
+        getEntity(unsigned int columnPos) const;
+
+        /*! \brief
+        Sets the ID at columnPos to entity.
+        */
+        void setEntity(unsigned int columnPos,
+                       const Sub_GameUtility::Identification& entity);
+
+        /*! \brief
+        Returns a reference to the ID at position columnPos.
+        */
+        Sub_GameUtility::Identification& operator[](unsigned int columnPos);
+
+        /*! \brief
+        Returns a reference to the ID at position columnPos. const version.
+        */
+        const Sub_GameUtility::Identification& operator[](unsigned int columnPos) const;
+
+    private:
+
+        /*!
+        The internal column.
+        */
+        QVector<Sub_GameUtility::Identification> m_column;
+
+        /*!
+        The size of the column in tiles.
+        */
+        unsigned int m_columnSize;
+
+
+        /*! \brief
+        Fits the column to a size greater than the current size.
+
+        Internal.
+        */
+        void fitToGreater(unsigned int newSize);
+
+        /*! \brief
+        Fist the column to a size smaller than the current size.
+
+        Internal.
+        */
+        void fitToSmaller(unsigned int newSize);
+
+        /*! \brief
+        Checks the class invariant.
+        */
+        void invariant() const;
+
+    }; // class MapColumn
+
+} // namespace Sub_GameLevel
+
+
+
+#endif // MAPCOLUMN_H

Added: trunk/mysventure/include/sub_level/maplayer.h
===================================================================
--- trunk/mysventure/include/sub_level/maplayer.h	                        (rev 0)
+++ trunk/mysventure/include/sub_level/maplayer.h	2010-07-28 13:17:23 UTC (rev 78)
@@ -0,0 +1,149 @@
+/*
+    Mys-venture is a 2D tile-based puzzle game.
+    Copyright (C) 2010 Kimmo Viitanen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef MAPLAYER_H
+#define MAPLAYER_H
+
+#include <QVector>
+
+#include "sub_level/mapcolumn.h"
+
+namespace Sub_GameLevel
+{
+
+    /*! \brief
+    MapLayer represents a layer on a game map.
+    */
+    /*!
+    MapLayer can be initialized on construction by passing number of rows and
+    columns, layer number and the layer data to the default constructor.
+
+    Layer size can be queried with getColumnSize() and getRowSize().
+
+    Contents of a whole column can be changed with setColumn().
+    Contents of a single position can be changed with setEntity().
+    */
+    class MapLayer
+    {
+    public:
+
+        /*! \brief
+        The default constructor.
+        */
+        MapLayer(unsigned int rowSize = 0,
+                 unsigned int columnSize = 0,
+                 unsigned int layerNumber = 0,
+                 const QVector<Sub_GameLevel::MapColumn>& layerData =
+                 QVector<Sub_GameLevel::MapColumn>());
+
+        /*! \brief
+        Returns the size of a column in layer.
+        */
+        unsigned int getColumnSize() const;
+
+        /*! \brief
+        Returns the number of rows in a layer.
+        */
+        unsigned int getNumberOfRows() const;
+
+        /*! \brief
+        Returns the size of a row in layer.
+        */
+        unsigned int getRowSize() const;
+
+        /*! \brief
+        Returns the number of columns in the layer.
+        */
+        unsigned int getNumberOfColumns() const;
+
+        /*! \brief
+        Returns the layer number of the layer.
+        */
+        unsigned int getLayerNumber() const;
+
+        /*! \brief
+        Sets the contents of column pos to column.
+        */
+        void setColumn(unsigned int pos,
+                       const MapColumn& column);
+
+        /*! \brief
+        Sets the contents of column pos to column.
+        */
+        void setColumn(unsigned int pos,
+                       const QVector<Sub_GameUtility::Identification>& column);
+        /*! \brief
+        Returns the ID of the entity at position (column, row).
+        */
+        Sub_GameUtility::Identification
+        getEntity(unsigned int row, unsigned int column) const;
+
+        /*! \brief
+        Sets the value of entity at (column, row) to entity.
+        */
+        void setEntity(unsigned int row, unsigned int column,
+                       const Sub_GameUtility::Identification& entity);
+        /*! \brief
+        Returns the contents of the column pos as a MapColumn.
+        */
+        MapColumn getColumn(unsigned int pos) const;
+
+        /*! \brief
+        Changes the size of the layer to rows rows and columns columns.
+        */
+        void resize(unsigned int rows,
+                    unsigned int columns);
+
+    private:
+
+        /*!
+        Internal layer.
+        */
+        QVector<Sub_GameLevel::MapColumn> m_layer;
+
+        /*!
+        Size of a row in layer.
+        */
+        unsigned int m_rowSize;
+
+        /*!
+        Size of a column in layer.
+        */
+        unsigned int m_columnSize;
+
+        /*!
+        Layer number of the layer.
+        */
+        unsigned int m_layerNumber;
+
+
+
+        void fitToGreater(unsigned int rows, unsigned int columns);
+
+        void fitToSmaller(unsigned int rows, unsigned int columns);
+
+        /*! \brief
+        Check class invariant.
+        */
+        void invariant() const;
+
+    };
+
+}
+
+#endif // MAPLAYER_H

Modified: trunk/mysventure/include/sub_level/sub_gamelevels.h
===================================================================
--- trunk/mysventure/include/sub_level/sub_gamelevels.h	2010-07-26 15:34:19 UTC (rev 77)
+++ trunk/mysventure/include/sub_level/sub_gamelevels.h	2010-07-28 13:17:23 UTC (rev 78)
@@ -23,6 +23,9 @@
 #ifndef SUB_GAMELEVELS_H
 #define SUB_GAMELEVELS_H
 
+#include "sub_level/mapcolumn.h"
+#include "sub_level/maplayer.h"
+
 /*! \brief
 Contains all identifiers in the levels subsystem.
 */

Modified: trunk/mysventure/mys-venture.pro
===================================================================
--- trunk/mysventure/mys-venture.pro	2010-07-26 15:34:19 UTC (rev 77)
+++ trunk/mysventure/mys-venture.pro	2010-07-28 13:17:23 UTC (rev 78)
@@ -23,7 +23,9 @@
     source/sub_entity/entitystorage.cpp \
     source/sub_entity/abstractentitymaker.cpp \
     source/sub_entity/basegameentitymaker.cpp \
-    source/sub_entity/entitymanager.cpp
+    source/sub_entity/entitymanager.cpp \
+    source/sub_level/mapcolumn.cpp \
+    source/sub_level/maplayer.cpp
 HEADERS += include/sub_view/mainwindow.h \
     include/util/Position.h \
     include/util/identification.h \
@@ -49,7 +51,9 @@
     include/sub_entity/abstractentitymaker.h \
     include/sub_entity/basegameentitymaker.h \
     include/util/util_functions.h \
-    include/sub_entity/entitymanager.h
+    include/sub_entity/entitymanager.h \
+    include/sub_level/mapcolumn.h \
+    include/sub_level/maplayer.h
 FORMS += source/sub_view/mainwindow.ui \
     source/sub_view/mapview.ui
 LIBS += -Llib \

Added: trunk/mysventure/source/sub_level/mapcolumn.cpp
===================================================================
--- trunk/mysventure/source/sub_level/mapcolumn.cpp	                        (rev 0)
+++ trunk/mysventure/source/sub_level/mapcolumn.cpp	2010-07-28 13:17:23 UTC (rev 78)
@@ -0,0 +1,174 @@
+/*
+    Mys-venture is a 2D tile-based puzzle game.
+    Copyright (C) 2010 Kimmo Viitanen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*! \file
+Implementation for class MapColumn.
+*/
+
+#include "sub_level/mapcolumn.h"
+
+using Sub_GameUtility::Identification;
+
+/*!
+The size of the column and the column data can be
+passed to the default constructor. If the column size and
+the size of the passed data are not equal, the column will be
+resized to fit columnSize.
+*/
+Sub_GameLevel
+::MapColumn::MapColumn(unsigned int columnSize,
+                       const QVector<Identification> &columnData)
+: m_column(columnData), m_columnSize(columnSize)
+{
+    if (columnData.size() != m_columnSize)
+        this->resize(m_columnSize);
+
+    invariant();
+}
+
+
+
+/*!
+If newSize is smaller than the current column size,
+the extra elements are cut off from the end.
+If newSize is greater than the current column size,
+the end of the column is filled with default values
+(invalid IDs).
+*/
+void
+Sub_GameLevel
+::MapColumn::resize(unsigned int newSize)
+{
+    invariant();
+    // If newSize is the same as existing size, do nothing.
+    if (newSize == m_columnSize)
+        return;
+
+    if (newSize > m_columnSize)
+        fitToGreater(newSize);
+    else if (newSize < m_columnSize)
+        fitToSmaller(newSize);
+
+    invariant();
+}
+
+
+
+unsigned int
+Sub_GameLevel
+::MapColumn::getColumnSize() const
+{
+    invariant();
+
+    return m_columnSize;
+}
+
+
+unsigned int
+Sub_GameLevel
+::MapColumn::getNumberOfRows() const
+{
+    invariant();
+
+    return m_columnSize;
+}
+
+
+
+Sub_GameUtility::Identification
+Sub_GameLevel
+::MapColumn::getEntity(unsigned int columnPos) const
+{
+    invariant();
+    Q_ASSERT(columnPos < m_columnSize);
+
+    return m_column.at(columnPos);
+}
+
+
+
+void
+Sub_GameLevel
+::MapColumn::setEntity(unsigned int columnPos, const Identification &entity)
+{
+    invariant();
+    Q_ASSERT(columnPos < m_columnSize);
+
+    m_column[columnPos] = entity;
+}
+
+
+
+Sub_GameUtility::Identification&
+Sub_GameLevel
+::MapColumn::operator[](unsigned int columnPos)
+{
+    invariant();
+    Q_ASSERT(columnPos < m_columnSize);
+
+    return m_column[columnPos];
+}
+
+
+const Sub_GameUtility::Identification&
+Sub_GameLevel
+::MapColumn::operator [](unsigned int columnPos) const
+{
+    invariant();
+    Q_ASSERT(columnPos < m_columnSize);
+
+    return m_column[columnPos];
+}
+
+
+
+void
+Sub_GameLevel
+::MapColumn::fitToGreater(unsigned int newSize)
+{
+    Q_ASSERT(newSize > m_columnSize);
+
+    for (int i = m_columnSize; i < newSize; ++i)
+    {
+        m_column.push_back(Identification::invalidId());
+    }
+
+    Q_ASSERT(newSize == m_column.size());
+}
+
+
+
+void
+Sub_GameLevel
+::MapColumn::fitToSmaller(unsigned int newSize)
+{
+    Q_ASSERT(newSize < m_columnSize);
+
+    m_column.resize(newSize);
+
+    Q_ASSERT(m_column.size() == newSize);
+}
+
+
+
+void
+Sub_GameLevel
+::MapColumn::invariant() const
+{
+    Q_ASSERT(m_columnSize == m_column.size());
+}

Added: trunk/mysventure/source/sub_level/maplayer.cpp
===================================================================
--- trunk/mysventure/source/sub_level/maplayer.cpp	                        (rev 0)
+++ trunk/mysventure/source/sub_level/maplayer.cpp	2010-07-28 13:17:23 UTC (rev 78)
@@ -0,0 +1,237 @@
+/*
+    Mys-venture is a 2D tile-based puzzle game.
+    Copyright (C) 2010 Kimmo Viitanen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*! \file
+Implementation for class MapLayer.
+*/
+
+#include "sub_level/maplayer.h"
+
+using namespace Sub_GameLevel;
+
+
+
+Sub_GameLevel
+::MapLayer::MapLayer(unsigned int rowSize,
+                     unsigned int columnSize,
+                     unsigned int layerNumber,
+                     const QVector<Sub_GameLevel::MapColumn> &layerData)
+: m_layer(layerData), m_rowSize(rowSize), m_columnSize(columnSize),
+  m_layerNumber(layerNumber)
+{
+    resize(columnSize, rowSize);
+
+    invariant();
+}
+
+
+
+unsigned int
+Sub_GameLevel
+::MapLayer::getColumnSize() const
+{
+    return m_columnSize;
+}
+
+
+
+unsigned int
+Sub_GameLevel
+::MapLayer::getNumberOfRows() const
+{
+    return m_columnSize;
+}
+
+
+
+unsigned int
+Sub_GameLevel
+::MapLayer::getRowSize() const
+{
+    return m_rowSize;
+}
+
+
+unsigned int
+Sub_GameLevel
+::MapLayer::getNumberOfColumns() const
+{
+    return m_rowSize;
+}
+
+
+
+unsigned int
+Sub_GameLevel
+::MapLayer::getLayerNumber() const
+{
+    return m_layerNumber;
+}
+
+
+
+void
+Sub_GameLevel
+::MapLayer::setColumn(unsigned int pos, const MapColumn &column)
+{
+    invariant();
+    Q_ASSERT(pos < m_rowSize);
+
+    // Replace column.
+    m_layer[pos] = column;
+
+    // Make sure column is of correct size.
+    m_layer[pos].resize(m_columnSize);
+
+    invariant();
+}
+
+
+
+void
+Sub_GameLevel
+::MapLayer::setColumn(unsigned int pos,
+                      const QVector<Sub_GameUtility::Identification> &column)
+{
+    MapColumn newColumn(m_columnSize, column);
+    setColumn(pos, column);
+}
+
+
+
+Sub_GameUtility::Identification
+Sub_GameLevel
+::MapLayer::getEntity(unsigned int row, unsigned int column) const
+{
+    invariant();
+    Q_ASSERT(row < m_columnSize);
+    Q_ASSERT(column < m_rowSize);
+
+    return m_layer.at(column).getEntity(row);
+}
+
+
+
+void
+Sub_GameLevel
+::MapLayer::setEntity(unsigned int row,
+                      unsigned int column,
+                      const Sub_GameUtility::Identification &entity)
+{
+    invariant();
+    Q_ASSERT(row < m_columnSize);
+    Q_ASSERT(column < m_rowSize);
+
+    m_layer[column].setEntity(row, entity);
+}
+
+
+
+Sub_GameLevel::MapColumn
+Sub_GameLevel
+::MapLayer::getColumn(unsigned int pos) const
+{
+    invariant();
+    Q_ASSERT(pos < m_rowSize);
+
+    return m_layer.at(pos);
+}
+
+
+
+void
+Sub_GameLevel
+::MapLayer::resize(unsigned int rows, unsigned int columns)
+{
+    invariant();
+    Q_ASSERT(rows < m_columnSize);
+    Q_ASSERT(columns < m_rowSize);
+
+    if (columns > m_rowSize)
+        fitToGreater(rows, columns);
+    else if (columns < m_rowSize)
+        fitToSmaller(rows, columns);
+
+    invariant();
+}
+
+
+/*!
+Fits the layer to a greater number of columns.
+This is performed by adding default-constructed columns to
+the end of the layer.
+*/
+void
+Sub_GameLevel
+::MapLayer::fitToGreater(unsigned int rows, unsigned int columns)
+{
+    // Create default column data.
+    QVector<Sub_GameUtility::Identification> columnData(
+            m_columnSize, Sub_GameUtility::Identification::invalidId());
+
+    // Create default new column.
+    MapColumn newColumn(m_columnSize, columnData);
+
+    // Loop from current max rows to the new max rows
+    // and append a default column each time.
+    for (int i = m_rowSize; i < columns; ++i)
+    {
+        m_layer.push_back(newColumn);
+
+        // After appending a default column, resize the column.
+        m_layer[i].resize(rows);
+    }
+
+    // Then set sizes.
+    m_columnSize = rows;
+    m_rowSize = columns;
+
+    invariant();
+}
+
+
+/*!
+Fits the layer to a smaller number of columns.
+This is performed by cutting the surplus columns off the
+end of the layer.
+*/
+void
+Sub_GameLevel
+::MapLayer::fitToSmaller(unsigned int rows, unsigned int columns)
+{
+    m_layer.resize(columns);
+
+    for (int i = 0; i < m_layer.size(); ++i)
+    {
+        m_layer[i].resize(rows);
+    }
+
+    m_columnSize = rows;
+    m_rowSize = columns;
+
+    invariant();
+}
+
+
+
+void
+Sub_GameLevel
+::MapLayer::invariant() const
+{
+    Q_ASSERT(m_layer.size() == m_rowSize);
+}


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.