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) #include <cmath>

7) #include <stdlib.h>

8) #include <string>
9) #include <vector>
10) 
11) #include <BlinkenLib/BlinkenFrame.h>
12) 
13) #include "File.h"
14) #include "Format.h"
15) #include "FormatFile.h"
16) #include "Game.h"
17) #include "Mgrs.h"
18) #include "Module.h"

19) #include "OpConn.h"
20) #include "OpConnIf.h"
21) #include "OpReqIf.h"

22) #include "OutStreamFile.h"
23) #include "Pong.h"

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

26) #include "UIntFile.h"

27) 
28) namespace Blinker {
29) 

30) /// descriptor for delay value
31) Pong::ValueDescr const Pong::c_delayDescr = { 200, 100, 500 };
32) 

33) /// operator connection name suffix for left player's connection

34) std::string const Pong::c_opConnSuffixLeft = "/left";

35) /// operator connection name suffix for right player's connection

36) std::string const Pong::c_opConnSuffixRight = "/right";

37) 

38) /**
39)  * @brief constructor
40)  * @param[in] name module name
41)  * @param[in] mgrs managers
42)  * @param[in] dirBase base directory
43)  */
44) Pong::Pong(const std::string &name, Mgrs &mgrs, const Directory &dirBase):
45)   Game(name, mgrs, dirBase),
46)   m_fileBallColor(dirBase.getFile("ballColor")),

47)   m_fileLineColor(dirBase.getFile("lineColor")),

48)   m_filePadColor(dirBase.getFile("padColor")),

49)   m_fileComputerColor(dirBase.getFile("computerColor")),

50)   m_fileScoreColor(dirBase.getFile("scoreColor")),
51)   m_fileGoalColor(dirBase.getFile("goalColor")),

52)   m_fileDelay(dirBase.getFile("delay")),

53)   m_ballColor(), m_lineColor(), m_padColor(), m_computerColor(),

54)   m_scoreColor(), m_goalColor(),

55)   m_delay(c_delayDescr.default_),

56)   m_pConnLeft(NULL), m_pConnRight(NULL),

57)   m_ballPosX(-1), m_ballPosY(-1), m_ballDirX(0), m_ballDirY(0),

58)   m_padSize(0), m_leftPosY(0), m_rightPosY(0), m_leftDelay(0), m_rightDelay(0),

59)   m_goalDelay(0), m_bounceCnt(0), m_scoreLeft(0), m_scoreRight(0)

60) {

61)   // open operator connection interfaces for left and right player

62)   m_mgrs.m_opMgr.open(m_name + c_opConnSuffixLeft, this);
63)   m_mgrs.m_opMgr.open(m_name + c_opConnSuffixRight, this);

64) }
65) 
66) /// virtual destructor
67) Pong::~Pong()
68) {

69)   // close operator connection interfaces

70)   m_mgrs.m_opMgr.close(m_name + c_opConnSuffixLeft);
71)   m_mgrs.m_opMgr.close(m_name + c_opConnSuffixRight);

72) 
73)   // close open operator connections
74)   if (m_pConnLeft) {
75)     m_pConnLeft->close();
76)     m_pConnLeft = NULL;
77)   }
78)   if (m_pConnRight) {
79)     m_pConnRight->close();
80)     m_pConnRight = NULL;
81)   }
82) 

83)   // cancel time callback request
84)   m_mgrs.m_callMgr.cancelTimeCall(this);

85) }
86) 
87) /// check for update of configuration (derived game), return true on update
88) bool Pong::updateConfigGame()
89) {
90)   bool ret = false;
91) 
92)   // color file was modified -> convert color, return true for update

93)   if (colorUpdate(m_fileBallColor, m_ballColor) ||

94)       colorUpdate(m_fileLineColor, m_lineColor) ||

95)       colorUpdate(m_filePadColor, m_padColor) ||

96)       colorUpdate(m_fileComputerColor, m_computerColor) ||
97)       colorUpdate(m_fileScoreColor, m_scoreColor) ||

98)       colorUpdate(m_fileGoalColor, m_goalColor) ||
99)       valueUpdate(m_fileDelay, c_delayDescr, m_delay)) {

100)     ret = true;
101)   }
102) 
103)   return ret;
104) }
105) 

