Blinker

1) /* Blinker
2)    Copyright 2011-2019 Stefan Schuermans <stefan@blinkenarea.org>
3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #ifndef BLINKER_GAME_H
7) #define BLINKER_GAME_H
8) 

9) #include <map>

10) #include <set>

11) #include <string>
12) #include <vector>
13) 
14) #include <BlinkenLib/BlinkenFrame.h>
15) 
16) #include "Color.h"
17) #include "ColorFile.h"
18) #include "File.h"
19) #include "Format.h"
20) #include "FormatFile.h"
21) #include "Mgrs.h"
22) #include "Module.h"

23) #include "NameFile.h"

24) #include "OpConn.h"

25) #include "OutStreamFile.h"

26) #include "Time.h"
27) #include "TimeCallee.h"

28) #include "UIntFile.h"

29) 
30) namespace Blinker {
31) 
32) /// base class for games

33) class Game: public Module, public TimeCallee

34) {
35) protected:
36)   /// raw color data matching image buffer
37)   typedef std::vector<unsigned char> ColorData;
38) 

39)   /// descriptor of value (e.g. a setting for the game)
40)   struct ValueDescr {
41)     unsigned int default_;
42)     unsigned int minimum;
43)     unsigned int maximum;
44)   };
45) 

46) private:
47)   /// set of operator connections
48)   typedef std::set<OpConn *> OpConnSet;
49) 

50)   /// sound (via sound name file) to play on operator connections
51)   typedef std::map<OpConn *, NameFile const *> OpConnSounds;
52) 

53) public:
54)   /**
55)    * @brief constructor
56)    * @param[in] name module name
57)    * @param[in] mgrs managers
58)    * @param[in] dirBase base directory
59)    */
60)   Game(const std::string &name, Mgrs &mgrs, const Directory &dirBase);
61) 
62)   /// virtual destructor
63)   virtual ~Game();
64) 
65) private:
66)   /// copy constructor disabled
67)   Game(const Game &that);
68) 
69)   /// assignment operator disabled
70)   const Game & operator=(const Game &that);
71) 
72) public:
73)   /// check for update of configuration

74)   virtual void updateConfig() final;
75) 

76)   /**
77)    * @brief check for update of configuration (derived game)
78)    * @param[in,out] doReinit set to true to ask for reinitialization
79)    * @param[in,out] doRedraw set to true to ask for redrawing
80)    */
81)   virtual void updateConfigGame(bool &doReinit, bool &doRedraw) = 0;

82) 

83)   /// callback when requested time reached
84)   virtual void timeCall();
85) 

86) protected:
87)   /// re-initialize game (e.g. due to config change)
88)   virtual void reinitialize() = 0;
89) 
90)   /// redraw current game image, expected to call sendFrame() at end
91)   virtual void redraw() = 0;
92) 

93)   /// process next time step of game
94)   virtual void timeStep() = 0;
95) 

96)   /// activate game: set up image buffer, call redraw()
97)   void activate();
98) 
99)   /// deactivate game: tear down image buffer, deactivate output
100)   void deactivate();
101) 

102)   /// check if game is active
103)   bool isActive() const;
104) 

105)   /// check if integer is between minimum and maximum values
106)   static bool checkLimitInt(int i, int min, int max)
107)   {
108)     return i >= min && i <= max;
109)   }
110) 
111)   /// limit integer to minimum and maximum values
112)   static void limitInt(int &i, int min, int max)
113)   {
114)     if (i < min) {
115)       i = min;
116)     }
117)     if (i > max) {
118)       i = max;
119)     }
120)   }
121) 
122)   /// check if range of two integers is nonEmpty and limit the integers
123)   static bool checkIntRangeLimit(int &i1, int &i2, int min, int max)
124)   {
125)     if (i1 > i2) {
126)       return false;
127)     }
128)     limitInt(i1, min, max);
129)     limitInt(i2, min, max);
130)     return true;
131)   }
132) 
133)   /// set pixel in image buffer
134)   void pixel(int y, int x, ColorData const &cd);
135) 
136)   /// draw horizontal line to image buffer
137)   void lineHor(int y, int x1, int x2, ColorData const &cd);
138) 
139)   /// draw vertical line to image buffer
140)   void lineVert(int y1, int y2, int x, ColorData const &cd);
141) 
142)   /// draw non-filled rectangle to image buffer
143)   void rect(int y1, int y2, int x1, int x2, ColorData const &cd);
144) 
145)   /// draw filled rectangle to image buffer
146)   void rectFill(int y1, int y2, int x1, int x2, ColorData const &cd);
147) 

