add: implemented #122.

fix: bots try to defuse already beeing defused bomb (fixes #116).
fix: line ending in source code.
fix:  do not retreat with sniper weapon, if currently shooting and have ammo.
crlib: added deque class.

ext/crlib/cr-array.h

@@ -413,4 +413,3 @@ public:
 template <typename T> using SmallArray = Array <T, ReservePolicy::Single, 64>;
 
 CR_NAMESPACE_END
-

ext/crlib/cr-binheap.h

@@ -156,4 +156,4 @@ private:
    }
 };
 
-CR_NAMESPACE_END
+CR_NAMESPACE_END

ext/crlib/cr-complete.h

@@ -20,6 +20,7 @@
 #include <crlib/cr-basic.h>
 #include <crlib/cr-alloc.h>
 #include <crlib/cr-array.h>
+#include <crlib/cr-deque.h>
 #include <crlib/cr-binheap.h>
 #include <crlib/cr-files.h>
 #include <crlib/cr-lambda.h>

ext/crlib/cr-deque.h

@@ -0,0 +1,232 @@
+//
+// CRLib - Simple library for STL replacement in private projects.
+// Copyright © 2020 YaPB Development Team <team@yapb.ru>.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+// 
+
+#pragma once
+
+#include <crlib/cr-alloc.h>
+#include <crlib/cr-uniqueptr.h>
+#include <crlib/cr-twin.h>
+
+CR_NAMESPACE_BEGIN
+
+template <typename T> class Deque : private DenyCopying {
+private:
+   size_t capacity_ {};
+
+   UniquePtr <T[]> contents_ {};
+   Twin <size_t, size_t> index_ {};
+
+private:
+   size_t pickFrontIndex () {
+      if (index_.first == 0) {
+         if (capacity_ && index_.second != capacity_ - 1) {
+            return capacity_ - 1;
+         }
+      }
+      else if (index_.first - 1 != index_.second) {
+         return index_.first - 1;
+      }
+      extendCapacity ();
+
+      return capacity_ - 1;
+   }
+
+   size_t pickRearIndex () {
+      if (index_.second < index_.first) {
+         if (index_.second + 1 != index_.first) {
+            return index_.second + 1;
+         }
+      }
+      else {
+         if (index_.second + 1 < capacity_) {
+            return index_.second + 1;
+         }
+         if (index_.first != 0) {
+            return 0;
+         }
+      }
+      extendCapacity ();
+
+      return index_.second + 1;
+   }
+
+   void extendCapacity () {
+      auto capacity = capacity_ ? capacity_ * 2 : 8;
+      auto contents = cr::makeUnique <T[]> (sizeof (T) * capacity);
+
+      if (index_.first < index_.second) {
+         for (size_t i = 0; i < index_.second - index_.first; ++i) {
+            contents[i] = cr::move (contents_[index_.first + i]);
+         }
+         index_.second = index_.second - index_.first;
+         index_.first = 0;
+      }
+      else {
+         for (size_t i = 0; i < capacity_ - index_.first; ++i) {
+            contents[i] = cr::move (contents_[index_.first + i]);
+         }
+
+         for (size_t i = 0; i < index_.second; ++i) {
+            contents[capacity_ - index_.first + i] = cr::move (contents_[i]);
+         }
+         index_.second = index_.second + (capacity_ - index_.first);
+         index_.first = 0;
+      }
+      contents_ = cr::move (contents);
+      capacity_ = capacity;
+   }
+
+   void destroy () {
+      auto destruct = [&] (size_t start, size_t end) {
+         for (size_t i = start; i < end; ++i) {
+            cr::alloc.destruct (&contents_[i]);
+         }
+      };
+
+      if (index_.first <= index_.second) {
+         destruct (index_.first, index_.second);
+      }
+      else {
+         destruct (index_.first, capacity_);
+         destruct (0, index_.second);
+      }
+      contents_ = nullptr;
+   }
+
+   void reset () {
+      contents_ = nullptr;
+      capacity_ = 0;
+      index_ = {};
+   }
+
+public:
+   explicit Deque () : contents_ (nullptr), capacity_ (0)
+   { }
+
+   Deque (Deque &&rhs) : contents_ (cr::move (rhs.contents_)), capacity_ (rhs.capacity_) {
+      index_.first (rhs.index_.first);
+      index_.second (rhs.index_.second);
+
+      rhs.reset ();
+   }
+
+   ~Deque () {
+      destroy ();
+   }
+
+public:
+   bool empty () const {
+      return index_.first == index_.second;
+   }
+
+   template <typename U> void emplaceLast (U &&object) {
+      auto rear = pickRearIndex ();
+
+      cr::alloc.construct (&contents_[index_.second], cr::forward <U> (object));
+      index_.second = rear;
+   }
+
+   template <typename U> void emplaceFront (U &&object) {
+      index_.first = pickFrontIndex ();
+
+      cr::alloc.construct (&contents_[index_.first], cr::forward <U> (object));
+   }
+
+   void discardFront () {
+      cr::alloc.destruct (&contents_[index_.first]);
+
+      if (index_.first == capacity_ - 1) {
+         index_.first = 0;
+      }
+      else {
+         index_.first++;
+      }
+   }
+
+   void discardLast () {
+      if (index_.second == 0) {
+         index_.second = capacity_ - 1;
+      }
+      else {
+         index_.second--;
+      }
+      cr::alloc.destruct (&contents_[index_.second]);
+   }
+
+   T popFront () {
+      auto first (front ());
+      discardFront ();
+
+      return first;
+   }
+
+   T popLast () {
+      auto last (back ());
+      discardLast ();
+
+      return last;
+   }
+
+public:
+   const T &front () const {
+      return contents_[index_.first];
+   }
+
+   const T &last () const {
+      if (index_.second == 0) {
+         return contents_[capacity_ - 1];
+      }
+      return contents_[index_.second - 1];
+   }
+
+   T &front () {
+      return contents_[index_.first];
+   }
+
+   T &last () {
+      if (index_.second == 0) {
+         return contents_[capacity_ - 1];
+      }
+      return contents_[index_.second - 1];
+   }
+
+   size_t length () const {
+      if (index_.first == index_.second) {
+         return 0;
+      }
+      return index_.first < index_.second ? index_.second - index_.first : index_.second + (capacity_ - index_.first);
+   }
+
+   void clear () {
+      index_.first = 0;
+      index_.second = 0;
+   }
+
+public:
+   Deque &operator = (Deque &&rhs) {
+      destroy ();
+
+      contents_ = cr::move (rhs.contents_);
+      capacity_ = rhs.capacity_;
+
+      index_.first = rhs.index_.first;
+      index_.second = rhs.index_.second;
+
+      rhs.reset ();
+      return *this;
+   }
+};
+
+CR_NAMESPACE_END