106) /**
107)  * @brief check if accepting new operator connction is possible
108)  * @param[in] name operator interface name
109)  * @return if accepting new connection is possible
110)  */
111) bool Pong::acceptNewOpConn(const std::string &name)
112) {
113)   // left player can join if none there yet

114)   if (name == m_name + c_opConnSuffixLeft && ! m_pConnLeft) {

115)     return true;
116)   }
117)   // right player can join if none there yet

118)   if (name == m_name + c_opConnSuffixRight && ! m_pConnRight) {

119)     return true;
120)   }
121)   // default: reject connection
122)   return false;
123) }
124) 
125) /**
126)  * @brief new operator connection
127)  * @param[in] name operator interface name
128)  * @param[in] pConn operator connection object
129)  *
130)  * The new connection may not yet be used for sending inside this callback.
131)  */
132) void Pong::newOpConn(const std::string &name, OpConn *pConn)
133) {
134)   // left player joins if none there yet

135)   if (name == m_name + c_opConnSuffixLeft && ! m_pConnLeft) {

136)     m_pConnLeft = pConn;
137)   }
138)   // right player joins if none there yet

139)   else if (name == m_name + c_opConnSuffixRight && ! m_pConnRight) {

140)     m_pConnRight = pConn;

141)   }
142)   // nothing happens
143)   else {

144)     return;
145)   }

146) 
147)   // already active
148)   if (isActive()) {
149)     redraw(); // player color is different for phone / computer
150)   }
151)   // first player joined
152)   else {
153)     activate();
154)   }

155) }
156) 
157) /**
158)  * @brief key command received on operator connection
159)  * @param[in] pConn operator connection object
160)  * @param[in] key key that was pressed
161)  */
162) void Pong::opConnRecvKey(OpConn *pConn, char key)
163) {
164)   // left player
165)   if (pConn == m_pConnLeft) {
166)     processKey(key, m_leftPosY);
167)   }
168)   // right player

169)   else if (pConn == m_pConnRight) {

170)     processKey(key, m_rightPosY);
171)   }
172) }
173) 
174) /**
175)  * @brief play command received on operator connection
176)  * @param[in] pConn operator connection object
177)  * @param[in] sound name of sound to play
178)  */
179) void Pong::opConnRecvPlay(OpConn *pConn, const std::string &sound)
180) {
181)   (void)pConn;
182)   (void)sound;
183) }
184) 
185) /**
186)  * @brief operator connection is closed
187)  * @param[in] pConn operator connection object
188)  *
189)  * The connection may not be used for sending any more in this callback.
190)  */
191) void Pong::opConnClose(OpConn *pConn)
192) {
193)   // left player leaves
194)   if (pConn == m_pConnLeft) {
195)     m_pConnLeft = NULL;
196)   }
197)   // right player leaves

198)   else if (pConn == m_pConnRight) {

199)     m_pConnRight = NULL;

200)   }
201)   // nothing happens
202)   else {

203)     return;
204)   }

205) 
206)   // still a phone player there
207)   if (m_pConnLeft || m_pConnRight) {
208)     redraw(); // player color is different for phone / computer
209)   }
210)   // no phone players left
211)   else {
212)     deactivate();
213)   }

214) }
215) 

216) /// re-initialize game (e.g. due to config change)
217) void Pong::reinitialize()
218) {

219)   // compute parameters
220)   m_padSize = (m_height + 1) / 3;
221)   m_leftPosY = (m_height - m_padSize) / 2;
222)   m_rightPosY = (m_height - m_padSize) / 2;

223)   m_leftDelay = 0;
224)   m_rightDelay = 0;

225) 
226)   // convert colors
227)   color2data(m_fileBallColor, m_ballColor);

228)   color2data(m_fileLineColor, m_lineColor);

229)   color2data(m_filePadColor, m_padColor);

230)   color2data(m_fileComputerColor, m_computerColor);

231)   color2data(m_fileScoreColor, m_scoreColor);
232)   color2data(m_fileGoalColor, m_goalColor);

233)   // get values
234)   valueFromFile(m_fileDelay, c_delayDescr, m_delay);

235) 

236)   // reset scores
237)   m_scoreLeft = 0;
238)   m_scoreRight = 0;
239) 
240)   // start first ball

241)   startBall();

