Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/modules/pong/PongCenterpoint.h @ 10624

Last change on this file since 10624 was 10624, checked in by landauf, 8 years ago

merged branch core7 back to trunk

  • Property svn:eol-style set to native
File size: 10.4 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @file PongCenterpoint.h
31    @brief Declaration of the PongCenterpoint class.
32    @ingroup Pong
33*/
34
35#ifndef _PongCenterpoint_H__
36#define _PongCenterpoint_H__
37
38#include "pong/PongPrereqs.h"
39
40#include <string>
41
42#include <util/Math.h>
43
44#include "worldentities/StaticEntity.h"
45
46namespace orxonox
47{
48   
49    /**
50    @brief
51        The PongCenterpoint implements the playing field @ref orxonox::Pong "Pong" takes place in and allows for many parameters of the minigame to be set.
52        The playing field resides in the x,z-plane, with the x-axis being the horizontal axis and the z-axis being the vertical axis.
53       
54        Various parameters can be set:
55        - The <b>dimension</b> is a vector, that defines the width and height of the playing field. The default is <em>(200, 120)</em>.
56        - The <b>balltemplate</b> is a template that is applied to the @ref orxonox::PongBall "PongBall", it can be used to attach different things to it, e.g. its @ref orxonox::Model "Model". See below for a usage example.
57        - The <b>battemplate</b> is a template that is applied to the @ref orxonox::PongBall "PongBat", it can be used to attach different things to it, e.g. its @ref orxonox::Model "Model". See below for a usage example.
58        - The <b>ballspeed</b> is the speed with which the @ref orxonox::PongBall "PongBall" moves. The default is <em>100</em>.
59        - The <b>ballaccfactor</b> is the acceleration factor for the @ref orxonox::PongBall "PongBall". The default is <em>1.0</em>.
60        - The <b>batspeed</b> is the speed with which the @ref orxonox::PongBat "PongBats" move. The default is <em>60</em>.
61        - The <b>batlength</b> is the length of the @ref orxonox::PongBat "PongBats" as the percentage of the height of the playing field. The default is <em>0.25</em>.
62       
63        An example in XML of the PongCenterpoint would be:
64       
65        First the needed templates:
66        The template for the @ref orxonox::PongBall "PongBall".
67        @code
68        <Template name="pongball">
69          <PongBall>
70            <attached>
71              <Model mesh="sphere.mesh" scale="2" />
72              <ParticleSpawner name="hiteffect" position="0,0,0" source="Orxonox/sparks2" lifetime="0.01" autostart="0" mainstate="spawn" />
73            </attached>
74            <eventlisteners>
75              <EventTarget target="hiteffect" />
76            </eventlisteners>
77          </PongBall>
78        </Template>
79        @endcode
80        As can be seen, a sphere is attached as the @ref orxonox::Model "Model" for the @ref orxonox::PongBall "PongBall", and also an @ref orxonox::EventListener "EventListener" that triggers a @ref orxonox::ParticleSpawner "ParticleSpawner", whenever the ball hits the boundaries is attached.
81       
82        Additionally the template for the @ref orxonox::PongBat "PongBat".
83        @code
84        <Template name="pongbatcameras" defaults="0">
85          <PongBat>
86            <camerapositions>
87              <CameraPosition position="0,200,0" pitch="-90" absolute="true" />
88            </camerapositions>
89          </PongBat>
90        </Template>
91
92        <Template name="pongbat">
93          <PongBat camerapositiontemplate=pongbatcameras>
94            <attached>
95              <Model position="0,0,3" mesh="cube.mesh" scale3D="14,2,2" />
96            </attached>
97          </PongBat>
98        </Template>
99        @endcode
100        As can be seen, there are actually two templates. The first template is needed to set the camera for the @ref orxonox::PongBat "PongBat". The second template ist the actual template for the @ref orxonox::PongBat "PongBat", the template for the camera position is added and a @ref orxonox::Model "Model" for the @ref orxonox::PongBat "PongBat" is attached.
101       
102        Finally the PongCenterpoint is created.
103        @code
104        <PongCenterpoint name="pongcenter" dimension="200,120" balltemplate="pongball" battemplate="pongbat" ballspeed="200" ballaccfactor="1.0" batspeed="130" batlength="0.25">
105          <attached>
106            <Model position="0,0,60" mesh="cube.mesh" scale3D="105,1,1" />
107            <Model position="0,0,-60" mesh="cube.mesh" scale3D="105,1,1" />
108          </attached>
109        </PongCenterpoint>
110        @endcode
111        All parameters are specified. And also two @ref orxonox::Model "Models" (for the upper and lower boundary) are attached.
112       
113        For a more elaborate example, have a look at the <code>pong.oxw</code> level file.
114   
115    @author
116        Fabian 'x3n' Landau
117       
118    @ingroup Pong
119    */
120    class _PongExport PongCenterpoint : public StaticEntity
121    {
122        public:
123            PongCenterpoint(Context* context); //!< Constructor. Registers and initializes the object and checks whether the gametype is actually Pong.
124            virtual ~PongCenterpoint() {}
125
126            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method to create a PongCenterpoint through XML.
127
128            /**
129            @brief Set the template for the ball. (e.g. to attach the model of the ball, but also to attach an EventListener to it to detect, when it hits the boundaries, and e.g. display some ParticleEffets, when it does.)
130            @param balltemplate The name of the template to be set.
131            */
132            void setBalltemplate(const std::string& balltemplate)
133                { this->balltemplate_ = balltemplate; }
134            /**
135            @brief Get the template of the ball.
136            @return Returns the name of the template of the ball.
137            */
138            const std::string& getBalltemplate() const
139                { return this->balltemplate_; }
140
141            /**
142            @brief Set the template for the bats. (e.g. to attach the model of the bat, but also to attach CameraPositions to it, to be able to view the game from the bats perspective)
143            @param battemplate The name of the template to be set.
144            */
145            void setBattemplate(const std::string& battemplate)
146                { this->battemplate_ = battemplate; }
147            /**
148            @brief Get the template of the bats.
149            @return Returns the name of the template of the bats.
150            */
151            const std::string& getBattemplate() const
152                { return this->battemplate_; }
153
154            /**
155            @brief Set the dimensions of the playing field.
156            @param dimension A vector with the width of the playing field as first component and the height as second.
157            */
158            void setFieldDimension(const Vector2& dimension)
159                { this->width_ = dimension.x; this->height_ = dimension.y; }
160            /**
161            @brief Get the dimensions of the playing field.
162            @return Returns a vector with the width of the playing field as first component and the height as second.
163            */
164            Vector2 getFieldDimension() const
165                { return Vector2(this->width_, this->height_); }
166
167            /**
168            @brief Set the speed of the ball.
169            @param ballspeed The speed of the ball.
170            */
171            void setBallSpeed(float ballspeed)
172                { this->ballspeed_ = ballspeed; }
173            /**
174            @brief Get the speed of the ball.
175            @return Returns the speed of the ball.
176            */
177            float getBallSpeed() const
178                { return this->ballspeed_; }
179
180            /**
181            @brief Set the ball's acceleration factor.
182            @param ballaccfactor The ball's acceleration factor.
183            */
184            void setBallAccelerationFactor(float ballaccfactor)
185                { this->ballaccfactor_ = ballaccfactor; }
186            /**
187            @brief Get the ball's acceleration factor
188            @return Returns the ball's acceleration factor.
189            */
190            float getBallAccelerationFactor() const
191                { return this->ballaccfactor_; }
192
193            /**
194            @brief Set the speed of the bats.
195            @param batspeed The speed of the bats.
196            */
197            void setBatSpeed(float batspeed)
198                { this->batspeed_ = batspeed; }
199            /**
200            @brief Get the speed of the bats.
201            @return Returns the speed of the bats.
202            */
203            float getBatSpeed() const
204                { return this->batspeed_; }
205
206            /**
207            @brief Set the length of the bats.
208            @param batlength The length of the bats (in z-direction) as a percentage of the height of the playing field.
209            */
210            void setBatLength(float batlength)
211                { this->batlength_ = batlength; }
212            /**
213            @brief Get the length of the bats.
214            @return Returns the length of the bats (in z-direction) as a percentage of the height of the playing field.
215            */
216            float getBatLength() const
217                { return this->batlength_; }
218
219        private:
220            void checkGametype(); //!< Checks whether the gametype is Pong and if it is, sets its centerpoint.
221
222            std::string balltemplate_; //!< The template for the ball.
223            std::string battemplate_; //!< The template for the bats.
224
225            float ballspeed_; //!< The speed of then ball.
226            float ballaccfactor_; //!< The acceleration factor of the ball.
227            float batspeed_; //!< The speed of the bat.
228            float batlength_; //!< The length of the bat (in z-direction) as a percentage of the height of the playing field.
229
230            float width_; //!< The height of the playing field.
231            float height_; //!< The width of the playing field.
232    };
233}
234
235#endif /* _PongCenterpoint_H__ */
Note: See TracBrowser for help on using the repository browser.