Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /******************************************************************
  2. *   21 days: a game for programmers
  3. *   Copyright (C) 2014 Maxim Grishin
  4. *
  5. *   This program is free software; you can redistribute it and/or
  6. *   modify it under the terms of the GNU General Public License
  7. *   as published by the Free Software Foundation; either version 2
  8. *   of the License, or (at your option) any later version.
  9. *
  10. *   This program is distributed in the hope that it will be useful,
  11. *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. *   GNU General Public License for more details.
  14. *
  15. *   You should have received a copy of the GNU General Public License
  16. *   along with this program; if not, write to the Free Software
  17. *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  18. *   MA  02110-1301, USA.
  19. *******************************************************************/
  20.  
  21. #ifndef H_PQ
  22. #define H_PQ
  23.  
  24. #define LETTER_RETURN_TO_DAY_21                 100001
  25. #define LETTER_WEBMASTER_CHECK_UNNAMEDSTUDIO    100002
  26. #define LETTER_BORING_WORK                      100003
  27. #define LETTER_PERSISTENT_AND_PATIENT           100004
  28. #define LETTER_BORING_DEFAULT_PATH              100005
  29. #define LETTER_TEST_OF_KNOWLEDGE                100006
  30. #define LETTER_KNOWLEDGE_QUESTION               100007
  31.  
  32. #ifdef _KOS32
  33.     #include "kos_vector.h"
  34.     #define vector vector21
  35. #else
  36.     #include <vector>
  37.     #include <algorithm>    // std::sort
  38.     #define printf2 printf
  39.     using std::vector;
  40. #endif
  41.  
  42. enum Letter { LETTER_SHITCODE_1 = 0, LETTER_SHITCODE_2, LETTER_SHITCODE_3,
  43.     LETTER_BOTSMANN, LETTER_ASTRA, LETTER_UNNAMEDSTUDIO_1, LETTER_UNNAMEDSTUDIO_2,
  44.     LETTER_UNNAMEDSTUDIO_3, LETTER_UNNAMEDSTUDIO_4, LETTER_UNNAMEDSTUDIO_5,
  45.     LETTER_ANGRYBOSS_1, LETTER_ANGRYBOSS_2, NO_POPULARITY_HINT, LETTER_FINALPATH_DEF,
  46.     LETTER_FINALPATH_STARTUP, LETTER_FINALPATH_WORK, LETTER_FINALPATH_NOMONEY, LETTER_FINALPATH_NOPOPULARITY};
  47. enum EventType { COURSE = 1000, SPECIAL_LETTER, MESSAGE, NEWS, INCREASEPOPULARITY,
  48.     CHANGEPATH, CHANGESALARY, CHANGESALARYFIRSTDAY, NOPOPULARITY};
  49.  
  50. class event {
  51.     public:
  52.     double time;
  53.     EventType type;
  54.     int idata;
  55.     event() : time(0.0), idata(-1) {}
  56.     event(double t,EventType ty, int data = -1) : time(t), type(ty), idata(data) {}
  57.     bool operator>(const event a) const {
  58.         return this->time > a.time;
  59.         }
  60.     bool operator<(const event ev) const {
  61.         return time < ev.time;
  62.         }
  63.     };
  64.  
  65. #ifdef _KOS32
  66. static void exch (event* A, event* B) {
  67.     event t = *A;
  68.     *A = *B;
  69.     *B = t;
  70.     }
  71. #endif
  72.  
  73. static void sort21(vector<event>* v, bool desc = false) {
  74. #ifdef _KOS32
  75.     // Sorry for the bubble sort
  76.     for (unsigned int i = 0; i < v->size()-1; i++)
  77.         for (unsigned int j = 0; j < v->size()-i-1; j++) {
  78.             if (desc && (*v)[j] < (*v)[j+1])
  79.                 exch(&((*v)[j]), &(*v)[j+1]);
  80.             else if (!desc && (*v)[j] > (*v)[j+1])
  81.                 exch(&(*v)[j], &(*v)[j+1]);
  82.             }
  83. #else
  84.     if (desc)
  85.         std::sort(v->begin(), v->end(), std::greater<event>());
  86.     else
  87.         std::sort(v->begin(), v->end());
  88. #endif
  89.     }
  90.  
  91. class PQ3 {
  92.     private:
  93.     vector<event> v;
  94.     bool sorted;
  95.     public:
  96.     void sort() {
  97.         sort21(&v, true);
  98.         sorted = true;
  99.         }
  100.     PQ3() : sorted(false) {}
  101.     int n() {
  102.         return v.size();
  103.         }
  104.     bool empty() const {
  105.         return v.empty();
  106.         }
  107.     void insert(event item) {
  108.         v.push_back(item);
  109.         sorted = false;
  110.         }
  111.     event delMin() {
  112.         if (empty())
  113.             return event();
  114.         if (!sorted)
  115.             sort();
  116.         event e = v.back();
  117.         v.pop_back();
  118.         return e;
  119.         }
  120.     event* getMin() {
  121.         if (empty())
  122.             return 0;
  123.         if (!sorted)
  124.             sort();
  125.         return &v.back();
  126.         }
  127.     event* get(int i) {
  128.         if (empty() || i >= (int)v.size())
  129.             return 0;
  130.         if (!sorted)
  131.             sort();
  132.         return &v[i];
  133.         }
  134.     bool hasCourse(int c) {
  135.         for(unsigned int i = 0; i < v.size(); i++)
  136.             if (v[i].type == COURSE && v[i].idata == c)
  137.                 return true;
  138.         return false;
  139.         }
  140.     bool hasCourses() {
  141.         for(unsigned int i = 0; i < v.size(); i++)
  142.             if (v[i].type == COURSE)
  143.                 return true;
  144.         return false;
  145.         }
  146.     bool containsType(int et) {
  147.         for (int i = v.size()-1; i >= 0; i--)
  148.             if (v[i].type == et)
  149.                 return true;
  150.         return false;
  151.         }
  152.     bool containsType(int et, int data) {
  153.         for (int i = v.size()-1; i >= 0; i--)
  154.             if (v[i].type == et && v[i].idata == data)
  155.                 return true;
  156.         return false;
  157.         }
  158.     };
  159.  
  160.  
  161. class Undo2 {
  162. private:
  163.     vector<event> v;
  164. public:
  165.     Undo2() {}
  166.     int n() {
  167.         return v.size();
  168.         }
  169.     bool empty() const {
  170.         return v.empty();
  171.         }
  172.     void insert(event item) {
  173.         if (item.type == MESSAGE)
  174.             return;
  175.         v.push_back(item);
  176.         }
  177.     event delMax() {
  178.         if (empty())
  179.             return event();
  180.         event e = v.back();
  181.         v.pop_back();
  182.         return e;
  183.         }
  184.     event getMax() {
  185.         if (empty())
  186.             return event();
  187.         return v.back();
  188.         }
  189.     event* get(int i) {
  190.         if (empty() || i >= (int)v.size())
  191.             return 0;
  192.         return &v[i];
  193.         }
  194.     void prepareForUndo() {
  195.         sort21(&v, false);
  196.         }
  197.     bool containsTypeBefore(EventType et, int data, long double t) {
  198.         for (unsigned int i = 0; i < v.size(); i++)
  199.             if (v[i].type == et && v[i].idata == data && v[i].time <= t)
  200.                 return true;
  201.         return false;
  202.         }
  203.     };
  204. #endif
  205.