242) }
243) 
244) /// redraw current game image, expected to call sendFrame() at end
245) void Pong::redraw()
246) {

247)   int y, x;
248) 
249)   // draw background

250)   rectFill(0, m_height, 0, m_width, m_backgroundColor);
251) 

252)   // draw middle line: single line on odd width, two dashed lines at even width
253)   for (y = 0; y < m_height; ++y) {
254)     x = (m_width - (y & 1)) / 2;
255)     pixel(y, x, m_lineColor);
256)   }
257) 

258)   // draw score
259)   ColorData const &scoreColor = m_goalDelay <= 0 ? m_scoreColor : m_goalColor;
260)   y = (m_height - 1) / 2;
261)   x = m_width / 4;
262)   number3x5(y, x, 0, 0, m_scoreLeft, scoreColor);
263)   number3x5(y, m_width - 1 - x, 0, 0, m_scoreRight, scoreColor);
264) 

265)   // draw pads

266)   lineVert(m_leftPosY, m_leftPosY + m_padSize - 1, 0,
267)            m_pConnLeft ? m_padColor : m_computerColor);
268)   lineVert(m_rightPosY, m_rightPosY + m_padSize - 1, m_width - 1,
269)            m_pConnRight ? m_padColor : m_computerColor);

270) 

271)   // draw ball (blinking if goal delay is active)
272)   if (m_goalDelay <= 0 || (m_goalDelay & 4) == 0) {
273)       pixel(m_ballPosY, m_ballPosX, m_ballColor);
274)   }

275) 
276)   // send updated image buffer as frame
277)   sendFrame();
278) }
279) 

280) /// callback when requested time reached
281) void Pong::timeCall()
282) {

283)   // game is running

284)   if (m_goalDelay <= 0) {

285) 
286)     // computer player: move pads
287)     if (! m_pConnLeft) {
288)       computerLeft();
289)     }
290)     if (! m_pConnRight) {
291)       computerRight();
292)     }
293) 
294)     // bounce ball
295)     bounceBall();
296) 
297)     // move ball
298)     m_ballPosX += m_ballDirX;
299)     m_ballPosY += m_ballDirY;
300) 
301)     // detect goal
302)     detectGoal();
303) 

304)   }

305)   // goal delay (blinking ball)
306)   else if (m_goalDelay > 0) {

307) 

308)     --m_goalDelay;

309) 

310)     // new ball when delay is over
311)     if (m_goalDelay <= 0) {
312)         startBall();
313)         return; // startBall calls redraw() and planTimeCall()
314)     }
315) 
316)   }

317) 
318)   // draw and send frame
319)   redraw();
320) 
321)   // request next call if needed
322)   planTimeCall();
323) }
324) 

325) /**
326)  * @brief process key received from phone player
327)  * @param[in] key received key from player
328)  * @param[in,out] padPosY y position of player's pad
329)  */
330) void Pong::processKey(char key, int &padPosY)
331) {

332)   // do not move pad if goal delay is active
333)   if (m_goalDelay > 0) {
334)     return;
335)   }
336) 

337)   // move pad (2 = up, 8 = down), do not move pad out of field
338)   if (key == '2' && padPosY > 0) {
339)     --padPosY;
340)     redraw();
341)   }
342)   else if (key == '8' && padPosY < m_height - m_padSize) {
343)     ++padPosY;
344)     redraw();
345)   }
346) }
347) 

348) /**
349)  * @brief delay processing for computer players
350)  * @param[in,out] delay delay variable of computer player
351)  * @return whether computer player is allowed to move
352)  */
353) bool Pong::computerDelay(int &delay) const
354) 
355) {
356)   // zero delay: generate new delay
357)   if (delay <= 0) {
358)     int avg_steps = (m_height - m_padSize) / 2;
359)     int delay_range = avg_steps > 1 ? m_width / avg_steps: m_width;
360)     delay = rand() % delay_range + delay_range;
361)   }
362) 
363)   // count down delay
364)   --delay;
365) 
366)   // moving allowd if delay expired
367)   return delay <= 0;
368) }
369) 

370) /**
371)  * @brief computation of ideal pad position for computer players
372)  * @param[in] padBallX x coordinate of position of ball when hitting the pad
373)  * @param[in] padY current y coordinate of pad
374)  * @param[out] padYmin minimum ideal y position of pad
375)  * @param[out] padYmax maximum ideal y position of pad
376)  */
377) void Pong::computerComputePadPos(int padBallX, int padY,
378)                                  int &padYmin, int &padYmax) const

