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 "LockNameFile.h"

22) #include "Mgrs.h"
23) #include "Module.h"

24) #include "NameFile.h"

25) #include "OpConn.h"

26) #include "OutStreamFile.h"

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

29) #include "UIntFile.h"

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

34) class Game: public Module, public TimeCallee

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

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

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

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

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

75)   virtual void updateConfig() final;
76) 

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

83) 

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

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

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

97)   /**
98)    * @brief check if game can be actiavted: if interlock is free
99)    * @return whether game can be activated (activate() might still fail)
100)    */
101)   bool canActivate();

102) 

103)   /**
104)    * @brief activate game:
105)    *        take interlock, set up image buffer, call redraw()
106)    * @return whether game could be activated
107)    */
108)   bool activate();
109) 
110)   /**
111)    * @brief deactivate game:
112)    *        tear down image buffer, deactivate output, release interlock
113)    */

114)   void deactivate();
115) 

116)   /// check if game is active
117)   bool isActive() const;
118) 

119)   /// check if integer is between minimum and maximum values
120)   static bool checkLimitInt(int i, int min, int max)
121)   {
122)     return i >= min && i <= max;
123)   }
124) 
125)   /// limit integer to minimum and maximum values
126)   static void limitInt(int &i, int min, int max)
127)   {
128)     if (i < min) {
129)       i = min;
130)     }
131)     if (i > max) {
132)       i = max;
133)     }
134)   }
135) 
136)   /// check if range of two integers is nonEmpty and limit the integers
137)   static bool checkIntRangeLimit(int &i1, int &i2, int min, int max)
138)   {
139)     if (i1 > i2) {
140)       return false;
141)     }
142)     limitInt(i1, min, max);
143)     limitInt(i2, min, max);
144)     return true;
145)   }
146) 
147)   /// set pixel in image buffer
148)   void pixel(int y, int x, ColorData const &cd);
149) 
150)   /// draw horizontal line to image buffer
151)   void lineHor(int y, int x1, int x2, ColorData const &cd);
152) 
153)   /// draw vertical line to image buffer
154)   void lineVert(int y1, int y2, int x, ColorData const &cd);
155) 
156)   /// draw non-filled rectangle to image buffer
157)   void rect(int y1, int y2, int x1, int x2, ColorData const &cd);
158) 
159)   /// draw filled rectangle to image buffer
160)   void rectFill(int y1, int y2, int x1, int x2, ColorData const &cd);
161) 

162)   /**
163)    * @brief draw a small digit (3x5 pixels) to image buffer
164)    * @param[in] topY y coordinate of top of digit
165)    * @param[in] leftX x coordinate of left of digit
166)    * @param[in] digit to draw ('0'..'9')
167)    * @param[in] cd color to use for drawing
168)    */
169)   void digit3x5(int topY, int leftX, char digit, ColorData const &cd);
170) 
171)   /**
172)    * @brief draw small digits (3x5 each, 1 pixel gap) to image buffer
173)    * @param[in] topY y coordinate of top of digits
174)    * @param[in] leftX x coordinate of left of digits
175)    * @param[in] digits to draw (string of '0'..'9')
176)    * @param[in] cd color to use for drawing
177)    */
178)   void digits3x5(int topY, int leftX, std::string const &digits,
179)                  ColorData const &cd);
180) 
181)   /**
182)    * @brief draw number using 3x5 digits to image buffer
183)    * @param[in] anchorY y coordinate of anchor point
184)    * @param[in] anchorX x coordinate of anchor point
185)    * @param[in] alignY y alignment, -1 for top, 0 for center, 1 for bottom
186)    * @param[in] alignX x alignment, -1 for left, 0 for center, 1 for right
187)    * @param[in] number non-negative number to draw
188)    * @param[in] cd color to use for drawing
189)    */
190)   void number3x5(int anchorY, int anchorX, int alignY, int alignX,
191)                  int number, ColorData const &cd);
192) 

193)   /**
194)    * @brief process update of color file
195)    * @param[in] colorFile file containing color as string
196)    * @param[in] def default color (grayscale) in case file is invalid (0..255)
197)    * @pram[out] data color data
198)    * @return true on update
199)    */
200)   bool colorUpdate(ColorFile &colorFile, unsigned char def,
201)                    ColorData &data) const;

202) 

203)   /**
204)    * @brief convert color to raw color data
205)    * @param[in] colorFile file containing color as string
206)    * @param[in] def default color (grayscale) in case file is invalid (0..255)
207)    * @pram[out] data color data
208)    */
209)   void color2data(ColorFile const &colorFile, unsigned char def,
210)                   ColorData &data) const;

211) 

212)   /// process update of value file, return true on update
213)   static bool valueUpdate(UIntFile &valueFile, ValueDescr const &descr,
214)                           unsigned int &value);
215) 
216)   /// get value from value file
217)   static void valueFromFile(UIntFile &valueFile, ValueDescr const &descr,
218)                             unsigned int &value);
219) 

220)   /// process update of sound name file
221)   static void soundUpdate(NameFile &soundFile);
222) 

223)   /// send current image buffer as frame to output stream
224)   void sendFrame();
225) 

226)   /// set next game time step - plan timed action of game
227)   void setTimeStep(const Time& timeStepTime);
228) 
229)   /// unset game time step - do timed action for game
230)   void unsetTimeStep();
231) 

232)   /// play a sound on operator connection (NULL ok) (direct)
233)   void playOpConnSound(OpConn *pConn, NameFile const &soundFile);
234) 
235)   //// request playing a sound on operator connection (NULL ok) (via time call)
236)   void requestOpConnSound(OpConn *pConn, NameFile const &soundFile);
237) 

238)   /// request closing operator connection (NULL ok) (closed via time call)
239)   void requestOpConnClose(OpConn *pConn);
240) 
241)   /// remove operator connection from requests (call when op conn is closed)
242)   void forgetOpConn(OpConn *pConn);
243) 

244) private:
245)   /// (re-)create image buffer
246)   void createImgBuf();
247) 
248)   /// tear down image buffer
249)   void destroyImgBuf();
250) 

251)   /// request next time call - or cancel request if not needed
252)   void planTimeCall();
253) 

254) protected:
255)   FormatFile    m_fileFormat;          ///< format file for output
256)   ColorFile     m_fileBackgroundColor; ///< color file for background color
257)   OutStreamFile m_fileOutStream;       ///< output stream name file
258)   int           m_height;              ///< height of image buffer
259)   int           m_width;               ///< width of image buffer
260)   int           m_channels;            ///< number of channels of image buffer
261)   ColorData     m_imgBuf;              ///< image buffer (empty if none)
262)   ColorData     m_backgroundColor;     ///< background color

263) 
264) private:

265)   LockNameFile m_fileLockName; ///< lock name file for game interlock

266)   bool         m_haveTimeStep; ///< if a time step is pending
267)   Time         m_timeStepTime; ///< time of next time step
268)   OpConnSounds m_opConnSounds; ///< sound to play on operator connections
269)   OpConnSet    m_opConnsClose; ///< operator connections to be closed

270) }; // class Game