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 <set>

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

22) #include "OpConn.h"

23) #include "OutStreamFile.h"

24) #include "Time.h"
25) #include "TimeCallee.h"

26) #include "UIntFile.h"

27) 
28) namespace Blinker {
29) 
30) /// base class for games

31) class Game: public Module, public TimeCallee

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

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

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

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

69)   virtual void updateConfig() final;
70) 
71)   /// check for update of configuration (derived game), return true on update
72)   virtual bool updateConfigGame() = 0;

73) 

74)   /// callback when requested time reached
75)   virtual void timeCall();
76) 

77) protected:
78)   /// re-initialize game (e.g. due to config change)
79)   virtual void reinitialize() = 0;
80) 
81)   /// redraw current game image, expected to call sendFrame() at end
82)   virtual void redraw() = 0;
83) 

84)   /// process next time step of game
85)   virtual void timeStep() = 0;
86) 

87)   /// activate game: set up image buffer, call redraw()
88)   void activate();
89) 
90)   /// deactivate game: tear down image buffer, deactivate output
91)   void deactivate();
92) 

93)   /// check if game is active
94)   bool isActive() const;
95) 

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

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

170)   /// process update of color file, return true on update
171)   bool colorUpdate(ColorFile &colorFile, ColorData &data) const;
172) 

173)   /// convert color to raw color data

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

175) 

176)   /// process update of value file, return true on update
177)   static bool valueUpdate(UIntFile &valueFile, ValueDescr const &descr,
178)                           unsigned int &value);
179) 
180)   /// get value from value file
181)   static void valueFromFile(UIntFile &valueFile, ValueDescr const &descr,
182)                             unsigned int &value);
183) 

184)   /// send current image buffer as frame to output stream
185)   void sendFrame();
186) 

187)   /// set next game time step - plan timed action of game
188)   void setTimeStep(const Time& timeStepTime);
189) 
190)   /// unset game time step - do timed action for game
191)   void unsetTimeStep();
192) 

193)   /// request closing operator connection (NULL ok) (closed via time call)
194)   void requestOpConnClose(OpConn *pConn);
195) 
196)   /// remove operator connection from requests (call when op conn is closed)
197)   void forgetOpConn(OpConn *pConn);
198) 

199) private:
200)   /// (re-)create image buffer
201)   void createImgBuf();
202) 
203)   /// tear down image buffer
204)   void destroyImgBuf();
205) 

206)   /// request next time call - or cancel request if not needed
207)   void planTimeCall();
208) 

209) protected:
210)   FormatFile    m_fileFormat;          ///< format file for output
211)   ColorFile     m_fileBackgroundColor; ///< color file for background color
212)   OutStreamFile m_fileOutStream;       ///< output stream name file
213)   int           m_height;              ///< height of image buffer
214)   int           m_width;               ///< width of image buffer
215)   int           m_channels;            ///< number of channels of image buffer
216)   ColorData     m_imgBuf;              ///< image buffer (empty if none)
217)   ColorData     m_backgroundColor;     ///< background color

218) 
219) private:

220)   bool      m_haveTimeStep; ///< if a time step is pending
221)   Time      m_timeStepTime; ///< time of next time step
222)   OpConnSet m_opConnsClose; ///< operator connections to be closed