379) {

380)   // ball not moving towards pad
381)   if ((padBallX - m_ballPosX) * m_ballDirX <= 0) {
382)     // do not move if ball is still close to pad
383)     if (abs(padBallX - m_ballPosX) <= 2) {
384)       padYmin = padY;
385)       padYmax = padY;
386)       return;
387)     }
388)     // move pad to middle (might be 2 pixels wide)
389)     padYmin = (m_height - m_padSize) / 2;
390)     padYmax = (m_height - m_padSize + 1) / 2;

391)     return;
392)   }
393) 
394)   // compute expected ball position at pad

395)   int ballPosX = m_ballPosX; // simulate were ball is going
396)   int ballPosY = m_ballPosY;
397)   int ballDirY = m_ballDirY;
398)   while ((padBallX - ballPosX) * m_ballDirX > 0) { // while moving to pad
399)     int deltaX = padBallX - ballPosX;
400)     int deltaY = deltaX * m_ballDirX * ballDirY;
401)     if (deltaY < -ballPosY) {
402)       deltaY = -ballPosY;
403)       ballPosX += deltaY * m_ballDirX * ballDirY;
404)       ballPosY = 0;
405)       ballDirY = 1;
406)     }
407)     else if (deltaY > m_height - 1 - ballPosY) {
408)       deltaY = m_height - 1 - ballPosY;
409)       ballPosX += deltaY * m_ballDirX * ballDirY;
410)       ballPosY = m_height - 1;
411)       ballDirY = -1;
412)     } else {
413)       ballPosX += deltaX;
414)       ballPosY += deltaY;
415)     }
416)   }

417) 
418)   // compute pad position to hit ball with center of pad

419)   padYmin = ballPosY - m_padSize / 2;
420)   padYmax = ballPosY - (m_padSize - 1) / 2;
421) }

422) 

423) /**
424)  * @brief move pad for computer players
425)  * @param[in] padYmin minimum desired y position of pad
426)  * @param[in] padYmax maximum desired y position of pad
427)  * @param[in,out] padPosY y position of pad
428)  */
429) void Pong::computerMovePad(int padYmin, int padYmax, int &padPosY) const
430) {

431)   // do not move pad if goal delay is active
432)   if (m_goalDelay > 0) {
433)     return;
434)   }
435) 

436)   // move pad, do not move pad out of field
437)   if (padPosY > padYmax && padPosY > 0) {
438)     --padPosY;

439)   }

440)   else if (padPosY < padYmin && padPosY < m_height - m_padSize) {
441)     ++padPosY;

442)   }

443) }

444) 

445) /// computer player for left pad
446) void Pong::computerLeft()
447) {

448)   if (computerDelay(m_leftDelay)) {
449)     int padYmin, padYmax;
450)     computerComputePadPos(1, m_leftPosY, padYmin, padYmax);
451)     computerMovePad(padYmin, padYmax, m_leftPosY);
452)   }

453) }
454) 
455) /// computer player for right pad
456) void Pong::computerRight()
457) {

458)   if (computerDelay(m_rightDelay)) {
459)     int padYmin, padYmax;
460)     computerComputePadPos(m_width - 2, m_rightPosY, padYmin, padYmax);
461)     computerMovePad(padYmin, padYmax, m_rightPosY);
462)   }

463) }
464) 

465) /// bounce ball
466) void Pong::bounceBall()
467) {

468)   bounceBallSide(); // must be done before player bounce to be safe

469)   bounceBallLeft();
470)   bounceBallRight();

471)   bounceBallSide(); // must also be done after player bounce to be safe

472) }
473) 
474) /// bounce ball at sides
475) void Pong::bounceBallSide()
476) {

477)   if (m_ballPosY <= 0 && m_ballDirY < 0) {
478)     m_ballDirY = 1;
479)   }
480)   if (m_ballPosY >= m_height - 1 && m_ballDirY > 0) {
481)     m_ballDirY = -1;
482)   }
483)   if (m_ballPosX <= 0 && m_ballDirX < 0) {
484)     m_ballDirX = 1;
485)   }
486)   if (m_ballPosX >= m_width - 1 && m_ballDirX > 0) {
487)     m_ballDirX = -1;
488)   }