148)   /**
149)    * @brief draw a small digit (3x5 pixels) to image buffer
150)    * @param[in] topY y coordinate of top of digit
151)    * @param[in] leftX x coordinate of left of digit
152)    * @param[in] digit to draw ('0'..'9')
153)    * @param[in] cd color to use for drawing
154)    */
155)   void digit3x5(int topY, int leftX, char digit, ColorData const &cd);
156) 
157)   /**
158)    * @brief draw small digits (3x5 each, 1 pixel gap) to image buffer
159)    * @param[in] topY y coordinate of top of digits
160)    * @param[in] leftX x coordinate of left of digits
161)    * @param[in] digits to draw (string of '0'..'9')
162)    * @param[in] cd color to use for drawing
163)    */
164)   void digits3x5(int topY, int leftX, std::string const &digits,
165)                  ColorData const &cd);
166) 
167)   /**
168)    * @brief draw number using 3x5 digits to image buffer
169)    * @param[in] anchorY y coordinate of anchor point
170)    * @param[in] anchorX x coordinate of anchor point
171)    * @param[in] alignY y alignment, -1 for top, 0 for center, 1 for bottom
172)    * @param[in] alignX x alignment, -1 for left, 0 for center, 1 for right
173)    * @param[in] number non-negative number to draw
174)    * @param[in] cd color to use for drawing
175)    */
176)   void number3x5(int anchorY, int anchorX, int alignY, int alignX,
177)                  int number, ColorData const &cd);
178) 

179)   /// process update of color file, return true on update
180)   bool colorUpdate(ColorFile &colorFile, ColorData &data) const;
181) 

182)   /// convert color to raw color data

183)   void color2data(ColorFile const &colorFile, ColorData &data) const;

184) 

185)   /// process update of value file, return true on update
186)   static bool valueUpdate(UIntFile &valueFile, ValueDescr const &descr,
187)                           unsigned int &value);
188) 
189)   /// get value from value file
190)   static void valueFromFile(UIntFile &valueFile, ValueDescr const &descr,
191)                             unsigned int &value);
192) 

193)   /// process update of sound name file
194)   static void soundUpdate(NameFile &soundFile);
195) 

196)   /// send current image buffer as frame to output stream
197)   void sendFrame();
198) 

199)   /// set next game time step - plan timed action of game
200)   void setTimeStep(const Time& timeStepTime);
201) 
202)   /// unset game time step - do timed action for game
203)   void unsetTimeStep();
204) 

205)   /// play a sound on operator connection (NULL ok) (direct)
206)   void playOpConnSound(OpConn *pConn, NameFile const &soundFile);
207) 
208)   //// request playing a sound on operator connection (NULL ok) (via time call)
209)   void requestOpConnSound(OpConn *pConn, NameFile const &soundFile);
210) 

211)   /// request closing operator connection (NULL ok) (closed via time call)
212)   void requestOpConnClose(OpConn *pConn);
213) 
214)   /// remove operator connection from requests (call when op conn is closed)
215)   void forgetOpConn(OpConn *pConn);
216) 

217) private:
218)   /// (re-)create image buffer
219)   void createImgBuf();
220) 
221)   /// tear down image buffer
222)   void destroyImgBuf();
223) 

224)   /// request next time call - or cancel request if not needed
225)   void planTimeCall();
226) 

227) protected:
228)   FormatFile    m_fileFormat;          ///< format file for output
229)   ColorFile     m_fileBackgroundColor; ///< color file for background color
230)   OutStreamFile m_fileOutStream;       ///< output stream name file
231)   int           m_height;              ///< height of image buffer
232)   int           m_width;               ///< width of image buffer
233)   int           m_channels;            ///< number of channels of image buffer
234)   ColorData     m_imgBuf;              ///< image buffer (empty if none)
235)   ColorData     m_backgroundColor;     ///< background color

236) 
237) private:

238)   bool         m_haveTimeStep; ///< if a time step is pending
239)   Time         m_timeStepTime; ///< time of next time step
240)   OpConnSounds m_opConnSounds; ///< sound to play on operator connections
241)   OpConnSet    m_opConnsClose; ///< operator connections to be closed

242) }; // class Game