ext/crlib/cr-detour.h

@@ -186,7 +186,23 @@ public:
       detour_ = nullptr;
    }
 
+private:
+   class DetourSwitch final {
+   private:
+      Detour <T> *detour_;
+
+   public:
+      DetourSwitch (Detour *detour) : detour_ (detour) {
+         detour_->restore ();
+      }
+
+      ~DetourSwitch () {
+         detour_->detour ();
+      }
+   };
+
 public:
+   
    void install (void *detour, const bool enable = false) {
       if (!original_) {
          return;
@@ -228,11 +244,8 @@ public:
    }
 
    template <typename... Args > decltype (auto) operator () (Args &&...args) {
-      restore ();
-      auto res = reinterpret_cast <T *> (original_) (args...);
-      detour ();
-
-      return res;
+      DetourSwitch sw (this);
+      return reinterpret_cast <T *> (original_) (args...);
    }
 };
 

ext/crlib/cr-logger.h

@@ -105,4 +105,4 @@ public:
 // expose global instance
 CR_EXPOSE_GLOBAL_SINGLETON (SimpleLogger, logger);
 
-CR_NAMESPACE_END
+CR_NAMESPACE_END

ext/hlsdk/progdefs.h

@@ -211,4 +211,3 @@ typedef struct entvars_s {
    edict_t *euser3;
    edict_t *euser4;
 } entvars_t;
-