489) }

490) 

491) /// bounce ball at left pad
492) void Pong::bounceBallLeft()
493) {
494)   if (m_ballPosX != 1 || m_ballDirX >= 0) {
495)     return;

496)   }
497) 

498)   // top corner
499)   if (m_ballPosY == m_leftPosY - 1 && m_ballDirY > 0) {
500)     m_ballDirX = 1;
501)     m_ballDirY = -1;

502)     ++m_bounceCnt;

503)   }
504) 

505)   // bottom corner
506)   else if (m_ballPosY == m_leftPosY + m_padSize && m_ballDirY < 0) {
507)     m_ballDirX = 1;
508)     m_ballDirY = 1;

509)     ++m_bounceCnt;

510)   }

511) 

512)   // pad edge
513)   else if (m_ballPosY >= m_leftPosY &&
514)            m_ballPosY < m_leftPosY + m_padSize) {
515)     m_ballDirX = 1;

516)     ++m_bounceCnt;

517)   }
518) }
519) 
520) /// bounce ball at right pad
521) void Pong::bounceBallRight()
522) {
523)   if (m_ballPosX != m_width - 2 || m_ballDirX <= 0) {
524)     return;
525)   }
526) 
527)   // top corner
528)   if (m_ballPosY == m_rightPosY - 1 && m_ballDirY > 0) {
529)     m_ballDirX = -1;
530)     m_ballDirY = -1;

531)     ++m_bounceCnt;

532)   }
533) 
534)   // bottom corner
535)   else if (m_ballPosY == m_rightPosY + m_padSize && m_ballDirY < 0) {
536)     m_ballDirX = -1;
537)     m_ballDirY = 1;

538)     ++m_bounceCnt;

539)   }
540) 
541)   // pad edge
542)   else if (m_ballPosY >= m_rightPosY &&
543)            m_ballPosY < m_rightPosY + m_padSize) {
544)     m_ballDirX = -1;

545)     ++m_bounceCnt;
546)   }
547) }
548) 
549) /// detect goal
550) void Pong::detectGoal()
551) {
552)   static int goalBlinkCnt = 3;
553)   static int goalDelay = goalBlinkCnt * 8 + 3;
554) 
555)   // ball at far left - goal for right player
556)   if (m_ballPosX == 0) {
557)     m_goalDelay = goalDelay;
558)     ++m_scoreRight;
559)   }
560) 
561)   // ball at far right - goal for left player
562)   else if (m_ballPosX == m_width - 1) {
563)     m_goalDelay = goalDelay;
564)     ++m_scoreLeft;

565)   }
566) }
567) 
568) /// request next time call - or cancel request if not needed
569) void Pong::planTimeCall()
570) {

571)   // no time call needed if not active
572)   if (! isActive()) {

573)     m_mgrs.m_callMgr.cancelTimeCall(this);
574)     return;
575)   }

576) 

577)   // compute interval based on score and bounce count

578)   int speedup = 10 * (m_scoreLeft + m_scoreRight) + m_bounceCnt;
579)   float scale = 0.3f + 0.7f * expf(-0.03f * speedup);
580)   float interval = 1e-3f * m_delay * scale;

581) 
582)   // request next time call

583)   Time stepTime;

584)   stepTime.fromFloatSec(interval);

585)   m_mgrs.m_callMgr.requestTimeCall(this, Time::now() + stepTime);
586) }
587) 
588) /// start ball
589) void Pong::startBall()
590) {
591)   // ball starts horizontally at middle of field, vertically random
592)   m_ballPosX = (m_width - (rand() & 1)) / 2;
593)   m_ballPosY = rand() % m_height;
594)   // random diagonal direction
595)   m_ballDirX = (rand() & 1) * 2 - 1;
596)   m_ballDirY = (rand() & 1) * 2 - 1;
597) 

598)   // no delays, ball has not bounced at pad
599)   m_leftDelay = 0;
600)   m_rightDelay = 0;
601)   m_goalDelay = 0;
602)   m_bounceCnt = 0;
603) 
604)   // draw and send frame
605)   redraw();
606) 

607)   // request first time call if needed
608)   planTimeCall();

609) }
610)