update amtl

# Conflicts:
#	extensions/sdkhooks/natives.cpp
#	plugins/include/sdkhooks.inc

.github/workflows/ci.yml

@@ -0,0 +1,98 @@
+name: Continuous Integration
+on: 
+  push:
+    branches:
+     - master
+     - '[0-9]+.[0-9]+-dev'
+  pull_request:
+    branches:
+     - master
+     - '[0-9]+.[0-9]+-dev'
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-18.04, ubuntu-latest, windows-latest]
+        include:
+          - os: windows-latest
+            os_short: win
+            compiler_cc: msvc
+          - os: ubuntu-latest
+            os_short: linux
+            compiler_cc: clang
+            compiler_cxx: clang++
+          - os: ubuntu-18.04
+            os_short: linux
+            compiler_cc: clang-8
+            compiler_cxx: clang++-8
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    name: ${{ matrix.os_short }}-${{ matrix.compiler_cc }}
+    env:
+      SDKS: '["episode1","css","tf2","l4d2","csgo"]'
+      ARCH: x86,x86_64
+      DEPENDENCIES_FOLDER: dependencies
+      DEPENDENCIES_ROOT: ${{ github.workspace }}/dependencies
+      MYSQL_VERSION: '5.5'
+      MMSOURCE_VERSION: '1.10'
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+          path: sourcemod
+
+      - name: Cache dependencies
+        uses: actions/cache@v2
+        env:
+          cache-name: hl2sdk-mysql-mmsource
+        with:
+          path: ${{ env.DEPENDENCIES_ROOT }}
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-mysql${{ env.MYSQL_VERSION }}-mmsource${{ env.MMSOURCE_VERSION }}-${{ join(fromJSON(env.SDKS), '') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-mysql${{ env.MYSQL_VERSION }}-mmsource${{ env.MMSOURCE_VERSION }}-
+            ${{ runner.os }}-build-${{ env.cache-name }}-mysql${{ env.MYSQL_VERSION }}-
+
+      # Setup Python for AMBuild
+      - uses: actions/setup-python@v2
+        name: Setup Python 3.8
+        with:
+          python-version: 3.8
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          mkdir -p ${{ env.DEPENDENCIES_FOLDER }}
+          cd ${{ env.DEPENDENCIES_FOLDER }}
+
+          # Satisfy checkout-deps requirement for a "sourcemod" folder.
+          mkdir -p sourcemod
+          ../sourcemod/tools/checkout-deps.sh -s ${{ join(fromJSON(env.SDKS)) }}
+
+      - name: Install Linux dependencies
+        if: startsWith(runner.os, 'Linux')
+        run: |
+          sudo dpkg --add-architecture i386
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            gcc-multilib g++-multilib libstdc++6 lib32stdc++6 \
+            libc6-dev libc6-dev-i386 linux-libc-dev \
+            linux-libc-dev:i386 lib32z1-dev ${{ matrix.compiler_cc }}
+
+      - name: Select clang compiler
+        if: startsWith(runner.os, 'Linux')
+        run: |
+          echo "CC=${{ matrix.compiler_cc }}" >> $GITHUB_ENV
+          echo "CXX=${{ matrix.compiler_cxx }}" >> $GITHUB_ENV
+          ${{ matrix.compiler_cc }} --version
+          ${{ matrix.compiler_cxx }} --version
+
+      - name: Build
+        working-directory: sourcemod
+        run: |
+          mkdir build
+          cd build
+          python ../configure.py --enable-optimize --sdks=${{ join(fromJSON(env.SDKS)) }} --targets=${{ env.ARCH }} --mms-path=${{ env.DEPENDENCIES_ROOT }}/mmsource-${{ env.MMSOURCE_VERSION }} --hl2sdk-root=${{ env.DEPENDENCIES_ROOT }} --mysql-path=${{ env.DEPENDENCIES_ROOT }}/mysql-${{ env.MYSQL_VERSION }} --mysql64-path=${{ env.DEPENDENCIES_ROOT }}/mysql-${{ env.MYSQL_VERSION }}-x86_64
+          ambuild

.github/workflows/scripting.yml

@@ -0,0 +1,79 @@
+name: SourcePawn scripting
+on: 
+  push:
+    branches:
+      - master
+      - '[0-9]+.[0-9]+-dev'
+    paths:
+      - 'plugins/include/*'
+      - 'sourcepawn/**'
+  workflow_dispatch:
+  schedule:
+    - cron: '53 05 01 */3 *' # Artifacts expire every 3 months
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        include:
+          - os: ubuntu-latest
+            os_short: linux
+          - os: windows-latest
+            os_short: win
+          - os: macos-latest
+            os_short: mac
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    env:
+      ARCH: x86,x86_64
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+
+      # Setup Python for AMBuild
+      - uses: actions/setup-python@v2
+        name: Setup Python 3.8
+        with:
+          python-version: 3.8
+      - name: Install AMBuild
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          pip install git+https://github.com/alliedmodders/ambuild
+
+      - name: Build only for x64 on macOS
+        if: startsWith(runner.os, 'macOS')
+        run: echo "ARCH=x86_64" >> $GITHUB_ENV
+
+      - name: Install Linux dependencies
+        if: startsWith(runner.os, 'Linux')
+        run: |
+          sudo dpkg --add-architecture i386
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            gcc-multilib g++-multilib libstdc++6 lib32stdc++6 \
+            libc6-dev libc6-dev-i386 linux-libc-dev \
+            linux-libc-dev:i386 lib32z1-dev ${{ matrix.compiler_cc }}
+
+      - name: Select clang compiler
+        if: startsWith(runner.os, 'Linux') || startsWith(runner.os, 'macOS')
+        run: |
+          echo "CC=clang" >> $GITHUB_ENV
+          echo "CXX=clang++" >> $GITHUB_ENV
+          clang --version
+          clang++ --version
+
+      - name: Build
+        shell: bash
+        run: |
+          mkdir build
+          cd build
+          python ../configure.py --enable-optimize --scripting-only --targets=${{ env.ARCH }}
+          ambuild
+          echo "SM_VERSION=$(cat ../product.version)" >> $GITHUB_ENV
+
+      - name: Archive tooling
+        uses: actions/upload-artifact@v2
+        with:
+          name: sourcemod-tooling-${{ env.SM_VERSION }}-${{ matrix.os_short }}
+          path: build/package

.gitignore

@@ -28,7 +28,7 @@ LIB-Debug/
 [Tt]humbs.db
 
 # AMBuild build directories
-build/
+build*/
 obj-*/
 *~
 *.rej
@@ -36,3 +36,7 @@ obj-*/
 *.smx
 *.swp
 *.gdb_history
+objdir
+
+.vs/*
+.vscode/*

.gitmodules

@@ -1,6 +1,8 @@
 [submodule "public/amtl"]
 	path = public/amtl
 	url = https://github.com/alliedmodders/amtl
+	shallow = true
 [submodule "sourcepawn"]
 	path = sourcepawn
 	url = https://github.com/alliedmodders/sourcepawn
+	shallow = true

.travis.yml

@@ -1,118 +1,86 @@
 git:
   depth: 3
 
-sudo: false
 language: cpp
 os: linux
-dist: trusty
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-      - llvm-toolchain-trusty-3.9
-      - llvm-toolchain-trusty-4.0
-      - llvm-toolchain-trusty-5.0
-    packages:
-      - lib32stdc++6
-      - lib32z1-dev
-      - libc6-dev-i386
-      - linux-libc-dev
-      - g++-multilib
-#      - clang-3.6
-#      - clang-3.8
-#      - clang-4.0
-#      - clang-5.0
-#      - g++-6
-#      - g++-6-multilib
-      - clang-3.9
-      - g++-4.8-multilib
-      - g++-4.8
-      - g++-4.9-multilib
-      - g++-4.9
-      - g++-5-multilib
-      - g++-5
-      - g++-7-multilib
-      - g++-7
-    cache:
-      directories:
-        - ../mysql-5.0
-env:
- - MATRIX_EVAL="CC=clang-3.9 && CXX=clang++-3.9"
- - MATRIX_EVAL="CC=gcc-4.8 && CXX=g++-4.8"
- - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9"
- - MATRIX_EVAL="CC=gcc-5 && CXX=g++-5"
- - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+dist: xenial
 
-matrix:
+jobs:
   fast_finish: true
   include:
     - os: linux
-      sudo: false
+      dist: trusty
       language: cpp
       addons:
         apt:
-          packages: ['clang-3.6', 'lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev', 'g++-multilib']
-        cache:
-          directories: ['../mysql-5.0']
-      env: ['MATRIX_EVAL="CC=clang-3.6 && CXX=clang++-3.6"']
+          sources:
+            - ubuntu-toolchain-r-test
+          packages: ['clang-3.8', 'lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev:i386', 'g++-4.9-multilib', 'python3-pip']
+      env:
+        - MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8"
+        - SDKS=episode1,css,tf2,l4d2,csgo
+        - MODE=optimize
+        - ARCH=x86,x86_64
 
     - os: linux
-      sudo: false
+      dist: trusty
       language: cpp
       addons:
         apt:
-          packages: ['clang-3.8', 'lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev', 'g++-multilib']
-        cache:
-          directories: ['../mysql-5.0']
-      env: ['MATRIX_EVAL="CC=clang-3.8 && CXX=clang++-3.8"']
+          sources:
+            - ubuntu-toolchain-r-test
+          packages: ['clang-3.4', 'lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev:i386', 'g++-4.9-multilib', 'python3-pip']
+      env:
+        - MATRIX_EVAL="CC=clang && CXX=clang++"
+        - SDKS=episode1,css,tf2,l4d2,csgo
+        - MODE=optimize
+        - ARCH=x86,x86_64
 
+    - os: osx
+      osx_image: xcode7.2
+      language: cpp
+      env:
+        - MATRIX_EVAL="CC=clang && CXX=clang++"
+        - SDKS=episode1,css,tf2,l4d2,csgo
+        - MODE=optimize
+        - ARCH=x86_64,x86
+
+    # # This is a faster test for the latest g++.
+    # - os: linux
+    #   dist: bionic
+    #   sudo: false
+    #   language: cpp
+    #   addons:
+    #     apt:
+    #       packages: ['lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev:i386', 'g++-multilib', 'g++']
+    #     cache:
+    #       directories: ['../mysql-5.0']
+    #   env:
+    #     - MATRIX_EVAL="CC=gcc && CXX=g++"
+    #     - SDKS=csgo
+    #     # GCC currently fails in opt builds trying to inline stuff in sqlite3.c.
+    #     - MODE=debug
+
+    # This is a faster test for the latest clang.
     - os: linux
-      sudo: false
+      dist: bionic
       language: cpp
       addons:
         apt:
-          sources: ['llvm-toolchain-trusty-4.0']
-          packages: ['clang-4.0', 'lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev', 'g++-multilib']
-        cache:
-          directories: ['../mysql-5.0']
-      env: ['MATRIX_EVAL="CC=clang-4.0 && CXX=clang++-4.0"']
-
-    - os: linux
-      sudo: false
-      language: cpp
-      addons:
-        apt:
-          sources: ['llvm-toolchain-trusty-5.0']
-          packages: ['clang-5.0', 'lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev', 'g++-multilib']
-        cache:
-          directories: ['../mysql-5.0']
-      env: ['MATRIX_EVAL="CC=clang-5.0 && CXX=clang++-5.0"']
-
-    - os: linux
-      sudo: false
-      language: cpp
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'g++-6-multilib', 'lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev', 'g++-multilib']
-        cache:
-          directories: ['../mysql-5.0']
-      env: ['MATRIX_EVAL="CC=gcc-6 && CXX=g++-6"']
-
-  allow_failures:
-    - env: MATRIX_EVAL="CC=clang-3.7 && CXX=clang++-3.7"
-    - env: MATRIX_EVAL="CC=clang-3.9 && CXX=clang++-3.9"
-    - env: MATRIX_EVAL="CC=gcc-4.8 && CXX=g++-4.8"
-    - env: MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9"
-    - env: MATRIX_EVAL="CC=gcc-5 && CXX=g++-5"
-    - env: MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
-
+          packages: ['lib32stdc++6', 'lib32z1-dev', 'libc6-dev-i386', 'linux-libc-dev:i386', 'g++-multilib', 'clang']
+      env:
+        - MATRIX_EVAL="CC=clang && CXX=clang++"
+        - SDKS=csgo
+        - MODE=optimize
+        - ARCH=x86
 
 before_script:
-  - CHECKOUT_DIR=$PWD && cd .. && $CHECKOUT_DIR/tools/checkout-deps.sh && cd $CHECKOUT_DIR
+  - CHECKOUT_DIR=$PWD && cd .. && $CHECKOUT_DIR/tools/checkout-deps.sh -s ${SDKS} && cd $CHECKOUT_DIR
 script:
   - mkdir build && cd build
   - PATH="~/.local/bin:$PATH"
   - eval "${MATRIX_EVAL}"
-  - python ../configure.py --enable-optimize --sdks=episode1,css,tf2,l4d2,csgo,dota
+  - eval "${CC} --version"
+  - eval "${CXX} --version"
+  - python3 ../configure.py --enable-${MODE} --sdks=${SDKS} --targets=${ARCH}
   - ambuild

AMBuildScript

@@ -1,5 +1,8 @@
 # vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:
+import collections
 import os, sys
+import subprocess
+import traceback
 
 class SDK(object):
   def __init__(self, sdk, ext, aDef, name, platform, dir):
@@ -19,23 +22,33 @@ class SDK(object):
     else:
       self.platformSpec = platform
 
-  def shouldBuild(self, target, archs):
-    if target.platform not in self.platformSpec:
-      return False
-    if not len([i for i in self.platformSpec[target.platform] if i in archs]):
-      return False
-    return True
+  def shouldBuild(self, targets):
+    for cxx in targets:
+      if cxx.target.platform in self.platformSpec:
+        if cxx.target.arch in self.platformSpec[cxx.target.platform]:
+          return True
+    return False
 
 WinOnly = ['windows']
 WinLinux = ['windows', 'linux']
 WinLinuxMac = ['windows', 'linux', 'mac']
+Blade = {
+  'windows': ['x86', 'x86_64'],
+  'linux': ['x86_64'],
+  'mac': ['x86_64']
+}
 CSGO = {
   'windows': ['x86'],
-  'linux': ['x86', 'x64'],
-  'mac': ['x64']
+  'linux': ['x86', 'x86_64'],
+  'mac': ['x86_64']
+}
+Mock = {
+  'windows': ['x86', 'x86_64'],
+  'linux': ['x86', 'x86_64'],
+  'mac': ['x86_64']
 }
 
-PossibleSDKs = {
+SDKMap = {
   'episode1':  SDK('HL2SDK', '2.ep1', '1', 'EPISODEONE', WinLinux, 'episode1'),
   'ep2':  SDK('HL2SDKOB', '2.ep2', '3', 'ORANGEBOX', WinLinux, 'orangebox'),
   'css':  SDK('HL2SDKCSS', '2.css', '6', 'CSS', WinLinuxMac, 'css'),
@@ -52,13 +65,19 @@ PossibleSDKs = {
   'eye':  SDK('HL2SDK-EYE', '2.eye', '5', 'EYE', WinOnly, 'eye'),
   'csgo': SDK('HL2SDKCSGO', '2.csgo', '21', 'CSGO', CSGO, 'csgo'),
   'portal2':  SDK('HL2SDKPORTAL2', '2.portal2', '17', 'PORTAL2', [], 'portal2'),
-  'blade':  SDK('HL2SDKBLADE', '2.blade', '18', 'BLADE', WinLinux, 'blade'),
+  'blade':  SDK('HL2SDKBLADE', '2.blade', '18', 'BLADE', Blade, 'blade'),
   'insurgency':  SDK('HL2SDKINSURGENCY', '2.insurgency', '19', 'INSURGENCY', WinLinuxMac, 'insurgency'),
   'contagion':  SDK('HL2SDKCONTAGION', '2.contagion', '14', 'CONTAGION', WinOnly, 'contagion'),
   'bms':  SDK('HL2SDKBMS', '2.bms', '10', 'BMS', WinLinux, 'bms'),
   'doi':  SDK('HL2SDKDOI', '2.doi', '20', 'DOI', WinLinuxMac, 'doi'),
+  'mock': SDK('HL2SDK-MOCK', '2.mock', '999', 'MOCK', Mock, 'mock'),
 }
 
+# Stable sorting for command equivalence in AMBuild.
+PossibleSDKs = collections.OrderedDict()
+for key in sorted(SDKMap.keys()):
+    PossibleSDKs[key] = SDKMap[key]
+
 def ResolveEnvPath(env, folder):
   if env in os.environ:
     path = os.environ[env]
@@ -80,32 +99,19 @@ def ResolveEnvPath(env, folder):
 def Normalize(path):
   return os.path.abspath(os.path.normpath(path))
   
-def SetArchFlags(compiler, arch, platform):
+def SetArchFlags(compiler):
   if compiler.behavior == 'gcc':
-    if arch == 'x86':
-      compiler.cflags += ['-m32']
-      compiler.linkflags += ['-m32']
-      if platform == 'mac':
-        compiler.linkflags += ['-arch', 'i386']
-    elif arch == 'x64':
-      compiler.cflags += ['-m64', '-fPIC']
-      compiler.linkflags += ['-m64']
-      if platform == 'mac':
-        compiler.linkflags += ['-arch', 'x86_64']
+    if compiler.target.arch == 'x86_64':
+      compiler.cflags += ['-fPIC']
   elif compiler.like('msvc'):
-    if builder.target.arch == 'x86':
-      compiler.linkflags += ['/MACHINE:X86']
-    elif builder.target.arch == 'x64':
-      compiler.linkflags += ['/MACHINE:X64']
-
-def AppendArchSuffix(binary, name, arch):
-  if arch == 'x64':
-    binary.localFolder = name + '.x64'
+    if compiler.target.arch == 'x86_64':
+      compiler.defines += ['WIN64']
 
 class SMConfig(object):
   def __init__(self):
     self.sdks = {}
     self.binaries = []
+    self.spvm = []
     self.extensions = []
     self.generated_headers = None
     self.mms_root = None
@@ -114,7 +120,32 @@ class SMConfig(object):
     self.spcomp_bins = None
     self.smx_files = {}
     self.versionlib = None
-    self.archs = builder.target.arch.replace('x86_64', 'x64').split(',')
+    self.all_targets = []
+    self.target_archs = set()
+    self.enable_asan = getattr(builder.options, 'enable_asan', False)
+    self.asan_libs = {}
+
+    if builder.options.targets:
+      target_archs = builder.options.targets.split(',')
+    else:
+      target_archs = ['x86']
+      if builder.backend != 'amb2':
+        target_archs.append('x86_64')
+
+    for arch in target_archs:
+        try:
+            cxx = builder.DetectCxx(target_arch = arch)
+            self.target_archs.add(cxx.target.arch)
+        except Exception as e:
+            # Error if archs were manually overridden.
+            if builder.options.targets:
+                raise
+            print('Skipping target {}: {}'.format(arch, e))
+            continue
+        self.all_targets.append(cxx)
+
+    if not self.all_targets:
+        raise Exception('No suitable C/C++ compiler was found.')
 
   def use_auto_versioning(self):
     if builder.backend != 'amb2':
@@ -143,32 +174,34 @@ class SMConfig(object):
 
   def detectSDKs(self):
     sdk_list = builder.options.sdks.split(',')
+    use_none = sdk_list[0] == 'none'
     use_all = sdk_list[0] == 'all'
     use_present = sdk_list[0] == 'present'
 
     for sdk_name in PossibleSDKs:
       sdk = PossibleSDKs[sdk_name]
-      if sdk.shouldBuild(builder.target, self.archs):
+      if sdk.shouldBuild(self.all_targets):
         if builder.options.hl2sdk_root:
           sdk_path = os.path.join(builder.options.hl2sdk_root, sdk.folder)
         else:
           sdk_path = ResolveEnvPath(sdk.envvar, sdk.folder)
         if sdk_path is None or not os.path.isdir(sdk_path):
-          if use_all or sdk_name in sdk_list:
+          if (use_all and sdk_name != 'mock') or sdk_name in sdk_list:
             raise Exception('Could not find a valid path for {0}'.format(sdk.envvar))
           continue
         if use_all or use_present or sdk_name in sdk_list:
           sdk.path = Normalize(sdk_path)
           self.sdks[sdk_name] = sdk
 
-    if len(self.sdks) < 1 and len(sdk_list):
-      raise Exception('No SDKs were found that build on {0}-{1}, nothing to do.'.format(
-        builder.target.platform, builder.target.arch))
+    if len(self.sdks) < 1 and len(sdk_list) and not use_none:
+      raise Exception('No applicable SDKs were found, nothing to do')
 
     if builder.options.mms_path:
       self.mms_root = builder.options.mms_path
     else:
-      self.mms_root = ResolveEnvPath('MMSOURCE110', 'mmsource-1.10')
+      self.mms_root = ResolveEnvPath('MMSOURCE111', 'mmsource-1.11')
+      if not self.mms_root:
+        self.mms_root = ResolveEnvPath('MMSOURCE110', 'mmsource-1.10')
       if not self.mms_root:
         self.mms_root = ResolveEnvPath('MMSOURCE_DEV', 'metamod-source')
       if not self.mms_root:
@@ -179,40 +212,49 @@ class SMConfig(object):
     self.mms_root = Normalize(self.mms_root)
 
     if builder.options.hasMySql:
-      if builder.options.mysql_path:
-        self.mysql_root['x86'] = builder.options.mysql_path
-      else:
-        for i in range(10):
-          self.mysql_root['x86'] = ResolveEnvPath('MYSQL55', 'mysql-5.' + str(i))
-          if self.mysql_root['x86']:
-            break
-      if not self.mysql_root['x86'] or not os.path.isdir(self.mysql_root['x86']):
-        raise Exception('Could not find a path to MySQL!')
-      self.mysql_root['x86'] = Normalize(self.mysql_root['x86'])
-
-      # For now, ignore 64-bit MySQL on Windows
-      if 'x64' in self.archs and builder.target.platform != 'windows':
-        if builder.options.mysql64_path:
-          self.mysql_root['x64'] = builder.options.mysql64_path
+      if 'x86' in self.target_archs:
+        if builder.options.mysql_path:
+          self.mysql_root['x86'] = builder.options.mysql_path
         else:
           for i in range(10):
-            self.mysql_root['x64'] = ResolveEnvPath('MYSQL55_64', 'mysql-5.' + str(i) + '-x86_64')
-            if self.mysql_root['x64']:
+            self.mysql_root['x86'] = ResolveEnvPath('MYSQL55', 'mysql-5.' + str(i))
+            if self.mysql_root['x86']:
               break
-        if not self.mysql_root['x64'] or not os.path.isdir(self.mysql_root['x64']):
+        if not self.mysql_root['x86'] or not os.path.isdir(self.mysql_root['x86']):
+          raise Exception('Could not find a path to MySQL. Configure with --no-mysql to disable it.')
+        self.mysql_root['x86'] = Normalize(self.mysql_root['x86'])
+
+      if 'x86_64' in self.target_archs:
+        if builder.options.mysql64_path:
+          self.mysql_root['x86_64'] = builder.options.mysql64_path
+        else:
+          for i in range(10):
+            self.mysql_root['x86_64'] = ResolveEnvPath('MYSQL55_64', 'mysql-5.' + str(i) + '-x86_64')
+            if self.mysql_root['x86_64']:
+              break
+        if not self.mysql_root['x86_64'] or not os.path.isdir(self.mysql_root['x86_64']):
           raise Exception('Could not find a path to 64-bit MySQL!')
-        self.mysql_root['x64'] = Normalize(self.mysql_root['x64'])
+        self.mysql_root['x86_64'] = Normalize(self.mysql_root['x86_64'])
 
   def configure(self):
     builder.AddConfigureFile('pushbuild.txt')
     
-    if not set(self.archs).issubset(['x86', 'x64']):
-      raise Exception('Unknown target architecture: {0}'.format(builder.target.arch))
+    if not set(self.target_archs).issubset(['x86', 'x86_64']):
+      raise Exception('Unknown target architecture: {0}'.format(self.target_archs))
 
-    cxx = builder.DetectCxx()
-    
-    if cxx.like('msvc') and len(self.archs) > 1:
-      raise Exception('Building multiple archs with MSVC is not currently supported')
+    for cxx in self.all_targets:
+        self.configure_cxx(cxx)
+
+  def configure_cxx(self, cxx):
+    if cxx.family == 'msvc':
+      if cxx.version < 1900:
+        raise Exception('Only MSVC 2015 and later are supported, c++14 support is required.')
+    if cxx.family == 'gcc':
+      if cxx.version < 'gcc-4.9':
+        raise Exception('Only GCC versions 4.9 or greater are supported, c++14 support is required.')
+    if cxx.family == 'clang':
+      if cxx.version < 'clang-3.4':
+        raise Exception('Only clang versions 3.4 or greater are supported, c++14 support is required.')
 
     if cxx.like('gcc'):
       self.configure_gcc(cxx)
@@ -228,11 +270,11 @@ class SMConfig(object):
       cxx.defines += ['DEBUG', '_DEBUG']
 
     # Platform-specifics
-    if builder.target.platform == 'linux':
+    if cxx.target.platform == 'linux':
       self.configure_linux(cxx)
-    elif builder.target.platform == 'mac':
+    elif cxx.target.platform == 'mac':
       self.configure_mac(cxx)
-    elif builder.target.platform == 'windows':
+    elif cxx.target.platform == 'windows':
       self.configure_windows(cxx)
 
     # Finish up.
@@ -270,9 +312,13 @@ class SMConfig(object):
       '-msse',
       '-fvisibility=hidden',
     ]
+
+    if cxx.version == 'apple-clang-6.0' or cxx.version == 'clang-3.4':
+      cxx.cxxflags += ['-std=c++1y']
+    else:
+      cxx.cxxflags += ['-std=c++14']
+
     cxx.cxxflags += [
-      '-std=c++11',
-      '-fno-exceptions',
       '-fno-threadsafe-statics',
       '-Wno-non-virtual-dtor',
       '-Wno-overloaded-virtual',
@@ -281,11 +327,11 @@ class SMConfig(object):
 
     have_gcc = cxx.family == 'gcc'
     have_clang = cxx.family == 'clang'
-    if cxx.version >= 'clang-3.9':
+    if cxx.version >= 'clang-3.9' or cxx.version == 'clang-3.4' or cxx.version > 'apple-clang-6.0':
       cxx.cxxflags += ['-Wno-expansion-to-defined']
     if cxx.version == 'clang-3.9' or cxx.version == 'apple-clang-8.0':
       cxx.cflags += ['-Wno-varargs']
-    if cxx.version >= 'clang-3.6' or cxx.version >= 'apple-clang-7.0':
+    if cxx.version >= 'clang-3.4' or cxx.version >= 'apple-clang-7.0':
       cxx.cxxflags += ['-Wno-inconsistent-missing-override']
     if cxx.version >= 'clang-2.9' or cxx.version >= 'apple-clang-3.0':
       cxx.cxxflags += ['-Wno-null-dereference']
@@ -305,14 +351,35 @@ class SMConfig(object):
         cxx.cxxflags += ['-Wno-deprecated']
       cxx.cflags += ['-Wno-sometimes-uninitialized']
 
+    if self.enable_asan:
+      if not have_clang:
+        raise Exception('--enable-asan only supported when using Clang')
+      self.configure_asan(cxx)
+
+    # Work around SDK warnings.
+    if cxx.version >= 'clang-10.0' or cxx.version >= 'apple-clang-12.0':
+        cxx.cflags += [
+            '-Wno-implicit-int-float-conversion',
+            '-Wno-tautological-overlap-compare',
+        ]
+
     if have_gcc:
       cxx.cflags += ['-mfpmath=sse']
       cxx.cflags += ['-Wno-maybe-uninitialized']
 
     if builder.options.opt == '1':
-      cxx.cflags += ['-O3']
+      if self.enable_asan:
+        cxx.cflags += ['-O1']
+      else:
+        cxx.cflags += ['-O3']
+
+    # Don't omit the frame pointer.
+    cxx.cflags += ['-fno-omit-frame-pointer']
 
   def configure_msvc(self, cxx):
+    if self.enable_asan:
+      raise Exception('--enable-asan only supported when using Clang')
+
     if builder.options.debug == '1':
       cxx.cflags += ['/MTd']
       cxx.linkflags += ['/NODEFAULTLIB:libcmt']
@@ -358,6 +425,29 @@ class SMConfig(object):
     # Don't omit the frame pointer.
     cxx.cflags += ['/Oy-']
 
+  def configure_asan(self, cxx):
+    if cxx.target.platform != 'linux':
+      raise Exception('--enable-asan only supported on Linux')
+    cxx.cflags += ['-fsanitize=address']
+    cxx.linkflags += ['-fsanitize=address']
+    if cxx.target.arch == 'x86':
+      libclang_rt = 'libclang_rt.asan-i386.so'
+    else:
+      libclang_rt = 'libclang_rt.asan-x86_64.so'
+
+    try:
+      argv = cxx.cxx_argv + ['--print-file-name', libclang_rt]
+      output = subprocess.check_output(argv)
+      output = output.decode('utf-8')
+      output = output.strip()
+    except:
+      raise Exception('Could not find {}'.format(libclang_rt))
+
+    print('ASAN library for {}: {}'.format(cxx.target.arch, output))
+    print('You will need to LD_PRELOAD this into srcds.')
+
+    self.asan_libs[cxx.target.arch] = os.path.dirname(output)
+
   def configure_linux(self, cxx):
     cxx.defines += ['_LINUX', 'POSIX', '_FILE_OFFSET_BITS=64']
     cxx.linkflags += ['-lm']
@@ -365,22 +455,33 @@ class SMConfig(object):
       cxx.linkflags += ['-static-libgcc']
     elif cxx.family == 'clang':
       cxx.linkflags += ['-lgcc_eh']
+    cxx.linkflags += ['-static-libstdc++']
 
   def configure_mac(self, cxx):
     cxx.defines += ['OSX', '_OSX', 'POSIX', 'KE_ABSOLUTELY_NO_STL']
-    cxx.cflags += ['-mmacosx-version-min=10.5']
+    cxx.cflags += ['-mmacosx-version-min=10.7']
     cxx.linkflags += [
-      '-mmacosx-version-min=10.5',
-      '-lstdc++',
-      '-stdlib=libstdc++',
+      '-mmacosx-version-min=10.7',
+      '-stdlib=libc++',
+      '-lc++',
     ]
-    cxx.cxxflags += ['-stdlib=libstdc++']
+    cxx.cxxflags += ['-stdlib=libc++']
 
   def configure_windows(self, cxx):
     cxx.defines += ['WIN32', '_WINDOWS']
 
-  def AddVersioning(self, binary, arch):
-    if builder.target.platform == 'windows':
+  def add_libamtl(self):
+    # Add libamtl.
+    self.libamtl = {}
+    for cxx in self.all_targets:
+      def get_configure_fn(cxx):
+        return lambda builder, name: self.StaticLibrary(builder, cxx, name)
+      extra_vars = {'Configure': get_configure_fn(cxx)}
+      libamtl = builder.Build('public/amtl/amtl/AMBuilder', extra_vars)
+      self.libamtl[cxx.target.arch] = libamtl.binary
+
+  def AddVersioning(self, binary):
+    if binary.compiler.target.platform == 'windows':
       binary.sources += ['version.rc']
       binary.compiler.rcdefines += [
         'BINARY_NAME="{0}"'.format(binary.outputFile),
@@ -388,31 +489,38 @@ class SMConfig(object):
       ]
       if self.use_auto_versioning():
         binary.compiler.rcdefines += ['SM_GENERATED_BUILD']
-    elif builder.target.platform == 'mac':
+    elif binary.compiler.target.platform == 'mac':
       if binary.type == 'library':
         binary.compiler.postlink += [
           '-compatibility_version', '1.0.0',
           '-current_version', self.productVersion
         ]
     if self.use_auto_versioning():
-      binary.compiler.linkflags += [self.versionlib[arch]]
+      binary.compiler.postlink += [self.versionlib[binary.compiler.target.arch]]
       binary.compiler.sourcedeps += SM.generated_headers
     return binary
     
-  def LibraryBuilder(self, compiler, name, arch):
+  def LibraryBuilder(self, compiler, name):
     binary = compiler.Library(name)
-    AppendArchSuffix(binary, name, arch)
-    self.AddVersioning(binary, arch)
+    self.AddVersioning(binary)
     if binary.compiler.like('msvc'):
       binary.compiler.linkflags += ['/SUBSYSTEM:WINDOWS']
+
+    # Dumb clang behavior means we have to manually find libclang_rt.
+    if self.enable_asan:
+      binary.compiler.linkflags += [
+        '-shared-libsan',
+        '-Wl,-rpath={}'.format(self.asan_libs[binary.compiler.target.arch]),
+      ]
     return binary
 
-  def ProgramBuilder(self, compiler, name, arch):
+  def ProgramBuilder(self, compiler, name):
     binary = compiler.Program(name)
-    AppendArchSuffix(binary, name, arch)
-    self.AddVersioning(binary, arch)
+    self.AddVersioning(binary)
     if '-static-libgcc' in binary.compiler.linkflags:
       binary.compiler.linkflags.remove('-static-libgcc')
+    if self.enable_asan:
+      binary.compiler.linkflags.append('-static-libsan')
     if '-lgcc_eh' in binary.compiler.linkflags:
       binary.compiler.linkflags.remove('-lgcc_eh')
     if binary.compiler.like('gcc'):
@@ -421,25 +529,23 @@ class SMConfig(object):
       binary.compiler.linkflags += ['/SUBSYSTEM:CONSOLE']
     return binary
     
-  def StaticLibraryBuilder(self, compiler, name, arch):
-    binary = compiler.StaticLibrary(name)
-    AppendArchSuffix(binary, name, arch)
-    return binary;
+  def StaticLibraryBuilder(self, compiler, name):
+    return compiler.StaticLibrary(name)
 
-  def Library(self, context, name, arch):
-    compiler = context.cxx.clone()
-    SetArchFlags(compiler, arch, builder.target.platform)
-    return self.LibraryBuilder(compiler, name, arch)
+  def Library(self, context, compiler, name):
+    compiler = compiler.clone()
+    SetArchFlags(compiler)
+    return self.LibraryBuilder(compiler, name)
 
-  def Program(self, context, name, arch):
-    compiler = context.cxx.clone()
-    SetArchFlags(compiler, arch, builder.target.platform)
-    return self.ProgramBuilder(compiler, name, arch)
+  def Program(self, context, compiler, name):
+    compiler = compiler.clone()
+    SetArchFlags(compiler)
+    return self.ProgramBuilder(compiler, name)
     
-  def StaticLibrary(self, context, name, arch):
-    compiler = context.cxx.clone()
-    SetArchFlags(compiler, arch, builder.target.platform)
-    return self.StaticLibraryBuilder(compiler, name, arch)
+  def StaticLibrary(self, context, compiler, name):
+    compiler = compiler.clone()
+    SetArchFlags(compiler)
+    return self.StaticLibraryBuilder(compiler, name)
 
   def ConfigureForExtension(self, context, compiler):
     compiler.cxxincludes += [
@@ -452,15 +558,15 @@ class SMConfig(object):
     ]
     return compiler
 
-  def ExtLibrary(self, context, name, arch):
-    binary = self.Library(context, name, arch)
+  def ExtLibrary(self, context, compiler, name):
+    binary = self.Library(context, compiler, name)
+    SetArchFlags(compiler)
     self.ConfigureForExtension(context, binary.compiler)
     return binary
 
-  def ConfigureForHL2(self, binary, sdk, arch):
+  def ConfigureForHL2(self, context, binary, sdk):
     compiler = binary.compiler
-    
-    SetArchFlags(compiler, arch, builder.target.platform)
+    SetArchFlags(compiler)
 
     compiler.cxxincludes += [
       os.path.join(self.mms_root, 'core'),
@@ -497,13 +603,16 @@ class SMConfig(object):
       compiler.defines.remove('_vsnprintf=vsnprintf')
 
     if compiler.like('msvc'):
-      compiler.defines += ['COMPILER_MSVC', 'COMPILER_MSVC32']
-      if compiler.version >= 1900:
-        compiler.linkflags += ['legacy_stdio_definitions.lib']
+      compiler.defines += ['COMPILER_MSVC']
+      if compiler.target.arch == 'x86':
+        compiler.defines += ['COMPILER_MSVC32']
+      elif compiler.target.arch == 'x86_64':
+        compiler.defines += ['COMPILER_MSVC64']
+      compiler.linkflags += ['legacy_stdio_definitions.lib']
     else:
       compiler.defines += ['COMPILER_GCC']
 
-    if arch == 'x64':
+    if compiler.target.arch == 'x86_64':
       compiler.defines += ['X64BITS', 'PLATFORM_64BITS']
 
     # For everything after Swarm, this needs to be defined for entity networking
@@ -512,107 +621,142 @@ class SMConfig(object):
       compiler.defines += ['NETWORK_VARS_ENABLED']
 
     if sdk.name in ['css', 'hl2dm', 'dods', 'sdk2013', 'bms', 'tf2', 'l4d', 'nucleardawn', 'l4d2']:
-      if builder.target.platform in ['linux', 'mac']:
+      if compiler.target.platform in ['linux', 'mac']:
         compiler.defines += ['NO_HOOK_MALLOC', 'NO_MALLOC_OVERRIDE']
 
-    if sdk.name == 'csgo' and builder.target.platform == 'linux':
-      compiler.linkflags += ['-lstdc++']
-      compiler.defines += ['_GLIBCXX_USE_CXX11_ABI=0']
+    if compiler.target.platform == 'linux':
+      if sdk.name in ['csgo', 'blade']:
+        compiler.linkflags.remove('-static-libstdc++')
+        compiler.linkflags += ['-lstdc++']
+        compiler.defines += ['_GLIBCXX_USE_CXX11_ABI=0']
+    elif compiler.target.platform == 'mac':
+      if sdk.name in ['csgo']:
+        # Switch libc++ to libstdc++ for protobuf linkage.
+        compiler.cxxflags.remove('-stdlib=libc++')
+        compiler.linkflags.remove('-stdlib=libc++')
+        compiler.linkflags.remove('-lc++')
+
+        compiler.cxxflags += ['-stdlib=libstdc++']
+        compiler.linkflags += ['-stdlib=libstdc++']
+        compiler.linkflags += ['-lstdc++']
+
+        if 'c++1y' in compiler.cxxflags:
+          compiler.cxxflags.remove('-std=c++1y')
+          compiler.cxxflags += ['-std=c++11']
+        elif 'c++14' in compiler.cxxflags:
+          compiler.cxxflags.remove('-std=c++14')
+          compiler.cxxflags += ['-std=c++11']
 
     for path in paths:
       compiler.cxxincludes += [os.path.join(sdk.path, *path)]
 
-    if builder.target.platform == 'linux':
+    if compiler.target.platform == 'linux':
       if sdk.name == 'episode1':
         lib_folder = os.path.join(sdk.path, 'linux_sdk')
       elif sdk.name in ['sdk2013', 'bms']:
         lib_folder = os.path.join(sdk.path, 'lib', 'public', 'linux32')
-      elif arch == 'x64':
+      elif compiler.target.arch == 'x86_64':
         lib_folder = os.path.join(sdk.path, 'lib', 'linux64')
       else:
         lib_folder = os.path.join(sdk.path, 'lib', 'linux')
-    elif builder.target.platform == 'mac':
+    elif compiler.target.platform == 'mac':
       if sdk.name in ['sdk2013', 'bms']:
         lib_folder = os.path.join(sdk.path, 'lib', 'public', 'osx32')
-      elif arch == 'x64':
+      elif compiler.target.arch == 'x86_64':
         lib_folder = os.path.join(sdk.path, 'lib', 'osx64')
       else:
         lib_folder = os.path.join(sdk.path, 'lib', 'mac')
 
-    if builder.target.platform in ['linux', 'mac']:
-      if sdk.name in ['sdk2013', 'bms'] or arch == 'x64':
+    if compiler.target.platform in ['linux', 'mac']:
+      if sdk.name in ['sdk2013', 'bms'] or compiler.target.arch == 'x86_64':
         compiler.postlink += [
-          compiler.Dep(os.path.join(lib_folder, 'tier1.a')),
-          compiler.Dep(os.path.join(lib_folder, 'mathlib.a'))
+          os.path.join(lib_folder, 'tier1.a'),
+          os.path.join(lib_folder, 'mathlib.a')
         ]
       else:
         compiler.postlink += [
-          compiler.Dep(os.path.join(lib_folder, 'tier1_i486.a')),
-          compiler.Dep(os.path.join(lib_folder, 'mathlib_i486.a'))
+          os.path.join(lib_folder, 'tier1_i486.a'),
+          os.path.join(lib_folder, 'mathlib_i486.a')
         ]
 
       if sdk.name in ['blade', 'insurgency', 'doi', 'csgo']:
-        if arch == 'x64':
-          compiler.postlink += [compiler.Dep(os.path.join(lib_folder, 'interfaces.a'))]
+        if compiler.target.arch == 'x86_64':
+          compiler.postlink += [os.path.join(lib_folder, 'interfaces.a')]
         else:
-          compiler.postlink += [compiler.Dep(os.path.join(lib_folder, 'interfaces_i486.a'))]
+          compiler.postlink += [os.path.join(lib_folder, 'interfaces_i486.a')]
 
     dynamic_libs = []
-    if builder.target.platform == 'linux':
+    if compiler.target.platform == 'linux':
       if sdk.name in ['css', 'hl2dm', 'dods', 'tf2', 'sdk2013', 'bms', 'nucleardawn', 'l4d2', 'insurgency', 'doi']:
         dynamic_libs = ['libtier0_srv.so', 'libvstdlib_srv.so']
-      elif arch == 'x64' and sdk.name == 'csgo':
+      elif compiler.target.arch == 'x86_64' and sdk.name in ['csgo', 'mock']:
         dynamic_libs = ['libtier0_client.so', 'libvstdlib_client.so']
       elif sdk.name in ['l4d', 'blade', 'insurgency', 'doi', 'csgo']:
         dynamic_libs = ['libtier0.so', 'libvstdlib.so']
       else:
         dynamic_libs = ['tier0_i486.so', 'vstdlib_i486.so']
-    elif builder.target.platform == 'mac':
+    elif compiler.target.platform == 'mac':
       compiler.linkflags.append('-liconv')
       dynamic_libs = ['libtier0.dylib', 'libvstdlib.dylib']
-    elif builder.target.platform == 'windows':
+    elif compiler.target.platform == 'windows':
       libs = ['tier0', 'tier1', 'vstdlib', 'mathlib']
       if sdk.name in ['swarm', 'blade', 'insurgency', 'doi', 'csgo']:
         libs.append('interfaces')
       for lib in libs:
-        lib_path = os.path.join(sdk.path, 'lib', 'public', lib) + '.lib'
-        compiler.linkflags.append(compiler.Dep(lib_path))
+        if compiler.target.arch == 'x86':
+          lib_path = os.path.join(sdk.path, 'lib', 'public', lib) + '.lib'
+        elif compiler.target.arch == 'x86_64':
+          lib_path = os.path.join(sdk.path, 'lib', 'public', 'win64', lib) + '.lib'
+        compiler.linkflags.append(lib_path)
 
     for library in dynamic_libs:
       source_path = os.path.join(lib_folder, library)
       output_path = os.path.join(binary.localFolder, library)
 
-      def make_linker(source_path, output_path):
-        def link(context, binary):
-          cmd_node, (output,) = context.AddSymlink(source_path, output_path)
-          return output
-        return link
+      # Ensure the output path exists.
+      context.AddFolder(binary.localFolder)
+      output = context.AddSymlink(source_path, output_path)
 
-      linker = make_linker(source_path, output_path)
-      compiler.linkflags[0:0] = [compiler.Dep(library, linker)]
+      compiler.weaklinkdeps += [output]
+      compiler.linkflags[0:0] = [library]
 
     return binary
 
-  def HL2Library(self, context, name, sdk, arch):
-    binary = self.Library(context, name, arch)
+  def HL2Library(self, context, compiler, name, sdk):
+    binary = self.Library(context, compiler, name)
     self.ConfigureForExtension(context, binary.compiler)
-    return self.ConfigureForHL2(binary, sdk, arch)
+    return self.ConfigureForHL2(context, binary, sdk)
 
-  def HL2Project(self, context, name):
-    project = context.cxx.LibraryProject(name)
-    self.ConfigureForExtension(context, project.compiler)
-    return project
+  def HL2Config(self, project, context, compiler, name, sdk):
+    binary = project.Configure(compiler, name,
+                               '{0} - {1} {2}'.format(self.tag, sdk.name, compiler.target.arch))
+    self.AddVersioning(binary)
+    return self.ConfigureForHL2(context, binary, sdk)
 
-  def HL2Config(self, project, name, sdk, arch):
-    binary = project.Configure(name, '{0} - {1}'.format(self.tag, sdk.name))
-    AppendArchSuffix(binary, name, arch)
-    self.AddVersioning(binary, arch)
-    return self.ConfigureForHL2(binary, sdk, arch)
+  def HL2ExtConfig(self, project, context, compiler, name, sdk):
+    binary = project.Configure(compiler, name,
+                               '{0} - {1} {2}'.format(self.tag, sdk.name, compiler.target.arch))
+    self.AddVersioning(binary)
+    self.ConfigureForHL2(context, binary, sdk)
+    self.ConfigureForExtension(context, binary.compiler)
+    return binary
+
+if getattr(builder, 'target', None) is not None:
+    sys.stderr.write("Your output folder was configured for AMBuild 2.1, and SourceMod is now\n")
+    sys.stderr.write("configured to use AMBuild 2.2. Please remove your output folder and\n")
+    sys.stderr.write("reconfigure to continue.\n")
+    os._exit(1)
 
 SM = SMConfig()
 SM.detectProductVersion()
-SM.detectSDKs()
+if not getattr(builder.options, 'scripting_only', False):
+  SM.detectSDKs()
 SM.configure()
+SM.add_libamtl()
+
+# This will clone the list and each cxx object as we recurse, preventing child
+# scripts from messing up global state.
+builder.targets = builder.CloneableList(SM.all_targets)
 
 if SM.use_auto_versioning():
   SM.generated_headers = builder.Build(
@@ -624,46 +768,79 @@ if SM.use_auto_versioning():
     { 'SM': SM }
   )
 
+class SPRoot(object):
+  # SourcePawn's build scripts are always one-offs, and attach the current target
+  # to the builder, so we have to provide a shim to our StaticLibrary() method.
+  def StaticLibrary(self, builder, name):
+    return SM.StaticLibrary(builder, builder.cxx, name)
+  def Program(self, builder, name):
+    return SM.Program(builder, builder.cxx, name)
+  def Library(self, builder, name):
+    return SM.Library(builder, builder.cxx, name)
+
+  @property
+  def targets(self):
+    return SM.all_targets
+
+  @property
+  def libamtl(self):
+    return SM.libamtl
+
+SP_build_parts = ['core']
+if getattr(builder.options, 'scripting_only', False):
+  SP_build_parts = ['spcomp']
+
 # Build SourcePawn externally.
 SP = builder.Build('sourcepawn/AMBuildScript', {
-  'external_root': SM,
+  'external_root': SPRoot(),
   'external_amtl': os.path.join(builder.sourcePath, 'public', 'amtl'),
-  'external_build': ['core'],
+  'external_build': SP_build_parts,
 })
 if len(SP.spcomp) > 1:
   SM.spcomp = SP.spcomp['x86']
 else:
   SM.spcomp = SP.spcomp[list(SP.spcomp.keys())[0]]
 SM.spcomp_bins = list(SP.spcomp.values())
-for arch in SM.archs:
-  SM.binaries += [
-     SP.libsourcepawn[arch]
+
+if not getattr(builder.options, 'scripting_only', False):
+  for cxx in SM.all_targets:
+    SM.spvm += [
+      SP.libsourcepawn[cxx.target.arch]
+    ]
+
+if getattr(builder.options, 'scripting_only', False):
+  BuildScripts = [
+    'tools/buildbot/PackageHelpers',
+    'tools/buildbot/ToolsPackageScript',
+  ]
+else:
+  BuildScripts = [
+    'loader/AMBuilder',
+    'core/AMBuilder',
+    'core/logic/AMBuilder',
+    'extensions/bintools/AMBuilder',
+    'extensions/clientprefs/AMBuilder',
+    'extensions/curl/AMBuilder',
+    'extensions/cstrike/AMBuilder',
+    'extensions/dhooks/AMBuilder',
+    'extensions/geoip/AMBuilder',
+    'extensions/mysql/AMBuilder',
+    'extensions/pgsql/AMBuilder',
+    'extensions/regex/AMBuilder',
+    'extensions/sdkhooks/AMBuilder',
+    'extensions/sdktools/AMBuilder',
+    'extensions/sqlite/AMBuilder',
+    'extensions/tf2/AMBuilder',
+    'extensions/topmenus/AMBuilder',
+    'extensions/updater/AMBuilder',
   ]
 
-BuildScripts = [
-  'loader/AMBuilder',
-  'core/AMBuilder',
-  'core/logic/AMBuilder',
-  'extensions/bintools/AMBuilder',
-  'extensions/clientprefs/AMBuilder',
-  'extensions/curl/AMBuilder',
-  'extensions/cstrike/AMBuilder',
-  'extensions/geoip/AMBuilder',
-  'extensions/mysql/AMBuilder',
-  'extensions/regex/AMBuilder',
-  'extensions/sdkhooks/AMBuilder',
-  'extensions/sdktools/AMBuilder',
-  'extensions/sqlite/AMBuilder',
-  'extensions/tf2/AMBuilder',
-  'extensions/topmenus/AMBuilder',
-  'extensions/updater/AMBuilder',
-]
-
-if builder.backend == 'amb2':
-  BuildScripts += [
-    'plugins/AMBuilder',
-    'tools/buildbot/PackageScript',
-  ]
+  if builder.backend == 'amb2':
+    BuildScripts += [
+      'plugins/AMBuilder',
+      'tools/buildbot/PackageHelpers',
+      'tools/buildbot/PackageScript',
+    ]
 
 builder.Build(BuildScripts, { 'SM': SM })
 

appveyor.yml

@@ -0,0 +1,17 @@
+version: 1.0.{build}
+image: Visual Studio 2015
+clone_folder: c:/projects/sourcemod
+clone_depth: 1
+install:
+- cmd: set PATH=C:\Python38;C:\Python38\Scripts;%PATH%
+- cmd: git submodule update --init --recursive
+- cmd: git pull --recurse-submodules
+- cmd: cd ..
+- ps: sourcemod/tools/checkout-deps.ps1 -SDKs episode1,css,tf2,l4d2,csgo
+- cmd: cd sourcemod
+build_script:
+- cmd: call "%VS140COMNTOOLS%/vsvars32.bat"
+- cmd: mkdir build
+- cmd: cd build
+- cmd: python.exe ../configure.py --enable-optimize --no-mysql --sdks=episode1,css,tf2,l4d2,csgo
+- cmd: ambuild

bridge/include/CoreProvider.h

@@ -67,7 +67,7 @@ struct DatabaseInfo;
 class IPlayerInfoBridge;
 class ICommandArgs;
 
-typedef ke::Lambda<bool(int client, const ICommandArgs*)> CommandFunc;
+typedef ke::Function<bool(int client, const ICommandArgs*)> CommandFunc;
 
 class CoreProvider
 {
@@ -115,6 +115,8 @@ public:
 	virtual void ConsolePrint(const char *fmt, ...) = 0;
 	virtual void ConsolePrintVa(const char *fmt, va_list ap) = 0;
 
+	virtual void FormatSourceBinaryName(const char *basename, char *buffer, size_t maxlength) = 0;
+
 	// Game engine helper functions.
 	virtual bool IsClientConVarQueryingSupported() = 0;
 	virtual int QueryClientConVar(int client, const char *cvar) = 0;

bridge/include/LogicProvider.h

@@ -73,6 +73,9 @@ struct sm_logic_t
 	void            (*FreeCellArray)(ICellArray *arr);
 	void *			(*FromPseudoAddress)(uint32_t pseudoAddr);
 	uint32_t		(*ToPseudoAddress)(void *addr);
+	void			(*SetEntityLumpWritable)(bool writable);
+	bool			(*ParseEntityLumpString)(const char *entityString, int &status, size_t &position);
+	const char *	(*GetEntityLumpString)();
 	IScriptManager	*scripts;
 	IShareSys		*sharesys;
 	IExtensionSys	*extsys;

configs/core.cfg

@@ -145,5 +145,15 @@
 	 * Disable this option at your own risk.
 	 */
 	"FollowCSGOServerGuidelines"	"yes"
-}
 
+	/**
+	 * Controls whether the SourcePawn runtime will generate additional metadata about
+	 * JIT-compiled functions for performance profiling or debugging purposes.
+	 *
+	 * "none"    - Don't generate any additional JIT metadata
+	 * "default" - Generate basic perf metadata (on Linux) and delete it automatically on quit
+	 * "perf"    - Generate basic perf metadata (Linux only - function names)
+	 * "jitdump" - Generate extended perf metadata (Linux only - function names, bytecode, and source information)
+	 */
+	"JITMetadata"	"default"
+}

configs/sql-init-scripts/pgsql/clientprefs-pgsql.sql

@@ -0,0 +1,41 @@
+CREATE TABLE IF NOT EXISTS sm_cookies
+(
+	id serial,
+	name varchar(30) NOT NULL UNIQUE,
+	description varchar(255),
+	access INTEGER,
+	PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS sm_cookie_cache
+(
+	player varchar(65) NOT NULL,
+	cookie_id int NOT NULL,
+	value varchar(100),
+	timestamp int NOT NULL,
+	PRIMARY KEY (player, cookie_id)
+);
+
+CREATE LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION add_or_update_cookie(in_player VARCHAR(65), in_cookie INT, in_value VARCHAR(100), in_time INT) RETURNS VOID AS
+$$
+BEGIN
+  LOOP
+    -- first try to update the it.
+    UPDATE sm_cookie_cache SET value = in_value, timestamp = in_time WHERE player = in_player AND cookie_id = in_cookie;
+    IF found THEN
+      RETURN;
+    END IF;
+    -- not there, so try to insert.
+    -- if someone else inserts the same key concurrently, we could get a unique-key failure.
+    BEGIN
+      INSERT INTO sm_cookie_cache (player, cookie_id, value, timestamp) VALUES (in_player, in_cookie, in_value, in_time);
+      RETURN;
+    EXCEPTION WHEN unique_violation THEN
+      -- do nothing...  loop again, and we'll update.
+    END;
+  END LOOP;
+END;
+$$
+LANGUAGE plpgsql;

configs/sql-init-scripts/pgsql/create_admins.sql

@@ -0,0 +1,65 @@
+CREATE TABLE sm_admins (
+  id serial,
+  authtype varchar(6) NOT NULL,
+  CHECK (authtype in ('steam', 'name', 'ip')),
+  identity varchar(65) NOT NULL,
+  password varchar(65),
+  flags varchar(30) NOT NULL,
+  name varchar(65) NOT NULL,
+  immunity int NOT NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE sm_groups (
+  id serial,
+  flags varchar(30) NOT NULL,
+  name varchar(120) NOT NULL,
+  immunity_level int NOT NULL,
+  PRIMARY KEY (id)
+);
+
+CREATE TABLE sm_group_immunity (
+  group_id int NOT NULL,
+  other_id int NOT NULL,
+  FOREIGN KEY (group_id) REFERENCES sm_groups(id) ON DELETE CASCADE,
+  FOREIGN KEY (other_id) REFERENCES sm_groups(id) ON DELETE CASCADE,
+  PRIMARY KEY (group_id, other_id)
+);
+
+CREATE TABLE sm_group_overrides (
+  group_id int NOT NULL,
+  FOREIGN KEY (group_id) REFERENCES sm_groups(id) ON DELETE CASCADE,
+  type varchar(10) NOT NULL,
+  CHECK (type in ('command', 'group')),
+  name varchar(32) NOT NULL,
+  access varchar(5) NOT NULL,
+  CHECK (access in ('allow', 'deny')),
+  PRIMARY KEY (group_id, type, name)
+);
+
+CREATE TABLE sm_overrides (
+  type varchar(10) NOT NULL,
+  CHECK (type in ('command', 'group')),
+  name varchar(32) NOT NULL,
+  flags varchar(30) NOT NULL,
+  PRIMARY KEY (type,name)
+);
+
+CREATE TABLE sm_admins_groups (
+  admin_id int NOT NULL,
+  group_id int NOT NULL,
+  FOREIGN KEY (admin_id) REFERENCES sm_admins(id) ON DELETE CASCADE,
+  FOREIGN KEY (group_id) REFERENCES sm_groups(id) ON DELETE CASCADE,
+  inherit_order int NOT NULL,
+  PRIMARY KEY (admin_id, group_id)
+);
+
+-- side note, this is pgsql module, sm_config will not exist if the above stuff exists... and it's being left to the admin
+-- to figure out if it exists.
+CREATE TABLE sm_config (
+  cfg_key varchar(32) NOT NULL,
+  cfg_value varchar(255) NOT NULL,
+  PRIMARY KEY (cfg_key)
+);
+
+INSERT INTO sm_config (cfg_key, cfg_value) VALUES ('admin_version', '1.0.0.1409');

configure.py

@@ -1,42 +1,49 @@
 # vim: set ts=2 sw=2 tw=99 noet:
 import sys
 try:
-	from ambuild2 import run, util
+  from ambuild2 import run, util
 except:
-	try:
-		import ambuild
-		sys.stderr.write('It looks like you have AMBuild 1 installed, but this project uses AMBuild 2.\n')
-		sys.stderr.write('Upgrade to the latest version of AMBuild to continue.\n')
-	except:
-		sys.stderr.write('AMBuild must be installed to build this project.\n')
-		sys.stderr.write('http://www.alliedmods.net/ambuild\n')
-	sys.exit(1)
+  try:
+    import ambuild
+    sys.stderr.write('It looks like you have AMBuild 1 installed, but this project uses AMBuild 2.\n')
+    sys.stderr.write('Upgrade to the latest version of AMBuild to continue.\n')
+  except:
+    sys.stderr.write('AMBuild must be installed to build this project.\n')
+    sys.stderr.write('http://www.alliedmods.net/ambuild\n')
+  sys.exit(1)
 
-def make_objdir_name(p):
-    return 'obj-' + util.Platform() + '-' + p.target_arch
+# Hack to show a decent upgrade message, which wasn't done until 2.2.
+ambuild_version = getattr(run, 'CURRENT_API', '2.1')
+if ambuild_version.startswith('2.1'):
+  sys.stderr.write("AMBuild 2.2 or higher is required; please update\n")
+  sys.exit(1)
 
-parser = run.BuildParser(sourcePath=sys.path[0], api='2.1')
-parser.default_arch = 'x86'
-parser.default_build_folder = make_objdir_name
-parser.options.add_option('--hl2sdk-root', type=str, dest='hl2sdk_root', default=None,
-		                   help='Root search folder for HL2SDKs')
-parser.options.add_option('--mysql-path', type=str, dest='mysql_path', default=None,
-		                   help='Path to MySQL 5')
-parser.options.add_option('--mysql64-path', type=str, dest='mysql64_path', default=None,
-		                   help='Path to 64-bit MySQL 5')
-parser.options.add_option('--mms-path', type=str, dest='mms_path', default=None,
+parser = run.BuildParser(sourcePath=sys.path[0], api='2.2')
+parser.options.add_argument('--hl2sdk-root', type=str, dest='hl2sdk_root', default=None,
+                       help='Root search folder for HL2SDKs')
+parser.options.add_argument('--mysql-path', type=str, dest='mysql_path', default=None,
+                       help='Path to MySQL 5')
+parser.options.add_argument('--mysql64-path', type=str, dest='mysql64_path', default=None,
+                       help='Path to 64-bit MySQL 5')
+parser.options.add_argument('--mms-path', type=str, dest='mms_path', default=None,
                        help='Path to Metamod:Source')
-parser.options.add_option('--enable-debug', action='store_const', const='1', dest='debug',
+parser.options.add_argument('--enable-debug', action='store_const', const='1', dest='debug',
                        help='Enable debugging symbols')
-parser.options.add_option('--enable-optimize', action='store_const', const='1', dest='opt',
+parser.options.add_argument('--enable-optimize', action='store_const', const='1', dest='opt',
                        help='Enable optimization')
-parser.options.add_option('--no-mysql', action='store_false', default=True, dest='hasMySql',
+parser.options.add_argument('--no-mysql', action='store_false', default=True, dest='hasMySql',
                        help='Disable building MySQL extension')
-parser.options.add_option('-s', '--sdks', default='all', dest='sdks',
-                       help='Build against specified SDKs; valid args are "all", "present", or '
-                            'comma-delimited list of engine names (default: %default)')
-parser.options.add_option('--breakpad-dump', action='store_true', dest='breakpad_dump',
-											 default=False, help='Dump and upload breakpad symbols')
-parser.options.add_option('--disable-auto-versioning', action='store_true', dest='disable_auto_versioning',
+parser.options.add_argument('-s', '--sdks', default='present', dest='sdks',
+                       help='Build against specified SDKs; valid args are "none", "all", "present",'
+                            ' or comma-delimited list of engine names')
+parser.options.add_argument('--breakpad-dump', action='store_true', dest='breakpad_dump',
+                       default=False, help='Dump and upload breakpad symbols')
+parser.options.add_argument('--disable-auto-versioning', action='store_true', dest='disable_auto_versioning',
                        default=False, help='Disable the auto versioning script')
+parser.options.add_argument('--targets', type=str, dest='targets', default=None,
+                          help="Override the target architecture (use commas to separate multiple targets).")
+parser.options.add_argument('--scripting-only', action='store_true', dest='scripting_only', default=False,
+                          help="Only build and package the files required for scripting in SourcePawn.")
+parser.options.add_argument('--enable-asan', action='store_true', dest='enable_asan',
+                            default=False, help='Enable ASAN (clang only)')
 parser.Configure()

core/AMBuilder

@@ -1,7 +1,8 @@
 # vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:
 import os
 
-project = SM.HL2Project(builder, 'sourcemod')
+project = builder.LibraryProject('sourcemod')
+
 project.sources += [
   'MenuStyle_Valve.cpp',
   'logic_bridge.cpp',
@@ -37,22 +38,22 @@ project.sources += [
   'MenuStyle_Radio.cpp',
   'sm_autonatives.cpp',
   'ConsoleDetours.cpp',
-  'vprof_tool.cpp',
   'smn_commandline.cpp',
   'GameHooks.cpp',
 ]
 
 for sdk_name in SM.sdks:
   sdk = SM.sdks[sdk_name]
-  for arch in SM.archs:
-    if not arch in sdk.platformSpec[builder.target.platform]:
+  for cxx in builder.targets:
+    if not cxx.target.arch in sdk.platformSpec[cxx.target.platform]:
       continue
 
     binary_name = 'sourcemod.' + sdk.ext
 
-    binary = SM.HL2Config(project, binary_name, sdk, arch)
-    compiler = binary.compiler
+    binary = SM.HL2Config(project, builder, cxx, binary_name, sdk)
+    SM.ConfigureForExtension(builder, binary.compiler)
 
+    compiler = binary.compiler
     compiler.cxxincludes += [
       builder.sourcePath
     ]
@@ -63,51 +64,72 @@ for sdk_name in SM.sdks:
         os.path.join(sdk.path, 'public', 'engine', 'protobuf'),
         os.path.join(sdk.path, 'public', 'game', 'shared', 'csgo', 'protobuf')
       ]
+    elif sdk.name == 'blade':
+      compiler.cxxincludes += [
+        os.path.join(sdk.path, 'common', 'protobuf-2.5.0', 'src'),
+        os.path.join(sdk.path, 'public', 'engine', 'protobuf'),
+        os.path.join(sdk.path, 'public', 'game', 'shared', 'berimbau', 'protobuf')
+      ]
 
     if compiler.like('msvc'):
       compiler.defines += ['_ALLOW_KEYWORD_MACROS']
-    if builder.target.platform == 'linux':
+    if cxx.target.platform == 'linux':
       compiler.postlink += ['-lpthread', '-lrt']
 
-    if sdk.name == 'csgo':
-      if builder.target.platform == 'linux':
-        if arch == 'x86':
+    if sdk.name in ['csgo', 'blade']:
+      if compiler.target.platform == 'linux':
+        if compiler.target.arch == 'x86':
           lib_path = os.path.join(sdk.path, 'lib', 'linux32', 'release', 'libprotobuf.a')
-        elif arch == 'x64':
+        elif compiler.target.arch == 'x86_64':
           lib_path = os.path.join(sdk.path, 'lib', 'linux64', 'release', 'libprotobuf.a')
         compiler.linkflags += ['-Wl,--exclude-libs=libprotobuf.a']
-      elif builder.target.platform == 'mac':
-        if arch == 'x86':
+      elif compiler.target.platform == 'mac':
+        if compiler.target.arch == 'x86':
           lib_path = os.path.join(sdk.path, 'lib', 'osx32', 'release', 'libprotobuf.a')
-        elif arch == 'x64':
+        elif compiler.target.arch == 'x86_64':
           lib_path = os.path.join(sdk.path, 'lib', 'osx64', 'release', 'libprotobuf.a')
-      elif builder.target.platform == 'windows':
+      elif compiler.target.platform == 'windows':
         msvc_ver = compiler.version
         vs_year = ''
-        if msvc_ver == 1800:
-          vs_year = '2013'
-        elif 1900 <= msvc_ver < 2000:
+        platform = ''
+        if compiler.target.arch == 'x86':
+          platform = 'win32'
+        elif compiler.target.arch == 'x86_64':
+          platform = 'win64'
+        
+        if 1900 <= msvc_ver < 2000:
           vs_year = '2015'
         else:
           raise Exception('Cannot find libprotobuf for MSVC version "' + str(compiler.version) + '"')
 
         if 'DEBUG' in compiler.defines:
-          lib_path = os.path.join(sdk.path, 'lib', 'win32', 'debug', 'vs' + vs_year, 'libprotobuf.lib')
+          lib_path = os.path.join(sdk.path, 'lib', platform, 'debug', 'vs' + vs_year, 'libprotobuf.lib')
         else:
-          lib_path = os.path.join(sdk.path, 'lib', 'win32', 'release', 'vs' + vs_year, 'libprotobuf.lib')
-      compiler.linkflags.insert(0, binary.Dep(lib_path))
+          lib_path = os.path.join(sdk.path, 'lib', platform, 'release', 'vs' + vs_year, 'libprotobuf.lib')
+      compiler.linkflags.insert(0, lib_path)
   
-    if sdk.name == 'csgo':
+    if sdk.name in ['csgo', 'blade']:
       binary.sources += ['smn_protobuf.cpp']
     else:
       binary.sources += ['smn_bitbuffer.cpp']
 
+    if sdk.name != 'blade':
+      binary.sources += [
+        'vprof_tool.cpp',
+      ]
+
     if sdk.name == 'csgo':
       binary.sources += [
         os.path.join(sdk.path, 'public', 'engine', 'protobuf', 'netmessages.pb.cc'),
         os.path.join(sdk.path, 'public', 'game', 'shared', 'csgo', 'protobuf', 'cstrike15_usermessages.pb.cc'),
         os.path.join(sdk.path, 'public', 'game', 'shared', 'csgo', 'protobuf', 'cstrike15_usermessage_helpers.cpp'),
       ]
+    elif sdk.name == 'blade':
+      binary.sources += [
+        os.path.join(sdk.path, 'public', 'engine', 'protobuf', 'netmessages.pb.cc'),
+        os.path.join(sdk.path, 'public', 'game', 'shared', 'berimbau', 'protobuf', 'berimbau_usermessages.pb.cc'),
+        os.path.join(sdk.path, 'public', 'game', 'shared', 'berimbau', 'protobuf', 'berimbau_usermessage_helpers.cpp'),
+      ]
 
 SM.binaries += builder.Add(project)
 

core/ChatTriggers.cpp

@@ -29,6 +29,8 @@
  * Version: $Id$
  */
 
+#include <memory>
+
 #include <ITextParsers.h>
 #include "ChatTriggers.h"
 #include "sm_stringutil.h"
@@ -64,7 +66,7 @@ ChatTriggers::~ChatTriggers()
 
 void ChatTriggers::SetChatTrigger(ChatTriggerType type, const char *value)
 {
-	ke::AutoPtr<char[]> filtered(new char[strlen(value) + 1]);
+	std::unique_ptr<char[]> filtered(new char[strlen(value) + 1]);
 
 	const char *src = value;
 	char *dest = filtered.get();
@@ -135,26 +137,26 @@ void ChatTriggers::OnSourceModGameInitialized()
 	};
 
 	if (ConCommand *say = FindCommand("say")) {
-		hooks_.append(sCoreProviderImpl.AddCommandHook(say, pre_hook));
-		hooks_.append(sCoreProviderImpl.AddPostCommandHook(say, post_hook));
+		hooks_.push_back(sCoreProviderImpl.AddCommandHook(say, pre_hook));
+		hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say, post_hook));
 	}
 	if (ConCommand *say_team = FindCommand("say_team")) {
-		hooks_.append(sCoreProviderImpl.AddCommandHook(say_team, pre_hook));
-		hooks_.append(sCoreProviderImpl.AddPostCommandHook(say_team, post_hook));
+		hooks_.push_back(sCoreProviderImpl.AddCommandHook(say_team, pre_hook));
+		hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say_team, post_hook));
 	}
 
 #if SOURCE_ENGINE == SE_EPISODEONE
 	m_bIsINS = (strcmp(g_SourceMod.GetGameFolderName(), "insurgency") == 0);
 	if (m_bIsINS) {
 		if (ConCommand *say2 = FindCommand("say2")) {
-			hooks_.append(sCoreProviderImpl.AddCommandHook(say2, pre_hook));
-			hooks_.append(sCoreProviderImpl.AddPostCommandHook(say2, post_hook));
+			hooks_.push_back(sCoreProviderImpl.AddCommandHook(say2, pre_hook));
+			hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say2, post_hook));
 		}
 	}
 #elif SOURCE_ENGINE == SE_NUCLEARDAWN
 	if (ConCommand *say_squad = FindCommand("say_squad")) {
-		hooks_.append(sCoreProviderImpl.AddCommandHook(say_squad, pre_hook));
-		hooks_.append(sCoreProviderImpl.AddPostCommandHook(say_squad, post_hook));
+		hooks_.push_back(sCoreProviderImpl.AddCommandHook(say_squad, pre_hook));
+		hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say_squad, post_hook));
 	}
 #endif
 }
@@ -275,10 +277,10 @@ bool ChatTriggers::OnSayCommand_Pre(int client, const ICommandArgs *command)
 	bool is_silent = false;
 
 	// Prefer the silent trigger in case of clashes.
-	if (strchr(m_PrivTrigger.chars(), m_ArgSBackup[0])) {
+	if (strchr(m_PrivTrigger.c_str(), m_ArgSBackup[0])) {
 		is_trigger = true;
 		is_silent = true;
-	} else if (strchr(m_PubTrigger.chars(), m_ArgSBackup[0])) {
+	} else if (strchr(m_PubTrigger.c_str(), m_ArgSBackup[0])) {
 		is_trigger = true;
 	}
 
@@ -361,7 +363,7 @@ bool ChatTriggers::PreProcessTrigger(edict_t *pEdict, const char *args)
 	if (!g_ConCmds.LookForSourceModCommand(cmd_buf))
 	{
 		/* Check if we had an "sm_" prefix */
-		if (strncmp(cmd_buf, "sm_", 3) == 0)
+		if (strncasecmp(cmd_buf, "sm_", 3) == 0)
 		{
 			return false;
 		}
@@ -385,15 +387,7 @@ bool ChatTriggers::PreProcessTrigger(edict_t *pEdict, const char *args)
 	/* See if we need to do extra string manipulation */
 	if (prepended)
 	{
-		size_t len;
-
-		/* Check if we need to prepend sm_ */
-		if (prepended)
-		{
-			len = ke::SafeSprintf(m_ToExecute, sizeof(m_ToExecute), "sm_%s", args);
-		} else {
-			len = ke::SafeStrcpy(m_ToExecute, sizeof(m_ToExecute), args);
-		}
+		ke::SafeSprintf(m_ToExecute, sizeof(m_ToExecute), "sm_%s", args);
 	} else {
 		ke::SafeStrcpy(m_ToExecute, sizeof(m_ToExecute), args);
 	}

core/ChatTriggers.h

@@ -73,9 +73,9 @@ private:
 	bool ClientIsFlooding(int client);
 	cell_t CallOnClientSayCommand(int client);
 private:
-	ke::Vector<ke::RefPtr<CommandHook>> hooks_;
-	ke::AString m_PubTrigger;
-	ke::AString m_PrivTrigger;
+	std::vector<ke::RefPtr<CommandHook>> hooks_;
+	std::string m_PubTrigger;
+	std::string m_PrivTrigger;
 	bool m_bWillProcessInPost;
 	bool m_bIsChatTrigger;
 	bool m_bWasFloodedMessage;

core/ConCmdManager.cpp

@@ -30,21 +30,22 @@
  */
 
 #include "ConCmdManager.h"
-#include "sm_stringutil.h"
-#include "PlayerManager.h"
-#include "HalfLife2.h"
-#include "ChatTriggers.h"
-#include "logic_bridge.h"
-#include "sourcemod.h"
-#include "provider.h"
-#include "command_args.h"
+
 #include <bridge/include/IScriptManager.h>
+#include "ChatTriggers.h"
+#include "HalfLife2.h"
+#include "PlayerManager.h"
+#include "command_args.h"
+#include "logic_bridge.h"
+#include "provider.h"
+#include "sm_stringutil.h"
+#include "sourcemod.h"
 
 using namespace ke;
 
 ConCmdManager g_ConCmds;
 
-typedef ke::LinkedList<CmdHook *> PluginHookList;
+typedef std::list<CmdHook *> PluginHookList;
 void RegisterInPlugin(CmdHook *hook);
 
 ConCmdManager::ConCmdManager()
@@ -120,8 +121,13 @@ void ConCmdManager::OnPluginDestroyed(IPlugin *plugin)
 		if (hook->admin)
 			hook->admin->group->hooks.remove(hook);
 
-		if (hook->info->hooks.empty())
+		if (hook->info->hooks.empty()) {
 			RemoveConCmd(hook->info, hook->info->pCmd->GetName(), true);
+		}
+		else { // update plugin reference to next hook in line
+			auto next = *hook->info->hooks.begin();
+			next->info->pPlugin = next->plugin;
+		}
 
 		iter = pList->erase(iter);
 		delete hook;
@@ -147,30 +153,13 @@ ConCmdInfo *ConCmdManager::FindInTrie(const char *name)
 	return pInfo;
 }
 
-ConCmdList::iterator ConCmdManager::FindInList(const char *cmd)
-{
-	List<ConCmdInfo *>::iterator iter = m_CmdList.begin();
-
-	while (iter != m_CmdList.end())
-	{
-		if (strcasecmp((*iter)->pCmd->GetName(), cmd) == 0)
-			break;
-		iter++;
-	}
-
-	return iter;
-}
-
 ResultType ConCmdManager::DispatchClientCommand(int client, const char *cmd, int args, ResultType type)
 {
-	ConCmdInfo *pInfo;
+	ConCmdInfo *pInfo = FindInTrie(cmd);
 
-	if ((pInfo = FindInTrie(cmd)) == NULL)
+	if (pInfo == NULL)
 	{
-		ConCmdList::iterator item = FindInList(cmd);
-		if (item == m_CmdList.end())
-			return type;
-		pInfo = *item;
+		return type;
 	}
 
 	cell_t result = type;
@@ -181,7 +170,7 @@ ResultType ConCmdManager::DispatchClientCommand(int client, const char *cmd, int
 		if (hook->type == CmdHook::Server || !hook->pf->IsRunnable())
 			continue;
 
-		if (hook->admin && !CheckAccess(client, cmd, hook->admin))
+		if (hook->admin && !CheckAccess(client, cmd, hook->admin.get()))
 		{
 			if (result < Pl_Handled)
 				result = Pl_Handled;
@@ -225,17 +214,7 @@ bool ConCmdManager::InternalDispatch(int client, const ICommandArgs *args)
 	ConCmdInfo *pInfo = FindInTrie(cmd);
 	if (pInfo == NULL)
 	{
-        /* Unfortunately, we now have to do a slow lookup because Valve made client commands 
-         * case-insensitive.  We can't even use our sortedness.
-         */
-        if (client == 0 && !engine->IsDedicatedServer())
-            return false;
-
-		ConCmdList::iterator item = FindInList(cmd);
-		if (item == m_CmdList.end())
-			return false;
-
-		pInfo = *item;
+		return false;
 	}
 
 	/* This is a hack to prevent say triggers from firing on messages that were 
@@ -271,7 +250,7 @@ bool ConCmdManager::InternalDispatch(int client, const ICommandArgs *args)
 		} else {
 			// Check admin rights if needed. realClient isn't needed since we
 			// should bypass admin checks if client == 0 anyway.
-			if (client && hook->admin && !CheckAccess(client, cmd, hook->admin))
+			if (client && hook->admin && !CheckAccess(client, cmd, hook->admin.get()))
 			{
 				if (result < Pl_Handled)
 					result = Pl_Handled;
@@ -359,8 +338,8 @@ bool ConCmdManager::AddAdminCommand(IPluginFunction *pFunction,
 	}
 	RefPtr<CommandGroup> cmdgroup = i->value;
 
-	CmdHook *pHook = new CmdHook(CmdHook::Client, pInfo, pFunction, description);
-	pHook->admin = new AdminCmdInfo(cmdgroup, adminflags);
+	CmdHook *pHook = new CmdHook(CmdHook::Client, pInfo, pFunction, description, pPlugin);
+	pHook->admin = std::make_unique<AdminCmdInfo>(cmdgroup, adminflags);
 
 	/* First get the command group override, if any */
 	bool override = adminsys->GetCommandOverride(group, 
@@ -380,7 +359,7 @@ bool ConCmdManager::AddAdminCommand(IPluginFunction *pFunction,
 		pHook->admin->eflags = pHook->admin->flags;
 	pInfo->eflags = pHook->admin->eflags;
 
-	cmdgroup->hooks.append(pHook);
+	cmdgroup->hooks.push_back(pHook);
 	pInfo->hooks.append(pHook);
 	RegisterInPlugin(pHook);
 	return true;
@@ -398,7 +377,7 @@ bool ConCmdManager::AddServerCommand(IPluginFunction *pFunction,
 	if (!pInfo)
 		return false;
 
-	CmdHook *pHook = new CmdHook(CmdHook::Server, pInfo, pFunction, description);
+	CmdHook *pHook = new CmdHook(CmdHook::Server, pInfo, pFunction, description, pPlugin);
 
 	pInfo->hooks.append(pHook);
 	RegisterInPlugin(pHook);
@@ -425,13 +404,13 @@ void RegisterInPlugin(CmdHook *hook)
 		const char *cmd = (*iter)->info->pCmd->GetName();
 		if (strcmp(orig, cmd) < 0)
 		{
-			pList->insertBefore(iter, hook);
+			pList->emplace(iter, hook);
 			return;
 		}
 		iter++;
 	}
 
-	pList->append(hook);
+	pList->emplace_back(hook);
 }
 
 void ConCmdManager::AddToCmdList(ConCmdInfo *info)
@@ -495,7 +474,7 @@ void ConCmdManager::UpdateAdminCmdFlags(const char *cmd, OverrideType type, Flag
 		for (PluginHookList::iterator iter = group->hooks.begin(); iter != group->hooks.end(); iter++)
 		{
 			CmdHook *hook = *iter;
-			if (remove)
+			if (!remove)
 				hook->admin->eflags = bits;
 			else
 				hook->admin->eflags = hook->admin->flags;
@@ -562,10 +541,6 @@ ConCmdInfo *ConCmdManager::AddOrFindCommand(const char *name, const char *descri
 	ConCmdInfo *pInfo;
 	if (!m_Cmds.retrieve(name, &pInfo))
 	{
-		ConCmdList::iterator item = FindInList(name);
-		if (item != m_CmdList.end())
-			return *item;
-
 		pInfo = new ConCmdInfo();
 		/* Find the commandopan */
 		ConCommand *pCmd = FindCommand(name);
@@ -648,7 +623,7 @@ void ConCmdManager::OnRootConsoleCommand(const char *cmdname, const ICommandArgs
 
 			name = hook->info->pCmd->GetName();
 			if (hook->helptext.length())
-				help = hook->helptext.chars();
+				help = hook->helptext.c_str();
 			else
 				help = hook->info->pCmd->GetHelpText();
 			UTIL_ConsolePrint("  %-17.16s %-12.11s %s", name, type, help);		

core/ConCmdManager.h

@@ -32,6 +32,14 @@
 #ifndef _INCLUDE_SOURCEMOD_CONCMDMANAGER_H_
 #define _INCLUDE_SOURCEMOD_CONCMDMANAGER_H_
 
+#include <list>
+#include <memory>
+
+#include <am-inlinelist.h>
+#include <am-refcounting.h>
+#include <am-utility.h>
+#include <sm_stringhashmap.h>
+
 #include "sm_globals.h"
 #include "sourcemm_api.h"
 #include <IForwardSys.h>
@@ -41,12 +49,7 @@
 #include <IAdminSystem.h>
 #include "concmd_cleaner.h"
 #include "GameHooks.h"
-#include <am-autoptr.h>
-#include <sm_stringhashmap.h>
-#include <am-utility.h>
-#include <am-inlinelist.h>
-#include <am-linkedlist.h>
-#include <am-refcounting.h>
+#include <sm_namehashset.h>
 
 using namespace SourceHook;
 
@@ -55,7 +58,7 @@ struct ConCmdInfo;
 
 struct CommandGroup : public ke::Refcounted<CommandGroup>
 {
-	ke::LinkedList<CmdHook *> hooks;
+	std::list<CmdHook *> hooks;
 };
 
 struct AdminCmdInfo
@@ -78,10 +81,11 @@ struct CmdHook : public ke::InlineListNode<CmdHook>
 		Client
 	};
 
-	CmdHook(Type type, ConCmdInfo *cmd, IPluginFunction *fun, const char *description)
+	CmdHook(Type type, ConCmdInfo *cmd, IPluginFunction *fun, const char *description, IPlugin *plugin)
 		: type(type),
 		  info(cmd),
 		  pf(fun),
+		  plugin(plugin),
 		  helptext(description)
 	{
 	}
@@ -89,8 +93,9 @@ struct CmdHook : public ke::InlineListNode<CmdHook>
 	Type type;
 	ConCmdInfo *info;
 	IPluginFunction *pf;				/* function hook */
-	ke::AString helptext;				/* help text */
-	ke::AutoPtr<AdminCmdInfo> admin;	/* admin requirements, if any */
+	IPlugin *plugin;					/* owning plugin */
+	std::string helptext;				/* help text */
+	std::unique_ptr<AdminCmdInfo> admin;	/* admin requirements, if any */
 };
 
 typedef ke::InlineList<CmdHook> CmdHookList;
@@ -104,12 +109,32 @@ struct ConCmdInfo
 		pCmd = nullptr;
 		eflags = 0;
 	}
+
 	bool sourceMod;					/**< Determines whether or not concmd was created by a SourceMod plugin */
 	ConCommand *pCmd;				/**< Pointer to the command itself */
 	CmdHookList hooks;				/**< Hook list */
 	FlagBits eflags;				/**< Effective admin flags */
 	ke::RefPtr<CommandHook> sh_hook;   /**< SourceHook hook, if any. */
 	IPlugin *pPlugin; 				/**< Owning plugin handle. */
+
+	struct ConCmdPolicy
+	{
+		static inline bool matches(const char *name, ConCmdInfo *info)
+		{
+			const char *conCmdChars = info->pCmd->GetName();
+
+			std::string concmdName = ke::Lowercase(conCmdChars);
+			std::string input = ke::Lowercase(name);
+
+			return concmdName == input;
+		}
+
+		static inline uint32_t hash(const detail::CharsAndLength &key)
+		{
+			std::string lower = ke::Lowercase(key.c_str());
+			return detail::CharsAndLength(lower.c_str()).hash();
+		}
+	};
 };
 
 typedef List<ConCmdInfo *> ConCmdList;
@@ -153,11 +178,6 @@ private:
 	void AddToCmdList(ConCmdInfo *info);
 	void RemoveConCmd(ConCmdInfo *info, const char *cmd, bool untrack);
 	bool CheckAccess(int client, const char *cmd, AdminCmdInfo *pAdmin);
-
-	// Case insensitive
-	ConCmdList::iterator FindInList(const char *name);
-
-	// Case sensitive
 	ConCmdInfo *FindInTrie(const char *name);
 public:
 	inline const List<ConCmdInfo *> & GetCommandList()
@@ -167,7 +187,7 @@ public:
 private:
 	typedef StringHashMap<ke::RefPtr<CommandGroup> > GroupMap;
 
-	StringHashMap<ConCmdInfo *> m_Cmds; /* command lookup */
+	NameHashSet<ConCmdInfo *, ConCmdInfo::ConCmdPolicy> m_Cmds; /* command lookup */
 	GroupMap m_CmdGrps;				/* command group map */
 	ConCmdList m_CmdList;			/* command list */
 };

core/ConVarManager.cpp

@@ -41,7 +41,11 @@ ConVarManager g_ConVarManager;
 
 const ParamType CONVARCHANGE_PARAMS[] = {Param_Cell, Param_String, Param_String};
 typedef List<const ConVar *> ConVarList;
-NameHashSet<ConVarInfo *> convar_cache;
+NameHashSet<ConVarInfo *, ConVarInfo::ConVarPolicy> convar_cache;
+
+enum {
+	eQueryCvarValueStatus_Cancelled = -1,
+};
 
 class ConVarReentrancyGuard
 {
@@ -206,18 +210,27 @@ void ConVarManager::OnUnlinkConCommandBase(ConCommandBase *pBase, const char *na
 void ConVarManager::OnPluginUnloaded(IPlugin *plugin)
 {
 	ConVarList *pConVarList;
-	List<ConVarQuery>::iterator iter;
-
 	/* If plugin has a convar list, free its memory */
 	if (plugin->GetProperty("ConVarList", (void **)&pConVarList, true))
 	{
 		delete pConVarList;
 	}
 
+	/* Clear any references to this plugin as the convar creator */
+	for (List<ConVarInfo *>::iterator iter = m_ConVars.begin(); iter != m_ConVars.end(); ++iter)
+	{
+		ConVarInfo *pInfo = (*iter);
+
+		if (pInfo->pPlugin == plugin)
+		{
+			pInfo->pPlugin = nullptr;
+		}
+	}
+
 	const IPluginRuntime * pRuntime = plugin->GetRuntime();
 
 	/* Remove convar queries for this plugin that haven't returned results yet */
-	for (iter = m_ConVarQueries.begin(); iter != m_ConVarQueries.end();)
+	for (List<ConVarQuery>::iterator iter = m_ConVarQueries.begin(); iter != m_ConVarQueries.end();)
 	{
 		ConVarQuery &query = (*iter);
 		if (query.pCallback->GetParentRuntime() == pRuntime)
@@ -238,6 +251,19 @@ void ConVarManager::OnClientDisconnected(int client)
 		ConVarQuery &query = (*iter);
 		if (query.client == client)
 		{
+			IPluginFunction *pCallback = query.pCallback;
+			if (pCallback)
+			{
+				cell_t ret;
+
+				pCallback->PushCell(query.cookie);
+				pCallback->PushCell(client);
+				pCallback->PushCell(eQueryCvarValueStatus_Cancelled);
+				pCallback->PushString("");
+				pCallback->PushString("");
+				pCallback->PushCell(query.value);
+				pCallback->Execute(&ret);
+			}
 			iter = m_ConVarQueries.erase(iter);
 			continue;
 		}
@@ -330,6 +356,8 @@ Handle_t ConVarManager::CreateConVar(IPluginContext *pContext, const char *name,
 	ConVarInfo *pInfo = NULL;
 	Handle_t hndl = 0;
 
+	IPlugin *plugin = scripts->FindPluginByContext(pContext->GetContext());
+
 	/* Find out if the convar exists already */
 	pConVar = icvar->FindVar(name);
 
@@ -337,11 +365,16 @@ Handle_t ConVarManager::CreateConVar(IPluginContext *pContext, const char *name,
 	if (pConVar)
 	{
 		/* Add convar to plugin's list */
-		AddConVarToPluginList(pContext, pConVar);
+		AddConVarToPluginList(plugin, pConVar);
 
 		/* First find out if we already have a handle to it */
 		if (convar_cache_lookup(name, &pInfo))
 		{
+			/* If the convar doesn't have an owning plugin, but SM created it, adopt it */
+			if (pInfo->sourceMod && pInfo->pPlugin == nullptr) {
+				pInfo->pPlugin = plugin;
+			}
+
 			return pInfo->handle;
 		}
 		else
@@ -382,6 +415,7 @@ Handle_t ConVarManager::CreateConVar(IPluginContext *pContext, const char *name,
 	pInfo->handle = hndl;
 	pInfo->sourceMod = true;
 	pInfo->pChangeForward = NULL;
+	pInfo->pPlugin = plugin;
 
 	/* Create a handle from the new convar */
 	hndl = handlesys->CreateHandle(m_ConVarType, pInfo, NULL, g_pCoreIdent, NULL);
@@ -398,7 +432,7 @@ Handle_t ConVarManager::CreateConVar(IPluginContext *pContext, const char *name,
 	pInfo->pVar = pConVar;
 
 	/* Add convar to plugin's list */
-	AddConVarToPluginList(pContext, pConVar);
+	AddConVarToPluginList(plugin, pConVar);
 
 	/* Insert struct into caches */
 	m_ConVars.push_back(pInfo);
@@ -552,15 +586,13 @@ QueryCvarCookie_t ConVarManager::QueryClientConVar(edict_t *pPlayer, const char
 	return cookie;
 }
 
-void ConVarManager::AddConVarToPluginList(IPluginContext *pContext, const ConVar *pConVar)
+void ConVarManager::AddConVarToPluginList(IPlugin *plugin, const ConVar *pConVar)
 {
 	ConVarList *pConVarList;
 	ConVarList::iterator iter;
 	bool inserted = false;
 	const char *orig = pConVar->GetName();
 
-	IPlugin *plugin = scripts->FindPluginByContext(pContext->GetContext());
-
 	/* Check plugin for an existing convar list */
 	if (!plugin->GetProperty("ConVarList", (void **)&pConVarList))
 	{
@@ -679,7 +711,7 @@ void ConVarManager::OnClientQueryFinished(QueryCvarCookie_t cookie,
 }
 #endif
 
-HandleError ConVarManager::ReadConVarHandle(Handle_t hndl, ConVar **pVar)
+HandleError ConVarManager::ReadConVarHandle(Handle_t hndl, ConVar **pVar, IPlugin **ppPlugin)
 {
 	ConVarInfo *pInfo;
 	HandleError error;
@@ -694,5 +726,10 @@ HandleError ConVarManager::ReadConVarHandle(Handle_t hndl, ConVar **pVar)
 		*pVar = pInfo->pVar;
 	}
 
+	if (ppPlugin)
+	{
+		*ppPlugin = pInfo->pPlugin;
+	}
+
 	return error;
 }

core/ConVarManager.h

@@ -62,16 +62,27 @@ struct ConVarInfo
 	bool sourceMod;						/**< Determines whether or not convar was created by a SourceMod plugin */
 	IChangeableForward *pChangeForward;	/**< Forward associated with convar */
 	ConVar *pVar;						/**< The actual convar */
+	IPlugin *pPlugin; 					/**< Originally owning plugin */
 	List<IConVarChangeListener *> changeListeners;
 
-	static inline bool matches(const char *name, const ConVarInfo *info)
+	struct ConVarPolicy
 	{
-		return strcmp(name, info->pVar->GetName()) == 0;
-	}
-	static inline uint32_t hash(const detail::CharsAndLength &key)
-	{
-		return key.hash();
-	}
+		static inline bool matches(const char *name, ConVarInfo *info)
+		{
+			const char *conVarChars = info->pVar->GetName();
+
+			std::string convarName = ke::Lowercase(conVarChars);
+			std::string input = ke::Lowercase(name);
+
+			return convarName == input;
+		}
+
+		static inline uint32_t hash(const detail::CharsAndLength &key)
+		{
+			std::string lower = ke::Lowercase(key.c_str());
+			return detail::CharsAndLength(lower.c_str()).hash();
+		}
+	};
 };
 
 /**
@@ -144,7 +155,7 @@ public:
 
 	bool IsQueryingSupported();
 
-	HandleError ReadConVarHandle(Handle_t hndl, ConVar **pVar);
+	HandleError ReadConVarHandle(Handle_t hndl, ConVar **pVar, IPlugin **ppPlugin = nullptr);
 
 	// Called via game hooks.
 	void OnConVarChanged(ConVar *pConVar, const char *oldValue, float flOldValue);
@@ -161,7 +172,7 @@ private:
 	/**
 	 * Adds a convar to a plugin's list.
 	 */
-	static void AddConVarToPluginList(IPluginContext *pContext, const ConVar *pConVar);
+	static void AddConVarToPluginList(IPlugin *plugin, const ConVar *pConVar);
 private:
 	HandleType_t m_ConVarType;
 	List<ConVarInfo *> m_ConVars;

core/ConsoleDetours.cpp

@@ -307,7 +307,7 @@ bool ConsoleDetours::AddListener(IPluginFunction *fun, const char *command)
 	}
 	else
 	{
-		ke::AutoPtr<char[]> str(UTIL_ToLowerCase(command));
+		std::unique_ptr<char[]> str(UTIL_ToLowerCase(command));
 		IChangeableForward *forward;
 		if (!m_Listeners.retrieve(str.get(), &forward))
 		{
@@ -329,7 +329,7 @@ bool ConsoleDetours::RemoveListener(IPluginFunction *fun, const char *command)
 	}
 	else
 	{
-		ke::AutoPtr<char[]> str(UTIL_ToLowerCase(command));
+		std::unique_ptr<char[]> str(UTIL_ToLowerCase(command));
 		IChangeableForward *forward;
 		if (!m_Listeners.retrieve(str.get(), &forward))
 			return false;

core/CoreConfig.cpp

@@ -290,18 +290,18 @@ ConfigResult CoreConfig::SetConfigOption(const char *option, const char *value,
 		pBase = pBase->m_pGlobalClassNext;
 	}
 
-	ke::AString vstr(value);
-	m_KeyValues.replace(option, ke::Move(vstr));
+	std::string vstr(value);
+	m_KeyValues.replace(option, std::move(vstr));
 
 	return result;
 }
 
 const char *CoreConfig::GetCoreConfigValue(const char *key)
 {
-	StringHashMap<ke::AString>::Result r = m_KeyValues.find(key);
+	StringHashMap<std::string>::Result r = m_KeyValues.find(key);
 	if (!r.found())
 		return NULL;
-	return r->value.chars();
+	return r->value.c_str();
 }
 
 bool SM_AreConfigsExecuted()

core/CoreConfig.h

@@ -68,7 +68,7 @@ private:
 	 */
 	ConfigResult SetConfigOption(const char *option, const char *value, ConfigSource, char *Error, size_t maxlength);
 private:
-	StringHashMap<ke::AString> m_KeyValues;
+	StringHashMap<std::string> m_KeyValues;
 };
 
 extern bool SM_AreConfigsExecuted();

core/EventManager.cpp

@@ -484,7 +484,7 @@ bool EventManager::OnFireEvent_Post(IGameEvent *pEvent, bool bDontBroadcast)
 				pForward->PushCell(BAD_HANDLE);
 			}
 
-			pForward->PushString(pHook->name.chars());
+			pForward->PushString(pHook->name.c_str());
 			pForward->PushCell(bDontBroadcast);
 			pForward->Execute(NULL);
 
@@ -505,7 +505,7 @@ bool EventManager::OnFireEvent_Post(IGameEvent *pEvent, bool bDontBroadcast)
 		{
 			assert(pHook->pPostHook == NULL);
 			assert(pHook->pPreHook == NULL);
-			m_EventHooks.remove(pHook->name.chars());
+			m_EventHooks.remove(pHook->name.c_str());
 			delete pHook;
 		}
 	}

core/EventManager.h

@@ -71,11 +71,11 @@ struct EventHook
 	IChangeableForward *pPostHook;
 	bool postCopy;
 	unsigned int refCount;
-	ke::AString name;
+	std::string name;
 
 	static inline bool matches(const char *name, const EventHook *hook)
 	{
-		return strcmp(name, hook->name.chars()) == 0;
+		return strcmp(name, hook->name.c_str()) == 0;
 	}
 	static inline uint32_t hash(const detail::CharsAndLength &key)
 	{

core/GameHooks.cpp

@@ -91,7 +91,7 @@ void GameHooks::OnVSPReceived()
 
 void GameHooks::Shutdown()
 {
-	for (size_t i = 0; i < hooks_.length(); i++)
+	for (size_t i = 0; i < hooks_.size(); i++)
 		SH_REMOVE_HOOK_ID(hooks_[i]);
 	hooks_.clear();
 
@@ -115,7 +115,7 @@ void GameHooks::OnQueryCvarValueFinished(QueryCvarCookie_t cookie, edict_t *pPla
                                          const char *cvarName, const char *cvarValue){
 	int client = IndexOfEdict(pPlayer);
 
-# if SOURCE_ENGINE == SE_CSGO
+# if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	if (g_Players.HandleConVarQuery(cookie, client, result, cvarName, cvarValue))
 		return;
 # endif

core/GameHooks.h

@@ -63,7 +63,7 @@ class CommandHook : public ke::Refcounted<CommandHook>
 {
 public:
 	// return false to RETURN_META(MRES_IGNORED), or true to SUPERCEDE.
-	typedef ke::Lambda<bool(int, const ICommandArgs *)> Callback;
+	typedef ke::Function<bool(int, const ICommandArgs *)> Callback;
 
 public:
 	CommandHook(ConCommand *cmd, const Callback &callback, bool post);
@@ -114,11 +114,11 @@ private:
 	void SetCommandClient(int client);
 
 private:
-	class HookList : public ke::Vector<int>
+	class HookList : public std::vector<int>
 	{
 	public:
 		HookList &operator += (int hook_id) {
-			this->append(hook_id);
+			this->push_back(hook_id);
 			return *this;
 		}
 	};

core/HalfLife2.cpp

@@ -45,9 +45,10 @@
 
 #if SOURCE_ENGINE == SE_CSGO
 #include <cstrike15_usermessages.pb.h>
+#elif SOURCE_ENGINE == SE_BLADE
+#include <berimbau_usermessages.pb.h>
 #endif
 
-
 typedef ICommandLine *(*FakeGetCommandLine)();
 
 #define TIER0_NAME			FORMAT_SOURCE_BIN_NAME("tier0")
@@ -59,6 +60,7 @@ ConVar *sv_lan = NULL;
 static void *g_EntList = NULL;
 static void **g_pEntInfoList = NULL;
 static int entInfoOffset = -1;
+static int utlVecOffsetOffset = -1;
 
 static CEntInfo *EntInfoArray()
 {
@@ -143,6 +145,7 @@ void CHalfLife2::OnSourceModAllInitialized_Post()
 	m_CSGOBadList.add("m_nActiveCoinRank");
 	m_CSGOBadList.add("m_nMusicID");
 #endif
+	g_pGameConf->GetOffset("CSendPropExtra_UtlVector::m_Offset", &utlVecOffsetOffset);
 }
 
 ConfigResult CHalfLife2::OnSourceModConfigChanged(const char *key, const char *value,
@@ -180,6 +183,7 @@ void CHalfLife2::InitLogicalEntData()
 	|| SOURCE_ENGINE == SE_CSS     \
 	|| SOURCE_ENGINE == SE_SDK2013 \
 	|| SOURCE_ENGINE == SE_BMS     \
+	|| SOURCE_ENGINE == SE_BLADE   \
 	|| SOURCE_ENGINE == SE_NUCLEARDAWN
 
 	if (g_SMAPI->GetServerFactory(false)("VSERVERTOOLS003", nullptr))
@@ -317,23 +321,41 @@ bool UTIL_FindInSendTable(SendTable *pTable,
 						  sm_sendprop_info_t *info,
 						  unsigned int offset)
 {
-	const char *pname;
 	int props = pTable->GetNumProps();
-	SendProp *prop;
-
-	for (int i=0; i<props; i++)
+	for (int i = 0; i < props; i++)
 	{
-		prop = pTable->GetProp(i);
-		pname = prop->GetName();
+		SendProp *prop = pTable->GetProp(i);
+
+		// Skip InsideArray props (SendPropArray / SendPropArray2),
+		// we'll find them later by their containing array.
+		if (prop->IsInsideArray()) {
+			continue;
+		}
+
+		const char *pname = prop->GetName();
+		SendTable *pInnerTable = prop->GetDataTable();
+
 		if (pname && strcmp(name, pname) == 0)
 		{
+			// get true offset of CUtlVector
+			if (utlVecOffsetOffset != -1 && prop->GetOffset() == 0 && pInnerTable && pInnerTable->GetNumProps())
+			{
+				SendProp *pLengthProxy = pInnerTable->GetProp(0);
+				const char *ipname = pLengthProxy->GetName();
+				if (ipname && strcmp(ipname, "lengthproxy") == 0 && pLengthProxy->GetExtraData())
+				{
+					info->prop = prop;
+					info->actual_offset = offset + *reinterpret_cast<size_t *>(reinterpret_cast<intptr_t>(pLengthProxy->GetExtraData()) + utlVecOffsetOffset);
+					return true;
+				}
+			}
 			info->prop = prop;
 			info->actual_offset = offset + info->prop->GetOffset();
 			return true;
 		}
-		if (prop->GetDataTable())
+		if (pInnerTable)
 		{
-			if (UTIL_FindInSendTable(prop->GetDataTable(), 
+			if (UTIL_FindInSendTable(pInnerTable, 
 				name,
 				info,
 				offset + prop->GetOffset())
@@ -516,7 +538,7 @@ bool CHalfLife2::TextMsg(int client, int dest, const char *msg)
 			char buffer[253];
 			ke::SafeSprintf(buffer, sizeof(buffer), "%s\1\n", msg);
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 			CCSUsrMsg_SayText *pMsg;
 			if ((pMsg = (CCSUsrMsg_SayText *)g_UserMsgs.StartProtobufMessage(m_SayTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)
 			{
@@ -543,7 +565,7 @@ bool CHalfLife2::TextMsg(int client, int dest, const char *msg)
 		}
 	}
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	CCSUsrMsg_TextMsg *pMsg;
 	if ((pMsg = (CCSUsrMsg_TextMsg *)g_UserMsgs.StartProtobufMessage(m_MsgTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)
 	{
@@ -580,7 +602,7 @@ bool CHalfLife2::HintTextMsg(int client, const char *msg)
 {
 	cell_t players[] = {client};
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	CCSUsrMsg_HintText *pMsg;
 	if ((pMsg = (CCSUsrMsg_HintText *)g_UserMsgs.StartProtobufMessage(m_HinTextMsg, players, 1, USERMSG_RELIABLE)) == NULL)
 	{
@@ -610,7 +632,7 @@ bool CHalfLife2::HintTextMsg(int client, const char *msg)
 
 bool CHalfLife2::HintTextMsg(cell_t *players, int count, const char *msg)
 {
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	CCSUsrMsg_HintText *pMsg;
 	if ((pMsg = (CCSUsrMsg_HintText *)g_UserMsgs.StartProtobufMessage(m_HinTextMsg, players, count, USERMSG_RELIABLE)) == NULL)
 	{
@@ -645,7 +667,7 @@ bool CHalfLife2::ShowVGUIMenu(int client, const char *name, KeyValues *data, boo
 	int count = 0;
 	cell_t players[] = {client};
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	CCSUsrMsg_VGUIMenu *pMsg;
 	if ((pMsg = (CCSUsrMsg_VGUIMenu *)g_UserMsgs.StartProtobufMessage(m_VGUIMenu, players, 1, USERMSG_RELIABLE)) == NULL)
 	{
@@ -670,7 +692,7 @@ bool CHalfLife2::ShowVGUIMenu(int client, const char *name, KeyValues *data, boo
 		SubKey = data->GetFirstSubKey();
 	}
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	pMsg->set_name(name);
 	pMsg->set_show(show);
 
@@ -1212,6 +1234,45 @@ bool IsWindowsReservedDeviceName(const char *pMapname)
 }
 #endif 
 
+#if SOURCE_ENGINE >= SE_LEFT4DEAD && defined PLATFORM_WINDOWS && SOURCE_ENGINE != SE_MOCK
+// This frees memory allocated by the game using the game's CRT on Windows,
+// avoiding a crash due to heap corruption (issue #910).
+template< class T, class I >
+class CUtlMemoryGlobalMalloc : public CUtlMemory< T, I >
+{
+	typedef CUtlMemory< T, I > BaseClass;
+
+public:
+	using BaseClass::BaseClass;
+
+	void Purge()
+	{
+		if (!IsExternallyAllocated())
+		{
+			if (m_pMemory)
+			{
+				UTLMEMORY_TRACK_FREE();
+				g_pMemAlloc->Free((void*)m_pMemory);
+				m_pMemory = 0;
+			}
+			m_nAllocationCount = 0;
+		}
+		BaseClass::Purge();
+	}
+};
+
+void CHalfLife2::FreeUtlVectorUtlString(CUtlVector<CUtlString, CUtlMemoryGlobalMalloc<CUtlString>> &vec)
+{
+	CUtlMemoryGlobalMalloc<unsigned char> *pMemory;
+	FOR_EACH_VEC(vec, i)
+	{
+		pMemory = (CUtlMemoryGlobalMalloc<unsigned char> *) &vec[i].m_Storage.m_Memory;
+		pMemory->Purge();
+		vec[i].m_Storage.SetLength(0);
+	}
+}
+#endif
+
 SMFindMapResult CHalfLife2::FindMap(const char *pMapName, char *pFoundMap, size_t nMapNameMax)
 {
 	/* We need to ensure user input does not contain reserved device names on windows */
@@ -1245,8 +1306,13 @@ SMFindMapResult CHalfLife2::FindMap(const char *pMapName, char *pFoundMap, size_
 
 	static size_t helperCmdLen = strlen(pHelperCmd->GetName());
 
+#ifdef PLATFORM_WINDOWS
+	CUtlVector<CUtlString, CUtlMemoryGlobalMalloc<CUtlString>> results;
+	pHelperCmd->AutoCompleteSuggest(pMapName, *(CUtlVector<CUtlString, CUtlMemory<CUtlString>>*)&results);
+#else
 	CUtlVector<CUtlString> results;
 	pHelperCmd->AutoCompleteSuggest(pMapName, results);
+#endif
 	if (results.Count() == 0)
 		return SMFindMapResult::NotFound;
 
@@ -1258,11 +1324,17 @@ SMFindMapResult CHalfLife2::FindMap(const char *pMapName, char *pFoundMap, size_
 	bool bExactMatch = Q_strcmp(pMapName, &results[0][helperCmdLen + 1]) == 0;
 	if (bExactMatch)
 	{
+#ifdef PLATFORM_WINDOWS
+		FreeUtlVectorUtlString(results);
+#endif
 		return SMFindMapResult::Found;
 	}
 	else
 	{
 		ke::SafeStrcpy(pFoundMap, nMapNameMax, &results[0][helperCmdLen + 1]);
+#ifdef PLATFORM_WINDOWS
+		FreeUtlVectorUtlString(results);
+#endif
 		return SMFindMapResult::FuzzyMatch;
 	}
 
@@ -1313,11 +1385,39 @@ bool CHalfLife2::IsMapValid(const char *map)
 	if (!map || !map[0])
 		return false;
 	
-	return FindMap(map) != SMFindMapResult::NotFound;
+	return FindMap(map) == SMFindMapResult::Found;
 }
 
-// TODO: Add ep1 support for this. (No IServerTools available there)
-#if SOURCE_ENGINE >= SE_ORANGEBOX
+#if SOURCE_ENGINE < SE_ORANGEBOX
+class VKeyValuesSS_Helper {};
+static bool VKeyValuesSS(CBaseEntity* pThisPtr, const char *pszKey, const char *pszValue, int offset)
+{
+	void** this_ptr = *reinterpret_cast<void***>(&pThisPtr);
+	void** vtable = *reinterpret_cast<void***>(pThisPtr);
+	void* vfunc = vtable[offset];
+
+	union
+	{
+		bool (VKeyValuesSS_Helper::* mfpnew)(const char *, const char *);
+#ifndef PLATFORM_POSIX
+		void* addr;
+	} u;
+	u.addr = vfunc;
+#else
+		struct
+		{
+			void* addr;
+			intptr_t adjustor;
+		} s;
+} u;
+	u.s.addr = vfunc;
+	u.s.adjustor = 0;
+#endif
+
+	return (bool)(reinterpret_cast<VKeyValuesSS_Helper*>(this_ptr)->*u.mfpnew)(pszKey, pszValue);
+}
+#endif
+
 string_t CHalfLife2::AllocPooledString(const char *pszValue)
 {
 	// This is admittedly a giant hack, but it's a relatively safe method for
@@ -1327,28 +1427,58 @@ string_t CHalfLife2::AllocPooledString(const char *pszValue)
 	// current targetname string_t, set it to our string to insert via SetKeyValue,
 	// read back the new targetname value, restore the old value, and return the new one.
 
+#if SOURCE_ENGINE < SE_ORANGEBOX
+	CBaseEntity* pEntity = nullptr;
+	for (int i = 0; i < gpGlobals->maxEntities; ++i)
+	{
+		pEntity = ReferenceToEntity(i);
+		if (pEntity)
+		{
+			break;
+		}
+	}
+
+	if (!pEntity)
+	{
+		logger->LogError("Failed to locate a valid entity for AllocPooledString.");
+		return NULL_STRING;
+	}
+
+#else
 	CBaseEntity *pEntity = ((IServerUnknown *) servertools->FirstEntity())->GetBaseEntity();
+#endif
 	auto *pDataMap = GetDataMap(pEntity);
 	assert(pDataMap);
 
-	static int offset = -1;
-	if (offset == -1)
+	static int iNameOffset = -1;
+	if (iNameOffset == -1)
 	{
 		sm_datatable_info_t info;
 		bool found = FindDataMapInfo(pDataMap, "m_iName", &info);
 		assert(found);
-		offset = info.actual_offset;
+		iNameOffset = info.actual_offset;
 	}
 
-	string_t *pProp = (string_t *) ((intp) pEntity + offset);
+	string_t* pProp = (string_t*)((intp)pEntity + iNameOffset);
 	string_t backup = *pProp;
+
+#if SOURCE_ENGINE < SE_ORANGEBOX
+	static int iFuncOffset;
+	if (!g_pGameConf->GetOffset("DispatchKeyValue", &iFuncOffset) || !iFuncOffset)
+	{
+		logger->LogError("Failed to locate DispatchKeyValue in core gamedata. AllocPooledString unsupported.");
+		return NULL_STRING;
+	}
+	VKeyValuesSS(pEntity, "targetname", pszValue, iFuncOffset);
+#else	
 	servertools->SetKeyValue(pEntity, "targetname", pszValue);
+#endif
+
 	string_t newString = *pProp;
 	*pProp = backup;
 
 	return newString;
 }
-#endif
 
 bool CHalfLife2::GetServerSteam3Id(char *pszOut, size_t len) const
 {

core/HalfLife2.h

@@ -179,6 +179,12 @@ enum class SMFindMapResult : cell_t {
 	PossiblyAvailable
 };
 
+#if SOURCE_ENGINE >= SE_LEFT4DEAD && defined PLATFORM_WINDOWS
+template< class T, class I = int >
+class CUtlMemoryGlobalMalloc;
+class CUtlString;
+#endif
+
 class CHalfLife2 : 
 	public SMGlobalClass,
 	public IGameHelpers
@@ -229,10 +235,11 @@ public: //IGameHelpers
 	bool IsMapValid(const char *map);
 	SMFindMapResult FindMap(char *pMapName, size_t nMapNameMax);
 	SMFindMapResult FindMap(const char *pMapName, char *pFoundMap = NULL, size_t nMapNameMax = 0);
-	bool GetMapDisplayName(const char *pMapName, char *pDisplayname, size_t nMapNameMax);
-#if SOURCE_ENGINE >= SE_ORANGEBOX
-	string_t AllocPooledString(const char *pszValue);
+#if SOURCE_ENGINE >= SE_LEFT4DEAD && defined PLATFORM_WINDOWS && SOURCE_ENGINE != SE_MOCK
+	void FreeUtlVectorUtlString(CUtlVector<CUtlString, CUtlMemoryGlobalMalloc<CUtlString>> &vec);
 #endif
+	bool GetMapDisplayName(const char *pMapName, char *pDisplayname, size_t nMapNameMax);
+	string_t AllocPooledString(const char *pszValue);
 	bool GetServerSteam3Id(char *pszOut, size_t len) const override;
 	uint64_t GetServerSteamId64() const override;
 public:
@@ -271,7 +278,7 @@ public:
 		return !m_bFollowCSGOServerGuidelines || !m_CSGOBadList.has(pszPropName);
 	}
 private:
-	ke::HashSet<ke::AString, detail::StringHashMapPolicy> m_CSGOBadList;
+	ke::HashSet<std::string, detail::StringHashMapPolicy> m_CSGOBadList;
 	bool m_bFollowCSGOServerGuidelines = true;
 #endif
 };

core/MenuManager.cpp

@@ -308,7 +308,7 @@ IMenuPanel *MenuManager::RenderMenu(int client, menu_states_t &md, ItemOrder ord
 	{
 		ItemDrawInfo &dr = drawItems[foundItems].draw;
 		/* Is the item valid? */
-		if (menu->GetItemInfo(i, &dr) != NULL)
+		if (menu->GetItemInfo(i, &dr, client) != NULL)
 		{
 			/* Ask the user to change the style, if necessary */
 			mh->OnMenuDrawItem(menu, client, i, dr.style);
@@ -398,7 +398,7 @@ IMenuPanel *MenuManager::RenderMenu(int client, menu_states_t &md, ItemOrder ord
 			}
 			while (++lastItem < totalItems)
 			{
-				if (menu->GetItemInfo(lastItem, &dr) != NULL)
+				if (menu->GetItemInfo(lastItem, &dr, client) != NULL)
 				{
 					mh->OnMenuDrawItem(menu, client, lastItem, dr.style);
 					if (IsSlotItem(panel, dr.style))
@@ -420,7 +420,7 @@ IMenuPanel *MenuManager::RenderMenu(int client, menu_states_t &md, ItemOrder ord
 			lastItem--;
 			while (lastItem != 0)
 			{
-				if (menu->GetItemInfo(lastItem, &dr) != NULL)
+				if (menu->GetItemInfo(lastItem, &dr, client) != NULL)
 				{
 					mh->OnMenuDrawItem(menu, client, lastItem, dr.style);
 					if (IsSlotItem(panel, dr.style))

core/MenuStyle_Base.cpp

@@ -36,7 +36,7 @@
 #include "MenuManager.h"
 #include "CellRecipientFilter.h"
 #if defined MENU_DEBUG
-#include "Logger.h"
+#include <bridge/include/ILogger.h>
 #endif
 #include "logic_bridge.h"
 #include "AutoHandleRooter.h"
@@ -59,7 +59,7 @@ Handle_t BaseMenuStyle::GetHandle()
 void BaseMenuStyle::AddClientToWatch(int client)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] AddClientToWatch(%d)", client);
+	logger->LogMessage("[SM_MENU] AddClientToWatch(%d)", client);
 #endif
 	m_WatchList.push_back(client);
 }
@@ -67,7 +67,7 @@ void BaseMenuStyle::AddClientToWatch(int client)
 void BaseMenuStyle::RemoveClientFromWatch(int client)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] RemoveClientFromWatch(%d)", client);
+	logger->LogMessage("[SM_MENU] RemoveClientFromWatch(%d)", client);
 #endif
 	m_WatchList.remove(client);
 }
@@ -75,7 +75,7 @@ void BaseMenuStyle::RemoveClientFromWatch(int client)
 void BaseMenuStyle::_CancelClientMenu(int client, MenuCancelReason reason, bool bAutoIgnore/* =false */)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] _CancelClientMenu() (client %d) (bAutoIgnore %d) (reason %d)", client, bAutoIgnore, reason);
+	logger->LogMessage("[SM_MENU] _CancelClientMenu() (client %d) (bAutoIgnore %d) (reason %d)", client, bAutoIgnore, reason);
 #endif
 	CBaseMenuPlayer *player = GetMenuPlayer(client);
 	menu_states_t &states = player->states;
@@ -115,7 +115,7 @@ void BaseMenuStyle::_CancelClientMenu(int client, MenuCancelReason reason, bool
 void BaseMenuStyle::CancelMenu(CBaseMenu *menu)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] CancelMenu() (menu %p)", menu);
+	logger->LogMessage("[SM_MENU] CancelMenu() (menu %p)", menu);
 #endif
 	int maxClients = g_Players.GetMaxClients();
 	for (int i=1; i<=maxClients; i++)
@@ -135,7 +135,7 @@ void BaseMenuStyle::CancelMenu(CBaseMenu *menu)
 bool BaseMenuStyle::CancelClientMenu(int client, bool autoIgnore)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] CancelClientMenu() (client %d) (bAutoIgnore %d)", client, autoIgnore);
+	logger->LogMessage("[SM_MENU] CancelClientMenu() (client %d) (bAutoIgnore %d)", client, autoIgnore);
 #endif
 	if (client < 1 || client > g_Players.MaxClients())
 	{
@@ -191,7 +191,7 @@ MenuSource BaseMenuStyle::GetClientMenu(int client, void **object)
 void BaseMenuStyle::OnClientDisconnected(int client)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] OnClientDisconnected(%d)", client);
+	logger->LogMessage("[SM_MENU] OnClientDisconnected(%d)", client);
 #endif
 	CBaseMenuPlayer *player = GetMenuPlayer(client);
 	if (!player->bInMenu)
@@ -214,7 +214,7 @@ void BaseMenuStyle::ProcessWatchList()
 	}
 
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("BaseMenuStyle::ProcessWatchList(%d,%d,%d,%d,%d,%p)", 
+	logger->LogMessage("BaseMenuStyle::ProcessWatchList(%d,%d,%d,%d,%d,%p)", 
 		m_WatchList.m_Size,
 		m_WatchList.m_FirstLink,
 		m_WatchList.m_FreeNodes,
@@ -232,7 +232,7 @@ void BaseMenuStyle::ProcessWatchList()
 #if defined MENU_DEBUG
 	if (total)
 	{
-		g_Logger.LogMessage("[SM_MENU] ProcessWatchList() found %d clients", total);
+		logger->LogMessage("[SM_MENU] ProcessWatchList() found %d clients", total);
 	}
 #endif
 
@@ -244,7 +244,7 @@ void BaseMenuStyle::ProcessWatchList()
 		client = do_lookup[i];
 		player = GetMenuPlayer(client);
 #if defined MENU_DEBUG
-		g_Logger.LogMessage("[SM_MENU] ProcessWatchList() (client %d) (bInMenu %d) (menuHoldTime %d) (curTime %f) (menuStartTime %f)",
+		logger->LogMessage("[SM_MENU] ProcessWatchList() (client %d) (bInMenu %d) (menuHoldTime %d) (curTime %f) (menuStartTime %f)",
 			client,
 			player->bInMenu,
 			player->menuHoldTime,
@@ -254,7 +254,7 @@ void BaseMenuStyle::ProcessWatchList()
 		if (!player->bInMenu || !player->menuHoldTime)
 		{
 #if defined MENU_DEBUG
-			g_Logger.LogMessage("[SM_MENU] ProcessWatchList() removing client %d", client);
+			logger->LogMessage("[SM_MENU] ProcessWatchList() removing client %d", client);
 #endif
 			m_WatchList.remove(client);
 			continue;
@@ -269,7 +269,7 @@ void BaseMenuStyle::ProcessWatchList()
 void BaseMenuStyle::ClientPressedKey(int client, unsigned int key_press)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] ClientPressedKey() (client %d) (key_press %d)", client, key_press);
+	logger->LogMessage("[SM_MENU] ClientPressedKey() (client %d) (key_press %d)", client, key_press);
 #endif
 	CBaseMenuPlayer *player = GetMenuPlayer(client);
 
@@ -412,7 +412,7 @@ void BaseMenuStyle::ClientPressedKey(int client, unsigned int key_press)
 bool BaseMenuStyle::DoClientMenu(int client, IMenuPanel *menu, IMenuHandler *mh, unsigned int time)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] DoClientMenu() (client %d) (panel %p) (mh %p) (time %d)",
+	logger->LogMessage("[SM_MENU] DoClientMenu() (client %d) (panel %p) (mh %p) (time %d)",
 		client,
 		menu,
 		mh,
@@ -475,7 +475,7 @@ bool BaseMenuStyle::DoClientMenu(int client,
 								 unsigned int time)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] DoClientMenu() (client %d) (menu %p) (mh %p) (time %d)",
+	logger->LogMessage("[SM_MENU] DoClientMenu() (client %d) (menu %p) (mh %p) (time %d)",
 		client,
 		menu,
 		mh,
@@ -487,7 +487,7 @@ bool BaseMenuStyle::DoClientMenu(int client,
 	if (!pPlayer || pPlayer->IsFakeClient() || !pPlayer->IsInGame())
 	{
 #if defined MENU_DEBUG
-		g_Logger.LogMessage("[SM_MENU] DoClientMenu(): Failed to display to client %d", client);
+		logger->LogMessage("[SM_MENU] DoClientMenu(): Failed to display to client %d", client);
 #endif
 		mh->OnMenuCancel(menu, client, MenuCancel_NoDisplay);
 		mh->OnMenuEnd(menu, MenuEnd_Cancelled);
@@ -498,7 +498,7 @@ bool BaseMenuStyle::DoClientMenu(int client,
 	if (player->bAutoIgnore)
 	{
 #if defined MENU_DEBUG
-		g_Logger.LogMessage("[SM_MENU] DoClientMenu(): Client %d is autoIgnoring", client);
+		logger->LogMessage("[SM_MENU] DoClientMenu(): Client %d is autoIgnoring", client);
 #endif
 		mh->OnMenuCancel(menu, client, MenuCancel_NoDisplay);
 		mh->OnMenuEnd(menu, MenuEnd_Cancelled);
@@ -517,7 +517,7 @@ bool BaseMenuStyle::DoClientMenu(int client,
 	if (player->bInMenu)
 	{
 #if defined MENU_DEBUG
-		g_Logger.LogMessage("[SM_MENU] DoClientMenu(): Cancelling old menu to client %d", client);
+		logger->LogMessage("[SM_MENU] DoClientMenu(): Cancelling old menu to client %d", client);
 #endif
 		_CancelClientMenu(client, MenuCancel_Interrupted, true);
 	}
@@ -532,7 +532,7 @@ bool BaseMenuStyle::DoClientMenu(int client,
 	if (!display)
 	{
 #if defined MENU_DEBUG
-		g_Logger.LogMessage("[SM_MENU] DoClientMenu(): Failed to render to client %d", client);
+		logger->LogMessage("[SM_MENU] DoClientMenu(): Failed to render to client %d", client);
 #endif
 		player->bAutoIgnore = false;
 		player->bInMenu = false;
@@ -562,7 +562,7 @@ bool BaseMenuStyle::DoClientMenu(int client,
 	player->bAutoIgnore = false;
 
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] DoClientMenu() finished successfully (client %d)", client);
+	logger->LogMessage("[SM_MENU] DoClientMenu() finished successfully (client %d)", client);
 #endif
 
 	return true;
@@ -571,7 +571,7 @@ bool BaseMenuStyle::DoClientMenu(int client,
 bool BaseMenuStyle::RedoClientMenu(int client, ItemOrder order)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] RedoClientMenu() (client %d) (order %d)", client, order);
+	logger->LogMessage("[SM_MENU] RedoClientMenu() (client %d) (order %d)", client, order);
 #endif
 	CBaseMenuPlayer *player = GetMenuPlayer(client);
 	menu_states_t &states = player->states;
@@ -581,7 +581,7 @@ bool BaseMenuStyle::RedoClientMenu(int client, ItemOrder order)
 	if (!display)
 	{
 #if defined MENU_DEBUG
-		g_Logger.LogMessage("[SM_MENU] RedoClientMenu(): Failed to render menu");
+		logger->LogMessage("[SM_MENU] RedoClientMenu(): Failed to render menu");
 #endif
 		if (player->menuHoldTime)
 		{
@@ -598,7 +598,7 @@ bool BaseMenuStyle::RedoClientMenu(int client, ItemOrder order)
 	player->bAutoIgnore = false;
 
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] RedoClientMenu(): Succeeded to client %d", client);
+	logger->LogMessage("[SM_MENU] RedoClientMenu(): Succeeded to client %d", client);
 #endif
 
 	return true;
@@ -628,49 +628,49 @@ Handle_t CBaseMenu::GetHandle()
 bool CBaseMenu::AppendItem(const char *info, const ItemDrawInfo &draw)
 {
 	if (m_Pagination == (unsigned)MENU_NO_PAGINATION
-		&& m_items.length() >= m_pStyle->GetMaxPageItems())
+		&& m_items.size() >= m_pStyle->GetMaxPageItems())
 	{
 		return false;
 	}
 
-	CItem item;
+	CItem item(m_items.size());
 
 	item.info = info;
 	if (draw.display)
-		item.display = new ke::AString(draw.display);
+		item.display = std::make_unique<std::string>(draw.display);
 	item.style = draw.style;
 
-	m_items.append(ke::Move(item));
+	m_items.push_back(std::move(item));
 	return true;
 }
 
 bool CBaseMenu::InsertItem(unsigned int position, const char *info, const ItemDrawInfo &draw)
 {
 	if (m_Pagination == (unsigned)MENU_NO_PAGINATION &&
-	    m_items.length() >= m_pStyle->GetMaxPageItems())
+	    m_items.size() >= m_pStyle->GetMaxPageItems())
 	{
 		return false;
 	}
 
-	if (position >= m_items.length())
+	if (position >= m_items.size())
 		return false;
 
-	CItem item;
+	CItem item(position);
 	item.info = info;
 	if (draw.display)
-		item.display = new ke::AString(draw.display);
+		item.display = std::make_unique<std::string>(draw.display);
 	item.style = draw.style;
 
-	m_items.insert(position, ke::Move(item));
+	m_items.emplace(m_items.begin() + position, std::move(item));
 	return true;
 }
 
 bool CBaseMenu::RemoveItem(unsigned int position)
 {
-	if (position >= m_items.length())
+	if (position >= m_items.size())
 		return false;
 
-	m_items.remove(position);
+	m_items.erase(m_items.begin() + position);
 	return true;
 }
 
@@ -679,23 +679,84 @@ void CBaseMenu::RemoveAllItems()
 	m_items.clear();
 }
 
-const char *CBaseMenu::GetItemInfo(unsigned int position, ItemDrawInfo *draw/* =NULL */)
+const char *CBaseMenu::GetItemInfo(unsigned int position, ItemDrawInfo *draw/* =NULL */, int client/* =0 */)
 {
-	if (position >= m_items.length())
+	if (position >= m_items.size())
 		return NULL;
 
+	if (client > 0 && position < m_RandomMaps[client].size())
+	{
+		position = m_RandomMaps[client][position];
+	}
+
 	if (draw)
 	{
-		draw->display = m_items[position].display->chars();
+		draw->display = m_items[position].display->c_str();
 		draw->style = m_items[position].style;
 	}
 
-	return m_items[position].info.chars();
+	return m_items[position].info.c_str();
+}
+
+void CBaseMenu::ShufflePerClient(int start, int stop)
+{
+	// limit map len to 255 items since it's using uint8
+	int length = MIN(GetItemCount(), 255);
+	if (stop >= 0)
+		length = MIN(length, stop);
+
+	for (int i = 1; i <= SM_MAXPLAYERS; i++)
+	{
+		// populate per-client map ...
+		m_RandomMaps[i].resize(length);
+		for (int j = 0; j < length; j++)
+			m_RandomMaps[i][j] = j;
+
+		// ... and random shuffle it
+		for (int j = length - 1; j > start; j--)
+		{
+			int x = rand() % (j - start + 1) + start;
+			uint8_t tmp = m_RandomMaps[i][x];
+			m_RandomMaps[i][x] = m_RandomMaps[i][j];
+			m_RandomMaps[i][j] = tmp;
+		}
+	}
+}
+
+void CBaseMenu::SetClientMapping(int client, int *array, int length)
+{
+	length = MIN(length, 255);
+	m_RandomMaps[client].resize(length);
+	for (int i = 0; i < length; i++)
+	{
+		m_RandomMaps[client][i] = array[i];
+	}
+}
+
+bool CBaseMenu::IsPerClientShuffled()
+{
+	for (int i = 1; i <= SM_MAXPLAYERS; i++)
+	{
+		if(m_RandomMaps[i].size() > 0)
+			return true;
+	}
+	return false;
+}
+
+unsigned int CBaseMenu::GetRealItemIndex(int client, unsigned int position)
+{
+	if (client > 0 && position < m_RandomMaps[client].size())
+	{
+		position = m_RandomMaps[client][position];
+		return m_items[position].index;
+	}
+
+	return position;
 }
 
 unsigned int CBaseMenu::GetItemCount()
 {
-	return m_items.length();
+	return m_items.size();
 }
 
 bool CBaseMenu::SetPagination(unsigned int itemsPerPage)
@@ -733,7 +794,7 @@ void CBaseMenu::SetDefaultTitle(const char *message)
 
 const char *CBaseMenu::GetDefaultTitle()
 {
-	return m_Title.chars();
+	return m_Title.c_str();
 }
 
 void CBaseMenu::Cancel()
@@ -744,7 +805,7 @@ void CBaseMenu::Cancel()
 	}
 
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] CBaseMenu::Cancel(%p) (m_bShouldDelete %d)",
+	logger->LogMessage("[SM_MENU] CBaseMenu::Cancel(%p) (m_bShouldDelete %d)",
 		this,
 		m_bShouldDelete);
 #endif
@@ -768,7 +829,7 @@ void CBaseMenu::Destroy(bool releaseHandle)
 	}
 
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] CBaseMenu::Destroy(%p) (release %d) (m_bCancelling %d) (m_bShouldDelete %d)",
+	logger->LogMessage("[SM_MENU] CBaseMenu::Destroy(%p) (release %d) (m_bCancelling %d) (m_bShouldDelete %d)",
 		this,
 		releaseHandle,
 		m_bCancelling,
@@ -825,5 +886,5 @@ IMenuHandler *CBaseMenu::GetHandler()
 
 unsigned int CBaseMenu::GetBaseMemUsage()
 {
-	return m_Title.length() + (m_items.length() * sizeof(CItem));
+	return m_Title.size() + (m_items.size() * sizeof(CItem));
 }

core/MenuStyle_Base.h

@@ -32,9 +32,11 @@
 #ifndef _INCLUDE_MENUSTYLE_BASE_H
 #define _INCLUDE_MENUSTYLE_BASE_H
 
+#include <memory>
+#include <utility>
+
 #include <IMenuManager.h>
 #include <IPlayerHelpers.h>
-#include <am-autoptr.h>
 #include <am-string.h>
 #include <am-vector.h>
 #include "sm_fastlink.h"
@@ -44,30 +46,34 @@ using namespace SourceMod;
 class CItem
 {
 public:
-	CItem()
+	CItem(unsigned int index)
 	{
+		this->index = index;
 		style = 0;
 		access = 0;
 	}
 	CItem(CItem &&other)
-	: info(ke::Move(other.info)),
-	  display(ke::Move(other.display))
+	: info(std::move(other.info)),
+	  display(std::move(other.display))
 	{
+		index = other.index;
 		style = other.style;
 		access = other.access;
 	}
 	CItem & operator =(CItem &&other)
 	{
-		info = ke::Move(other.info);
-		display = ke::Move(other.display);
+		index = other.index;
+		info = std::move(other.info);
+		display = std::move(other.display);
 		style = other.style;
 		access = other.access;
 		return *this;
 	}
 
 public:
-	ke::AString info;
-	ke::AutoPtr<ke::AString> display;
+	unsigned int index;
+	std::string info;
+	std::unique_ptr<std::string> display;
 	unsigned int style;
 	unsigned int access;
 
@@ -138,7 +144,7 @@ public:
 	virtual bool InsertItem(unsigned int position, const char *info, const ItemDrawInfo &draw);
 	virtual bool RemoveItem(unsigned int position);
 	virtual void RemoveAllItems();
-	virtual const char *GetItemInfo(unsigned int position, ItemDrawInfo *draw=NULL);
+	virtual const char *GetItemInfo(unsigned int position, ItemDrawInfo *draw=NULL, int client=0);
 	virtual unsigned int GetItemCount();
 	virtual bool SetPagination(unsigned int itemsPerPage);
 	virtual unsigned int GetPagination();
@@ -152,14 +158,18 @@ public:
 	virtual unsigned int GetMenuOptionFlags();
 	virtual void SetMenuOptionFlags(unsigned int flags);
 	virtual IMenuHandler *GetHandler();
+	virtual void ShufflePerClient(int start, int stop);
+	virtual void SetClientMapping(int client, int *array, int length);
+	virtual bool IsPerClientShuffled();
+	virtual unsigned int GetRealItemIndex(int client, unsigned int position);
 	unsigned int GetBaseMemUsage();
 private:
 	void InternalDelete();
 protected:
-	ke::AString m_Title;
+	std::string m_Title;
 	IMenuStyle *m_pStyle;
 	unsigned int m_Pagination;
-	ke::Vector<CItem> m_items;
+	std::vector<CItem> m_items;
 	bool m_bShouldDelete;
 	bool m_bCancelling;
 	IdentityToken_t *m_pOwner;
@@ -168,6 +178,7 @@ protected:
 	Handle_t m_hHandle;
 	IMenuHandler *m_pHandler;
 	unsigned int m_nFlags;
+	std::vector<uint8_t> m_RandomMaps[SM_MAXPLAYERS+1];
 };
 
 #endif //_INCLUDE_MENUSTYLE_BASE_H

core/MenuStyle_Radio.cpp

@@ -35,7 +35,7 @@
 #include <IGameConfigs.h>
 #include "PlayerManager.h"
 #if defined MENU_DEBUG
-#include "Logger.h"
+#include <bridge/include/ILogger.h>
 #endif
 #include "logic_bridge.h"
 
@@ -45,6 +45,8 @@
 
 #if SOURCE_ENGINE == SE_CSGO
 #include <game/shared/csgo/protobuf/cstrike15_usermessages.pb.h>
+#elif SOURCE_ENGINE == SE_BLADE
+#include <game/shared/berimbau/protobuf/berimbau_usermessages.pb.h>
 #endif
 
 extern const char *g_RadioNumTable[];
@@ -59,7 +61,7 @@ unsigned int g_RadioMenuTimeout = 0;
 #define MAX_MENUSLOT_KEYS 10
 
 static unsigned int s_RadioMaxPageItems = MAX_MENUSLOT_KEYS;
-
+static bool s_RadioClosesOnInvalidSlot = false;
 
 CRadioStyle::CRadioStyle()
 {
@@ -122,6 +124,12 @@ void CRadioStyle::OnSourceModLevelChange(const char *mapName)
 		}
 	}
 
+	const char *closes = g_pGameConf->GetKeyValue("RadioMenuClosesOnInvalidSlot");
+	if (closes != nullptr && strcmp(closes, "yes") == 0)
+	{
+		s_RadioClosesOnInvalidSlot = true;
+	}
+
 	g_Menus.SetDefaultStyle(this);
 
 	g_UserMsgs.HookUserMessage(g_ShowMenuId, this, false);
@@ -174,7 +182,7 @@ void CRadioStyle::OnUserMessage(int msg_id, bf_write *bf, IRecipientFilter *pFil
 {
 	int count = pFilter->GetRecipientCount();
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	int c = ((CCSUsrMsg_ShowMenu &)msg).display_time();
 #else
 	bf_read br(bf->GetBasePointer(), 3);
@@ -197,7 +205,7 @@ void CRadioStyle::OnUserMessageSent(int msg_id)
 	{
 		int client = g_last_clients[i];
 #if defined MENU_DEBUG
-		g_Logger.LogMessage("[SM_MENU] CRadioStyle got ShowMenu (client %d) (bInMenu %d)",
+		logger->LogMessage("[SM_MENU] CRadioStyle got ShowMenu (client %d) (bInMenu %d)",
 			client,
 			m_players[client].bInExternMenu);
 #endif
@@ -462,7 +470,16 @@ void CRadioMenuPlayer::Radio_Init(int keys, const char *title, const char *text)
 			sizeof(display_pkt), 
 			text);
 	}
-	display_keys = keys;
+
+	// Some games have implemented CHudMenu::SelectMenuItem to close the menu
+	// even if an invalid slot has been selected, which causes us a problem as
+	// we'll never get any notification from the client and we'll keep the menu
+	// alive on our end indefinitely. For these games, pretend that every slot
+	// is valid for selection so we're guaranteed to get a menuselect command.
+	// We don't want to do this for every game as the common SelectMenuItem
+	// implementation ignores invalid selections and keeps the menu open, which
+	// is a much nicer user experience.
+	display_keys = s_RadioClosesOnInvalidSlot ? 0x7ff : keys;
 }
 
 void CRadioMenuPlayer::Radio_Refresh()
@@ -483,9 +500,13 @@ void CRadioMenuPlayer::Radio_Refresh()
 		time = menuHoldTime - (unsigned int)(gpGlobals->curtime - menuStartTime);
 	}
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	// TODO: find what happens past 240 on CS:GO
 	CCSUsrMsg_ShowMenu *msg = (CCSUsrMsg_ShowMenu *)g_UserMsgs.StartProtobufMessage(g_ShowMenuId, players, 1, USERMSG_BLOCKHOOKS);
+	if (!msg)
+	{
+		return;
+	}
 	msg->set_bits_valid_slots(display_keys);
 	msg->set_display_time(time);
 	msg->set_menu_string(ptr);
@@ -576,7 +597,7 @@ bool CRadioMenu::DisplayAtItem(int client,
 							   IMenuHandler *alt_handler)
 {
 #if defined MENU_DEBUG
-	g_Logger.LogMessage("[SM_MENU] CRadioMenu::Display(%p) (client %d) (time %d)",
+	logger->LogMessage("[SM_MENU] CRadioMenu::Display(%p) (client %d) (time %d)",
 		this,
 		client,
 		time);

core/MenuVoting.cpp

@@ -514,15 +514,16 @@ void VoteMenuHandler::OnMenuSelect(IBaseMenu *menu, int client, unsigned int ite
 	/* Check by our item count, NOT the vote array size */
 	if (item < m_Items)
 	{
-		m_ClientVotes[client] = item;
-		m_Votes[item]++;
+		unsigned int index = menu->GetRealItemIndex(client, item);
+		m_ClientVotes[client] = index;
+		m_Votes[index]++;
 		m_NumVotes++;
 
 		if (sm_vote_chat.GetBool() || sm_vote_console.GetBool() || sm_vote_client_console.GetBool())
 		{
 			static char buffer[1024];
 			ItemDrawInfo dr;
-			menu->GetItemInfo(item, &dr);
+			menu->GetItemInfo(item, &dr, client);
 
 			if (sm_vote_console.GetBool())
 			{

core/NextMap.cpp

@@ -63,11 +63,7 @@ bool g_forcedChange = false;
 
 void NextMapManager::OnSourceModAllInitialized_Post()
 {
-#if SOURCE_ENGINE >= SE_ORANGEBOX
 	SH_ADD_HOOK(IVEngineServer, ChangeLevel, engine, SH_MEMBER(this, &NextMapManager::HookChangeLevel), false);
-#else
-	SH_ADD_HOOK(IVEngineServer, ChangeLevel, engine, SH_MEMBER(this, &NextMapManager::HookChangeLevel), false);
-#endif
 
 	ConCommand *pCmd = FindCommand("changelevel");
 	if (pCmd != NULL)
@@ -79,11 +75,7 @@ void NextMapManager::OnSourceModAllInitialized_Post()
 
 void NextMapManager::OnSourceModShutdown()
 {
-#if SOURCE_ENGINE >= SE_ORANGEBOX
 	SH_REMOVE_HOOK(IVEngineServer, ChangeLevel, engine, SH_MEMBER(this, &NextMapManager::HookChangeLevel), false);
-#else
-	SH_REMOVE_HOOK(IVEngineServer, ChangeLevel, engine, SH_MEMBER(this, &NextMapManager::HookChangeLevel), false);
-#endif
 
 	if (changeLevelCmd != NULL)
 	{

core/PlayerManager.cpp

@@ -30,6 +30,7 @@
  */
 
 #include "PlayerManager.h"
+#include "sourcemod.h"
 #include "IAdminSystem.h"
 #include "ConCmdManager.h"
 #include "MenuStyle_Valve.h"
@@ -92,6 +93,12 @@ SH_DECL_EXTERN1_void(ConCommand, Dispatch, SH_NOATTRIB, false, const CCommand &)
 #else
 SH_DECL_EXTERN0_void(ConCommand, Dispatch, SH_NOATTRIB, false);
 #endif
+SH_DECL_HOOK2_void(IVEngineServer, ClientPrintf, SH_NOATTRIB, 0, edict_t *, const char *);
+
+static void PrintfBuffer_FrameAction(void *data)
+{
+	g_Players.OnPrintfFrameAction(static_cast<unsigned int>(reinterpret_cast<uintptr_t>(data)));
+}
 
 ConCommand *maxplayersCmd = NULL;
 
@@ -172,6 +179,7 @@ void PlayerManager::OnSourceModAllInitialized()
 #elif SOURCE_ENGINE > SE_EYE // 2013/orangebox, but not original orangebox.
 	SH_ADD_HOOK(IServerGameDLL, SetServerHibernation, gamedll, SH_MEMBER(this, &PlayerManager::OnServerHibernationUpdate), true);
 #endif
+	SH_ADD_HOOK(IVEngineServer, ClientPrintf, engine, SH_MEMBER(this, &PlayerManager::OnClientPrintf), false);
 
 	sharesys->AddInterface(NULL, this);
 
@@ -188,6 +196,7 @@ void PlayerManager::OnSourceModAllInitialized()
 	m_clcommandkv_post = forwardsys->CreateForward("OnClientCommandKeyValues_Post", ET_Ignore, 2, NULL, Param_Cell, Param_Cell);
 	m_clinfochanged = forwardsys->CreateForward("OnClientSettingsChanged", ET_Ignore, 1, p2);
 	m_clauth = forwardsys->CreateForward("OnClientAuthorized", ET_Ignore, 2, NULL, Param_Cell, Param_String);
+	m_cllang = forwardsys->CreateForward("OnClientLanguageChanged", ET_Ignore, 2, NULL, Param_Cell, Param_Cell);
 	m_onActivate = forwardsys->CreateForward("OnServerLoad", ET_Ignore, 0, NULL);
 	m_onActivate2 = forwardsys->CreateForward("OnMapStart", ET_Ignore, 0, NULL);
 
@@ -204,6 +213,9 @@ void PlayerManager::OnSourceModAllInitialized()
 		SH_ADD_HOOK(ConCommand, Dispatch, pCmd, SH_STATIC(CmdMaxplayersCallback), true);
 		maxplayersCmd = pCmd;
 	}
+
+	gameevents->AddListener(this, "player_connect", true);
+	gameevents->AddListener(this, "player_disconnect", true);
 }
 
 void PlayerManager::OnSourceModShutdown()
@@ -225,6 +237,7 @@ void PlayerManager::OnSourceModShutdown()
 #elif SOURCE_ENGINE > SE_EYE // 2013/orangebox, but not original orangebox.
 	SH_REMOVE_HOOK(IServerGameDLL, SetServerHibernation, gamedll, SH_MEMBER(this, &PlayerManager::OnServerHibernationUpdate), true);
 #endif
+	SH_REMOVE_HOOK(IVEngineServer, ClientPrintf, engine, SH_MEMBER(this, &PlayerManager::OnClientPrintf), false);
 
 	/* Release forwards */
 	forwardsys->ReleaseForward(m_clconnect);
@@ -237,6 +250,7 @@ void PlayerManager::OnSourceModShutdown()
 	forwardsys->ReleaseForward(m_clcommandkv_post);
 	forwardsys->ReleaseForward(m_clinfochanged);
 	forwardsys->ReleaseForward(m_clauth);
+	forwardsys->ReleaseForward(m_cllang);
 	forwardsys->ReleaseForward(m_onActivate);
 	forwardsys->ReleaseForward(m_onActivate2);
 
@@ -250,6 +264,8 @@ void PlayerManager::OnSourceModShutdown()
 	{
 		SH_REMOVE_HOOK(ConCommand, Dispatch, maxplayersCmd, SH_STATIC(CmdMaxplayersCallback), true);
 	}
+
+	gameevents->RemoveListener(this);
 }
 
 ConfigResult PlayerManager::OnSourceModConfigChanged(const char *key, 
@@ -396,7 +412,7 @@ void PlayerManager::RunAuthChecks()
 		pPlayer = &m_Players[m_AuthQueue[i]];
 		pPlayer->UpdateAuthIds();
 		
-		authstr = pPlayer->m_AuthID.chars();
+		authstr = pPlayer->m_AuthID.c_str();
 
 		if (!pPlayer->IsAuthStringValidated())
 		{
@@ -503,7 +519,7 @@ bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const
 	/* Get the client's language */
 	if (m_QueryLang)
 	{
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		pPlayer->m_LangId = translator->GetServerLanguage();
 #else
 		const char *name;
@@ -511,6 +527,8 @@ bool PlayerManager::OnClientConnect(edict_t *pEntity, const char *pszName, const
 		{
 			unsigned int langid;
 			pPlayer->m_LangId = (translator->GetLanguageByName(name, &langid)) ? langid : translator->GetServerLanguage();
+
+			OnClientLanguageChanged(client, pPlayer->m_LangId);
 		} else {
 			pPlayer->m_LangId = translator->GetServerLanguage();
 		}
@@ -657,6 +675,8 @@ void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername
 			&& (m_SourceTVUserId == userId
 #if SOURCE_ENGINE == SE_CSGO
 				|| strcmp(playername, "GOTV") == 0
+#elif SOURCE_ENGINE == SE_BLADE
+				|| strcmp(playername, "BBTV") == 0
 #elif (SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_HL2DM || SOURCE_ENGINE == SE_DODS || SOURCE_ENGINE == SE_TF2 || SOURCE_ENGINE == SE_SDK2013 \
 	|| SOURCE_ENGINE == SE_BMS || SOURCE_ENGINE == SE_NUCLEARDAWN  || SOURCE_ENGINE == SE_LEFT4DEAD2)
 				|| (tv_name && strcmp(playername, tv_name->GetString()) == 0) || (tv_name && tv_name->GetString()[0] == 0 && strcmp(playername, "unnamed") == 0)
@@ -700,19 +720,19 @@ void PlayerManager::OnClientPutInServer(edict_t *pEntity, const char *playername
 		for (iter=m_hooks.begin(); iter!=m_hooks.end(); iter++)
 		{
 			pListener = (*iter);
-			pListener->OnClientAuthorized(client, steamId ? steamId : pPlayer->m_AuthID.chars());
+			pListener->OnClientAuthorized(client, steamId ? steamId : pPlayer->m_AuthID.c_str());
 		}
 		/* Finally, tell plugins */
 		if (m_clauth->GetFunctionCount())
 		{
 			m_clauth->PushCell(client);
 			/* For legacy reasons, people are expecting the Steam2 id here if using Steam auth */
-			m_clauth->PushString(steamId ? steamId : pPlayer->m_AuthID.chars());
+			m_clauth->PushString(steamId ? steamId : pPlayer->m_AuthID.c_str());
 			m_clauth->Execute(NULL);
 		}
 		pPlayer->Authorize_Post();
 	}
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	else if(m_QueryLang)
 	{
 		// Not a bot
@@ -772,7 +792,7 @@ void PlayerManager::OnServerHibernationUpdate(bool bHibernating)
 			CPlayer *pPlayer = &m_Players[i];
 			if (pPlayer->IsConnected() && pPlayer->IsFakeClient())
 			{
-#if SOURCE_ENGINE < SE_LEFT4DEAD || SOURCE_ENGINE >= SE_CSGO || SOURCE_ENGINE == SE_NUCLEARDAWN
+#if SOURCE_ENGINE < SE_LEFT4DEAD || SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE || SOURCE_ENGINE == SE_NUCLEARDAWN
 				// These games have the bug fixed where hltv/replay was getting kicked on hibernation
 				if (pPlayer->IsSourceTV() || pPlayer->IsReplay())
 					continue;
@@ -846,6 +866,88 @@ void PlayerManager::OnClientDisconnect_Post(edict_t *pEntity)
 	}
 }
 
+void PlayerManager::OnClientPrintf(edict_t *pEdict, const char *szMsg)
+{
+	int client = IndexOfEdict(pEdict);
+
+	CPlayer &player = m_Players[client];
+	if (!player.IsConnected())
+		RETURN_META(MRES_IGNORED);
+
+	INetChannel *pNetChan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(client));
+	if (pNetChan == NULL)
+		RETURN_META(MRES_IGNORED);
+
+	size_t nMsgLen = strlen(szMsg);
+#if SOURCE_ENGINE == SE_EPISODEONE || SOURCE_ENGINE == SE_DARKMESSIAH
+	static const int nNumBitsWritten = 0;
+#else
+	int nNumBitsWritten = pNetChan->GetNumBitsWritten(false); // SVC_Print uses unreliable netchan
+#endif
+
+	// if the msg is bigger than allowed then just let it fail
+	if (nMsgLen + 1 >= SVC_Print_BufferSize) // +1 for NETMSG_TYPE_BITS
+		RETURN_META(MRES_IGNORED);
+
+	// enqueue msgs if we'd overflow the SVC_Print buffer (+7 as ceil)
+	if (!player.m_PrintfBuffer.empty() || (nNumBitsWritten + NETMSG_TYPE_BITS + 7) / 8 + nMsgLen >= SVC_Print_BufferSize)
+	{
+		// Don't send any more messages for this player until the buffer is empty.
+		// Queue up a gameframe hook to empty the buffer (if we haven't already)
+		if (player.m_PrintfBuffer.empty())
+			g_SourceMod.AddFrameAction(PrintfBuffer_FrameAction, (void *)(uintptr_t)player.GetSerial());
+
+		player.m_PrintfBuffer.push_back(szMsg);
+
+		RETURN_META(MRES_SUPERCEDE);
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void PlayerManager::OnPrintfFrameAction(unsigned int serial)
+{
+	int client = GetClientFromSerial(serial);
+	CPlayer &player = m_Players[client];
+	if (!player.IsConnected())
+	{
+		player.ClearNetchannelQueue();
+		return;
+	}
+
+	INetChannel *pNetChan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(client));
+	if (pNetChan == NULL)
+	{
+		player.ClearNetchannelQueue();
+		return;
+	}
+
+	while (!player.m_PrintfBuffer.empty())
+	{
+#if SOURCE_ENGINE == SE_EPISODEONE || SOURCE_ENGINE == SE_DARKMESSIAH
+		static const int nNumBitsWritten = 0;
+#else
+		int nNumBitsWritten = pNetChan->GetNumBitsWritten(false); // SVC_Print uses unreliable netchan
+#endif
+
+		std::string &string = player.m_PrintfBuffer.front();
+
+		// stop if we'd overflow the SVC_Print buffer  (+7 as ceil)
+		if ((nNumBitsWritten + NETMSG_TYPE_BITS + 7) / 8 + string.length() >= SVC_Print_BufferSize)
+			break;
+
+		SH_CALL(engine, &IVEngineServer::ClientPrintf)(player.m_pEdict, string.c_str());
+
+		player.m_PrintfBuffer.pop_front();
+	}
+
+	if (!player.m_PrintfBuffer.empty())
+	{
+		// continue processing it on the next gameframe as buffer is not empty
+		g_SourceMod.AddFrameAction(PrintfBuffer_FrameAction, (void *)(uintptr_t)player.GetSerial());
+	}
+}
+
 void ClientConsolePrint(edict_t *e, const char *fmt, ...)
 {
 	char buffer[512];
@@ -1065,14 +1167,18 @@ void PlayerManager::OnClientCommand(edict_t *pEntity)
 		}
 		else if (args.ArgC() > 1 && strcmp(args.Arg(1), "credits") == 0)
 		{
- 			ClientConsolePrint(pEntity,
- 				"SourceMod would not be possible without:");
- 			ClientConsolePrint(pEntity,
+			ClientConsolePrint(pEntity,
+				"SourceMod would not be possible without:");
+			ClientConsolePrint(pEntity,
 				" David \"BAILOPAN\" Anderson, Matt \"pRED\" Woodrow");
- 			ClientConsolePrint(pEntity,
+			ClientConsolePrint(pEntity,
 				" Scott \"DS\" Ehlert, Fyren");
- 			ClientConsolePrint(pEntity,
+			ClientConsolePrint(pEntity,
 				" Nicholas \"psychonic\" Hastings, Asher \"asherkin\" Baker");
+			ClientConsolePrint(pEntity,
+				" Ruben \"Dr!fter\" Gonzalez, Josh \"KyleS\" Allard");
+			ClientConsolePrint(pEntity,
+				" Michael \"Headline\" Flaherty, Jannik \"Peace-Maker\" Hartung");
 			ClientConsolePrint(pEntity,
 				" Borja \"faluco\" Ferrer, Pavol \"PM OnoTo\" Marko");
 			ClientConsolePrint(pEntity,
@@ -1087,7 +1193,7 @@ void PlayerManager::OnClientCommand(edict_t *pEntity)
 		ClientConsolePrint(pEntity,
 			"To see credits, type \"sm credits\"");
 		ClientConsolePrint(pEntity,
-			"Visit http://www.sourcemod.net/");
+			"Visit https://www.sourcemod.net/");
 		RETURN_META(MRES_SUPERCEDE);
 	}
 
@@ -1242,65 +1348,69 @@ void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)
 	m_clinfochanged->PushCell(client);
 	m_clinfochanged->Execute(&res, NULL);
 
-	if (pPlayer->IsFakeClient())
-	{
-		return;
-	}
-
 	IPlayerInfo *info = pPlayer->GetPlayerInfo();
 	const char *new_name = info ? info->GetName() : engine->GetClientConVarValue(client, "name");
 	const char *old_name = pPlayer->m_Name.c_str();
 
-#if SOURCE_ENGINE >= SE_LEFT4DEAD
-	const char *networkid_force;
-	if ((networkid_force = engine->GetClientConVarValue(client, "networkid_force")) && networkid_force[0] != '\0')
-	{
-		unsigned int accountId = pPlayer->GetSteamAccountID();
-		logger->LogMessage("\"%s<%d><STEAM_1:%d:%d><>\" has bad networkid (id \"%s\") (ip \"%s\")",
-			new_name, pPlayer->GetUserId(), accountId & 1, accountId >> 1, networkid_force, pPlayer->GetIPAddress());
-
-		pPlayer->Kick("NetworkID spoofing detected.");
-		RETURN_META(MRES_IGNORED);
-	}
-#endif
-
 	if (strcmp(old_name, new_name) != 0)
 	{
-		AdminId id = adminsys->FindAdminByIdentity("name", new_name);
-		if (id != INVALID_ADMIN_ID && pPlayer->GetAdminId() != id)
+		if (!pPlayer->IsFakeClient())
 		{
-			if (!CheckSetAdminName(client, pPlayer, id))
+			AdminId id = adminsys->FindAdminByIdentity("name", new_name);
+			if (id != INVALID_ADMIN_ID && pPlayer->GetAdminId() != id)
 			{
-				char kickMsg[128];
-				logicore.CoreTranslate(kickMsg, sizeof(kickMsg), "%T", 2, NULL, "Name Reserved", &client);
-				pPlayer->Kick(kickMsg);
-				RETURN_META(MRES_IGNORED);
+				if (!CheckSetAdminName(client, pPlayer, id))
+				{
+					char kickMsg[128];
+					logicore.CoreTranslate(kickMsg, sizeof(kickMsg), "%T", 2, NULL, "Name Reserved", &client);
+					pPlayer->Kick(kickMsg);
+					RETURN_META(MRES_IGNORED);
+				}
 			}
-		} else if ((id = adminsys->FindAdminByIdentity("name", old_name)) != INVALID_ADMIN_ID) {
-			if (id == pPlayer->GetAdminId())
-			{
-				/* This player is changing their name; force them to drop admin privileges! */
-				pPlayer->SetAdminId(INVALID_ADMIN_ID, false);
+			else if ((id = adminsys->FindAdminByIdentity("name", old_name)) != INVALID_ADMIN_ID) {
+				if (id == pPlayer->GetAdminId())
+				{
+					/* This player is changing their name; force them to drop admin privileges! */
+					pPlayer->SetAdminId(INVALID_ADMIN_ID, false);
+				}
 			}
 		}
+
 		pPlayer->SetName(new_name);
 	}
 	
-	if (m_PassInfoVar.size() > 0)
+	if (!pPlayer->IsFakeClient())
 	{
-		/* Try for a password change */
-		const char *old_pass = pPlayer->m_LastPassword.c_str();
-		const char *new_pass = engine->GetClientConVarValue(client, m_PassInfoVar.c_str());
-		if (strcmp(old_pass, new_pass) != 0)
+		if (m_PassInfoVar.size() > 0)
 		{
-			pPlayer->m_LastPassword.assign(new_pass);
-			if (pPlayer->IsInGame() && pPlayer->IsAuthorized())
+			/* Try for a password change */
+			const char* old_pass = pPlayer->m_LastPassword.c_str();
+			const char* new_pass = engine->GetClientConVarValue(client, m_PassInfoVar.c_str());
+			if (strcmp(old_pass, new_pass) != 0)
 			{
-				/* If there is already an admin id assigned, this will just bail out. */
-				pPlayer->DoBasicAdminChecks();
+				pPlayer->m_LastPassword.assign(new_pass);
+				if (pPlayer->IsInGame() && pPlayer->IsAuthorized())
+				{
+					/* If there is already an admin id assigned, this will just bail out. */
+					pPlayer->DoBasicAdminChecks();
+				}
 			}
 		}
+
+#if SOURCE_ENGINE >= SE_LEFT4DEAD
+		const char* networkid_force;
+		if ((networkid_force = engine->GetClientConVarValue(client, "networkid_force")) && networkid_force[0] != '\0')
+		{
+			unsigned int accountId = pPlayer->GetSteamAccountID();
+			logger->LogMessage("\"%s<%d><STEAM_1:%d:%d><>\" has bad networkid (id \"%s\") (ip \"%s\")",
+				new_name, pPlayer->GetUserId(), accountId & 1, accountId >> 1, networkid_force, pPlayer->GetIPAddress());
+
+			pPlayer->Kick("NetworkID spoofing detected.");
+			RETURN_META(MRES_IGNORED);
+		}
+#endif
 	}
+
 	/* Notify Extensions */
 	List<IClientListener *>::iterator iter;
 	IClientListener *pListener = NULL;
@@ -1314,6 +1424,13 @@ void PlayerManager::OnClientSettingsChanged(edict_t *pEntity)
 	}
 }
 
+void PlayerManager::OnClientLanguageChanged(int client, unsigned int language)
+{
+	m_cllang->PushCell(client);
+	m_cllang->PushCell(language);
+	m_cllang->Execute(NULL);
+}
+
 int PlayerManager::GetMaxClients()
 {
 	return m_maxClients;
@@ -1333,6 +1450,11 @@ int PlayerManager::GetNumPlayers()
 	return m_PlayerCount;
 }
 
+int PlayerManager::GetNumClients()
+{
+	return m_ClientCount;
+}
+
 int PlayerManager::GetClientOfUserId(int userid)
 {
 	if (userid < 0 || userid > USHRT_MAX)
@@ -1474,7 +1596,10 @@ void PlayerManager::InvalidatePlayer(CPlayer *pPlayer)
 		}
 	}
 	
-	m_UserIdLookUp[engine->GetPlayerUserId(pPlayer->m_pEdict)] = 0;
+	auto userid = engine->GetPlayerUserId(pPlayer->m_pEdict);
+	if (userid != -1)
+		m_UserIdLookUp[userid] = 0;
+
 	pPlayer->Disconnect();
 }
 
@@ -1910,7 +2035,7 @@ void CmdMaxplayersCallback()
 	g_Players.MaxPlayersChanged();
 }
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 bool PlayerManager::HandleConVarQuery(QueryCvarCookie_t cookie, int client, EQueryCvarValueStatus result, const char *cvarName, const char *cvarValue)
 {
 	for (int i = 1; i <= m_maxClients; i++)
@@ -1918,7 +2043,9 @@ bool PlayerManager::HandleConVarQuery(QueryCvarCookie_t cookie, int client, EQue
 		if (m_Players[i].m_LanguageCookie == cookie)
 		{
 			unsigned int langid;
-			m_Players[i].m_LangId = (translator->GetLanguageByName(cvarValue, &langid)) ? langid : translator->GetServerLanguage();
+			unsigned int new_langid = (translator->GetLanguageByName(cvarValue, &langid)) ? langid : translator->GetServerLanguage();
+			m_Players[i].m_LangId = new_langid;
+			OnClientLanguageChanged(i, new_langid);
 
 			return true;
 		}
@@ -1928,6 +2055,27 @@ bool PlayerManager::HandleConVarQuery(QueryCvarCookie_t cookie, int client, EQue
 }
 #endif
 
+/* IGameEventListener2::FireGameEvent */
+void PlayerManager::FireGameEvent(IGameEvent *pEvent)
+{
+	const char *name = pEvent->GetName();
+
+	if (strcmp(name, "player_connect") == 0)
+	{
+		const int client = pEvent->GetInt("index") + 1;
+		const int userid = pEvent->GetInt("userid");
+
+		m_ClientCount++;
+	}
+	else if (strcmp(name, "player_disconnect") == 0)
+	{
+		const int userid = pEvent->GetInt("userid");
+		const int client = m_UserIdLookUp[userid];
+
+		m_ClientCount--;
+	}
+}
+
 
 /*******************
  *** PLAYER CODE ***
@@ -1966,7 +2114,8 @@ void CPlayer::Initialize(const char *name, const char *ip, edict_t *pEntity)
 	|| SOURCE_ENGINE == SE_HL2DM \
 	|| SOURCE_ENGINE == SE_BMS   \
 	|| SOURCE_ENGINE == SE_INSURGENCY \
-	|| SOURCE_ENGINE == SE_DOI
+	|| SOURCE_ENGINE == SE_DOI   \
+	|| SOURCE_ENGINE == SE_BLADE
 	m_pIClient = engine->GetIServer()->GetClient(m_iIndex - 1);
 #else
   #if SOURCE_ENGINE == SE_SDK2013
@@ -2142,9 +2291,16 @@ void CPlayer::Disconnect()
 	m_bIsSourceTV = false;
 	m_bIsReplay = false;
 	m_Serial.value = -1;
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	m_LanguageCookie = InvalidQueryCvarCookie;
 #endif
+	ClearNetchannelQueue();
+}
+
+void CPlayer::ClearNetchannelQueue(void)
+{
+	while (!m_PrintfBuffer.empty())
+		m_PrintfBuffer.pop_front();
 }
 
 void CPlayer::SetName(const char *name)
@@ -2177,11 +2333,6 @@ void CPlayer::SetName(const char *name)
 
 const char *CPlayer::GetName()
 {
-	if (m_Info && m_pEdict->GetUnknown())
-	{
-		return m_Info->GetName();
-	}
-	
 	return m_Name.c_str();
 }
 
@@ -2197,7 +2348,7 @@ const char *CPlayer::GetAuthString(bool validated)
 		return NULL;
 	}
 
-	return m_AuthID.chars();
+	return m_AuthID.c_str();
 }
 
 const CSteamID &CPlayer::GetSteamId(bool validated)
@@ -2218,7 +2369,7 @@ const char *CPlayer::GetSteam2Id(bool validated)
 		return NULL;
 	}
 
-	return m_Steam2Id.chars();
+	return m_Steam2Id.c_str();
 }
 
 const char *CPlayer::GetSteam3Id(bool validated)
@@ -2228,14 +2379,14 @@ const char *CPlayer::GetSteam3Id(bool validated)
 		return NULL;
 	}
 
-	return m_Steam3Id.chars();
+	return m_Steam3Id.c_str();
 }
 
 unsigned int CPlayer::GetSteamAccountID(bool validated)
 {
 	if (!IsFakeClient() && (!validated || IsAuthStringValidated()))
 	{
-		const CSteamID &id = GetSteamId();
+		const CSteamID &id = GetSteamId(validated);
 		if (id.IsValid())
 			return id.GetAccountID();
 	}
@@ -2362,7 +2513,7 @@ void CPlayer::Kick(const char *str)
 	}
 	else
 	{
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		pClient->Disconnect(str);
 #else
 		pClient->Disconnect("%s", str);
@@ -2495,7 +2646,7 @@ void CPlayer::DoBasicAdminChecks()
 	}
 
 	/* Check steam id */
-	if ((id = adminsys->FindAdminByIdentity("steam", m_AuthID.chars())) != INVALID_ADMIN_ID)
+	if ((id = adminsys->FindAdminByIdentity("steam", m_AuthID.c_str())) != INVALID_ADMIN_ID)
 	{
 		if (g_Players.CheckSetAdmin(client, this, id))
 		{
@@ -2511,7 +2662,11 @@ unsigned int CPlayer::GetLanguageId()
 
 void CPlayer::SetLanguageId(unsigned int id)
 {
-	m_LangId = id;
+	if(m_LangId != id)
+	{
+		m_LangId = id;
+		g_Players.OnClientLanguageChanged(m_iIndex, id);
+	}
 }
 
 int CPlayer::GetUserId()

core/PlayerManager.h

@@ -1,5 +1,5 @@
 /**
- * vim: set ts=4 :
+ * vim: set ts=4 sts=8 sw=4 tw=99 noet :
  * =============================================================================
  * SourceMod
  * Copyright (C) 2004-2015 AlliedModders LLC.  All rights reserved.
@@ -43,6 +43,7 @@
 #include <sh_list.h>
 #include <sh_vector.h>
 #include <am-string.h>
+#include <am-deque.h>
 #include "ConVarManager.h"
 
 #include <steam/steamclientpublic.h>
@@ -123,6 +124,7 @@ private:
 	bool IsAuthStringValidated();
 	bool SetEngineString();
 	bool SetCSteamID();
+	void ClearNetchannelQueue(void);
 private:
 	bool m_IsConnected = false;
 	bool m_IsInGame = false;
@@ -131,9 +133,9 @@ private:
 	String m_Name;
 	String m_Ip;
 	String m_IpNoPort;
-	ke::AString m_AuthID;
-	ke::AString m_Steam2Id;
-	ke::AString m_Steam3Id;
+	std::string m_AuthID;
+	std::string m_Steam2Id;
+	std::string m_Steam3Id;
 	AdminId m_Admin = INVALID_ADMIN_ID;
 	bool m_TempAdmin = false;
 	edict_t *m_pEdict = nullptr;
@@ -149,14 +151,16 @@ private:
 	bool m_bIsReplay = false;
 	serial_t m_Serial;
 	CSteamID m_SteamId;
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	QueryCvarCookie_t m_LanguageCookie = InvalidQueryCvarCookie;
 #endif
+	std::deque<std::string> m_PrintfBuffer;
 };
 
 class PlayerManager : 
 	public SMGlobalClass,
-	public IPlayerManager
+	public IPlayerManager,
+	public IGameEventListener2
 {
 	friend class CPlayer;
 public:
@@ -189,7 +193,10 @@ public:
 #endif
 	void OnClientSettingsChanged(edict_t *pEntity);
 	//void OnClientSettingsChanged_Pre(edict_t *pEntity);
+	void OnClientLanguageChanged(int client, unsigned int language);
 	void OnServerHibernationUpdate(bool bHibernating);
+	void OnClientPrintf(edict_t *pEdict, const char *szMsg);
+	void OnPrintfFrameAction(unsigned int serial);
 public: //IPlayerManager
 	void AddClientListener(IClientListener *listener);
 	void RemoveClientListener(IClientListener *listener);
@@ -197,6 +204,7 @@ public: //IPlayerManager
 	IGamePlayer *GetGamePlayer(edict_t *pEdict);
 	int GetMaxClients();
 	int GetNumPlayers();
+	int GetNumClients();
 	int GetClientOfUserId(int userid);
 	bool IsServerActivated();
 	int FilterCommandTarget(IGamePlayer *pAdmin, IGamePlayer *pTarget, int flags);
@@ -207,6 +215,11 @@ public: //IPlayerManager
 	int GetClientFromSerial(unsigned int serial);
 	void ClearAdminId(AdminId id);
 	void RecheckAnyAdmins();
+public: // IGameEventListener2
+	void FireGameEvent(IGameEvent *pEvent);
+#if SOURCE_ENGINE >= SE_ALIENSWARM
+	virtual int	 GetEventDebugID( void ) { return 42; }
+#endif
 public:
 	inline int MaxClients()
 	{
@@ -230,7 +243,7 @@ public:
 	{
 		return m_bInCCKVHook;
 	}
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	bool HandleConVarQuery(QueryCvarCookie_t cookie, int client, EQueryCvarValueStatus result, const char *cvarName, const char *cvarValue);
 #endif
 private:
@@ -248,6 +261,7 @@ private:
 	IForward *m_clcommandkv_post;
 	IForward *m_clinfochanged;
 	IForward *m_clauth;
+	IForward *m_cllang;
 	IForward *m_onActivate;
 	IForward *m_onActivate2;
 	CPlayer *m_Players;
@@ -267,6 +281,10 @@ private:
 	int m_SourceTVUserId;
 	int m_ReplayUserId;
 	bool m_bInCCKVHook;
+	int m_ClientCount;
+private:
+	static const int NETMSG_TYPE_BITS = 5; // SVC_Print overhead for netmsg type
+	static const int SVC_Print_BufferSize = 2048 - 1; // -1 for terminating \0
 };
 
 #if SOURCE_ENGINE >= SE_ORANGEBOX

core/TimerSys.cpp

@@ -69,6 +69,13 @@ class DefaultMapTimer :
 	public IConVarChangeListener
 {
 public:
+
+#if SOURCE_ENGINE == SE_BMS
+	static constexpr int kMapTimeScaleFactor = 60;
+#else
+	static constexpr int kMapTimeScaleFactor = 1;
+#endif
+	
 	DefaultMapTimer()
 	{
 		m_bInUse = false;
@@ -81,7 +88,7 @@ public:
 
 	int GetMapTimeLimit()
 	{
-		return mp_timelimit->GetInt();
+		return (mp_timelimit->GetInt() / kMapTimeScaleFactor);
 	}
 
 	void SetMapTimerStatus(bool enabled)
@@ -105,7 +112,7 @@ public:
 			return;
 		}
 
-		extra_time /= 60;
+		extra_time /= (60 / kMapTimeScaleFactor);
 
 		mp_timelimit->SetValue(mp_timelimit->GetInt() + extra_time);
 	}
@@ -484,4 +491,3 @@ bool TimerSystem::GetMapTimeLeft(float *time_left)
 
 	return true;
 }
-

core/UserMessagePBHelpers.h

@@ -816,7 +816,7 @@ public:
 
 	inline bool GetColor(const char *pszFieldName, Color *out)
 	{
-#if SOURCE_ENGINE != SE_CSGO
+#if SOURCE_ENGINE != SE_CSGO && SOURCE_ENGINE != SE_BLADE
 		return false;
 #else
 		GETCHECK_FIELD();
@@ -837,7 +837,7 @@ public:
 
 	inline bool SetColor(const char *pszFieldName, const Color &value)
 	{
-#if SOURCE_ENGINE != SE_CSGO
+#if SOURCE_ENGINE != SE_CSGO && SOURCE_ENGINE != SE_BLADE
 		return false;
 #else
 		GETCHECK_FIELD();
@@ -856,7 +856,7 @@ public:
 
 	inline bool GetRepeatedColor(const char *pszFieldName, int index, Color *out)
 	{
-#if SOURCE_ENGINE != SE_CSGO
+#if SOURCE_ENGINE != SE_CSGO && SOURCE_ENGINE != SE_BLADE
 		return false;
 #else
 		GETCHECK_FIELD();
@@ -878,7 +878,7 @@ public:
 
 	inline bool SetRepeatedColor(const char *pszFieldName, int index, const Color &value)
 	{
-#if SOURCE_ENGINE != SE_CSGO
+#if SOURCE_ENGINE != SE_CSGO && SOURCE_ENGINE != SE_BLADE
 		return false;
 #else
 		GETCHECK_FIELD();
@@ -898,7 +898,7 @@ public:
 
 	inline bool AddColor(const char *pszFieldName, const Color &value)
 	{
-#if SOURCE_ENGINE != SE_CSGO
+#if SOURCE_ENGINE != SE_CSGO && SOURCE_ENGINE != SE_BLADE
 		return false;
 #else
 		GETCHECK_FIELD();

core/UserMessages.cpp

@@ -35,12 +35,14 @@
 
 #if SOURCE_ENGINE == SE_CSGO
 #include <cstrike15_usermessage_helpers.h>
+#elif SOURCE_ENGINE == SE_BLADE
+#include <berimbau_usermessage_helpers.h>
 #endif
 #include <amtl/am-string.h>
 
 UserMessages g_UserMsgs;
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 SH_DECL_HOOK3_void(IVEngineServer, SendUserMessage, SH_NOATTRIB, 0, IRecipientFilter &, int, const protobuf::Message &);
 #else
 #if SOURCE_ENGINE >= SE_LEFT4DEAD
@@ -49,7 +51,7 @@ SH_DECL_HOOK3(IVEngineServer, UserMessageBegin, SH_NOATTRIB, 0, bf_write *, IRec
 SH_DECL_HOOK2(IVEngineServer, UserMessageBegin, SH_NOATTRIB, 0, bf_write *, IRecipientFilter *, int);
 #endif
 SH_DECL_HOOK0_void(IVEngineServer, MessageEnd, SH_NOATTRIB, 0);
-#endif // ==SE_CSGO
+#endif // ==SE_CSGO || ==SE_BLADE
 
 UserMessages::UserMessages()
 #ifndef USE_PROTOBUF_USERMESSAGES
@@ -93,7 +95,7 @@ void UserMessages::OnSourceModAllShutdown()
 {
 	if (m_HookCount)
 	{
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		SH_REMOVE_HOOK(IVEngineServer, SendUserMessage, engine, SH_MEMBER(this, &UserMessages::OnSendUserMessage_Pre), false);
 		SH_REMOVE_HOOK(IVEngineServer, SendUserMessage, engine, SH_MEMBER(this, &UserMessages::OnSendUserMessage_Post), true);
 #else
@@ -111,6 +113,8 @@ int UserMessages::GetMessageIndex(const char *msg)
 #if SOURCE_ENGINE == SE_CSGO
 	// Can split this per engine and/or game later
 	return g_Cstrike15UsermessageHelpers.GetIndex(msg);
+#elif SOURCE_ENGINE == SE_BLADE
+	return g_BerimbauUsermessageHelpers.GetIndex(msg);
 #else
 
 	int msgid;
@@ -148,6 +152,8 @@ bool UserMessages::GetMessageName(int msgid, char *buffer, size_t maxlength) con
 #ifdef USE_PROTOBUF_USERMESSAGES
 #if SOURCE_ENGINE == SE_CSGO
 	const char *pszName = g_Cstrike15UsermessageHelpers.GetName(msgid);
+#elif SOURCE_ENGINE == SE_BLADE
+	const char *pszName = g_BerimbauUsermessageHelpers.GetName(msgid);
 #endif
 	if (!pszName)
 		return false;
@@ -297,7 +303,7 @@ bool UserMessages::EndMessage()
 		return false;
 	}
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	if (m_CurFlags & USERMSG_BLOCKHOOKS)
 	{
 		ENGINE_CALL(SendUserMessage)(static_cast<IRecipientFilter &>(m_CellRecFilter), m_CurId, *m_FakeEngineBuffer);
@@ -327,7 +333,7 @@ bool UserMessages::EndMessage()
 	} else {
 		engine->MessageEnd();
 	}
-#endif // SE_CSGO
+#endif // SE_CSGO || SE_BLADE
 
 	m_InExec = false;
 	m_CurFlags = 0;
@@ -412,7 +418,7 @@ bool UserMessages::InternalHook(int msg_id, IBitBufUserMessageListener *pListene
 
 	if (!m_HookCount++)
 	{
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		SH_ADD_HOOK(IVEngineServer, SendUserMessage, engine, SH_MEMBER(this, &UserMessages::OnSendUserMessage_Pre), false);
 		SH_ADD_HOOK(IVEngineServer, SendUserMessage, engine, SH_MEMBER(this, &UserMessages::OnSendUserMessage_Post), true);
 #else
@@ -438,6 +444,8 @@ const protobuf::Message *UserMessages::GetMessagePrototype(int msg_type)
 {
 #if SOURCE_ENGINE == SE_CSGO
 	return g_Cstrike15UsermessageHelpers.GetPrototype(msg_type);
+#elif SOURCE_ENGINE == SE_BLADE
+	return g_BerimbauUsermessageHelpers.GetPrototype(msg_type);
 #endif
 }
 #endif
@@ -487,7 +495,7 @@ void UserMessages::_DecRefCounter()
 {
 	if (--m_HookCount == 0)
 	{
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		SH_REMOVE_HOOK(IVEngineServer, SendUserMessage, engine, SH_MEMBER(this, &UserMessages::OnSendUserMessage_Pre), false);
 		SH_REMOVE_HOOK(IVEngineServer, SendUserMessage, engine, SH_MEMBER(this, &UserMessages::OnSendUserMessage_Post), true);
 #else
@@ -499,12 +507,17 @@ void UserMessages::_DecRefCounter()
 	}
 }
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 void UserMessages::OnSendUserMessage_Pre(IRecipientFilter &filter, int msg_type, const protobuf::Message &msg)
 {
 #if SOURCE_ENGINE == SE_CSGO
-	OnStartMessage_Pre(&filter, msg_type, g_Cstrike15UsermessageHelpers.GetName(msg_type));
+	const char *pszName = g_Cstrike15UsermessageHelpers.GetName(msg_type);
+#elif SOURCE_ENGINE == SE_BLADE
+	const char *pszName = g_BerimbauUsermessageHelpers.GetName(msg_type);
 #endif
+
+	OnStartMessage_Pre(&filter, msg_type, pszName);
+
 	if (m_FakeMetaRes == MRES_SUPERCEDE)
 	{
 		int size = msg.ByteSize();
@@ -517,9 +530,7 @@ void UserMessages::OnSendUserMessage_Pre(IRecipientFilter &filter, int msg_type,
 		m_FakeEngineBuffer = &const_cast<protobuf::Message &>(msg);
 	}
 
-#if SOURCE_ENGINE == SE_CSGO
-	OnStartMessage_Post(&filter, msg_type, g_Cstrike15UsermessageHelpers.GetName(msg_type));
-#endif
+	OnStartMessage_Post(&filter, msg_type, pszName);
 
 	OnMessageEnd_Pre();
 	if (m_FakeMetaRes == MRES_SUPERCEDE)
@@ -551,7 +562,7 @@ void UserMessages::OnSendUserMessage_Post(IRecipientFilter &filter, int msg_type
 	RETURN_META(res)
 #endif
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 protobuf::Message *UserMessages::OnStartMessage_Pre(IRecipientFilter *filter, int msg_type, const char *msg_name)
 #elif SOURCE_ENGINE >= SE_LEFT4DEAD
 bf_write *UserMessages::OnStartMessage_Pre(IRecipientFilter *filter, int msg_type, const char *msg_name)
@@ -591,7 +602,7 @@ bf_write *UserMessages::OnStartMessage_Pre(IRecipientFilter *filter, int msg_typ
 	UM_RETURN_META_VALUE(MRES_IGNORED, NULL);
 }
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 protobuf::Message *UserMessages::OnStartMessage_Post(IRecipientFilter *filter, int msg_type, const char *msg_name)
 #elif SOURCE_ENGINE >= SE_LEFT4DEAD
 bf_write *UserMessages::OnStartMessage_Post(IRecipientFilter *filter, int msg_type, const char *msg_name)
@@ -756,7 +767,7 @@ void UserMessages::OnMessageEnd_Pre()
 
 	if (!handled && intercepted)
 	{
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		ENGINE_CALL(SendUserMessage)(static_cast<IRecipientFilter &>(*m_CurRecFilter), m_CurId, *m_InterceptBuffer);
 #else
 		bf_write *engine_bfw;
@@ -768,11 +779,11 @@ void UserMessages::OnMessageEnd_Pre()
 		m_ReadBuffer.StartReading(m_InterceptBuffer.GetBasePointer(), m_InterceptBuffer.GetNumBytesWritten());
 		engine_bfw->WriteBitsFromBuffer(&m_ReadBuffer, m_InterceptBuffer.GetNumBitsWritten());
 		ENGINE_CALL(MessageEnd)();
-#endif // SE_CSGO
+#endif // SE_CSGO || SE_BLADE
 	}
 
 	{
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		int size = m_OrigBuffer->ByteSize();
 		uint8 *data = (uint8 *)stackalloc(size);
 		m_OrigBuffer->SerializePartialToArray(data, size);
@@ -802,7 +813,7 @@ void UserMessages::OnMessageEnd_Pre()
 			iter++;
 		}
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 		delete pTempMsg;
 #endif
 	}

core/UserMessages.h

@@ -44,7 +44,7 @@
 using namespace SourceHook;
 using namespace SourceMod;
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 #define USE_PROTOBUF_USERMESSAGES
 #endif
 
@@ -102,12 +102,12 @@ public: //IUserMessages
 		bool intercept=false);
 	UserMessageType GetUserMessageType() const;
 public:
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	void OnSendUserMessage_Pre(IRecipientFilter &filter, int msg_type, const protobuf::Message &msg);
 	void OnSendUserMessage_Post(IRecipientFilter &filter, int msg_type, const protobuf::Message &msg);
 #endif
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	protobuf::Message *OnStartMessage_Pre(IRecipientFilter *filter, int msg_type, const char *msg_name);
 	protobuf::Message *OnStartMessage_Post(IRecipientFilter *filter, int msg_type, const char *msg_name);
 #elif SOURCE_ENGINE >= SE_LEFT4DEAD

core/concmd_cleaner.cpp

@@ -36,7 +36,7 @@
 
 #if SOURCE_ENGINE >= SE_ORANGEBOX
 SH_DECL_HOOK1_void(ICvar, UnregisterConCommand, SH_NOATTRIB, 0, ConCommandBase *);
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 SH_DECL_HOOK2_void(ICvar, RegisterConCommand, SH_NOATTRIB, 0, ConCommandBase *, bool);
 #else
 SH_DECL_HOOK1_void(ICvar, RegisterConCommand, SH_NOATTRIB, 0, ConCommandBase *);
@@ -82,7 +82,7 @@ public:
 #endif
 	}
 
-#if SOURCE_ENGINE == SE_CSGO
+#if SOURCE_ENGINE == SE_CSGO || SOURCE_ENGINE == SE_BLADE
 	void LinkConCommandBase(ConCommandBase *pBase, bool unknown)
 #else
 	void LinkConCommandBase(ConCommandBase *pBase)
@@ -108,20 +108,20 @@ public:
 			listener = listener->next;
 		}
 
-        while (iter != tracked_bases.end())
-        {
-            if ((*iter)->pBase == pBase)
-            {
-                pInfo = (*iter);
-                iter = tracked_bases.erase(iter);
-                pInfo->cls->OnUnlinkConCommandBase(pBase, pBase->GetName());
-                delete pInfo;
-            }
-            else
-            {
-                iter++;
-            }
-        }
+		while (iter != tracked_bases.end())
+		{
+		    if ((*iter)->pBase == pBase)
+		    {
+			pInfo = (*iter);
+			iter = tracked_bases.erase(iter);
+			pInfo->cls->OnUnlinkConCommandBase(pBase, pBase->GetName());
+			delete pInfo;
+		    }
+		    else
+		    {
+			iter++;
+		    }
+		}
 	}
 
 	void AddTarget(ConCommandBase *pBase, IConCommandTracker *cls)

core/logic/AMBuilder

@@ -1,8 +1,8 @@
 # vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:
 import os
 
-for arch in SM.archs:
-  binary = SM.Library(builder, 'sourcemod.logic', arch)
+for cxx in builder.targets:
+  binary = SM.Library(builder, cxx, 'sourcemod.logic')
   binary.compiler.cxxincludes += [
     builder.sourcePath,
     os.path.join(builder.sourcePath, 'core', 'logic'),
@@ -17,9 +17,9 @@ for arch in SM.archs:
     'SM_LOGIC'
   ]
   
-  if builder.target.platform == 'linux':
+  if binary.compiler.target.platform == 'linux':
     binary.compiler.postlink += ['-lpthread', '-lrt']
-  elif builder.target.platform == 'mac':
+  elif binary.compiler.target.platform == 'mac':
     binary.compiler.cflags += ['-Wno-deprecated-declarations']
     binary.compiler.postlink += ['-framework', 'CoreServices']
 
@@ -35,8 +35,7 @@ for arch in SM.archs:
     'smn_maplists.cpp',
     'ADTFactory.cpp',
     'smn_adt_stack.cpp',
-    'thread/ThreadWorker.cpp',
-    'thread/BaseWorker.cpp',
+    'BaseWorker.cpp',
     'ThreadSupport.cpp',
     'smn_float.cpp',
     'TextParsers.cpp',
@@ -85,14 +84,12 @@ for arch in SM.archs:
     'smn_halflife.cpp',
     'FrameIterator.cpp',
     'DatabaseConfBuilder.cpp',
+    'LumpManager.cpp',
+    'smn_entitylump.cpp',
+    'NativeInvoker.cpp',
   ]
 
-  if arch == 'x64':
+  if binary.compiler.target.arch == 'x86_64':
     binary.sources += ['PseudoAddrManager.cpp']
 
-  if builder.target.platform == 'windows':
-    binary.sources += ['thread/WinThreads.cpp']
-  else:
-    binary.sources += ['thread/PosixThreads.cpp']
-
   SM.binaries += [builder.Add(binary)]

core/logic/AdminCache.cpp

@@ -1581,7 +1581,7 @@ bool AdminCache::CanAdminTarget(AdminId id, AdminId target)
 		{
 			id = grp_table[i];
 			num = GetGroupImmunityCount(id);
-			for (unsigned int j=0; j<num; i++)
+			for (unsigned int j=0; j<num; j++)
 			{
 				other = GetGroupImmunity(id, j);
 				for (unsigned int k=0; k<pUser->grp_count; k++)
@@ -1843,13 +1843,13 @@ bool AdminCache::DumpCache(const char *filename)
 		fprintf(fp, "\n\t\t\"Overrides\"\n\t\t{\n");
 		if (pGroup->pCmdGrpTable != NULL)
 		{
-			for (OverrideMap::iterator iter = pGroup->pCmdTable->iter(); !iter.empty(); iter.next())
-				iterator_group_grp_override(fp, iter->key.chars(), iter->value);
+			for (OverrideMap::iterator iter = pGroup->pCmdGrpTable->iter(); !iter.empty(); iter.next())
+				iterator_group_grp_override(fp, iter->key.c_str(), iter->value);
 		}
 		if (pGroup->pCmdTable != NULL)
 		{
 			for (OverrideMap::iterator iter = pGroup->pCmdTable->iter(); !iter.empty(); iter.next())
-				iterator_group_basic_override(fp, iter->key.chars(), iter->value);
+				iterator_group_basic_override(fp, iter->key.c_str(), iter->value);
 		}
 		fprintf(fp, "\t\t}\n");
 
@@ -1924,9 +1924,9 @@ bool AdminCache::DumpCache(const char *filename)
 
 	fprintf(fp, "\"Overrides\"\n{\n");
 	for (FlagMap::iterator iter = m_CmdGrpOverrides.iter(); !iter.empty(); iter.next())
-		iterator_glob_grp_override(fp, iter->key.chars(), iter->value);
+		iterator_glob_grp_override(fp, iter->key.c_str(), iter->value);
 	for (FlagMap::iterator iter = m_CmdOverrides.iter(); !iter.empty(); iter.next())
-		iterator_glob_basic_override(fp, iter->key.chars(), iter->value);
+		iterator_glob_basic_override(fp, iter->key.c_str(), iter->value);
 	fprintf(fp, "}\n");
 	
 	fclose(fp);

core/logic/BaseWorker.cpp

@@ -40,7 +40,7 @@ BaseWorker::BaseWorker(IThreadWorkerCallbacks *hooks) :
 
 BaseWorker::~BaseWorker()
 {
-	if (m_state != Worker_Stopped || m_state != Worker_Invalid)
+	if (m_state != Worker_Stopped && m_state != Worker_Invalid)
 		Stop(true);
 
 	if (m_ThreadQueue.size())

core/logic/BaseWorker.h

@@ -43,6 +43,7 @@ class BaseWorker;
 class SWThreadHandle : public IThreadHandle
 {
 	friend class BaseWorker;
+	friend class CompatWorker;
 public:
 	SWThreadHandle(IThreadCreator *parent, const ThreadParams *p, IThread *thread);
 	IThread *GetThread();

core/logic/CDataPack.cpp

@@ -31,8 +31,10 @@
 
 #include <stdlib.h>
 #include <string.h>
+
+#include <memory>
+
 #include "CDataPack.h"
-#include <amtl/am-autoptr.h>
 
 CDataPack::CDataPack()
 {
@@ -44,33 +46,15 @@ CDataPack::~CDataPack()
 	Initialize();
 }
 
-static ke::Vector<ke::AutoPtr<CDataPack>> sDataPackCache;
-
-CDataPack *CDataPack::New()
-{
-  if (sDataPackCache.empty())
-    return new CDataPack();
-
-  CDataPack *pack = sDataPackCache.back().take();
-  sDataPackCache.pop();
-  pack->Initialize();
-  return pack;
-}
-
-void
-CDataPack::Free(CDataPack *pack)
-{
-  sDataPackCache.append(static_cast<CDataPack *>(pack));
-}
-
 void CDataPack::Initialize()
 {
+	position = 0;
+	
 	do
 	{
 	} while (this->RemoveItem());
 
 	elements.clear();
-	position = 0;
 }
 
 void CDataPack::ResetSize()
@@ -84,7 +68,7 @@ size_t CDataPack::CreateMemory(size_t size, void **addr)
 	val.type = CDataPackType::Raw;
 	val.pData.vval = new uint8_t[size + sizeof(size)];
 	reinterpret_cast<size_t *>(val.pData.vval)[0] = size;
-	elements.insert(position, val);
+	elements.emplace(elements.begin() + position, val);
 
 	return position++;
 }
@@ -94,7 +78,8 @@ void CDataPack::PackCell(cell_t cell)
 	InternalPack val;
 	val.type = CDataPackType::Cell;
 	val.pData.cval = cell;
-	elements.insert(position++, val);
+	elements.emplace(elements.begin() + position, val);
+	position++;
 }
 
 void CDataPack::PackFunction(cell_t function)
@@ -102,7 +87,8 @@ void CDataPack::PackFunction(cell_t function)
 	InternalPack val;
 	val.type = CDataPackType::Function;
 	val.pData.cval = function;
-	elements.insert(position++, val);
+	elements.emplace(elements.begin() + position, val);
+	position++;
 }
 
 void CDataPack::PackFloat(float floatval)
@@ -110,16 +96,42 @@ void CDataPack::PackFloat(float floatval)
 	InternalPack val;
 	val.type = CDataPackType::Float;
 	val.pData.fval = floatval;
-	elements.insert(position++, val);
+	elements.emplace(elements.begin() + position, val);
+	position++;
 }
 
 void CDataPack::PackString(const char *string)
 {
 	InternalPack val;
 	val.type = CDataPackType::String;
-	ke::AString *sval = new ke::AString(string);
+	std::string *sval = new std::string(string);
 	val.pData.sval = sval;
-	elements.insert(position++, val);
+	elements.emplace(elements.begin() + position, val);
+	position++;
+}
+
+void CDataPack::PackCellArray(cell_t const *vals, cell_t count)
+{
+	InternalPack val;
+	val.type = CDataPackType::CellArray;
+
+	val.pData.aval = new cell_t [count + 1];
+	memcpy(&val.pData.aval[1], vals, sizeof(cell_t) * count);
+	val.pData.aval[0] = count;
+	elements.emplace(elements.begin() + position, val);
+	position++;
+}
+
+void CDataPack::PackFloatArray(cell_t const *vals, cell_t count)
+{
+	InternalPack val;
+	val.type = CDataPackType::FloatArray;
+
+	val.pData.aval = new cell_t [count + 1];
+	memcpy(&val.pData.aval[1], vals, sizeof(cell_t) * count);
+	val.pData.aval[0] = count;
+	elements.emplace(elements.begin() + position, val);
+	position++;
 }
 
 void CDataPack::Reset() const
@@ -134,7 +146,7 @@ size_t CDataPack::GetPosition() const
 
 bool CDataPack::SetPosition(size_t pos) const
 {
-	if (pos > elements.length())
+	if (pos > elements.size())
 		return false;
 
 	position = pos;
@@ -167,7 +179,7 @@ float CDataPack::ReadFloat() const
 
 bool CDataPack::IsReadable(size_t bytes) const
 {
-	return (position < elements.length());
+	return (position < elements.size());
 }
 
 const char *CDataPack::ReadString(size_t *len) const
@@ -180,11 +192,51 @@ const char *CDataPack::ReadString(size_t *len) const
 		return nullptr;
 	}
 
-	const ke::AString &val = *elements[position++].pData.sval;
+	const std::string &val = *elements[position++].pData.sval;
 	if (len)
-		*len = val.length();
+		*len = val.size();
 
-	return val.chars();
+	return val.c_str();
+}
+
+cell_t *CDataPack::ReadCellArray(cell_t *size) const
+{
+	if (!IsReadable() || elements[position].type != CDataPackType::CellArray)
+	{
+		if(size)
+			*size = 0;
+		
+		return nullptr;
+	}
+
+	cell_t *val = elements[position].pData.aval;
+	cell_t *ptr = &(val[1]);
+	++position;
+
+	if (size)
+		*size = val[0];
+
+	return ptr;
+}
+
+cell_t *CDataPack::ReadFloatArray(cell_t *size) const
+{
+	if (!IsReadable() || elements[position].type != CDataPackType::FloatArray)
+	{
+		if(size)
+			*size = 0;
+		
+		return nullptr;
+	}
+
+	cell_t *val = elements[position].pData.aval;
+	cell_t *ptr = &(val[1]);
+	++position;
+
+	if (size)
+		*size = val[0];
+
+	return ptr;
 }
 
 void *CDataPack::ReadMemory(size_t *size) const
@@ -205,7 +257,7 @@ void *CDataPack::ReadMemory(size_t *size) const
 
 bool CDataPack::RemoveItem(size_t pos)
 {
-	if (!elements.length())
+	if (!elements.size())
 	{
 		return false;
 	}
@@ -214,7 +266,8 @@ bool CDataPack::RemoveItem(size_t pos)
 	{
 		pos = position;
 	}
-	if (pos >= elements.length())
+	
+	if (pos >= elements.size())
 	{
 		return false;
 	}
@@ -228,7 +281,7 @@ bool CDataPack::RemoveItem(size_t pos)
 	{
 		case CDataPackType::Raw:
 		{
-			delete elements[pos].pData.vval;
+			delete [] elements[pos].pData.vval;
 			break;
 		}
 
@@ -237,8 +290,15 @@ bool CDataPack::RemoveItem(size_t pos)
 			delete elements[pos].pData.sval;
 			break;
 		}
+
+		case CDataPackType::CellArray:
+		case CDataPackType::FloatArray:
+		{
+			delete [] elements[pos].pData.aval;
+			break;
+		}
 	}
 
-	elements.remove(pos);
+	elements.erase(elements.begin() + pos);
 	return true;
 }

core/logic/CDataPack.h

@@ -43,7 +43,9 @@ enum CDataPackType {
 	Cell,
 	Float,
 	String,
-	Function
+	Function,
+	CellArray,
+	FloatArray,
 };
 
 class CDataPack
@@ -52,9 +54,6 @@ public:
 	CDataPack();
 	~CDataPack();
 
-    static CDataPack *New();
-    static void Free(CDataPack *pack);
-
 public: // Originally IDataReader
 	/**
 	 * @brief Resets the position in the data stream to the beginning.
@@ -90,6 +89,21 @@ public: // Originally IDataReader
 	 */
 	float ReadFloat() const;
 
+	/**
+	 * @brief Reads an array of values from the data stream.
+	 *
+	 * @param len       The size of the array stored at this position to return.
+	 * @return			A cell array read from the current position.
+	 */
+	cell_t *ReadCellArray(cell_t *len) const;
+	/**
+	 * @brief Reads an array of values from the data stream.
+	 *
+	 * @param len       The size of the array stored at this position to return.
+	 * @return			A cell array read from the current position.
+	 */
+	cell_t *ReadFloatArray(cell_t *len) const;
+
 	/**
 	 * @brief Returns whether or not a specified number of bytes from the current stream
 	 *  position to the end can be read.
@@ -150,6 +164,21 @@ public: // Originally IDataPack
 	 */
 	void PackString(const char *string);
 
+	/**
+	 * @brief Packs an array of cells into the data stream.
+	 *
+	 * @param vals		Cells to write.
+	 * @param count     Number of cells.
+	 */
+	void PackCellArray(cell_t const *vals, cell_t count);
+	/**
+	 * @brief Packs an array of cells into the data stream.
+	 *
+	 * @param vals		Cells to write.
+	 * @param count     Number of cells.
+	 */
+	void PackFloatArray(cell_t const *vals, cell_t count);
+
 	/**
 	 * @brief Creates a generic block of memory in the stream.
 	 *
@@ -172,7 +201,7 @@ public: // Originally IDataPack
 
 public:
 	void Initialize();
-	inline size_t GetCapacity() const { return this->elements.length(); };
+	inline size_t GetCapacity() const { return this->elements.size(); };
 	inline CDataPackType GetCurrentType(void) const { return this->elements[this->position].type; };
 	bool RemoveItem(size_t pos = -1);
 
@@ -181,7 +210,8 @@ private:
 		cell_t cval;
 		float fval;
 		uint8_t *vval;
-		ke::AString *sval;
+		std::string *sval;
+		cell_t *aval;
 	} InternalPackValue;
 	
 	typedef struct {
@@ -189,7 +219,7 @@ private:
 		CDataPackType type;
 	} InternalPack;
 
-	ke::Vector<InternalPack> elements;
+	std::vector<InternalPack> elements;
 	mutable size_t position;
 };
 

core/logic/CellArray.h

@@ -35,6 +35,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <ICellArray.h>
+#include <amtl/am-bits.h>
 
 extern HandleType_t htCellArray;
 
@@ -214,30 +215,34 @@ private:
 		{
 			return true;
 		}
+		size_t newAllocSize = m_AllocSize;
 		/* Set a base allocation size of 8 items */
-		if (!m_AllocSize)
+		if (!newAllocSize)
 		{
-			m_AllocSize = 8;
+			newAllocSize = 8;
+		}
+		if (!ke::IsUintPtrAddSafe(m_Size, count))
+		{
+			return false;
 		}
 		/* If it's not enough, keep doubling */
-		while (m_Size + count > m_AllocSize)
+		while (m_Size + count > newAllocSize)
 		{
-			m_AllocSize *= 2;
-		}
-		/* finally, allocate the new block */
-		if (m_Data)
-		{
-			cell_t *data = static_cast<cell_t*>(realloc(m_Data, sizeof(cell_t) * m_BlockSize * m_AllocSize));
-			if (!data)  // allocation failure
+			if (!ke::IsUintPtrMultiplySafe(newAllocSize, 2))
 			{
 				return false;
 			}
-
-			m_Data = data;
-		} else {
-			m_Data = static_cast<cell_t*>(malloc(sizeof(cell_t) * m_BlockSize * m_AllocSize));
+			newAllocSize *= 2;
 		}
-		return (m_Data != nullptr);
+		/* finally, allocate the new block */
+		cell_t *data = static_cast<cell_t*>(realloc(m_Data, sizeof(cell_t) * m_BlockSize * newAllocSize));
+		/* Update state if allocation was successful */
+		if (data)
+		{
+			m_AllocSize = newAllocSize;
+			m_Data = data;
+		}
+		return (data != nullptr);
 	}
 private:
 	cell_t *m_Data;

core/logic/Database.cpp

@@ -34,17 +34,20 @@
 #include "HandleSys.h"
 #include "ExtensionSys.h"
 #include "PluginSys.h"
+#include <chrono>
+#include <amtl/am-thread.h>
 #include <stdlib.h>
 #include <IThreader.h>
 #include <bridge/include/ILogger.h>
 #include <bridge/include/CoreProvider.h>
 
+using namespace std::chrono_literals;
+
 #define DBPARSE_LEVEL_NONE		0
 #define DBPARSE_LEVEL_MAIN		1
 #define DBPARSE_LEVEL_DATABASE	2
 
 DBManager g_DBMan;
-static bool s_OneTimeThreaderErrorMsg = false;
 
 DBManager::DBManager() 
 	: m_Terminate(false),
@@ -125,8 +128,8 @@ void DBManager::OnHandleDestroy(HandleType_t type, void *object)
 
 bool DBManager::Connect(const char *name, IDBDriver **pdr, IDatabase **pdb, bool persistent, char *error, size_t maxlength)
 {
-	ConfDbInfoList *list = m_Builder.GetConfigList();
-	ke::RefPtr<ConfDbInfo> pInfo = list->GetDatabaseConf(name);
+	ConfDbInfoList &list = m_Builder.GetConfigList();
+	ke::RefPtr<ConfDbInfo> pInfo = list.GetDatabaseConf(name);
 
 	if (!pInfo)
 	{
@@ -145,12 +148,12 @@ bool DBManager::Connect(const char *name, IDBDriver **pdr, IDatabase **pdb, bool
 		/* Try to assign a real driver pointer */
 		if (pInfo->info.driver[0] == '\0')
 		{
-			ke::AString defaultDriver = list->GetDefaultDriver();
+			std::string defaultDriver = list.GetDefaultDriver();
 			if (!m_pDefault && defaultDriver.length() > 0)
 			{
-				m_pDefault = FindOrLoadDriver(defaultDriver.chars());
+				m_pDefault = FindOrLoadDriver(defaultDriver.c_str());
 			}
-			dname = defaultDriver.length() ? defaultDriver.chars() : "default";
+			dname = defaultDriver.length() ? defaultDriver.c_str() : "default";
 			pInfo->realDriver = m_pDefault;
 		} else {
 			pInfo->realDriver = FindOrLoadDriver(pInfo->info.driver);
@@ -206,17 +209,14 @@ void DBManager::RemoveDriver(IDBDriver *pDriver)
 		}
 	}
 
-	ConfDbInfoList *list = m_Builder.GetConfigList();
-	for (size_t i = 0; i < list->length(); i++)
-	{
-		ke::RefPtr<ConfDbInfo> current = list->at(i);
-		if (current->realDriver == pDriver)
+	ConfDbInfoList &list = m_Builder.GetConfigList();
+	for (auto conf : list) {
+		if (conf->realDriver == pDriver)
 		{
-			current->realDriver = NULL;
+			conf->realDriver = NULL;
 		}
 	}
 
-
 	/* Someone unloaded the default driver? Silly.. */
 	if (pDriver == m_pDefault)
 	{
@@ -252,11 +252,11 @@ void DBManager::RemoveDriver(IDBDriver *pDriver)
 
 IDBDriver *DBManager::GetDefaultDriver()
 {
-	ConfDbInfoList *list = m_Builder.GetConfigList();
-	ke::AString defaultDriver = list->GetDefaultDriver();
+	ConfDbInfoList &list = m_Builder.GetConfigList();
+	std::string defaultDriver = list.GetDefaultDriver();
 	if (!m_pDefault && defaultDriver.length() > 0)
 	{
-		m_pDefault = FindOrLoadDriver(defaultDriver.chars());
+		m_pDefault = FindOrLoadDriver(defaultDriver.c_str());
 	}
 
 	return m_pDefault;
@@ -319,12 +319,12 @@ IDBDriver *DBManager::GetDriver(unsigned int index)
 
 const DatabaseInfo *DBManager::FindDatabaseConf(const char *name)
 {
-	ConfDbInfoList *list = m_Builder.GetConfigList();
-	ke::RefPtr<ConfDbInfo> info = list->GetDatabaseConf(name);
+	ConfDbInfoList &list = m_Builder.GetConfigList();
+	ke::RefPtr<ConfDbInfo> info = list.GetDatabaseConf(name);
 	if (!info)
 	{
 		// couldn't find requested conf, return default if exists
-		info = list->GetDefaultConfiguration();
+		info = list.GetDefaultConfiguration();
 		if (!info)
 		{
 			return NULL;
@@ -334,11 +334,10 @@ const DatabaseInfo *DBManager::FindDatabaseConf(const char *name)
 	return &info->info;
 }
 
-ConfDbInfo *DBManager::GetDatabaseConf(const char *name)
+ke::RefPtr<ConfDbInfo> DBManager::GetDatabaseConf(const char *name)
 {
-	ConfDbInfoList *list = m_Builder.GetConfigList();
-	ke::RefPtr<ConfDbInfo> info(list->GetDatabaseConf(name));
-	return info;
+	ConfDbInfoList &list = m_Builder.GetConfigList();
+	return list.GetDatabaseConf(name);
 }
 
 IDBDriver *DBManager::FindOrLoadDriver(const char *name)
@@ -377,13 +376,12 @@ void DBManager::KillWorkerThread()
 	if (m_Worker)
 	{
 		{
-			ke::AutoLock lock(&m_QueueEvent);
+			std::lock_guard<std::mutex> lock(m_Lock);
 			m_Terminate = true;
-			m_QueueEvent.Notify();
+			m_QueueEvent.notify_all();
 		}
-		m_Worker->Join();
+		m_Worker->join();
 		m_Worker = nullptr;
-		s_OneTimeThreaderErrorMsg = false;
 		m_Terminate = false;
 	}
 }
@@ -399,27 +397,17 @@ bool DBManager::AddToThreadQueue(IDBThreadOperation *op, PrioQueueLevel prio)
 
 	if (!m_Worker)
 	{
-		m_Worker = new ke::Thread([this]() -> void {
+		m_Worker = ke::NewThread("SM Database Worker", [this]() -> void {
 			Run();
-		}, "SM SQL Worker");
-		if (!m_Worker->Succeeded())
-		{
-			if (!s_OneTimeThreaderErrorMsg)
-			{
-				logger->LogError("[SM] Unable to create db threader (error unknown)");
-				s_OneTimeThreaderErrorMsg = true;
-			}
-			m_Worker = nullptr;
-			return false;
-		}
+		});
 	}
 
 	/* Add to the queue */
 	{
-		ke::AutoLock lock(&m_QueueEvent);
+		std::lock_guard<std::mutex> lock(m_Lock);
 		Queue<IDBThreadOperation *> &queue = m_OpQueue.GetQueue(prio);
 		queue.push(op);
-		m_QueueEvent.Notify();
+		m_QueueEvent.notify_one();
 	}
 
 	return true;
@@ -450,7 +438,7 @@ void DBManager::Run()
 
 void DBManager::ThreadMain()
 {
-	ke::AutoLock lock(&m_QueueEvent);
+	std::unique_lock<std::mutex> lock(m_Lock);
 
 	while (true) {
 		// The lock has been acquired. Grab everything we can out of the
@@ -458,46 +446,43 @@ void DBManager::ThreadMain()
 		// we process all operations we can before checking to terminate.
 		// There's no risk of starvation since the main thread blocks on us
 		// terminating.
-		while (true)
-		{
-			Queue<IDBThreadOperation *> &queue = m_OpQueue.GetLikelyQueue();
-			if (queue.empty())
-				break;
+		auto queue = &m_OpQueue.GetLikelyQueue();
+		if (queue->empty()) {
+			// If the queue is empty and we've been asked to stop, leave now.
+			if (m_Terminate)
+				return;
 
-			IDBThreadOperation *op = queue.first();
-			queue.pop();
-
-			// Unlock the queue when we run the query, so the main thread can
-			// keep pumping events. We re-acquire the lock to check for more
-			// items. It's okay if we terminate while unlocked; the main
-			// thread would be blocked and we'd need to flush the queue
-			// anyway, so after we've depleted the queue here, we'll just
-			// reach the terminate at the top of the loop.
-			{
-				ke::AutoUnlock unlock(&m_QueueEvent);
-				op->RunThreadPart();
-
-				ke::AutoLock lock(&m_ThinkLock);
-				m_ThinkQueue.push(op);
-			}
-			
-			
-			if (!m_Terminate)
-			{
-				ke::AutoUnlock unlock(&m_QueueEvent);
-#ifdef _WIN32
-				Sleep(20);
-#else
-				usleep(20000);
-#endif
-			}
+			// Otherwise, wait for something to happen.
+			m_QueueEvent.wait(lock);
+			continue;
 		}
 
-		if (m_Terminate)
-			return;
+		IDBThreadOperation *op = queue->first();
+		queue->pop();
 
-		// Release the lock and wait for a signal.
-		m_QueueEvent.Wait();
+		// Unlock the queue when we run the query, so the main thread can
+		// keep pumping events. We re-acquire the lock to check for more
+		// items. It's okay if we terminate while unlocked; the main
+		// thread would be blocked and we'd need to flush the queue
+		// anyway, so after we've depleted the queue here, we'll just
+		// reach the terminate at the top of the loop.
+		lock.unlock();
+		op->RunThreadPart();
+
+		// Re-acquire the lock and give the data back to the main thread
+		// immediately. We use a separate lock to minimize game thread
+		// contention.
+		{
+			std::lock_guard<std::mutex> think_lock(m_ThinkLock);
+			m_ThinkQueue.push(op);
+		}
+
+		// Note that we add a 20ms delay after processing a query. This is
+		// questionable but the intent is to avoid starving the game thread.
+		if (!m_Terminate)
+			std::this_thread::sleep_for(20ms);
+
+		lock.lock();
 	}
 }
 
@@ -512,7 +497,7 @@ void DBManager::RunFrame()
 	/* Dump one thing per-frame so the server stays sane. */
 	IDBThreadOperation *op;
 	{
-		ke::AutoLock lock(&m_ThinkLock);
+		std::lock_guard<std::mutex> lock(m_ThinkLock);
 		op = m_ThinkQueue.first();
 		m_ThinkQueue.pop();
 	}
@@ -591,10 +576,10 @@ void DBManager::OnPluginWillUnload(IPlugin *plugin)
 	}
 }
 
-ke::AString DBManager::GetDefaultDriverName()
+std::string DBManager::GetDefaultDriverName()
 {
-	ConfDbInfoList *list = m_Builder.GetConfigList();
-	return list->GetDefaultDriver();
+	ConfDbInfoList &list = m_Builder.GetConfigList();
+	return list.GetDefaultDriver();
 }
 
 void DBManager::AddDependency(IExtension *myself, IDBDriver *driver)

core/logic/Database.h

@@ -38,7 +38,10 @@
 #include <sh_list.h>
 #include <IThreader.h>
 #include <IPluginSys.h>
-#include <am-thread-utils.h>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <thread>
 #include "sm_simple_prioqueue.h"
 #include <am-refcounting.h>
 #include "DatabaseConfBuilder.h"
@@ -68,7 +71,7 @@ public: //IDBManager
 	void AddDriver(IDBDriver *pDrivera);
 	void RemoveDriver(IDBDriver *pDriver);
 	const DatabaseInfo *FindDatabaseConf(const char *name);
-	ConfDbInfo *GetDatabaseConf(const char *name);
+	ke::RefPtr<ConfDbInfo> GetDatabaseConf(const char *name);
 	bool Connect(const char *name, IDBDriver **pdr, IDatabase **pdb, bool persistent, char *error, size_t maxlength);
 	unsigned int GetDriverCount();
 	IDBDriver *GetDriver(unsigned int index);
@@ -84,7 +87,7 @@ public: //IPluginsListener
 public:
 	IDBDriver *FindOrLoadDriver(const char *name);
 	IDBDriver *GetDefaultDriver();
-	ke::AString GetDefaultDriverName();
+	std::string GetDefaultDriverName();
 	bool AddToThreadQueue(IDBThreadOperation *op, PrioQueueLevel prio);
 	void RunFrame();
 	inline HandleType_t GetDatabaseType()
@@ -101,9 +104,10 @@ private:
 	PrioQueue<IDBThreadOperation *> m_OpQueue;
 	Queue<IDBThreadOperation *> m_ThinkQueue;
 	CVector<bool> m_drSafety;			/* which drivers are safe? */
-	ke::AutoPtr<ke::Thread> m_Worker;
-	ke::ConditionVariable m_QueueEvent;
-	ke::Mutex m_ThinkLock;
+	std::unique_ptr<std::thread> m_Worker;
+	std::condition_variable m_QueueEvent;
+	std::mutex m_ThinkLock;
+	std::mutex m_Lock;
 	bool m_Terminate;
 
 	DatabaseConfBuilder m_Builder;

core/logic/DatabaseConfBuilder.cpp

@@ -36,8 +36,8 @@
 #define DBPARSE_LEVEL_DATABASE	2
 
 DatabaseConfBuilder::DatabaseConfBuilder()
-	: m_ParseList(nullptr),
-	  m_InfoList(new ConfDbInfoList())
+	: m_ParseList(),
+	  m_InfoList()
 {
 }
 
@@ -50,7 +50,7 @@ DatabaseConfBuilder::~DatabaseConfBuilder()
 {
 }
 
-ConfDbInfoList *DatabaseConfBuilder::GetConfigList()
+ConfDbInfoList &DatabaseConfBuilder::GetConfigList()
 {
 	return m_InfoList;
 }
@@ -59,9 +59,9 @@ void DatabaseConfBuilder::StartParse()
 {
 	SMCError err;
 	SMCStates states = {0, 0};
-	if ((err = textparsers->ParseFile_SMC(m_Filename.chars(), this, &states)) != SMCError_Okay)
+	if ((err = textparsers->ParseFile_SMC(m_Filename.c_str(), this, &states)) != SMCError_Okay)
 	{
-		logger->LogError("[SM] Detected parse error(s) in file \"%s\"", m_Filename.chars());
+		logger->LogError("[SM] Detected parse error(s) in file \"%s\"", m_Filename.c_str());
 		if (err != SMCError_Custom)
 		{
 			const char *txt = textparsers->GetSMCErrorString(err);
@@ -75,7 +75,7 @@ void DatabaseConfBuilder::ReadSMC_ParseStart()
 	m_ParseLevel = 0;
 	m_ParseState = DBPARSE_LEVEL_NONE;
 	
-	m_ParseList = new ConfDbInfoList();
+	m_ParseList.clear();
 }
  
 SMCResult DatabaseConfBuilder::ReadSMC_NewSection(const SMCStates *states, const char *name)
@@ -116,7 +116,7 @@ SMCResult DatabaseConfBuilder::ReadSMC_KeyValue(const SMCStates *states, const c
 	{
 		if (strcmp(key, "driver_default") == 0)
 		{
-			m_ParseList->SetDefaultDriver(value);
+			m_ParseList.SetDefaultDriver(value);
 		}
 	} else if (m_ParseState == DBPARSE_LEVEL_DATABASE) {
 		if (strcmp(key, "driver") == 0)
@@ -153,15 +153,15 @@ SMCResult DatabaseConfBuilder::ReadSMC_LeavingSection(const SMCStates *states)
 
 	if (m_ParseState == DBPARSE_LEVEL_DATABASE)
 	{
-		m_ParseCurrent->info.driver = m_ParseCurrent->driver.chars();
-		m_ParseCurrent->info.database = m_ParseCurrent->database.chars();
-		m_ParseCurrent->info.host = m_ParseCurrent->host.chars();
-		m_ParseCurrent->info.user = m_ParseCurrent->user.chars();
-		m_ParseCurrent->info.pass = m_ParseCurrent->pass.chars();
+		m_ParseCurrent->info.driver = m_ParseCurrent->driver.c_str();
+		m_ParseCurrent->info.database = m_ParseCurrent->database.c_str();
+		m_ParseCurrent->info.host = m_ParseCurrent->host.c_str();
+		m_ParseCurrent->info.user = m_ParseCurrent->user.c_str();
+		m_ParseCurrent->info.pass = m_ParseCurrent->pass.c_str();
 		
 		/* Save it.. */
 		m_ParseCurrent->AddRef();
-		m_ParseList->append(m_ParseCurrent);
+		m_ParseList.push_back(m_ParseCurrent);
 		m_ParseCurrent = nullptr;
 		
 		/* Go up one level */
@@ -176,9 +176,7 @@ SMCResult DatabaseConfBuilder::ReadSMC_LeavingSection(const SMCStates *states)
 
 void DatabaseConfBuilder::ReadSMC_ParseEnd(bool halted, bool failed)
 {
-	m_InfoList->ReleaseMembers();
-	delete m_InfoList;
+	m_InfoList.clear();
 	m_InfoList = m_ParseList;
-	
-	m_ParseList = nullptr;
+	m_ParseList.clear();
 }

core/logic/DatabaseConfBuilder.h

@@ -38,6 +38,7 @@
 
 #include <am-vector.h>
 #include <am-string.h>
+#include <am-refcounting.h>
 #include <am-refcounting-threadsafe.h>
 
 class ConfDbInfo : public ke::RefcountedThreadsafe<ConfDbInfo>
@@ -46,58 +47,53 @@ public:
 	ConfDbInfo() : realDriver(NULL)
 	{
 	}
-	ke::AString name;
-	ke::AString driver;
-	ke::AString host;
-	ke::AString user;
-	ke::AString pass;
-	ke::AString database;
+	std::string name;
+	std::string driver;
+	std::string host;
+	std::string user;
+	std::string pass;
+	std::string database;
 	IDBDriver *realDriver;
 	DatabaseInfo info;
 };
 
-class ConfDbInfoList : public ke::Vector<ConfDbInfo *>
+class ConfDbInfoList : public std::vector<ke::RefPtr<ConfDbInfo>>
 {
 	/* Allow internal usage of ConfDbInfoList */
 	friend class DBManager;
 	friend class DatabaseConfBuilder;
 private:
-	ke::AString& GetDefaultDriver() {
+	std::string& GetDefaultDriver() {
 		return m_DefDriver;
 	}
 	
-	ConfDbInfo *GetDatabaseConf(const char *name) {
-		for (size_t i = 0; i < this->length(); i++)
+	ke::RefPtr<ConfDbInfo> GetDatabaseConf(const char *name) {
+		for (size_t i = 0; i < this->size(); i++)
 		{
-			ConfDbInfo *current = this->at(i);
+			ke::RefPtr<ConfDbInfo> current = this->at(i);
 			/* If we run into the default configuration, then we'll save it
 			 * for the next call to GetDefaultConfiguration */ 
-			if (strcmp(current->name.chars(), "default") == 0)
+			if (strcmp(current->name.c_str(), "default") == 0)
 			{
 				m_DefaultConfig = current;
 			}
-			if (strcmp(current->name.chars(), name) == 0)
+			if (strcmp(current->name.c_str(), name) == 0)
 			{
 				return current;
 			}
 		}
 		return nullptr;
 	}
-	ConfDbInfo *GetDefaultConfiguration() {
+
+	ke::RefPtr<ConfDbInfo> GetDefaultConfiguration() {
 		return m_DefaultConfig;
 	}
 	void SetDefaultDriver(const char *input) {
-		m_DefDriver = ke::AString(input);
-	}
-	void ReleaseMembers() {
-		for (size_t i = 0; i < this->length(); i++) {
-			ConfDbInfo *current = this->at(i);
-			current->Release();
-		}
+		m_DefDriver = std::string(input);
 	}
 private:
-	ConfDbInfo *m_DefaultConfig;
-	ke::AString m_DefDriver;
+	ke::RefPtr<ConfDbInfo> m_DefaultConfig;
+	std::string m_DefDriver;
 };
 
 
@@ -108,7 +104,7 @@ public:
 	~DatabaseConfBuilder();
 	void StartParse();
 	void SetPath(char* path);
-	ConfDbInfoList *GetConfigList();
+	ConfDbInfoList &GetConfigList();
 public: //ITextListener_SMC
 	void ReadSMC_ParseStart();
 	SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name);
@@ -120,10 +116,10 @@ private:
 	unsigned int m_ParseLevel;
 	unsigned int m_ParseState;
 	ConfDbInfo *m_ParseCurrent;
-	ConfDbInfoList *m_ParseList;
+	ConfDbInfoList m_ParseList;
 private:
-	ke::AString m_Filename;
-	ConfDbInfoList *m_InfoList;
+	std::string m_Filename;
+	ConfDbInfoList m_InfoList;
 };
 
 #endif //_INCLUDE_DATABASE_CONF_BUILDER_H_

core/logic/DebugReporter.cpp

@@ -69,13 +69,13 @@ void DebugReport::GenerateErrorVA(IPluginContext *ctx, cell_t func_idx, int err,
 	ke::SafeVsprintf(buffer, sizeof(buffer), message, ap);
 
 	const char *plname = pluginsys->FindPluginByContext(ctx->GetContext())->GetFilename();
-	const char *error = g_pSourcePawn2->GetErrorString(err);
 
-	if (error)
-	{
-		g_Logger.LogError("[SM] Plugin \"%s\" encountered error %d: %s", plname, err, error);
-	} else {
-		g_Logger.LogError("[SM] Plugin \"%s\" encountered unknown error %d", plname, err);
+	if (err >= 0) {
+		const char *error = g_pSourcePawn2->GetErrorString(err);
+		if (error)
+			g_Logger.LogError("[SM] Plugin \"%s\" encountered error %d: %s", plname, err, error);
+		else
+			g_Logger.LogError("[SM] Plugin \"%s\" encountered unknown error %d", plname, err);
 	}
 
 	g_Logger.LogError("[SM] %s", buffer);
@@ -194,22 +194,22 @@ void DebugReport::ReportError(const IErrorReport &report, IFrameIterator &iter)
 		g_Logger.LogError("[SM] Blaming: %s", blame);
 	}
 
-	ke::Vector<ke::AString> arr = GetStackTrace(&iter);
-	for (size_t i = 0; i < arr.length(); i++)
+	std::vector<std::string> arr = GetStackTrace(&iter);
+	for (size_t i = 0; i < arr.size(); i++)
 	{
-		g_Logger.LogError("%s", arr[i].chars());
+		g_Logger.LogError("%s", arr[i].c_str());
 	}
 }
 
-ke::Vector<ke::AString> DebugReport::GetStackTrace(IFrameIterator *iter)
+std::vector<std::string> DebugReport::GetStackTrace(IFrameIterator *iter)
 {
 	char temp[3072];
-	ke::Vector<ke::AString> trace;
+	std::vector<std::string> trace;
 	iter->Reset();
 	
 	if (!iter->Done())
 	{
-		trace.append("[SM] Call stack trace:");
+		trace.push_back("[SM] Call stack trace:");
 
 		for (int index = 0; !iter->Done(); iter->Next(), index++) 
 		{
@@ -221,7 +221,7 @@ ke::Vector<ke::AString> DebugReport::GetStackTrace(IFrameIterator *iter)
 			if (iter->IsNativeFrame()) 
 			{
 				g_pSM->Format(temp, sizeof(temp), "[SM]   [%d] %s", index, fn);
-				trace.append(temp);
+				trace.push_back(temp);
 				continue;
 			}
 			if (iter->IsScriptedFrame()) 
@@ -237,7 +237,7 @@ ke::Vector<ke::AString> DebugReport::GetStackTrace(IFrameIterator *iter)
 						file,
 						fn);
 				
-				trace.append(temp);
+				trace.push_back(temp);
 			}
 		}
 	}

core/logic/DebugReporter.h

@@ -47,10 +47,12 @@ public: // IDebugListener
 	void ReportError(const IErrorReport &report, IFrameIterator &iter);
 	void OnDebugSpew(const char *msg, ...);
 public:
+	// If err is -1, caller assumes the automatic reporting by SourcePawn is
+	// good enough, and only wants the supplemental logging provided here.
 	void GenerateError(IPluginContext *ctx, cell_t func_idx, int err, const char *message, ...);
 	void GenerateErrorVA(IPluginContext *ctx, cell_t func_idx, int err, const char *message, va_list ap); 
 	void GenerateCodeError(IPluginContext *ctx, uint32_t code_addr, int err, const char *message, ...);
-	ke::Vector<ke::AString> GetStackTrace(IFrameIterator *iter);
+	std::vector<std::string> GetStackTrace(IFrameIterator *iter);
 private:
 	int _GetPluginIndex(IPluginContext *ctx);
 };

core/logic/ExtensionSys.cpp

@@ -30,6 +30,9 @@
  */
 
 #include <stdlib.h>
+
+#include <memory>
+
 #include "ExtensionSys.h"
 #include <ILibrarySys.h>
 #include <ISourceMod.h>
@@ -76,7 +79,7 @@ CLocalExtension::CLocalExtension(const char *filename, bool bRequired)
 		g_pSM->BuildPath(Path_SM,
 			path,
 			PLATFORM_MAX_PATH,
-			"extensions/%s." PLATFORM_LIB_EXT,
+			"extensions/" PLATFORM_ARCH_FOLDER "%s." PLATFORM_LIB_EXT,
 			filename);
 	}
 	else
@@ -85,7 +88,7 @@ CLocalExtension::CLocalExtension(const char *filename, bool bRequired)
 		g_pSM->BuildPath(Path_SM,
 			path,
 			PLATFORM_MAX_PATH,
-			"extensions/%s.%s." PLATFORM_LIB_EXT,
+			"extensions/" PLATFORM_ARCH_FOLDER "%s.%s." PLATFORM_LIB_EXT,
 			filename,
 			bridge->gamesuffix);
 
@@ -100,7 +103,7 @@ CLocalExtension::CLocalExtension(const char *filename, bool bRequired)
 				g_pSM->BuildPath(Path_SM,
 					path,
 					PLATFORM_MAX_PATH,
-					"extensions/%s.2.ep2v." PLATFORM_LIB_EXT,
+					"extensions/" PLATFORM_ARCH_FOLDER "%s.2.ep2v." PLATFORM_LIB_EXT,
 					filename);
 			}
 			else if (strcmp(bridge->gamesuffix, "2.nd") == 0)
@@ -108,7 +111,7 @@ CLocalExtension::CLocalExtension(const char *filename, bool bRequired)
 				g_pSM->BuildPath(Path_SM,
 					path,
 					PLATFORM_MAX_PATH,
-					"extensions/%s.2.l4d2." PLATFORM_LIB_EXT,
+					"extensions/" PLATFORM_ARCH_FOLDER "%s.2.l4d2." PLATFORM_LIB_EXT,
 					filename);
 			}
 
@@ -119,7 +122,7 @@ CLocalExtension::CLocalExtension(const char *filename, bool bRequired)
 				g_pSM->BuildPath(Path_SM,
 					path,
 					PLATFORM_MAX_PATH,
-					"extensions/auto.%s/%s." PLATFORM_LIB_EXT,
+					"extensions/" PLATFORM_ARCH_FOLDER "auto.%s/%s." PLATFORM_LIB_EXT,
 					filename,
 					bridge->gamesuffix);
 
@@ -129,7 +132,7 @@ CLocalExtension::CLocalExtension(const char *filename, bool bRequired)
 					g_pSM->BuildPath(Path_SM,
 						path,
 						PLATFORM_MAX_PATH,
-						"extensions/%s." PLATFORM_LIB_EXT,
+						"extensions/" PLATFORM_ARCH_FOLDER "%s." PLATFORM_LIB_EXT,
 						filename);
 				}
 			}
@@ -237,6 +240,8 @@ void CLocalExtension::Unload()
 		m_pLib->CloseLibrary();
 		m_pLib = NULL;
 	}
+
+	m_bFullyLoaded = false;
 }
 
 bool CRemoteExtension::Reload(char *error, size_t maxlength)
@@ -301,7 +306,7 @@ bool CExtension::Load(char *error, size_t maxlength)
 	/* Check if we're past load time */
 	if (!bridge->IsMapLoading())
 	{
-		m_pAPI->OnExtensionsAllLoaded();
+		MarkAllLoaded();
 	}
 
 	return true;
@@ -496,7 +501,7 @@ void CExtensionManager::TryAutoload()
 
 	g_pSM->BuildPath(Path_SM, path, sizeof(path), "extensions");
 
-	ke::AutoPtr<IDirectory> pDir(libsys->OpenDirectory(path));
+	std::unique_ptr<IDirectory> pDir(libsys->OpenDirectory(path));
 	if (!pDir)
 		return;
 
@@ -628,9 +633,15 @@ IExtension *CExtensionManager::FindExtensionByName(const char *ext)
 
 IExtension *CExtensionManager::LoadExtension(const char *file, char *error, size_t maxlength)
 {
+	if (strstr(file, "..") != NULL)
+	{
+		ke::SafeStrcpy(error, maxlength, "Cannot load extensions outside the \"extensions\" folder.");
+		return NULL;
+	}
+
 	/* Remove platform extension if it's there. Compat hack. */
 	const char *ext = libsys->GetFileExtension(file);
-	if (strcmp(ext, PLATFORM_LIB_EXT) == 0)
+	if (ext && strcmp(ext, PLATFORM_LIB_EXT) == 0)
 	{
 		char path2[PLATFORM_MAX_PATH];
 		ke::SafeStrcpy(path2, sizeof(path2), file);
@@ -1171,7 +1182,6 @@ void CExtensionManager::OnRootConsoleCommand(const char *cmdname, const ICommand
 						rootmenu->ConsolePrint(" -> %s", pPlugin->GetFilename());
 					}
 				}
-				srand(static_cast<int>(time(NULL)));
 				pExt->unload_code = (rand() % 877) + 123;	//123 to 999
 				rootmenu->ConsolePrint("[SM] To verify unloading %s, please use the following: ", pExt->GetFilename());
 				rootmenu->ConsolePrint("[SM] sm exts unload %d %d", num, pExt->unload_code);
@@ -1364,7 +1374,7 @@ bool CLocalExtension::IsSameFile(const char *file)
 
 bool CRemoteExtension::IsSameFile(const char *file)
 {
-	/* :TODO: this could be better, but no one uses this API anyway. */
-	return strcmp(file, m_Path.c_str()) == 0;
+	/* Check full path and name passed in from LoadExternal */
+	return strcmp(file, m_Path.c_str()) == 0 || strcmp(file, m_File.c_str()) == 0;
 }
 

core/logic/ForwardSys.cpp

@@ -61,7 +61,7 @@ IForward *CForwardManager::CreateForward(const char *name, ExecType et, unsigned
 	{
 		scripts->AddFunctionsToForward(name, fwd);
 
-		m_managed.append(fwd);
+		m_managed.push_back(fwd);
 	}
 
 	return fwd;
@@ -78,7 +78,7 @@ IChangeableForward *CForwardManager::CreateForwardEx(const char *name, ExecType
 
 	if (fwd)
 	{
-		m_unmanaged.append(fwd);
+		m_unmanaged.push_back(fwd);
 	}
 
 	return fwd;
@@ -751,9 +751,9 @@ bool CForward::AddFunction(IPluginFunction *func)
 		return false;
 
 	if (func->IsRunnable())
-		m_functions.append(func);
+		m_functions.push_back(func);
 	else
-		m_paused.append(func);
+		m_paused.push_back(func);
 
 	return true;
 }
@@ -780,7 +780,7 @@ const char *CForward::GetForwardName()
 
 unsigned int CForward::GetFunctionCount()
 {
-	return m_functions.length();
+	return m_functions.size();
 }
 
 ExecType CForward::GetExecType()

core/logic/FrameIterator.cpp

@@ -36,7 +36,7 @@ SafeFrameIterator::SafeFrameIterator(IFrameIterator *it)
 	while (!it->Done())
 	{
 		FrameInfo info = FrameInfo(it);
-		frames.append(info);
+		frames.push_back(info);
 		it->Next(); 
 	}
 	
@@ -46,7 +46,7 @@ SafeFrameIterator::SafeFrameIterator(IFrameIterator *it)
 
 bool SafeFrameIterator::Done() const
 {
-	return current >= frames.length();
+	return current >= frames.size();
 }
 
 bool SafeFrameIterator::Next()
@@ -77,7 +77,7 @@ const char *SafeFrameIterator::FunctionName() const
 		return NULL;
 	}
 
-	return frames[current].FunctionName.chars();
+	return frames[current].FunctionName.c_str();
 }
 
 const char *SafeFrameIterator::FilePath() const
@@ -87,5 +87,5 @@ const char *SafeFrameIterator::FilePath() const
 		return NULL;
 	}
 
-	return frames[current].FilePath.chars();
+	return frames[current].FilePath.c_str();
 }

core/logic/FrameIterator.h

@@ -48,16 +48,18 @@ public:
 	 */
 	struct FrameInfo
 	{	
-		ke::AString FunctionName;
-		ke::AString FilePath;
+		std::string FunctionName;
+		std::string FilePath;
 		unsigned LineNumber;
 
 		FrameInfo(IFrameIterator *it)
 		{		
 			LineNumber = it->LineNumber();
 			
-			FunctionName = it->FunctionName();
-			FilePath = it->FilePath();
+			if (it->FunctionName())
+				FunctionName = it->FunctionName();
+			if (it->FilePath())
+				FilePath = it->FilePath();
 		}
 	};
 
@@ -73,5 +75,5 @@ public:
 
 private:
 	size_t current;
-	ke::Vector<FrameInfo> frames;
-};
+	std::vector<FrameInfo> frames;
+};

core/logic/GameConfigs.cpp

@@ -85,15 +85,12 @@ static const char *g_pParseEngine = NULL;
 
 #if defined PLATFORM_WINDOWS
 #define PLATFORM_NAME				"windows" PLATFORM_ARCH_SUFFIX
-#define PLATFORM_SERVER_BINARY		"server.dll"
 #elif defined PLATFORM_LINUX
 #define PLATFORM_NAME				"linux" PLATFORM_ARCH_SUFFIX
 #define PLATFORM_COMPAT_ALT			"mac" PLATFORM_ARCH_SUFFIX	/* Alternate platform name if game data is missing for primary one */
-#define PLATFORM_SERVER_BINARY		"server_i486.so"
 #elif defined PLATFORM_APPLE
 #define PLATFORM_NAME				"mac" PLATFORM_ARCH_SUFFIX
 #define PLATFORM_COMPAT_ALT			"linux" PLATFORM_ARCH_SUFFIX
-#define PLATFORM_SERVER_BINARY		"server.dylib"
 #endif
 
 struct TempSigInfo
@@ -153,6 +150,23 @@ static inline bool IsPlatformCompatible(const char *platform, bool *hadPrimaryMa
 	return false;
 }
 
+static inline time_t GetFileModTime(const char *path)
+{
+	char filepath[PLATFORM_MAX_PATH];
+	g_pSM->BuildPath(Path_SM, filepath, sizeof(filepath), "gamedata/%s.txt", path);
+#ifdef PLATFORM_WINDOWS
+	struct _stat64 s;
+	if (_stat64(filepath, &s) != 0)
+#elif defined PLATFORM_POSIX
+	struct stat s;
+	if (stat(filepath, &s) != 0)
+#endif
+	{
+		return 0;
+	}
+	return s.st_mtime;
+}
+
 CGameConfig::CGameConfig(const char *file, const char *engine)
 {
 	strncopy(m_File, file, sizeof(m_File));
@@ -160,6 +174,8 @@ CGameConfig::CGameConfig(const char *file, const char *engine)
 	m_CustomLevel = 0;
 	m_CustomHandler = NULL;
 
+	m_ModTime = GetFileModTime(file);
+
 	if (!engine)
 		m_pEngine = bridge->GetSourceEngineName();
 	else
@@ -206,7 +222,7 @@ SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *n
 			{
 				bShouldBeReadingDefault = true;
 				m_ParseState = PSTATE_GAMEDEFS;
-				strncopy(m_Game, name, sizeof(m_Game));
+				m_Game = name;
 			} else {
 				m_IgnoreLevel++;
 			}
@@ -222,7 +238,7 @@ SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *n
 			{
 				m_ParseState = PSTATE_GAMEDEFS_KEYS;
 			}
-			else if ((strcmp(name, "#supported") == 0) && (strcmp(m_Game, "#default") == 0))
+			else if ((strcmp(name, "#supported") == 0) && (m_Game == "#default"))
 			{
 				m_ParseState = PSTATE_GAMEDEFS_SUPPORTED;
 				/* Ignore this section unless we get a game. */
@@ -261,23 +277,23 @@ SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *n
 		}
 	case PSTATE_GAMEDEFS_KEYS:
 		{
-			strncopy(m_Key, name, sizeof(m_Key));
+			m_Key = name;
 			m_ParseState = PSTATE_GAMEDEFS_KEYS_PLATFORM;
 			matched_platform = false;
 			break;
 		}
 	case PSTATE_GAMEDEFS_OFFSETS:
 		{
-			m_Prop[0] = '\0';
-			m_Class[0] = '\0';
-			strncopy(m_offset, name, sizeof(m_offset));
+			m_Prop.clear();
+			m_Class.clear();
+			m_offset = name;
 			m_ParseState = PSTATE_GAMEDEFS_OFFSETS_OFFSET;
 			matched_platform = false;
 			break;
 		}
 	case PSTATE_GAMEDEFS_SIGNATURES:
 		{
-			strncopy(m_offset, name, sizeof(m_offset));
+			m_offset = name;
 			s_TempSig.Reset();
 			m_ParseState = PSTATE_GAMEDEFS_SIGNATURES_SIG;
 			matched_platform = false;
@@ -296,7 +312,10 @@ SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *n
 				FILE *fp;
 				char path[PLATFORM_MAX_PATH];
 
-				g_pSM->BuildPath(Path_Game, path, sizeof(path), "bin/" PLATFORM_SERVER_BINARY);
+				char binName[64];
+				bridge->FormatSourceBinaryName(name, binName, sizeof(binName));
+
+				g_pSM->BuildPath(Path_Game, path, sizeof(path), "bin/%s", binName);
 				if ((fp = fopen(path, "rb")) == NULL)
 				{
 					ke::SafeSprintf(error, sizeof(error), "Could not open binary: %s", path);
@@ -319,7 +338,7 @@ SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *n
 			if (error[0] != '\0')
 			{
 				m_IgnoreLevel = 1;
-				logger->LogError("[SM] Error while parsing CRC section for \"%s\" (%s):", m_Game, m_CurFile);
+				logger->LogError("[SM] Error while parsing CRC section for \"%s\" (%s):", m_Game.c_str(), m_CurFile);
 				logger->LogError("[SM] %s", error);
 			} else {
 				m_ParseState = PSTATE_GAMEDEFS_CRC_BINARY;
@@ -334,12 +353,12 @@ SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *n
 		}
 	case PSTATE_GAMEDEFS_ADDRESSES:
 		{
-			m_Address[0] = '\0';
-			m_AddressSignature[0] = '\0';
+			m_Address.clear();
+			m_AddressSignature.clear();
 			m_AddressReadCount = 0;
 			m_AddressLastIsOffset = false;
 
-			strncopy(m_Address, name, sizeof(m_Address));
+			m_Address = name;
 			m_ParseState = PSTATE_GAMEDEFS_ADDRESSES_ADDRESS;
 
 			break;
@@ -355,7 +374,7 @@ SMCResult CGameConfig::ReadSMC_NewSection(const SMCStates *states, const char *n
 				if (strcmp(name, "linux") != 0 && strcmp(name, "windows") != 0 && strcmp(name, "mac") != 0 &&
 					strcmp(name, "linux64") != 0 && strcmp(name, "windows64") != 0 && strcmp(name, "mac64") != 0)
 				{
-					logger->LogError("[SM] Error while parsing Address section for \"%s\" (%s):", m_Address, m_CurFile);
+					logger->LogError("[SM] Error while parsing Address section for \"%s\" (%s):", m_Address.c_str(), m_CurFile);
 					logger->LogError("[SM] Unrecognized platform \"%s\"", name);
 				}
 				m_IgnoreLevel = 1;
@@ -392,21 +411,21 @@ SMCResult CGameConfig::ReadSMC_KeyValue(const SMCStates *states, const char *key
 	{
 		if (strcmp(key, "class") == 0)
 		{
-			strncopy(m_Class, value, sizeof(m_Class));
+			m_Class = value;
 		} else if (strcmp(key, "prop") == 0) {
-			strncopy(m_Prop, value, sizeof(m_Prop));
+			m_Prop = value;
 		} else if (IsPlatformCompatible(key, &matched_platform)) {
-			m_Offsets.replace(m_offset, atoi(value));
+			m_Offsets.replace(m_offset.c_str(), static_cast<int>(strtol(value, NULL, 0)));
 		}
 	} else if (m_ParseState == PSTATE_GAMEDEFS_KEYS) {
-		ke::AString vstr(value);
-		m_Keys.replace(key, ke::Move(vstr));
+		std::string vstr(value);
+		m_Keys.replace(key, std::move(vstr));
 	}
 	else if (m_ParseState == PSTATE_GAMEDEFS_KEYS_PLATFORM) {
 		if (IsPlatformCompatible(key, &matched_platform))
 		{
-			ke::AString vstr(value);
-			m_Keys.replace(m_Key, ke::Move(vstr));
+			std::string vstr(value);
+			m_Keys.replace(m_Key.c_str(), std::move(vstr));
 		}
 	} else if (m_ParseState == PSTATE_GAMEDEFS_SUPPORTED) {
 		if (strcmp(key, "game") == 0)
@@ -457,7 +476,7 @@ SMCResult CGameConfig::ReadSMC_KeyValue(const SMCStates *states, const char *key
 			int limit = sizeof(m_AddressRead)/sizeof(m_AddressRead[0]);
 			if (m_AddressLastIsOffset)
 			{
-				logger->LogError("[SM] Error parsing Address \"%s\", 'offset' entry must be the last entry (gameconf \"%s\")", m_Address, m_CurFile);
+				logger->LogError("[SM] Error parsing Address \"%s\", 'offset' entry must be the last entry (gameconf \"%s\")", m_Address.c_str(), m_CurFile);
 			}
 			else if (m_AddressReadCount < limit)
 			{
@@ -465,15 +484,15 @@ SMCResult CGameConfig::ReadSMC_KeyValue(const SMCStates *states, const char *key
 				{
 					m_AddressLastIsOffset = true;
 				}
-				m_AddressRead[m_AddressReadCount] = atoi(value);
+				m_AddressRead[m_AddressReadCount] = static_cast<int>(strtol(value, NULL, 0));
 				m_AddressReadCount++;
 			}
 			else
 			{
-				logger->LogError("[SM] Error parsing Address \"%s\", does not support more than %d read offsets (gameconf \"%s\")", m_Address, limit, m_CurFile);
+				logger->LogError("[SM] Error parsing Address \"%s\", does not support more than %d read offsets (gameconf \"%s\")", m_Address.c_str(), limit, m_CurFile);
 			}
 		} else if (strcmp(key, "signature") == 0) {
-			strncopy(m_AddressSignature, value, sizeof(m_AddressSignature));
+			m_AddressSignature = value;
 		}
 	} else if (m_ParseState == PSTATE_GAMEDEFS_CUSTOM) {
 		return m_CustomHandler->ReadSMC_KeyValue(states, key, value);
@@ -529,25 +548,24 @@ SMCResult CGameConfig::ReadSMC_LeavingSection(const SMCStates *states)
 	case PSTATE_GAMEDEFS_OFFSETS_OFFSET:
 		{
 			/* Parse the offset... */
-			if (m_Class[0] != '\0'
-				&& m_Prop[0] != '\0')
+			if (!m_Class.empty() && !m_Prop.empty())
 			{
-				SendProp *pProp = gamehelpers->FindInSendTable(m_Class, m_Prop);
+				SendProp *pProp = gamehelpers->FindInSendTable(m_Class.c_str(), m_Prop.c_str());
 				if (pProp)
 				{
 					int val = gamehelpers->GetSendPropOffset(pProp);
-					m_Offsets.replace(m_offset, val);
-					m_Props.replace(m_offset, pProp);
+					m_Offsets.replace(m_offset.c_str(), val);
+					m_Props.replace(m_offset.c_str(), pProp);
 				} else {
 					/* Check if it's a non-default game and no offsets exist */
-					if (((strcmp(m_Game, "*") != 0) && strcmp(m_Game, "#default") != 0)
-						&& (!m_Offsets.retrieve(m_offset)))
+					if ((m_Game != "*" && m_Game != "#default")
+						&& (!m_Offsets.retrieve(m_offset.c_str())))
 					{
 						logger->LogError("[SM] Unable to find property %s.%s (file \"%s\") (mod \"%s\")", 
-							m_Class,
-							m_Prop,
+							m_Class.c_str(),
+							m_Prop.c_str(),
 							m_CurFile,
-							m_Game);
+							m_Game.c_str());
 					}
 				}
 			}
@@ -655,7 +673,7 @@ SMCResult CGameConfig::ReadSMC_LeavingSection(const SMCStates *states)
 					}
 				}
 
-				m_Sigs.replace(m_offset, final_addr);
+				m_Sigs.replace(m_offset.c_str(), final_addr);
 			}
 
 			m_ParseState = PSTATE_GAMEDEFS_SIGNATURES;
@@ -671,10 +689,10 @@ SMCResult CGameConfig::ReadSMC_LeavingSection(const SMCStates *states)
 		{
 			m_ParseState = PSTATE_GAMEDEFS_ADDRESSES;
 
-			if (m_Address[0] != '\0' && m_AddressSignature[0] != '\0')
+			if (!m_Address.empty() && !m_AddressSignature.empty())
 			{
-				AddressConf addrConf(m_AddressSignature, sizeof(m_AddressSignature), m_AddressReadCount, m_AddressRead, m_AddressLastIsOffset);
-				m_Addresses.replace(m_Address, addrConf);
+				AddressConf addrConf(std::move(m_AddressSignature), m_AddressReadCount, m_AddressRead, m_AddressLastIsOffset);
+				m_Addresses.replace(m_Address.c_str(), addrConf);
 			}
 
 			break;
@@ -792,7 +810,10 @@ public:
 				(!had_game && matched_engine) ||
 				(matched_engine && matched_game))
 			{
-				fileList->push_back(cur_file);
+				if (fileList->find(cur_file) == fileList->end())
+				{
+					fileList->push_back(cur_file);
+				}
 			}
 			state = MSTATE_MAIN;
 		}
@@ -1001,10 +1022,10 @@ bool CGameConfig::GetOffset(const char *key, int *value)
 
 const char *CGameConfig::GetKeyValue(const char *key)
 {
-	StringHashMap<ke::AString>::Result r = m_Keys.find(key);
+	StringHashMap<std::string>::Result r = m_Keys.find(key);
 	if (!r.found())
 		return NULL;
-	return r->value.chars();
+	return r->value.c_str();
 }
 
 //memory addresses below 0x10000 are automatically considered invalid for dereferencing
@@ -1022,7 +1043,7 @@ bool CGameConfig::GetAddress(const char *key, void **retaddr)
 	AddressConf &addrConf = r->value;
 
 	void *addr;
-	if (!GetMemSig(addrConf.signatureName, &addr))
+	if (!GetMemSig(addrConf.signatureName.c_str(), &addr))
 	{
 		*retaddr = NULL;
 		return false;
@@ -1055,11 +1076,11 @@ static inline unsigned minOf(unsigned a, unsigned b)
 	return a <= b ? a : b;
 }
 
-CGameConfig::AddressConf::AddressConf(char *sigName, unsigned sigLength, unsigned readCount, int *read, bool lastIsOffset)
+CGameConfig::AddressConf::AddressConf(std::string&& sigName, unsigned readCount, int *read, bool lastIsOffset)
 {
 	unsigned readLimit = minOf(readCount, sizeof(this->read) / sizeof(this->read[0]));
 
-	strncopy(signatureName, sigName, sizeof(signatureName) / sizeof(signatureName[0]));
+	this->signatureName = std::move(sigName);
 	this->readCount = readLimit;
 	memcpy(&this->read[0], read, sizeof(this->read[0])*readLimit);
 
@@ -1132,9 +1153,17 @@ bool GameConfigManager::LoadGameConfigFile(const char *file, IGameConfig **_pCon
 
 	if (m_Lookup.retrieve(file, &pConfig))
 	{
+		bool ret = true;
+		time_t modtime = GetFileModTime(file);
+		if (pConfig->m_ModTime != modtime)
+		{
+			pConfig->m_ModTime = modtime;
+			ret = pConfig->Reparse(error, maxlength);
+		}
+
 		pConfig->AddRef();
 		*_pConfig = pConfig;
-		return true;
+		return ret;
 	}
 
 	pConfig = new CGameConfig(file);

core/logic/GameConfigs.h

@@ -81,16 +81,16 @@ private:
 	char m_CurFile[PLATFORM_MAX_PATH];
 	StringHashMap<int> m_Offsets;
 	StringHashMap<SendProp *> m_Props;
-	StringHashMap<ke::AString> m_Keys;
+	StringHashMap<std::string> m_Keys;
 	StringHashMap<void *> m_Sigs;
 	/* Parse states */
 	int m_ParseState;
 	unsigned int m_IgnoreLevel;
-	char m_Class[64];
-	char m_Prop[64];
-	char m_offset[64];
-	char m_Game[256];
-	char m_Key[64];
+	std::string m_Class;
+	std::string m_Prop;
+	std::string m_offset;
+	std::string m_Game;
+	std::string m_Key;
 	bool bShouldBeReadingDefault;
 	bool had_game;
 	bool matched_game;
@@ -105,24 +105,25 @@ private:
 	/* Support for reading Addresses */
 	struct AddressConf
 	{
-		char signatureName[64];
+		std::string signatureName;
 		int readCount;
 		int read[8];
 		bool lastIsOffset;
 
-		AddressConf(char *sigName, unsigned sigLength, unsigned readCount, int *read, bool lastIsOffset);
+		AddressConf(std::string&& sigName, unsigned readCount, int *read, bool lastIsOffset);
 
 		AddressConf() {}
 	};
 
-	char m_Address[64];
-	char m_AddressSignature[64];
+	std::string m_Address;
+	std::string m_AddressSignature;
 	int m_AddressReadCount;
 	int m_AddressRead[8];
 	bool m_AddressLastIsOffset;
 	StringHashMap<AddressConf> m_Addresses;
 	const char *m_pEngine;
 	const char *m_pBaseEngine;
+	time_t m_ModTime;
 };
 
 class GameConfigManager : 

core/logic/HandleSys.cpp

@@ -30,6 +30,7 @@
  */
 
 #include "HandleSys.h"
+#include <time.h>
 #include <assert.h>
 #include <string.h>
 #include "common_logic.h"
@@ -38,10 +39,20 @@
 #include "PluginSys.h"
 #include <am-string.h>
 #include <bridge/include/ILogger.h>
+#include <bridge/include/CoreProvider.h>
+#include <ISourceMod.h>
+
+#include "sm_platform.h"
+#ifdef PLATFORM_WINDOWS
+#include "sm_invalidparamhandler.h"
+#endif
+
+using namespace std::string_literals;
 
 HandleSystem g_HandleSys;
 
 QHandle *ignore_handle;
+extern ConVar *g_datetime_format;
 
 inline HandleType_t TypeParent(HandleType_t type)
 {
@@ -206,7 +217,7 @@ HandleType_t HandleSystem::CreateType(const char *name,
 	pType->dispatch = dispatch;
 	if (name && name[0] != '\0')
 	{
-		pType->name = new ke::AString(name);
+		pType->name = std::make_unique<std::string>(name);
 		m_TypeLookup.insert(name, pType);
 	}
 
@@ -290,6 +301,28 @@ HandleError HandleSystem::MakePrimHandle(HandleType_t type,
 		}
 	}
 
+	if (owner)
+	{
+		owner->num_handles++;
+		if (!owner->warned_handle_usage && owner->num_handles >= HANDLESYS_WARN_USAGE)
+		{
+			owner->warned_handle_usage = true;
+
+			std::string path = "<unknown>";
+			if (auto plugin = scripts->FindPluginByIdentity(owner))
+			{
+				path = "plugin "s + plugin->GetFilename();
+			}
+			else if (auto ext = g_Extensions.GetExtensionFromIdent(owner))
+			{
+				path = "extension "s + ext->GetFilename();
+			}
+
+			logger->LogError("[SM] Warning: %s is using more than %d handles!",
+				path.c_str(), HANDLESYS_WARN_USAGE);
+		}
+	}
+
 	QHandle *pHandle = &m_Handles[handle];
 	
 	assert(pHandle->set == false);
@@ -311,7 +344,7 @@ HandleError HandleSystem::MakePrimHandle(HandleType_t type,
 
 	/* Create the hash value */
 	Handle_t hash = pHandle->serial;
-	hash <<= 16;
+	hash <<= HANDLESYS_HANDLE_BITS;
 	hash |= handle;
 
 	/* Add a reference count to the type */
@@ -430,7 +463,7 @@ Handle_t HandleSystem::CreateHandleInt(HandleType_t type,
 
 	pHandle->object = object;
 	pHandle->clone = 0;
-
+	pHandle->timestamp = g_pSM->GetAdjustedTime();
 	return handle;
 }
 
@@ -475,7 +508,7 @@ HandleError HandleSystem::GetHandle(Handle_t handle,
 									unsigned int *in_index,
 									bool ignoreFree)
 {
-	unsigned int serial = (handle >> 16);
+	unsigned int serial = (handle >> HANDLESYS_HANDLE_BITS);
 	unsigned int index = (handle & HANDLESYS_HANDLE_MASK);
 
 	if (index == 0 || index > m_HandleTail || index > HANDLESYS_MAX_HANDLES)
@@ -631,7 +664,7 @@ Handle_t HandleSystem::FastCloneHandle(Handle_t hndl)
 void HandleSystem::GetHandleUnchecked(Handle_t hndl, QHandle *& pHandle, unsigned int &index)
 {
 #ifndef NDEBUG
-	unsigned int serial = (hndl >> 16);
+	unsigned int serial = (hndl >> HANDLESYS_HANDLE_BITS);
 #endif
 	index = (hndl & HANDLESYS_HANDLE_MASK);
 
@@ -655,6 +688,9 @@ HandleError HandleSystem::FreeHandle(QHandle *pHandle, unsigned int index)
 
 	QHandleType *pType = &m_Types[pHandle->type];
 
+	if (pHandle->owner && pHandle->owner->num_handles > 0)
+		pHandle->owner->num_handles--;
+
 	if (pHandle->clone)
 	{
 		/* If we're a clone, decrease the parent reference count */
@@ -925,7 +961,7 @@ bool HandleSystem::RemoveType(HandleType_t type, IdentityToken_t *ident)
 
 	/* Remove it from the type cache. */
 	if (pType->name)
-		m_TypeLookup.remove(pType->name->chars());
+		m_TypeLookup.remove(pType->name->c_str());
 
 	return true;
 }
@@ -1014,6 +1050,8 @@ bool HandleSystem::TryAndFreeSomeHandles()
 	unsigned int * pCount = new unsigned int[HANDLESYS_TYPEARRAY_SIZE+1];
 	memset(pCount, 0, ((HANDLESYS_TYPEARRAY_SIZE + 1) * sizeof(unsigned int)));
 
+	const QHandle *oldest = nullptr;
+	const QHandle *newest = nullptr;
 	for (unsigned int i = 1; i <= m_HandleTail; ++i)
 	{
 		const QHandle &Handle = m_Handles[i];
@@ -1030,6 +1068,15 @@ bool HandleSystem::TryAndFreeSomeHandles()
 			highest_index = ((Handle.type) + 1);
 		}
 
+		if (!oldest || oldest->timestamp > Handle.timestamp)
+		{
+			oldest = &Handle;
+		}
+		if (!newest || newest->timestamp < Handle.timestamp)
+		{
+			newest = &Handle;
+		}
+		
 		if (Handle.clone != 0)
 		{
 			continue;
@@ -1051,13 +1098,39 @@ bool HandleSystem::TryAndFreeSomeHandles()
 		}
 
 		if (m_Types[i].name)
-			pTypeName = m_Types[i].name->chars();
+			pTypeName = m_Types[i].name->c_str();
 		else
 			pTypeName = "ANON";
 
 		HANDLE_LOG_VERY_BAD("Type\t%-20.20s|\tCount\t%u", pTypeName, pCount[i]);
 	}
+	
+	const char *fmt = bridge->GetCvarString(g_datetime_format);
 
+	char oldstamp[256], newstamp[256]; // 256 should be more than enough
+
+	// scope for InvalidParameterHandler
+	{
+#ifdef PLATFORM_WINDOWS
+		InvalidParameterHandler p;
+#endif
+		size_t written = strftime(oldstamp, sizeof(oldstamp), fmt, localtime(&oldest->timestamp));
+		if (!written)
+		{
+			ke::SafeStrcpy(oldstamp, sizeof(oldstamp), "INVALID");
+		}
+
+		written = strftime(newstamp, sizeof(newstamp), fmt, localtime(&newest->timestamp));
+		if (!written)
+		{
+			ke::SafeStrcpy(newstamp, sizeof(newstamp), "INVALID");
+		}
+	}
+
+
+	HANDLE_LOG_VERY_BAD("--------------------------------------------------------------------------");
+	HANDLE_LOG_VERY_BAD("Oldest Living Handle: %s created at %s", m_Types[oldest->type].name->c_str(), oldstamp);
+	HANDLE_LOG_VERY_BAD("Newest Living Handle: %s created at %s", m_Types[newest->type].name->c_str(), newstamp);
 	HANDLE_LOG_VERY_BAD("-- Approximately %d bytes of memory are in use by (%u) Handles.\n", total_size, total);
 	delete [] pCount;
 
@@ -1081,8 +1154,10 @@ static void rep(const HandleReporter &fn, const char *fmt, ...)
 void HandleSystem::Dump(const HandleReporter &fn)
 {
 	unsigned int total_size = 0;
-	rep(fn, "%-10.10s\t%-20.20s\t%-20.20s\t%-10.10s", "Handle", "Owner", "Type", "Memory");
-	rep(fn, "--------------------------------------------------------------------------");
+	rep(fn, "%-10.10s\t%-20.20s\t%-20.20s\t%-10.10s\t%-30.30s", "Handle", "Owner", "Type", "Memory", "Time Created");
+	rep(fn, "---------------------------------------------------------------------------------------------");
+	
+	const char *fmt = bridge->GetCvarString(g_datetime_format);
 	for (unsigned int i = 1; i <= m_HandleTail; i++)
 	{
 		if (m_Handles[i].set != HandleSet_Used)
@@ -1090,12 +1165,12 @@ void HandleSystem::Dump(const HandleReporter &fn)
 			continue;
 		}
 		/* Get the index */
-		unsigned int index = (m_Handles[i].serial << 16) | i;
+		unsigned int index = (m_Handles[i].serial << HANDLESYS_HANDLE_BITS) | i;
 		/* Determine the owner */
 		const char *owner = "UNKNOWN";
 		if (m_Handles[i].owner)
 		{
-			IdentityToken_t *pOwner = m_Handles[i].owner;
+			IdentityToken_t	*pOwner = m_Handles[i].owner;
 			if (pOwner == g_pCoreIdent)
 			{
 				owner = "CORE";
@@ -1131,7 +1206,7 @@ void HandleSystem::Dump(const HandleReporter &fn)
 		unsigned int parentIdx;
 		bool bresult;
 		if (pType->name)
-			type = pType->name->chars();
+			type = pType->name->c_str();
 
 		if ((parentIdx = m_Handles[i].clone) != 0)
 		{
@@ -1150,19 +1225,33 @@ void HandleSystem::Dump(const HandleReporter &fn)
 			bresult = pType->dispatch->GetHandleApproxSize(m_Handles[i].type, m_Handles[i].object, &size);
 		}
 
+		char date[256]; // 256 should be more than enough
+		size_t written = 0;
+		// scope for InvalidParameterHandler
+		{
+#ifdef PLATFORM_WINDOWS
+			InvalidParameterHandler p;
+#endif
+			written = strftime(date, sizeof(date), fmt, localtime(&m_Handles[i].timestamp));
+		}
+
+		if (!written)
+		{
+			ke::SafeStrcpy(date, sizeof(date), "INVALID");
+		}
+
 		if (pType->dispatch->GetDispatchVersion() < HANDLESYS_MEMUSAGE_MIN_VERSION
 			|| !bresult)
 		{
-			rep(fn, "0x%08x\t%-20.20s\t%-20.20s\t%-10.10s", index, owner, type, "-1");
+			rep(fn, "0x%08x\t%-20.20s\t%-20.20s\t%-10.10s\t%-30.30s", index, owner, type, "-1", date);
 		}
 		else
 		{
 			char buffer[32];
 			ke::SafeSprintf(buffer, sizeof(buffer), "%d", size);
-			rep(fn, "0x%08x\t%-20.20s\t%-20.20s\t%-10.10s", index, owner, type, buffer);
+			rep(fn, "0x%08x\t%-20.20s\t%-20.20s\t%-10.10s\t%-30.30s", index, owner, type, buffer, date);
 			total_size += size;
 		}
 	}
 	rep(fn, "-- Approximately %d bytes of memory are in use by Handles.\n", total_size);
 }
-

core/logic/HandleSys.h

@@ -32,22 +32,27 @@
 #ifndef _INCLUDE_SOURCEMOD_HANDLESYSTEM_H_
 #define _INCLUDE_SOURCEMOD_HANDLESYSTEM_H_
 
-#include <IHandleSys.h>
 #include <stdio.h>
-#include <sm_namehashset.h>
-#include <amtl/am-autoptr.h>
+
+#include <memory>
+
 #include <amtl/am-string.h>
 #include <amtl/am-function.h>
+#include <IHandleSys.h>
+#include <sm_namehashset.h>
 #include "common_logic.h"
 
-#define HANDLESYS_MAX_HANDLES		(1<<15)
+#define HANDLESYS_HANDLE_BITS   20
+#define HANDLESYS_MAX_HANDLES		((1 << HANDLESYS_HANDLE_BITS) - 1)
 #define HANDLESYS_MAX_TYPES			(1<<9)
 #define HANDLESYS_MAX_SUBTYPES		0xF
 #define HANDLESYS_SUBTYPE_MASK		0xF
 #define HANDLESYS_TYPEARRAY_SIZE	(HANDLESYS_MAX_TYPES * (HANDLESYS_MAX_SUBTYPES + 1))
-#define HANDLESYS_MAX_SERIALS		0xFFFF
-#define HANDLESYS_SERIAL_MASK		0xFFFF0000
-#define HANDLESYS_HANDLE_MASK		0x0000FFFF
+#define HANDLESYS_SERIAL_BITS		(32 - HANDLESYS_HANDLE_BITS)
+#define HANDLESYS_MAX_SERIALS		(1 << HANDLESYS_SERIAL_BITS)
+#define HANDLESYS_SERIAL_MASK		(((1 << HANDLESYS_SERIAL_BITS) - 1) << HANDLESYS_HANDLE_BITS)
+#define HANDLESYS_HANDLE_MASK		((1 << HANDLESYS_HANDLE_BITS) - 1)
+#define HANDLESYS_WARN_USAGE		100000
 
 #define HANDLESYS_MEMUSAGE_MIN_VERSION		3
 
@@ -88,6 +93,7 @@ struct QHandle
 	bool access_special;		/* Whether or not access rules are special or type-derived */
 	bool is_destroying;			/* Whether or not the handle is being destroyed */
 	HandleAccess sec;			/* Security rules */
+	time_t timestamp;			/* Creation timestamp */
 	/* The following variables are unrelated to the Handle array, and used 
 	 * as an inlined chain of information */
 	unsigned int freeID;		/* ID of a free handle in the free handle chain */
@@ -105,7 +111,7 @@ struct QHandleType
 	TypeAccess typeSec;
 	HandleAccess hndlSec;
 	unsigned int opened;
-	ke::AutoPtr<ke::AString> name;
+	std::unique_ptr<std::string> name;
 
 	static inline bool matches(const char *key, const QHandleType *type)
 	{
@@ -117,7 +123,7 @@ struct QHandleType
 	}
 };
 
-typedef ke::Lambda<void(const char *)> HandleReporter;
+typedef ke::Function<void(const char *)> HandleReporter;
 
 class HandleSystem : 
 	public IHandleSys

core/logic/Logger.cpp

@@ -319,7 +319,7 @@ void Logger::_UpdateFiles(bool bLevelChange)
 	char buff[PLATFORM_MAX_PATH];
 	ke::SafeSprintf(buff, sizeof(buff), "%04d%02d%02d", curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday);
 
-	ke::AString currentDate(buff);
+	std::string currentDate(buff);
 
 	if (m_Mode == LoggingMode_PerMap)
 	{
@@ -327,7 +327,7 @@ void Logger::_UpdateFiles(bool bLevelChange)
 		{
 			for (size_t iter = 0; iter < static_cast<size_t>(-1); ++iter)
 			{
-				g_pSM->BuildPath(Path_SM, buff, sizeof(buff), "logs/L%s%u.log", currentDate.chars(), iter);
+				g_pSM->BuildPath(Path_SM, buff, sizeof(buff), "logs/L%s%u.log", currentDate.c_str(), iter);
 				if (!libsys->IsPathFile(buff))
 				{
 					break;
@@ -336,12 +336,12 @@ void Logger::_UpdateFiles(bool bLevelChange)
 		}
 		else
 		{
-			ke::SafeStrcpy(buff, sizeof(buff), m_NormalFileName.chars());
+			ke::SafeStrcpy(buff, sizeof(buff), m_NormalFileName.c_str());
 		}
 	}
 	else
 	{
-		g_pSM->BuildPath(Path_SM, buff, sizeof(buff), "logs/L%s.log", currentDate.chars());
+		g_pSM->BuildPath(Path_SM, buff, sizeof(buff), "logs/L%s.log", currentDate.c_str());
 	}
 
 	if (m_NormalFileName.compare(buff))
@@ -353,11 +353,11 @@ void Logger::_UpdateFiles(bool bLevelChange)
 	{
 		if (bLevelChange)
 		{
-			LogMessage("-------- Mapchange to %s --------", m_CurrentMapName.chars());
+			LogMessage("-------- Mapchange to %s --------", m_CurrentMapName.c_str());
 		}
 	}
 
-	g_pSM->BuildPath(Path_SM, buff, sizeof(buff), "logs/errors_%s.log", currentDate.chars());
+	g_pSM->BuildPath(Path_SM, buff, sizeof(buff), "logs/errors_%s.log", currentDate.c_str());
 	if (bLevelChange || m_ErrorFileName.compare(buff))
 	{
 		_CloseError();
@@ -369,7 +369,7 @@ FILE *Logger::_OpenNormal()
 {
 	_UpdateFiles();
 
-	FILE *pFile = fopen(m_NormalFileName.chars(), "a+");
+	FILE *pFile = fopen(m_NormalFileName.c_str(), "a+");
 	if (pFile == NULL)
 	{
 		_LogFatalOpen(m_NormalFileName);
@@ -383,7 +383,7 @@ FILE *Logger::_OpenNormal()
 		char date[32];
 
 		strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);
-		fprintf(pFile, "L %s: SourceMod log file session started (file \"%s\") (Version \"%s\")\n", date, m_NormalFileName.chars(), SOURCEMOD_VERSION);
+		fprintf(pFile, "L %s: SourceMod log file session started (file \"%s\") (Version \"%s\")\n", date, m_NormalFileName.c_str(), SOURCEMOD_VERSION);
 		m_DamagedNormalFile = true;
 	}
 
@@ -394,7 +394,7 @@ FILE *Logger::_OpenError()
 {
 	_UpdateFiles();
 
-	FILE *pFile = fopen(m_ErrorFileName.chars(), "a+");
+	FILE *pFile = fopen(m_ErrorFileName.c_str(), "a+");
 	if (pFile == NULL)
 	{
 		_LogFatalOpen(m_ErrorFileName);
@@ -409,7 +409,7 @@ FILE *Logger::_OpenError()
 		char date[32];
 		strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);
 		fprintf(pFile, "L %s: SourceMod error session started\n", date);
-		fprintf(pFile, "L %s: Info (map \"%s\") (file \"%s\")\n", date, m_CurrentMapName.chars(), m_ErrorFileName.chars());
+		fprintf(pFile, "L %s: Info (map \"%s\") (file \"%s\")\n", date, m_CurrentMapName.c_str(), m_ErrorFileName.c_str());
 		m_DamagedErrorFile = true;
 	}
 
@@ -423,11 +423,11 @@ FILE *Logger::_OpenFatal()
 	return fopen(path, "at");
 }
 
-void Logger::_LogFatalOpen(ke::AString &str)
+void Logger::_LogFatalOpen(std::string &str)
 {
 	char error[255];
 	libsys->GetPlatformError(error, sizeof(error));
-	LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", str.chars());
+	LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", str.c_str());
 	LogFatal("[SM] Platform returned error: \"%s\"", error);
 }
 

core/logic/Logger.h

@@ -92,13 +92,13 @@ private:
 	FILE *_OpenError();
 	FILE *_OpenFatal();
 
-	void _LogFatalOpen(ke::AString &str);
+	void _LogFatalOpen(std::string &str);
 	void _PrintToGameLog(const char *fmt, va_list ap);
 	void _UpdateFiles(bool bLevelChange = false);
 private:
-	ke::AString m_NormalFileName;
-	ke::AString m_ErrorFileName;
-	ke::AString m_CurrentMapName;
+	std::string m_NormalFileName;
+	std::string m_ErrorFileName;
+	std::string m_CurrentMapName;
 
 	int m_Day;
 

core/logic/LumpManager.cpp

@@ -0,0 +1,131 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * Entity Lump Manager
+ * Copyright (C) 2021-2022 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include "LumpManager.h"
+
+#include <iomanip>
+#include <sstream>
+
+EntityLumpParseResult::operator bool() const {
+	return m_Status == Status_OK;
+}
+
+EntityLumpParseResult EntityLumpManager::Parse(const char* pMapEntities) {
+	m_Entities.clear();
+	
+	std::istringstream mapEntities(pMapEntities);
+	
+	for (;;) {
+		std::string token;
+		mapEntities >> std::ws >> token >> std::ws;
+		
+		// Assert that we're at the start of a new block, otherwise we're done parsing
+		if (token != "{") {
+			if (token == "\0") {
+				break;
+			} else {
+				return EntityLumpParseResult {
+					Status_UnexpectedChar, mapEntities.tellg()
+				};
+			}
+		}
+		
+		/**
+		 * Parse key / value pairs until we reach a closing brace.  We currently assume there
+		 * are only quoted keys / values up to the next closing brace.
+		 *
+		 * The SDK suggests that there are cases that could use non-quoted symbols and nested
+		 * braces (`shared/mapentities_shared.cpp::MapEntity_ParseToken`), but I haven't seen
+		 * those in practice.
+		 */
+		EntityLumpEntry entry;
+		while (mapEntities.peek() != '}') {
+			std::string key, value;
+			
+			if (mapEntities.peek() != '"') {
+				return EntityLumpParseResult {
+					Status_UnexpectedChar, mapEntities.tellg()
+				};
+			}
+			mapEntities >> quoted(key) >> std::ws;
+			
+			if (mapEntities.peek() != '"') {
+				return EntityLumpParseResult {
+					Status_UnexpectedChar, mapEntities.tellg()
+				};
+			}
+			mapEntities >> quoted(value) >> std::ws;
+			
+			entry.emplace_back(key, value);
+		}
+		mapEntities.get();
+		m_Entities.push_back(std::make_shared<EntityLumpEntry>(entry));
+	}
+	
+	return EntityLumpParseResult{};
+}
+
+std::string EntityLumpManager::Dump() {
+	std::ostringstream stream;
+	for (const auto& entry : m_Entities) {
+		// ignore empty entries
+		if (entry->empty()) {
+			continue;
+		}
+		stream << "{\n";
+		for (const auto& pair : *entry) {
+			stream << '"' << pair.first << "\" \"" << pair.second << '"' << '\n';
+		}
+		stream << "}\n";
+	}
+	return stream.str();
+}
+
+std::weak_ptr<EntityLumpEntry> EntityLumpManager::Get(size_t index) {
+	return m_Entities[index];
+}
+
+void EntityLumpManager::Erase(size_t index) {
+	m_Entities.erase(m_Entities.begin() + index);
+}
+
+void EntityLumpManager::Insert(size_t index) {
+	m_Entities.emplace(m_Entities.begin() + index, std::make_shared<EntityLumpEntry>());
+}
+
+size_t EntityLumpManager::Append() {
+	auto it = m_Entities.emplace(m_Entities.end(), std::make_shared<EntityLumpEntry>());
+	return std::distance(m_Entities.begin(), it);
+}
+
+size_t EntityLumpManager::Length() {
+	return m_Entities.size();
+}

core/logic/LumpManager.h

@@ -0,0 +1,116 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * Entity Lump Manager
+ * Copyright (C) 2021-2022 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_LUMPMANAGER_H_
+#define _INCLUDE_LUMPMANAGER_H_
+
+#include <vector>
+#include <memory>
+#include <string>
+
+/**
+ * Entity lump manager.  Provides a list that stores a list of key / value pairs and the
+ * functionality to (de)serialize it from / to an entity string.
+ * This file and its corresponding .cpp should be compilable independently of SourceMod;
+ * the SourceMod interop is located within smn_entitylump.
+ *
+ * @file lumpmanager.h
+ * @brief Class definition for object that parses lumps.
+ */
+
+/**
+ * @brief A container of key / value pairs.
+ */
+using EntityLumpEntry = std::vector<std::pair<std::string, std::string>>;
+
+enum EntityLumpParseStatus {
+	Status_OK,
+	Status_UnexpectedChar,
+};
+
+/**
+ * @brief Result of parsing an entity lump.  On a parse error, m_Status is not Status_OK and
+ * m_Position indicates the offset within the string that caused the parse error.
+ */
+struct EntityLumpParseResult {
+	EntityLumpParseStatus m_Status;
+	std::streamoff m_Position;
+	
+	operator bool() const;
+	const char* Description() const;
+};
+
+/**
+ * @brief Manages entity lump entries.
+ */
+class EntityLumpManager
+{
+public:
+	/**
+	 * @brief Parses the map entities string into an internal representation.
+	 */
+	EntityLumpParseResult Parse(const char* pMapEntities);
+	
+	/**
+	 * @brief Dumps the current internal representation out to an std::string.
+	 */
+	std::string Dump();
+
+	/**
+	 * @brief Returns a weak reference to an EntityLumpEntry.  Used for handles on the scripting side.
+	 */
+	std::weak_ptr<EntityLumpEntry> Get(size_t index);
+
+	/**
+	 * @brief Removes an EntityLumpEntry at the given index, shifting down all entries after it by one.
+	 */
+	void Erase(size_t index);
+
+	/**
+	 * @brief Inserts a new EntityLumpEntry at the given index, shifting up the entries previously at the index and after it up by one.
+	 */
+	void Insert(size_t index);
+
+	/**
+	 * @brief Adds a new EntityLumpEntry to the end.  Returns the index of the entry.
+	 */
+	size_t Append();
+
+	/**
+	 * @brief Returns the number of EntityLumpEntry items in the list.
+	 */
+	size_t Length();
+
+private:
+	std::vector<std::shared_ptr<EntityLumpEntry>> m_Entities;
+};
+
+#endif // _INCLUDE_LUMPMANAGER_H_

core/logic/MemoryUtils.cpp

@@ -49,6 +49,7 @@ MemoryUtils g_MemUtils;
 
 MemoryUtils::MemoryUtils()
 {
+	m_InfoMap.init();
 #ifdef PLATFORM_APPLE
 
 	task_dyld_info_data_t dyld_info;
@@ -77,20 +78,19 @@ void MemoryUtils::OnSourceModAllInitialized()
 
 void *MemoryUtils::FindPattern(const void *libPtr, const char *pattern, size_t len)
 {
-	DynLibInfo lib;
-	bool found;
-	char *ptr, *end;
+	const DynLibInfo* lib = nullptr;
 
-	memset(&lib, 0, sizeof(DynLibInfo));
-
-	if (!GetLibraryInfo(libPtr, lib))
+	if ((lib = GetLibraryInfo(libPtr)) == nullptr)
 	{
 		return NULL;
 	}
 
-	ptr = reinterpret_cast<char *>(lib.baseAddress);
-	end = ptr + lib.memorySize - len;
+	// Search in the original unaltered state of the binary.
+	char *start = lib->originalCopy.get();
+	char *ptr = start;
+	char *end = ptr + lib->memorySize - len;
 
+	bool found;
 	while (ptr < end)
 	{
 		found = true;
@@ -103,8 +103,9 @@ void *MemoryUtils::FindPattern(const void *libPtr, const char *pattern, size_t l
 			}
 		}
 
+		// Translate the found offset into the actual live binary memory space.
 		if (found)
-			return ptr;
+			return reinterpret_cast<char *>(lib->baseAddress) + (ptr - start);
 
 		ptr++;
 	}
@@ -116,6 +117,8 @@ void *MemoryUtils::ResolveSymbol(void *handle, const char *symbol)
 {
 #ifdef PLATFORM_WINDOWS
 
+	/* Add this this library into the cache */
+	GetLibraryInfo(handle);
 	return GetProcAddress((HMODULE)handle, symbol);
 	
 #elif defined PLATFORM_LINUX
@@ -162,6 +165,9 @@ void *MemoryUtils::ResolveSymbol(void *handle, const char *symbol)
 		}
 	}
 
+	/* Add this this library into the cache */
+	GetLibraryInfo((void *)dlmap->l_addr);
+
 	/* If we don't have a symbol table for this library, then create one */
 	if (table == NULL)
 	{
@@ -325,6 +331,9 @@ void *MemoryUtils::ResolveSymbol(void *handle, const char *symbol)
 		/* Uh oh, we couldn't find a matching handle */
 		return NULL;
 	}
+
+	/* Add this this library into the cache */
+	GetLibraryInfo((void *)dlbase);
 	
 	/* See if we already have a symbol table for this library */
 	for (size_t i = 0; i < m_SymTables.size(); i++)
@@ -429,21 +438,25 @@ void *MemoryUtils::ResolveSymbol(void *handle, const char *symbol)
 #endif
 }
 
-bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
+const DynLibInfo *MemoryUtils::GetLibraryInfo(const void *libPtr)
 {
 	uintptr_t baseAddr;
 
 	if (libPtr == NULL)
 	{
-		return false;
+		return nullptr;
 	}
 
+	DynLibInfo lib;
+
 #ifdef PLATFORM_WINDOWS
 
 #ifdef PLATFORM_X86
 	const WORD PE_FILE_MACHINE = IMAGE_FILE_MACHINE_I386;
+	const WORD PE_NT_OPTIONAL_HDR_MAGIC = IMAGE_NT_OPTIONAL_HDR32_MAGIC;
 #else
 	const WORD PE_FILE_MACHINE = IMAGE_FILE_MACHINE_AMD64;
+	const WORD PE_NT_OPTIONAL_HDR_MAGIC = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
 #endif
 
 	MEMORY_BASIC_INFORMATION info;
@@ -454,7 +467,7 @@ bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
 
 	if (!VirtualQuery(libPtr, &info, sizeof(MEMORY_BASIC_INFORMATION)))
 	{
-		return false;
+		return nullptr;
 	}
 
 	baseAddr = reinterpret_cast<uintptr_t>(info.AllocationBase);
@@ -466,21 +479,21 @@ bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
 	opt = &pe->OptionalHeader;
 
 	/* Check PE magic and signature */
-	if (dos->e_magic != IMAGE_DOS_SIGNATURE || pe->Signature != IMAGE_NT_SIGNATURE || opt->Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
+	if (dos->e_magic != IMAGE_DOS_SIGNATURE || pe->Signature != IMAGE_NT_SIGNATURE || opt->Magic != PE_NT_OPTIONAL_HDR_MAGIC)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* Check architecture */
 	if (file->Machine != PE_FILE_MACHINE)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* For our purposes, this must be a dynamic library */
 	if ((file->Characteristics & IMAGE_FILE_DLL) == 0)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* Finally, we can do this */
@@ -507,12 +520,12 @@ bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
 
 	if (!dladdr(libPtr, &info))
 	{
-		return false;
+		return nullptr;
 	}
 
 	if (!info.dli_fbase || !info.dli_fname)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* This is for our insane sanity checks :o */
@@ -522,31 +535,31 @@ bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
 	/* Check ELF magic */
 	if (memcmp(ELFMAG, file->e_ident, SELFMAG) != 0)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* Check ELF version */
 	if (file->e_ident[EI_VERSION] != EV_CURRENT)
 	{
-		return false;
+		return nullptr;
 	}
 	
 	/* Check ELF endianness */
 	if (file->e_ident[EI_DATA] != ELFDATA2LSB)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* Check ELF architecture */
 	if (file->e_ident[EI_CLASS] != ELF_CLASS || file->e_machine != ELF_MACHINE)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* For our purposes, this must be a dynamic library/shared object */
 	if (file->e_type != ET_DYN)
 	{
-		return false;
+		return nullptr;
 	}
 
 	phdrCount = file->e_phnum;
@@ -596,12 +609,12 @@ bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
 
 	if (!dladdr(libPtr, &info))
 	{
-		return false;
+		return nullptr;
 	}
 
 	if (!info.dli_fbase || !info.dli_fname)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* This is for our insane sanity checks :o */
@@ -611,19 +624,19 @@ bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
 	/* Check Mach-O magic */
 	if (file->magic != MACH_MAGIC)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* Check architecture */
 	if (file->cputype != MACH_CPU_TYPE || file->cpusubtype != MACH_CPU_SUBTYPE)
 	{
-		return false;
+		return nullptr;
 	}
 
 	/* For our purposes, this must be a dynamic library */
 	if (file->filetype != MH_DYLIB)
 	{
-		return false;
+		return nullptr;
 	}
 
 	cmd_count = file->ncmds;
@@ -644,5 +657,17 @@ bool MemoryUtils::GetLibraryInfo(const void *libPtr, DynLibInfo &lib)
 
 	lib.baseAddress = reinterpret_cast<void *>(baseAddr);
 
-	return true;
+	LibraryInfoMap::Insert i = m_InfoMap.findForAdd(lib.baseAddress);
+	if (i.found())
+	{
+		// We already loaded this binary before.
+		return &i->value;
+	}
+	
+	// Keep a copy of the binary in its initial unpatched state for lookup.
+	lib.originalCopy = std::make_unique<char[]>(lib.memorySize);
+	memcpy(lib.originalCopy.get(), lib.baseAddress, lib.memorySize);
+	m_InfoMap.add(i, lib.baseAddress, std::move(lib));
+
+	return &i->value;
 }

core/logic/MemoryUtils.h

@@ -32,6 +32,8 @@
 
 #include "common_logic.h"
 #include <IMemoryUtils.h>
+#include <am-hashmap.h>
+#include <memory>
 #if defined PLATFORM_LINUX || defined PLATFORM_APPLE
 #include <sh_vector.h>
 #include "sm_symtable.h"
@@ -49,6 +51,7 @@ struct DynLibInfo
 {
 	void *baseAddress;
 	size_t memorySize;
+	std::unique_ptr<char[]> originalCopy;
 };
 
 #if defined PLATFORM_LINUX || defined PLATFORM_APPLE
@@ -73,7 +76,7 @@ public: // IMemoryUtils
 	void *FindPattern(const void *libPtr, const char *pattern, size_t len);
 	void *ResolveSymbol(void *handle, const char *symbol);
 public:
-	bool GetLibraryInfo(const void *libPtr, DynLibInfo &lib);
+	const DynLibInfo *GetLibraryInfo(const void *libPtr);
 #if defined PLATFORM_LINUX || defined PLATFORM_APPLE
 private:
 	CVector<LibSymbolTable *> m_SymTables;
@@ -83,6 +86,8 @@ private:
 	SInt32 m_OSXMinor;
 #endif
 #endif
+	typedef ke::HashMap<void *, DynLibInfo, ke::PointerPolicy<void> > LibraryInfoMap;
+	LibraryInfoMap m_InfoMap;
 };
 
 extern MemoryUtils g_MemUtils;

core/logic/Native.h

@@ -33,7 +33,6 @@
 
 #include <IShareSys.h>
 #include <IHandleSys.h>
-#include <am-autoptr.h>
 #include <am-string.h>
 #include <am-utility.h>
 #include <am-refcounting.h>
@@ -47,16 +46,14 @@ struct FakeNative
 	FakeNative(const char *name, IPluginFunction *fun)
 		: name(name),
 		  ctx(fun->GetParentContext()),
-		  call(fun),
-		  gate(NULL)
+		  call(fun)
 	{
 	}
-	~FakeNative();
 
-	ke::AString name;
+	std::string name;
 	IPluginContext *ctx;
 	IPluginFunction *call;
-	SPVM_NATIVE_FUNC gate;
+	ke::RefPtr<INativeCallback> wrapper;
 };
 
 struct Native : public ke::Refcounted<Native>
@@ -64,31 +61,25 @@ struct Native : public ke::Refcounted<Native>
 	Native(CNativeOwner *owner, const sp_nativeinfo_t *native)
 		: owner(owner),
 		  native(native),
-		  fake(NULL)
+		  fake(nullptr)
 	{
 	}
-	Native(CNativeOwner *owner, FakeNative *fake)
+	Native(CNativeOwner *owner, std::unique_ptr<FakeNative>&& fake)
 		: owner(owner),
-		  native(NULL),
-		  fake(fake)
+		  native(nullptr),
+		  fake(std::move(fake))
 	{
 	}
 
 	CNativeOwner *owner;
 	const sp_nativeinfo_t *native;
-	ke::AutoPtr<FakeNative> fake;
+	std::unique_ptr<FakeNative> fake;
 
-	SPVM_NATIVE_FUNC func() const
-	{
-		if (native)
-			return native->func;
-		return fake->gate;
-	}
 	const char *name() const
 	{
 		if (native)
 			return native->name;
-		return fake->name.chars();
+		return fake->name.c_str();
 	}
 
 	static inline bool matches(const char *name, const ke::RefPtr<Native> &entry)

core/logic/NativeInvoker.cpp

@@ -0,0 +1,324 @@
+// vim: set sts=2 ts=8 sw=2 tw=99 et:
+//
+// Copyright (C) 2006-2015 AlliedModders LLC
+//
+// This file is part of SourcePawn. SourcePawn 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.
+//
+// You should have received a copy of the GNU General Public License along with
+// SourcePawn. If not, see http://www.gnu.org/licenses/.
+//
+
+#include <stdio.h>
+#include <string.h>
+#include "NativeInvoker.h"
+
+/********************
+* FUNCTION CALLING *
+********************/
+
+NativeInvoker::NativeInvoker(IPluginContext *pContext, const ke::RefPtr<Native> &native)
+ : context_(pContext),
+   m_curparam(0),
+   m_errorstate(SP_ERROR_NONE),
+   native_(native)
+{
+}
+
+NativeInvoker::~NativeInvoker()
+{
+  Cancel();
+}
+
+bool
+NativeInvoker::IsRunnable()
+{
+  return true;
+}
+
+IPluginContext *
+NativeInvoker::GetParentContext()
+{
+  return context_;
+}
+
+int NativeInvoker::PushCell(cell_t cell)
+{
+  if (m_curparam >= SP_MAX_EXEC_PARAMS)
+    return SetError(SP_ERROR_PARAMS_MAX);
+
+  m_info[m_curparam].marked = false;
+  m_params[m_curparam] = cell;
+  m_curparam++;
+
+  return SP_ERROR_NONE;
+}
+
+int
+NativeInvoker::PushCellByRef(cell_t *cell, int flags)
+{
+  return PushArray(cell, 1, flags);
+}
+
+int
+NativeInvoker::PushFloat(float number)
+{
+  cell_t val = sp::FloatCellUnion(number).cell;
+
+  return PushCell(val);
+}
+
+int
+NativeInvoker::PushFloatByRef(float *number, int flags)
+{
+  return PushCellByRef((cell_t *)number, flags);
+}
+
+int
+NativeInvoker::PushArray(cell_t *inarray, unsigned int cells, int copyback)
+{
+  if (m_curparam >= SP_MAX_EXEC_PARAMS)
+  {
+    return SetError(SP_ERROR_PARAMS_MAX);
+  }
+
+  ParamInfo *info = &m_info[m_curparam];
+
+  info->flags = inarray ? copyback : 0;
+  info->marked = true;
+  info->size = cells;
+  info->str.is_sz = false;
+  info->orig_addr = inarray;
+
+  m_curparam++;
+
+  return SP_ERROR_NONE;
+}
+
+int
+NativeInvoker::PushString(const char *string)
+{
+  return _PushString(string, SM_PARAM_STRING_COPY, 0, strlen(string)+1);
+}
+
+int
+NativeInvoker::PushStringEx(char *buffer, size_t length, int sz_flags, int cp_flags)
+{
+  return _PushString(buffer, sz_flags, cp_flags, length);
+}
+
+int
+NativeInvoker::_PushString(const char *string, int sz_flags, int cp_flags, size_t len)
+{
+  if (m_curparam >= SP_MAX_EXEC_PARAMS)
+    return SetError(SP_ERROR_PARAMS_MAX);
+
+  ParamInfo *info = &m_info[m_curparam];
+
+  info->marked = true;
+  info->orig_addr = (cell_t *)string;
+  info->flags = cp_flags;
+  info->size = len;
+  info->str.sz_flags = sz_flags;
+  info->str.is_sz = true;
+
+  m_curparam++;
+
+  return SP_ERROR_NONE;
+}
+
+void
+NativeInvoker::Cancel()
+{
+  if (!m_curparam)
+    return;
+
+  m_errorstate = SP_ERROR_NONE;
+  m_curparam = 0;
+}
+
+int
+NativeInvoker::Execute(cell_t *result, cell_t buffer, cell_t size)
+{
+  context_->ClearLastNativeError();
+
+  // For backward compatibility, we have to clear the exception state.
+  // Otherwise code like this:
+  //
+  // static cell_t native(cx, params) {
+  //   for (auto callback : callbacks) {
+  //     callback->Execute();
+  //   }
+  // }
+  //
+  // Could unintentionally leak a pending exception back to the caller,
+  // which wouldn't have happened before the Great Exception Refactoring.
+
+  SourcePawn::ExceptionHandler eh(context_);
+  eh.Debug(!size);
+
+  if (!Invoke(result)) {
+    if(size)
+      context_->StringToLocalUTF8(buffer, size, eh.Message(), NULL);
+    int Err = context_->GetLastNativeError();
+    context_->ClearLastNativeError();
+    return Err;
+  }
+
+  return SP_ERROR_NONE;
+}
+
+bool
+NativeInvoker::Invoke(cell_t *result)
+{
+  if (!IsRunnable()) {
+    Cancel();
+    context_->ReportErrorNumber(SP_ERROR_NOT_RUNNABLE);
+    return false;
+  }
+  if (int err = m_errorstate) {
+    Cancel();
+    context_->ReportErrorNumber(err);
+    return false;
+  }
+
+  //This is for re-entrancy!
+  cell_t _temp_params[SP_MAX_EXEC_PARAMS + 1];
+  cell_t *temp_params = &_temp_params[1];
+  ParamInfo temp_info[SP_MAX_EXEC_PARAMS];
+  unsigned int numparams = m_curparam;
+  unsigned int i;
+
+  if (numparams)
+  {
+    //Save the info locally, then reset it for re-entrant calls.
+    memcpy(temp_info, m_info, numparams * sizeof(ParamInfo));
+  }
+  m_curparam = 0;
+
+  /* Initialize 0th parameter */
+  _temp_params[0] = numparams;
+
+  /* Browse the parameters and build arrays */
+  bool ok = true;
+  for (i=0; i<numparams; i++) {
+    /* Is this marked as an array? */
+    if (temp_info[i].marked) {
+      if (!temp_info[i].str.is_sz) {
+        /* Allocate a normal/generic array */
+        int err = context_->HeapAlloc(
+          temp_info[i].size,
+          &(temp_info[i].local_addr),
+          &(temp_info[i].phys_addr));
+        if (err != SP_ERROR_NONE) {
+          context_->ReportErrorNumber(err);
+          ok = false;
+          break;
+        }
+        if (temp_info[i].orig_addr)
+        {
+          memcpy(temp_info[i].phys_addr, temp_info[i].orig_addr, sizeof(cell_t) * temp_info[i].size);
+        }
+      } else {
+        /* Calculate cells required for the string */
+        size_t cells = (temp_info[i].size + sizeof(cell_t) - 1) / sizeof(cell_t);
+
+        /* Allocate the buffer */
+        int err = context_->HeapAlloc(
+          cells,
+          &(temp_info[i].local_addr),
+          &(temp_info[i].phys_addr));
+        if (err != SP_ERROR_NONE) {
+          context_->ReportErrorNumber(err);
+          ok = false;
+          break;
+        }
+
+        /* Copy original string if necessary */
+        if ((temp_info[i].str.sz_flags & SM_PARAM_STRING_COPY) && (temp_info[i].orig_addr != NULL))
+        {
+          /* Cut off UTF-8 properly */
+          if (temp_info[i].str.sz_flags & SM_PARAM_STRING_UTF8) {
+            context_->StringToLocalUTF8(
+              temp_info[i].local_addr,
+              temp_info[i].size,
+              (const char *)temp_info[i].orig_addr,
+              NULL);
+          }
+          /* Copy a binary blob */
+          else if (temp_info[i].str.sz_flags & SM_PARAM_STRING_BINARY)
+          {
+            memmove(temp_info[i].phys_addr, temp_info[i].orig_addr, temp_info[i].size);
+          }
+          /* Copy ASCII characters */
+          else
+          {
+            context_->StringToLocal(
+              temp_info[i].local_addr,
+              temp_info[i].size,
+              (const char *)temp_info[i].orig_addr);
+          }
+        }
+      } /* End array/string calculation */
+      /* Update the pushed parameter with the byref local address */
+      temp_params[i] = temp_info[i].local_addr;
+    } else {
+      /* Just copy the value normally */
+      temp_params[i] = m_params[i];
+    }
+  }
+
+  /* Make the call if we can */
+  if (ok)
+  {
+    if(native_->native)
+      *result = native_->native->func(context_, _temp_params);
+    else
+      *result = native_->fake->wrapper->Invoke(context_, _temp_params);
+  }
+
+  /* i should be equal to the last valid parameter + 1 */
+  bool docopies = ok;
+  while (i--) {
+    if (!temp_info[i].marked)
+      continue;
+
+    if (docopies && (temp_info[i].flags & SM_PARAM_COPYBACK)) {
+      if (temp_info[i].orig_addr) {
+        if (temp_info[i].str.is_sz) {
+          memcpy(temp_info[i].orig_addr, temp_info[i].phys_addr, temp_info[i].size);
+
+        } else {
+          if (temp_info[i].size == 1) {
+            *temp_info[i].orig_addr = *(temp_info[i].phys_addr);
+          } else {
+            memcpy(temp_info[i].orig_addr,
+                temp_info[i].phys_addr,
+                temp_info[i].size * sizeof(cell_t));
+          }
+        }
+      }
+    }
+
+    if (int err = context_->HeapPop(temp_info[i].local_addr))
+      context_->ReportErrorNumber(err);
+  }
+
+  return context_->GetLastNativeError() == SP_ERROR_NONE;
+}
+
+int
+NativeInvoker::SetError(int err)
+{
+  m_errorstate = err;
+
+  return err;
+}
+
+int NativeInvoker::CallFunction(const cell_t *params, unsigned int num_params, cell_t *result) { return 0; }
+funcid_t NativeInvoker::GetFunctionID() { return 0; }
+int NativeInvoker::Execute2(IPluginContext *ctx, cell_t *result) { return 0; }
+int NativeInvoker::CallFunction2(IPluginContext *ctx, const cell_t *params, unsigned int num_params, cell_t *result) { return 0; }
+IPluginRuntime *NativeInvoker::GetParentRuntime() { return NULL; }

core/logic/NativeInvoker.h

@@ -0,0 +1,78 @@
+// vim: set sts=2 ts=8 sw=2 tw=99 et:
+//
+// Copyright (C) 2006-2015 AlliedModders LLC
+//
+// This file is part of SourcePawn. SourcePawn 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.
+//
+// You should have received a copy of the GNU General Public License along with
+// SourcePawn. If not, see http://www.gnu.org/licenses/.
+//
+#ifndef _INCLUDE_SOURCEMOD_NATIVE_INVOKER_H_
+#define _INCLUDE_SOURCEMOD_NATIVE_INVOKER_H_
+
+#include <sp_vm_api.h>
+#include <amtl/am-refcounting.h>
+#include "Native.h"
+
+struct ParamInfo
+{
+  int flags;      /* Copy-back flags */
+  bool marked;    /* Whether this is marked as being used */
+  cell_t local_addr;  /* Local address to free */
+  cell_t *phys_addr;  /* Physical address of our copy */
+  cell_t *orig_addr;  /* Original address to copy back to */
+  ucell_t size;    /* Size of array in bytes */
+  struct {
+    bool is_sz;    /* is a string */
+    int sz_flags;  /* has sz flags */
+  } str;
+};
+
+class NativeInvoker : public IPluginFunction
+{
+ public:
+  NativeInvoker(IPluginContext *pContext, const ke::RefPtr<Native> &native);
+  virtual ~NativeInvoker();
+
+ public:
+  int PushCell(cell_t cell);
+  int PushCellByRef(cell_t *cell, int flags);
+  int PushFloat(float number);
+  int PushFloatByRef(float *number, int flags);
+  int PushArray(cell_t *inarray, unsigned int cells, int copyback);
+  int PushString(const char *string);
+  int PushStringEx(char *buffer, size_t length, int sz_flags, int cp_flags);
+  int Execute(cell_t *result, cell_t buffer=0, cell_t size=0);
+  void Cancel();
+  int CallFunction(const cell_t *params, unsigned int num_params, cell_t *result);
+  IPluginContext *GetParentContext();
+  bool Invoke(cell_t *result);
+  bool IsRunnable();
+  funcid_t GetFunctionID();
+  int Execute2(IPluginContext *ctx, cell_t *result);
+  int CallFunction2(IPluginContext *ctx,
+    const cell_t *params,
+    unsigned int num_params,
+    cell_t *result);
+  IPluginRuntime *GetParentRuntime();
+  const char *DebugName() {
+    return native_->name();
+  }
+
+ private:
+  int _PushString(const char *string, int sz_flags, int cp_flags, size_t len);
+  int SetError(int err);
+
+ private:
+  IPluginContext *context_;
+  cell_t m_params[SP_MAX_EXEC_PARAMS];
+  ParamInfo m_info[SP_MAX_EXEC_PARAMS];
+  unsigned int m_curparam;
+  int m_errorstate;
+  ke::RefPtr<Native> native_;
+};
+
+#endif //_INCLUDE_SOURCEMOD_NATIVE_INVOKER_H_

core/logic/NativeOwner.cpp

@@ -62,7 +62,7 @@ void CNativeOwner::AddNatives(const sp_nativeinfo_t *natives)
 	for (const sp_nativeinfo_t *native = natives; native->func && native->name; native++)
 		g_ShareSys.AddNativeToCache(this, native);
 
-	m_natives.append(natives);
+	m_natives.push_back(natives);
 }
 
 void CNativeOwner::UnbindWeakRef(const WeakNative &ref)
@@ -90,14 +90,14 @@ void CNativeOwner::DropEverything()
 	}
 
 	/* Strip all of our natives from the cache */
-	for (size_t i = 0; i < m_natives.length(); i++) {
+	for (size_t i = 0; i < m_natives.size(); i++) {
 		const sp_nativeinfo_t *natives = m_natives[i];
 		for (const sp_nativeinfo_t *native = natives; native->func && native->name; native++)
 			g_ShareSys.ClearNativeFromCache(this, native->name);
 	}
 	m_natives.clear();
 
-	for (size_t i = 0; i < m_fakes.length(); i++)
+	for (size_t i = 0; i < m_fakes.size(); i++)
 		g_ShareSys.ClearNativeFromCache(this, m_fakes[i]->name());
 	m_fakes.clear();
 }

core/logic/NativeOwner.h

@@ -33,7 +33,6 @@
 
 #include <sp_vm_types.h>
 #include <sh_list.h>
-#include <am-linkedlist.h>
 #include <am-vector.h>
 #include "common_logic.h"
 #include "Native.h"
@@ -80,8 +79,8 @@ protected:
 	List<CPlugin *> m_Dependents;
 	unsigned int m_nMarkSerial;
 	List<WeakNative> m_WeakRefs;
-	ke::Vector<const sp_nativeinfo_t *> m_natives;
-	ke::Vector<ke::RefPtr<Native> > m_fakes;
+	std::vector<const sp_nativeinfo_t *> m_natives;
+	std::vector<ke::RefPtr<Native> > m_fakes;
 };
 
 extern CNativeOwner g_CoreNatives;

core/logic/PluginSys.cpp

@@ -45,7 +45,6 @@
 #include "Logger.h"
 #include "frame_tasks.h"
 #include <amtl/am-string.h>
-#include <amtl/am-linkedlist.h>
 #include <bridge/include/IVEngineServerBridge.h>
 #include <bridge/include/CoreProvider.h>
 
@@ -79,7 +78,7 @@ CPlugin::CPlugin(const char *file)
 
 	memset(&m_info, 0, sizeof(m_info));
 
-	m_pPhrases = g_Translator.CreatePhraseCollection();
+	m_pPhrases.reset(g_Translator.CreatePhraseCollection());
 }
 
 CPlugin::~CPlugin()
@@ -227,7 +226,7 @@ bool CPlugin::SetProperty(const char *prop, void *ptr)
 
 IPluginRuntime *CPlugin::GetRuntime()
 {
-	return m_pRuntime;
+	return m_pRuntime.get();
 }
 
 void CPlugin::EvictWithError(PluginStatus status, const char *error_fmt, ...)
@@ -276,7 +275,7 @@ bool CPlugin::ReadInfo()
 		sm_plugininfo_c_t *cinfo;
 		cell_t local_addr;
 
-		auto update_field = [base](cell_t addr, ke::AString *dest) {
+		auto update_field = [base](cell_t addr, std::string *dest) {
 			const char* ptr;
 			if (base->LocalToString(addr, (char **)&ptr) == SP_ERROR_NONE)
 				*dest = ptr;
@@ -483,7 +482,7 @@ bool CPlugin::TryCompile()
 	g_pSM->BuildPath(Path_SM, fullpath, sizeof(fullpath), "plugins/%s", m_filename);
 
 	char loadmsg[255];
-	m_pRuntime = g_pSourcePawn2->LoadBinaryFromFile(fullpath, loadmsg, sizeof(loadmsg));
+	m_pRuntime.reset(g_pSourcePawn2->LoadBinaryFromFile(fullpath, loadmsg, sizeof(loadmsg)));
 	if (!m_pRuntime) {
 		EvictWithError(Plugin_BadLoad, "Unable to load plugin (%s)", loadmsg);
 		return false;
@@ -524,11 +523,11 @@ PluginType CPlugin::GetType()
 
 const sm_plugininfo_t *CPlugin::GetPublicInfo()
 {
-	m_info.author = info_author_.chars();
-	m_info.description = info_description_.chars();
-	m_info.name = info_name_.chars();
-	m_info.url = info_url_.chars();
-	m_info.version = info_version_.chars();
+	m_info.author = info_author_.c_str();
+	m_info.description = info_description_.c_str();
+	m_info.name = info_name_.c_str();
+	m_info.url = info_url_.c_str();
+	m_info.version = info_version_.c_str();
 	return &m_info;
 }
 
@@ -658,7 +657,7 @@ time_t CPlugin::GetFileTimeStamp()
 
 IPhraseCollection *CPlugin::GetPhrases()
 {
-	return m_pPhrases;
+	return m_pPhrases.get();
 }
 
 void CPlugin::DependencyDropped(CPlugin *pOwner)
@@ -674,7 +673,7 @@ void CPlugin::DependencyDropped(CPlugin *pOwner)
 	}
 
 	unsigned int unbound = 0;
-	for (size_t i = 0; i < pOwner->m_fakes.length(); i++)
+	for (size_t i = 0; i < pOwner->m_fakes.size(); i++)
 	{
 		ke::RefPtr<Native> entry(pOwner->m_fakes[i]);
 
@@ -773,13 +772,13 @@ bool CPlugin::AddFakeNative(IPluginFunction *pFunc, const char *name, SPVM_FAKEN
 	if (!entry)
 		return false;
 
-	m_fakes.append(entry);
+	m_fakes.push_back(entry);
 	return true;
 }
 
 void CPlugin::BindFakeNativesTo(CPlugin *other)
 {
-	for (size_t i = 0; i < m_fakes.length(); i++)
+	for (size_t i = 0; i < m_fakes.size(); i++)
 		g_ShareSys.BindNativeToPlugin(other, m_fakes[i]);
 }
 
@@ -790,7 +789,7 @@ void CPlugin::BindFakeNativesTo(CPlugin *other)
 CPluginManager::CPluginIterator::CPluginIterator(ReentrantList<CPlugin *>& in)
 {
 	for (PluginIter iter(in); !iter.done(); iter.next())
-		mylist.append(*iter);
+		mylist.push_back(*iter);
 	current = mylist.begin();
 	g_PluginSys.AddPluginsListener(this);
 }
@@ -847,11 +846,7 @@ CPluginManager::~CPluginManager()
 
 void CPluginManager::Shutdown()
 {
-	List<CPlugin *>::iterator iter;
-
-	for (PluginIter iter(m_plugins); !iter.done(); iter.next()) {
-		UnloadPlugin(*iter);
-	}
+	UnloadAll();
 }
 
 void CPluginManager::LoadAll(const char *config_path, const char *plugins_path)
@@ -979,6 +974,20 @@ IPlugin *CPluginManager::LoadPlugin(const char *path, bool debug, PluginType typ
 	LoadRes res;
 
 	*wasloaded = false;
+
+	if (strstr(path, "..") != NULL)
+	{
+		ke::SafeStrcpy(error, maxlength, "Cannot load plugins outside the \"plugins\" folder");
+		return NULL;
+	}
+
+	const char *ext = libsys->GetFileExtension(path);
+	if (!ext || strcmp(ext, "smx") != 0)
+	{
+		ke::SafeStrcpy(error, maxlength, "Plugin files must have the \".smx\" file extension");
+		return NULL;
+	}
+
 	if ((res=LoadPlugin(&pl, path, true, PluginType_MapUpdated)) == LoadRes_Failure)
 	{
 		ke::SafeStrcpy(error, maxlength, pl->GetErrorMsg());
@@ -1033,7 +1042,7 @@ void CPluginManager::LoadAutoPlugin(const char *plugin)
 
 void CPluginManager::AddPlugin(CPlugin *pPlugin)
 {
-	m_plugins.append(pPlugin);
+	m_plugins.push_back(pPlugin);
 	m_LoadLookup.insert(pPlugin->GetFilename(), pPlugin);
 
 	pPlugin->SetRegistered();
@@ -1165,7 +1174,7 @@ bool CPlugin::ForEachExtVar(const ExtVarCallback& callback)
 	return true;
 }
 
-void CPlugin::ForEachLibrary(ke::Lambda<void(const char *)> callback)
+void CPlugin::ForEachLibrary(ke::Function<void(const char *)> callback)
 {
 	for (auto iter = m_Libraries.begin(); iter != m_Libraries.end(); iter++)
 		callback((*iter).c_str());
@@ -1177,7 +1186,7 @@ void CPlugin::AddRequiredLib(const char *name)
 		m_RequiredLibs.push_back(name);
 }
 
-bool CPlugin::ForEachRequiredLib(ke::Lambda<bool(const char *)> callback)
+bool CPlugin::ForEachRequiredLib(ke::Function<bool(const char *)> callback)
 {
 	for (auto iter = m_RequiredLibs.begin(); iter != m_RequiredLibs.end(); iter++) {
 		if (!callback((*iter).c_str()))
@@ -1211,7 +1220,7 @@ void CPluginManager::LoadExtensions(CPlugin *pPlugin)
 		}
 		return true;
 	};
-	pPlugin->ForEachExtVar(ke::Move(callback));
+	pPlugin->ForEachExtVar(std::move(callback));
 }
 
 bool CPluginManager::RequireExtensions(CPlugin *pPlugin)
@@ -1247,7 +1256,7 @@ bool CPluginManager::RequireExtensions(CPlugin *pPlugin)
 		return true;
 	};
 
-	return pPlugin->ForEachExtVar(ke::Move(callback));
+	return pPlugin->ForEachExtVar(std::move(callback));
 }
 
 CPlugin *CPluginManager::CompileAndPrep(const char *path)
@@ -1490,6 +1499,9 @@ void CPluginManager::Purge(CPlugin *plugin)
 	if (plugin->GetStatus() == Plugin_Running)
 		plugin->Call_OnPluginEnd();
 
+	m_pOnNotifyPluginUnloaded->PushCell(plugin->GetMyHandle());
+	m_pOnNotifyPluginUnloaded->Execute(NULL);
+
 	// Notify listeners of unloading.
 	if (plugin->EnteredSecondPass()) {
 		for (ListenerIter iter(m_listeners); !iter.done(); iter.next())
@@ -1536,12 +1548,12 @@ CPlugin *CPluginManager::GetPluginByCtx(const sp_context_t *ctx)
 
 unsigned int CPluginManager::GetPluginCount()
 {
-	return m_plugins.length();
+	return m_plugins.size();
 }
 
 void CPluginManager::AddPluginsListener(IPluginsListener *listener)
 {
-	m_listeners.append(listener);
+	m_listeners.push_back(listener);
 }
 
 void CPluginManager::RemovePluginsListener(IPluginsListener *listener)
@@ -1578,6 +1590,7 @@ void CPluginManager::OnSourceModAllInitialized()
 
 	m_pOnLibraryAdded = forwardsys->CreateForward("OnLibraryAdded", ET_Ignore, 1, NULL, Param_String);
 	m_pOnLibraryRemoved = forwardsys->CreateForward("OnLibraryRemoved", ET_Ignore, 1, NULL, Param_String);
+	m_pOnNotifyPluginUnloaded = forwardsys->CreateForward("OnNotifyPluginUnloaded", ET_Ignore, 1, NULL, Param_Cell);
 }
 
 void CPluginManager::OnSourceModShutdown()
@@ -1592,6 +1605,7 @@ void CPluginManager::OnSourceModShutdown()
 
 	forwardsys->ReleaseForward(m_pOnLibraryAdded);
 	forwardsys->ReleaseForward(m_pOnLibraryRemoved);
+	forwardsys->ReleaseForward(m_pOnNotifyPluginUnloaded);
 }
 
 ConfigResult CPluginManager::OnSourceModConfigChanged(const char *key,
@@ -1715,7 +1729,7 @@ void CPluginManager::OnRootConsoleCommand(const char *cmdname, const ICommandArg
 				rootmenu->ConsolePrint("[SM] Listing %d plugin%s:", plnum, (plnum > 1) ? "s" : "");
 			}
 
-			ke::LinkedList<CPlugin *> fail_list;
+			std::list<CPlugin *> fail_list;
 
 			for (PluginIter iter(m_plugins); !iter.done(); iter.next(), id++) {
 				CPlugin *pl = (*iter);
@@ -1727,7 +1741,7 @@ void CPluginManager::OnRootConsoleCommand(const char *cmdname, const ICommandArg
 					len += ke::SafeSprintf(buffer, sizeof(buffer), "  %0*d <%s>", plpadding, id, GetStatusText(pl->GetDisplayStatus()));
 
 					/* Plugin has failed to load. */
-					fail_list.append(pl);
+					fail_list.push_back(pl);
 				}
 				else
 				{
@@ -2033,7 +2047,8 @@ void CPluginManager::OnRootConsoleCommand(const char *cmdname, const ICommandArg
 					//the unload/reload attempt next frame will print a message
 					case PluginState::WaitingToUnload:
 					case PluginState::WaitingToUnloadAndReload:
-						return;
+						rootmenu->ConsolePrint("[SM] Plugin %s will be reloaded on the next frame.", name);
+						break;
 
 					default:
 						rootmenu->ConsolePrint("[SM] Failed to reload plugin %s.", name);
@@ -2063,7 +2078,7 @@ bool CPluginManager::ReloadPlugin(CPlugin *pl, bool print)
 	if (state == PluginState::WaitingToUnloadAndReload)
 		return false;
 
-	ke::AString filename(pl->GetFilename());
+	std::string filename(pl->GetFilename());
 	PluginType ptype = pl->GetType();
 
 	int id = 1;
@@ -2078,13 +2093,13 @@ bool CPluginManager::ReloadPlugin(CPlugin *pl, bool print)
 		{
 			pl->SetWaitingToUnload(true);
 			ScheduleTaskForNextFrame([this, id, filename, ptype, print]() -> void {
-				ReloadPluginImpl(id, filename.chars(), ptype, print);
+				ReloadPluginImpl(id, filename.c_str(), ptype, print);
 			});
 		}
 		return false;
 	}
 
-	ReloadPluginImpl(id, filename.chars(), ptype, false);
+	ReloadPluginImpl(id, filename.c_str(), ptype, false);
 	return true;
 }
 
@@ -2208,7 +2223,6 @@ void CPluginManager::UnloadAll()
 int CPluginManager::GetOrderOfPlugin(IPlugin *pl)
 {
 	int id = 1;
-	List<CPlugin *>::iterator iter;
 
 	for (PluginIter iter(m_plugins); !iter.done(); iter.next()) {
 		if ((*iter) == pl)
@@ -2273,7 +2287,7 @@ void CPluginManager::FreePluginList(const CVector<SMPlugin *> *list)
 	delete const_cast<CVector<SMPlugin *> *>(list);
 }
 
-void CPluginManager::ForEachPlugin(ke::Lambda<void(CPlugin *)> callback)
+void CPluginManager::ForEachPlugin(ke::Function<void(CPlugin *)> callback)
 {
 	for (PluginIter iter(m_plugins); !iter.done(); iter.next())
 		callback(*iter);
@@ -2351,7 +2365,7 @@ public:
 	{
 		ke::RefPtr<PluginsListenerV1Wrapper> wrapper = new PluginsListenerV1Wrapper(listener);
 
-		v1_wrappers_.append(wrapper);
+		v1_wrappers_.push_back(wrapper);
 		g_PluginSys.AddPluginsListener(wrapper);
 	}
 
@@ -2394,4 +2408,4 @@ static OldPluginAPI sOldPluginAPI;
 IPluginManager *CPluginManager::GetOldAPI()
 {
 	return &sOldPluginAPI;
-}
+}

core/logic/PluginSys.h

@@ -32,9 +32,12 @@
 #ifndef _INCLUDE_SOURCEMOD_PLUGINSYSTEM_H_
 #define _INCLUDE_SOURCEMOD_PLUGINSYSTEM_H_
 
-#include <time.h>
 #include <errno.h>
 #include <sys/stat.h>
+#include <time.h>
+
+#include <memory>
+
 #include <IPluginSys.h>
 #include <IHandleSys.h>
 #include <IForwardSys.h>
@@ -129,10 +132,10 @@ public:
 		bool required;
 	};
 
-	typedef ke::Lambda<bool(const sp_pubvar_t *, const ExtVar& ext)> ExtVarCallback;
+	typedef ke::Function<bool(const sp_pubvar_t *, const ExtVar& ext)> ExtVarCallback;
 	bool ForEachExtVar(const ExtVarCallback& callback);
 
-	void ForEachLibrary(ke::Lambda<void(const char *)> callback);
+	void ForEachLibrary(ke::Function<void(const char *)> callback);
 public:
 	/**
 	 * Creates a plugin object with default values.
@@ -215,7 +218,7 @@ public:
 	}
 
 	void AddRequiredLib(const char *name);
-	bool ForEachRequiredLib(ke::Lambda<bool(const char *)> callback);
+	bool ForEachRequiredLib(ke::Function<bool(const char *)> callback);
 
 	bool HasMissingFakeNatives() const {
 		return m_FakeNativesMissing;
@@ -224,7 +227,7 @@ public:
 		return m_LibraryMissing;
 	}
 	bool HasFakeNatives() const {
-		return m_fakes.length() > 0;
+		return m_fakes.size() > 0;
 	}
 
 	// True if we got far enough into the second pass to call OnPluginLoaded
@@ -267,8 +270,8 @@ private:
 	char m_errormsg[256];
 
 	// Internal properties that must by reset if the runtime is evicted.
-	ke::AutoPtr<IPluginRuntime> m_pRuntime;
-	ke::AutoPtr<CPhraseCollection> m_pPhrases;
+	std::unique_ptr<IPluginRuntime> m_pRuntime;
+	std::unique_ptr<CPhraseCollection> m_pPhrases;
 	IPluginContext *m_pContext;
 	sp_pubvar_t *m_MaxClientsVar;
 	StringHashMap<void *> m_Props;
@@ -286,11 +289,11 @@ private:
 
 	// Cached.
 	sm_plugininfo_t m_info;
-	ke::AString info_name_;
-	ke::AString info_author_;
-	ke::AString info_description_;
-	ke::AString info_version_;
-	ke::AString info_url_;
+	std::string info_name_;
+	std::string info_author_;
+	std::string info_description_;
+	std::string info_version_;
+	std::string info_url_;
 };
 
 class CPluginManager : 
@@ -317,8 +320,8 @@ public:
 		void Release();
 		void OnPluginDestroyed(IPlugin *plugin) override;
 	private:
-		ke::LinkedList<CPlugin *> mylist;
-		ke::LinkedList<CPlugin *>::iterator current;
+		std::list<CPlugin *> mylist;
+		std::list<CPlugin *>::iterator current;
 	};
 	friend class CPluginManager::CPluginIterator;
 public: //IScriptManager
@@ -432,7 +435,7 @@ public:
 
 	void _SetPauseState(CPlugin *pPlugin, bool pause);
 
-	void ForEachPlugin(ke::Lambda<void(CPlugin *)> callback);
+	void ForEachPlugin(ke::Function<void(CPlugin *)> callback);
 private:
 	LoadRes LoadPlugin(CPlugin **pPlugin, const char *path, bool debug, PluginType type);
 
@@ -473,7 +476,7 @@ private:
 private:
 	ReentrantList<IPluginsListener *> m_listeners;
 	ReentrantList<CPlugin *> m_plugins;
-	ke::LinkedList<CPluginIterator *> m_iterators;
+	std::list<CPluginIterator *> m_iterators;
 
 	typedef decltype(m_listeners)::iterator ListenerIter;
 	typedef decltype(m_plugins)::iterator PluginIter;
@@ -484,10 +487,8 @@ private:
 		{
 /* For windows & mac, we convert the path to lower-case in order to avoid duplicate plugin loading */
 #if defined PLATFORM_WINDOWS || defined PLATFORM_APPLE
-			ke::AString original(key.chars());
-			ke::AString lower = original.lowercase();
-			
-			return detail::CharsAndLength(lower.chars()).hash();
+			std::string lower = ke::Lowercase(key.c_str());
+			return detail::CharsAndLength(lower.c_str()).hash();
 #else
 			return key.hash();
 #endif
@@ -497,8 +498,8 @@ private:
 		{
 			const char *pluginFileChars = const_cast<CPlugin*>(plugin)->GetFilename();
 #if defined PLATFORM_WINDOWS || defined PLATFORM_APPLE
-			ke::AString pluginFile = ke::AString(pluginFileChars).lowercase();
-			ke::AString input = ke::AString(file).lowercase();
+			std::string pluginFile = ke::Lowercase(pluginFileChars);
+			std::string input = ke::Lowercase(file);
 			
 			return pluginFile == input;
 #else
@@ -522,6 +523,7 @@ private:
 	// Forwards
 	IForward *m_pOnLibraryAdded;
 	IForward *m_pOnLibraryRemoved;
+	IForward *m_pOnNotifyPluginUnloaded;
 };
 
 extern CPluginManager g_PluginSys;

core/logic/ProfileTools.cpp

@@ -52,7 +52,7 @@ ProfileToolManager::OnSourceModShutdown()
 IProfilingTool *
 ProfileToolManager::FindToolByName(const char *name)
 {
-	for (size_t i = 0; i < tools_.length(); i++) {
+	for (size_t i = 0; i < tools_.size(); i++) {
 		if (strcmp(tools_[i]->Name(), name) == 0)
 			return tools_[i];
 	}
@@ -97,7 +97,7 @@ ProfileToolManager::StartFromConsole(IProfilingTool *tool)
 void
 ProfileToolManager::OnRootConsoleCommand(const char *cmdname, const ICommandArgs *args)
 {
-	if (tools_.length() == 0) {
+	if (tools_.size() == 0) {
 		rootmenu->ConsolePrint("No profiling tools are enabled.");
 		return;
 	}
@@ -107,7 +107,7 @@ ProfileToolManager::OnRootConsoleCommand(const char *cmdname, const ICommandArgs
 
 		if (strcmp(cmdname, "list") == 0) {
 			rootmenu->ConsolePrint("Profiling tools:");
-			for (size_t i = 0; i < tools_.length(); i++) {
+			for (size_t i = 0; i < tools_.size(); i++) {
 				rootmenu->DrawGenericOption(tools_[i]->Name(), tools_[i]->Description());
 			}
 			return;
@@ -135,7 +135,7 @@ ProfileToolManager::OnRootConsoleCommand(const char *cmdname, const ICommandArgs
 			if (strcmp(cmdname, "start") == 0) {
 				if (!default_) {
 					default_ = FindToolByName("vprof");
-					if (!default_ && tools_.length() > 0)
+					if (!default_ && tools_.size() > 0)
 						default_ = tools_[0];
 					if (!default_) {
 						rootmenu->ConsolePrint("Could not find any profiler to use.");

core/logic/ProfileTools.h

@@ -51,7 +51,7 @@ public:
 	void OnRootConsoleCommand(const char *cmdname, const ICommandArgs *args) override;
 
 	void RegisterTool(IProfilingTool *tool) {
-		tools_.append(tool);
+		tools_.push_back(tool);
 	}
 
 	bool IsActive() const {
@@ -76,7 +76,7 @@ private:
 	void StartFromConsole(IProfilingTool *tool);
 
 private:
-	ke::Vector<IProfilingTool *> tools_;
+	std::vector<IProfilingTool *> tools_;
 	IProfilingTool *active_;
 	IProfilingTool *default_;
 	bool enabled_;

core/logic/RootConsoleMenu.cpp

@@ -221,11 +221,15 @@ void RootConsoleMenu::OnRootConsoleCommand(const char *cmdname, const ICommandAr
 		ConsolePrint("  Fyren");
 		ConsolePrint("  Nicholas \"psychonic\" Hastings");
 		ConsolePrint("  Asher \"asherkin\" Baker");
+		ConsolePrint("  Ruben \"Dr!fter\" Gonzalez");
+		ConsolePrint("  Josh \"KyleS\" Allard");
+		ConsolePrint("  Michael \"Headline\" Flaherty");
+		ConsolePrint("  Jannik \"Peace-Maker\" Hartung");
 		ConsolePrint("  Borja \"faluco\" Ferrer");
 		ConsolePrint("  Pavol \"PM OnoTo\" Marko");
 		ConsolePrint(" Special thanks to Liam, ferret, and Mani");
 		ConsolePrint(" Special thanks to Viper and SteamFriends");
-		ConsolePrint(" http://www.sourcemod.net/");
+		ConsolePrint(" https://www.sourcemod.net/");
 	}
 	else if (strcmp(cmdname, "version") == 0)
 	{

core/logic/ShareSys.cpp

@@ -29,13 +29,16 @@
  * Version: $Id$
  */
 
+#include <assert.h>
+
+#include <memory>
+
 #include "ShareSys.h"
 #include "ExtensionSys.h"
 #include <ILibrarySys.h>
 #include "common_logic.h"
 #include "PluginSys.h"
 #include "HandleSys.h"
-#include <assert.h>
 
 using namespace ke;
 
@@ -361,11 +364,11 @@ void ShareSystem::BindNativeToPlugin(CPlugin *pPlugin, const sp_native_t *native
 		}
 	}
 
-	pPlugin->GetRuntime()->UpdateNativeBinding(
-	  index,
-	  pEntry->func(),
-	  flags,
-	  nullptr);
+	auto rt = pPlugin->GetRuntime();
+	if (pEntry->fake)
+		rt->UpdateNativeBindingObject(index, pEntry->fake->wrapper, flags, nullptr);
+	else
+		rt->UpdateNativeBinding(index, pEntry->native->func, flags, nullptr);
 }
 
 AlreadyRefed<Native> ShareSystem::AddNativeToCache(CNativeOwner *pOwner, const sp_nativeinfo_t *ntv)
@@ -379,11 +382,6 @@ AlreadyRefed<Native> ShareSystem::AddNativeToCache(CNativeOwner *pOwner, const s
 	return entry.forget();
 }
 
-FakeNative::~FakeNative()
-{
-	g_pSourcePawn2->DestroyFakeNative(gate);
-}
-
 void ShareSystem::ClearNativeFromCache(CNativeOwner *pOwner, const char *name)
 {
 	NativeCache::Result r = m_NtvCache.find(name);
@@ -400,21 +398,44 @@ void ShareSystem::ClearNativeFromCache(CNativeOwner *pOwner, const char *name)
 	m_NtvCache.remove(r);
 }
 
+class DynamicNative final : public INativeCallback
+{
+public:
+	DynamicNative(SPVM_FAKENATIVE_FUNC callback, void* data)
+		: callback_(callback),
+		  data_(data)
+	{}
+
+	void AddRef() override {
+		refcount_++;
+	}
+	void Release() override {
+		assert(refcount_ > 0);
+		if (--refcount_ == 0)
+			delete this;
+	}
+	int Invoke(IPluginContext* ctx, const cell_t* params) override {
+		return callback_(ctx, params, data_);
+	}
+
+private:
+	size_t refcount_ = 0;
+	SPVM_FAKENATIVE_FUNC callback_;
+	void* data_;
+};
+
 AlreadyRefed<Native> ShareSystem::AddFakeNative(IPluginFunction *pFunc, const char *name, SPVM_FAKENATIVE_FUNC func)
 {
 	RefPtr<Native> entry(FindNative(name));
 	if (entry)
 		return nullptr;
 
-	AutoPtr<FakeNative> fake(new FakeNative(name, pFunc));
-
-	fake->gate = g_pSourcePawn2->CreateFakeNative(func, fake);
-	if (!fake->gate)
-		return nullptr;
+	std::unique_ptr<FakeNative> fake(new FakeNative(name, pFunc));
+	fake->wrapper = new DynamicNative(func, fake.get());
 
 	CNativeOwner *owner = g_PluginSys.GetPluginByCtx(fake->ctx->GetContext());
 
-	entry = new Native(owner, fake.take());
+	entry = new Native(owner, std::move(fake));
 	m_NtvCache.insert(name, entry);
 
 	return entry.forget();

core/logic/ShareSys.h

@@ -49,9 +49,11 @@ namespace SourceMod
 {
 	struct IdentityToken_t
 	{
-		Handle_t ident;
-		void *ptr;
-		IdentityType_t type;
+		Handle_t ident = 0;
+		void *ptr = nullptr;
+		IdentityType_t type = 0;
+		size_t num_handles = 0;
+		bool warned_handle_usage = false;
 	};
 };
 

core/logic/ThreadSupport.cpp

@@ -1,5 +1,5 @@
 /**
- * vim: set ts=4 sw=4 :
+ * vim: set ts=4 sw=4 tw=99 noet :
  * =============================================================================
  * SourceMod
  * Copyright (C) 2004-2009 AlliedModders LLC.  All rights reserved.
@@ -29,17 +29,518 @@
  * Version: $Id$
  */
 #include <sm_platform.h>
+#include <amtl/am-deque.h>
+#include <amtl/am-maybe.h>
+#include <amtl/am-thread.h>
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include "BaseWorker.h"
 #include "ThreadSupport.h"
 #include "common_logic.h"
 
-#if defined PLATFORM_POSIX
-#include "thread/PosixThreads.h"
-#elif defined PLATFORM_WINDOWS
-#include "thread/WinThreads.h"
-#endif
+static constexpr unsigned int DEFAULT_THINK_TIME_MS	= 20;
 
-MainThreader g_MainThreader;
-IThreader *g_pThreader = &g_MainThreader;
+class CompatWorker final : public IThreadWorker
+{
+  public:
+	explicit CompatWorker(IThreadWorkerCallbacks* callbacks);
+	~CompatWorker();
+
+	void MakeThread(IThread *pThread) override;
+	IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags) override;
+	IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params) override;
+	void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min) override;
+	unsigned int RunFrame() override;
+	bool Pause() override;
+	bool Unpause() override;
+	bool Start() override;
+	bool Stop(bool flush) override;
+	WorkerState GetStatus(unsigned int *numThreads) override;
+	void SetMaxThreadsPerFrame(unsigned int threads) override;
+	void SetThinkTimePerFrame(unsigned int thinktime) override;
+
+  private:
+	void Flush();
+	void Worker();
+	void RunWork(SWThreadHandle* handle);
+	void RunWorkLocked(std::unique_lock<std::mutex>* lock, SWThreadHandle* handle);
+
+  private:
+	IThreadWorkerCallbacks* callbacks_;
+	WorkerState state_;
+	std::mutex mutex_;
+	std::condition_variable work_cv_;
+	std::deque<SWThreadHandle*> work_;
+	std::unique_ptr<std::thread> thread_;
+	std::atomic<unsigned int> jobs_per_wakeup_;
+	std::atomic<unsigned int> wait_between_jobs_;
+};
+
+CompatWorker::CompatWorker(IThreadWorkerCallbacks* callbacks)
+	: callbacks_(callbacks),
+	  state_(Worker_Stopped),
+	  jobs_per_wakeup_(SM_DEFAULT_THREADS_PER_FRAME),
+	  wait_between_jobs_(DEFAULT_THINK_TIME_MS)
+{
+}
+
+CompatWorker::~CompatWorker()
+{
+	Stop(false /* ignored */);
+	Flush();
+}
+
+bool CompatWorker::Start()
+{
+	std::lock_guard<std::mutex> lock(mutex_);
+	if (state_ != Worker_Stopped)
+		return false;
+
+	thread_ = ke::NewThread("SM CompatWorker Thread", [this]() -> void {
+		Worker();
+	});
+
+	state_ = Worker_Running;
+	return true;
+}
+
+bool CompatWorker::Stop(bool)
+{
+	{
+		std::lock_guard<std::mutex> lock(mutex_);
+
+		if (state_ <= Worker_Stopped)
+			return false;
+
+		state_ = Worker_Stopped;
+		work_cv_.notify_all();
+	}
+
+	thread_->join();
+	thread_ = nullptr;
+
+	Flush();
+	return true;
+}
+
+bool CompatWorker::Pause()
+{
+	std::lock_guard<std::mutex> lock(mutex_);
+	if (state_ != Worker_Running)
+		return false;
+
+	state_ = Worker_Paused;
+	work_cv_.notify_all();
+	return true;
+}
+
+bool CompatWorker::Unpause()
+{
+	std::lock_guard<std::mutex> lock(mutex_);
+	if (state_ != Worker_Paused)
+		return false;
+
+	state_ = Worker_Running;
+	work_cv_.notify_all();
+	return true;
+}
+
+void CompatWorker::Flush()
+{
+	while (!work_.empty()) {
+		auto handle = ke::PopFront(&work_);
+		handle->GetThread()->OnTerminate(handle, true);
+		if (handle->m_params.flags & Thread_AutoRelease)
+			delete handle;
+	}
+}
+
+void CompatWorker::Worker()
+{
+	// Note: this must be first to ensure an ordering between Worker() and
+	// Start(). It must also be outside of the loop to ensure the lock is
+	// held across wakeup and retesting the predicates.
+	std::unique_lock<std::mutex> lock(mutex_);
+
+	if (callbacks_) {
+		lock.unlock();
+		callbacks_->OnWorkerStart(this);
+		lock.lock();
+	}
+
+	typedef std::chrono::system_clock Clock;
+	typedef std::chrono::time_point<Clock> TimePoint;
+
+	auto can_work = [this]() -> bool {
+		return state_ == Worker_Running && !work_.empty();
+	};
+
+	ke::Maybe<TimePoint> wait;
+	unsigned int work_in_frame = 0;
+	for (;;) {
+		if (state_ == Worker_Stopped)
+			break;
+
+		if (!can_work()) {
+			// Wait for work or a Stop.
+			work_cv_.wait(lock);
+			continue;
+		}
+
+		if (wait.isValid()) {
+			// Wait until the specified time has passed. If we wake up with a
+			// timeout, then the wait has elapsed, so reset the holder.
+			if (work_cv_.wait_until(lock, wait.get()) == std::cv_status::timeout)
+				wait = ke::Nothing();
+			continue;
+		}
+
+		assert(state_ == Worker_Running);
+		assert(!work_.empty());
+
+		SWThreadHandle* handle = ke::PopFront(&work_);
+		RunWorkLocked(&lock, handle);
+		work_in_frame++;
+
+		// If we've reached our max jobs per "frame", signal that the next
+		// immediate job must be delayed. We retain the old ThreadWorker
+		// behavior by checking if the queue has more work. Thus, a delay
+		// only occurs if two jobs would be processed in the same wakeup.
+		if (work_in_frame >= jobs_per_wakeup_ && wait_between_jobs_ && can_work())
+			wait = ke::Some(Clock::now() + std::chrono::milliseconds(wait_between_jobs_));
+	}
+
+	assert(lock.owns_lock());
+
+	while (!work_.empty()) {
+		SWThreadHandle* handle = ke::PopFront(&work_);
+		RunWorkLocked(&lock, handle);
+	}
+}
+
+unsigned int CompatWorker::RunFrame()
+{
+	unsigned int nprocessed = 0;
+	for (unsigned int i = 1; i <= jobs_per_wakeup_; i++) {
+		SWThreadHandle* handle;
+		{
+			std::lock_guard<std::mutex> lock(mutex_);
+			if (work_.empty())
+				break;
+			handle = ke::PopFront(&work_);
+		}
+
+		RunWork(handle);
+		nprocessed++;
+	}
+	return nprocessed;
+}
+
+void CompatWorker::RunWorkLocked(std::unique_lock<std::mutex>* lock, SWThreadHandle* handle)
+{
+	lock->unlock();
+	RunWork(handle);
+	lock->lock();
+}
+
+void CompatWorker::RunWork(SWThreadHandle* handle)
+{
+	bool autorelease = !!(handle->m_params.flags & Thread_AutoRelease);
+	handle->m_state = Thread_Running;
+	handle->GetThread()->RunThread(handle);
+	handle->m_state = Thread_Done;
+	handle->GetThread()->OnTerminate(handle, false);
+	if (autorelease)
+		delete handle;
+}
+
+void CompatWorker::MakeThread(IThread *pThread)
+{
+	ThreadParams params;
+	params.flags = Thread_AutoRelease;
+	MakeThread(pThread, &params);
+}
+
+IThreadHandle *CompatWorker::MakeThread(IThread *pThread, ThreadFlags flags)
+{
+	ThreadParams params;
+	params.flags = flags;
+	return MakeThread(pThread, &params);
+}
+
+IThreadHandle *CompatWorker::MakeThread(IThread *pThread, const ThreadParams *params)
+{
+	std::lock_guard<std::mutex> lock(mutex_);
+
+	ThreadParams def_params;
+	if (!params)
+		params = &def_params;
+
+	if (state_ <= Worker_Stopped)
+		return nullptr;
+
+	SWThreadHandle* handle = new SWThreadHandle(this, params, pThread);
+	work_.push_back(handle);
+	work_cv_.notify_one();
+	return handle;
+}
+
+void CompatWorker::GetPriorityBounds(ThreadPriority &max, ThreadPriority &min)
+{
+	min = ThreadPrio_Normal;
+	max = ThreadPrio_Normal;
+}
+
+void CompatWorker::SetMaxThreadsPerFrame(unsigned int threads)
+{
+	jobs_per_wakeup_ = threads;
+}
+
+void CompatWorker::SetThinkTimePerFrame(unsigned int thinktime)
+{
+	wait_between_jobs_ = thinktime;
+}
+
+WorkerState CompatWorker::GetStatus(unsigned int *numThreads)
+{ 
+	std::lock_guard<std::mutex> lock(mutex_);
+
+	// This number is meaningless and the status is racy.
+	if (numThreads)
+		*numThreads = jobs_per_wakeup_;
+	return state_;
+}
+
+class CompatThread final : public IThreadHandle
+{
+public:
+	CompatThread(IThread* callbacks, const ThreadParams* params);
+
+	bool WaitForThread() override;
+	void DestroyThis() override;
+	IThreadCreator *Parent() override;
+	void GetParams(ThreadParams *ptparams) override;
+	ThreadPriority GetPriority() override;
+	bool SetPriority(ThreadPriority prio) override;
+	ThreadState GetState() override;
+	bool Unpause() override;
+
+private:
+	void Run();
+
+private:
+	IThread* callbacks_;
+	ThreadParams params_;
+	std::unique_ptr<std::thread> thread_;
+	std::mutex mutex_;
+	std::condition_variable check_cv_;
+	std::atomic<bool> finished_;
+};
+
+CompatThread::CompatThread(IThread* callbacks, const ThreadParams* params)
+	: callbacks_(callbacks),
+	  params_(*params)
+{
+	if (!(params_.flags & Thread_CreateSuspended))
+		Unpause();
+}
+
+bool CompatThread::Unpause()
+{
+	std::unique_lock<std::mutex> lock(mutex_);
+	if (thread_)
+		return false;
+
+	thread_ = ke::NewThread("SM CompatThread", [this]() -> void {
+		Run();
+	});
+
+	return true;
+}
+
+void CompatThread::Run()
+{
+	// Create an ordering between when the thread runs and when thread_ is assigned.
+	std::unique_lock<std::mutex> lock(mutex_);
+
+	lock.unlock();
+	callbacks_->RunThread(this);
+	finished_ = true;
+	callbacks_->OnTerminate(this, false);
+
+	if (params_.flags & Thread_AutoRelease) {
+		// There should be no handles outstanding, so it's safe to self-destruct.
+		thread_->detach();
+		delete this;
+		return;
+	}
+
+	lock.lock();
+	callbacks_ = nullptr;
+	check_cv_.notify_all();
+}
+
+bool CompatThread::WaitForThread()
+{
+	std::unique_lock<std::mutex> lock(mutex_);
+	for (;;) {
+		// When done, callbacks are unset. If paused, this will deadlock.
+		if (!callbacks_)
+			break;
+		check_cv_.wait(lock);
+	}
+
+	thread_->join();
+	return true;
+}
+
+ThreadState CompatThread::GetState()
+{
+	std::unique_lock<std::mutex> lock(mutex_);
+	if (!thread_)
+		return Thread_Paused;
+	return finished_ ? Thread_Done : Thread_Running;
+}
+
+void CompatThread::DestroyThis()
+{
+	delete this;
+}
+
+ThreadPriority CompatThread::GetPriority()
+{
+	return ThreadPrio_Normal;
+}
+
+bool CompatThread::SetPriority(ThreadPriority prio)
+{
+	return prio == ThreadPrio_Normal;
+}
+
+IThreadCreator *CompatThread::Parent()
+{
+	return g_pThreader;
+}
+
+void CompatThread::GetParams(ThreadParams *ptparams)
+{
+	*ptparams = params_;
+}
+
+class CompatMutex : public IMutex
+{
+public:
+	bool TryLock() {
+		return mutex_.try_lock();
+	}
+	void Lock() {
+		mutex_.lock();
+	}
+	void Unlock() {
+		mutex_.unlock();
+	}
+	void DestroyThis() {
+		delete this;
+	}
+private:
+	std::mutex mutex_;
+};
+
+class CompatThreader final : public IThreader
+{
+public:
+	void MakeThread(IThread *pThread) override;
+	IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags) override;
+	IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params) override;
+	void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min) override;
+	IMutex *MakeMutex() override;
+	void ThreadSleep(unsigned int ms) override;
+	IEventSignal *MakeEventSignal() override;
+	IThreadWorker *MakeWorker(IThreadWorkerCallbacks *hooks, bool threaded) override;
+	void DestroyWorker(IThreadWorker *pWorker) override;
+} sCompatThreader;
+
+void CompatThreader::MakeThread(IThread *pThread)
+{
+	ThreadParams params;
+	params.flags = Thread_AutoRelease;
+	MakeThread(pThread, &params);
+}
+
+IThreadHandle *CompatThreader::MakeThread(IThread *pThread, ThreadFlags flags)
+{
+	ThreadParams params;
+	params.flags = flags;
+	return MakeThread(pThread, &params);
+}
+
+IThreadHandle *CompatThreader::MakeThread(IThread *pThread, const ThreadParams *params)
+{
+	ThreadParams def_params;
+	if (!params)
+		params = &def_params;
+
+	return new CompatThread(pThread, params);
+}
+
+void CompatThreader::GetPriorityBounds(ThreadPriority &max, ThreadPriority &min)
+{
+	min = ThreadPrio_Normal;
+	max = ThreadPrio_Normal;
+}
+
+IMutex *CompatThreader::MakeMutex()
+{
+	return new CompatMutex();
+}
+
+void CompatThreader::ThreadSleep(unsigned int ms)
+{
+	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+}
+
+class CompatEventSignal final : public IEventSignal
+{
+public:
+	void Wait() override {
+		std::unique_lock<std::mutex> lock(mutex_);
+		cv_.wait(lock);
+	}
+	void Signal() override {
+		std::lock_guard<std::mutex> lock(mutex_);
+		cv_.notify_all();
+	}
+	void DestroyThis() override {
+		delete this;
+	}
+
+private:
+	std::mutex mutex_;
+	std::condition_variable cv_;
+};
+
+IEventSignal *CompatThreader::MakeEventSignal()
+{
+	return new CompatEventSignal();
+}
+
+IThreadWorker *CompatThreader::MakeWorker(IThreadWorkerCallbacks *hooks, bool threaded)
+{
+	if (!threaded)
+		return new BaseWorker(hooks);
+    return new CompatWorker(hooks);
+}
+
+void CompatThreader::DestroyWorker(IThreadWorker *pWorker)
+{
+	delete pWorker;
+}
+
+IThreader *g_pThreader = &sCompatThreader;
 
 class RegThreadStuff : public SMGlobalClass
 {

core/logic/ThreadSupport.h

@@ -32,49 +32,13 @@
 #ifndef _INCLUDE_SOURCEMOD_THREAD_SUPPORT_H
 #define _INCLUDE_SOURCEMOD_THREAD_SUPPORT_H
 
+#include <mutex>
+
 #include <IThreader.h>
-#include <am-thread-utils.h>
 #include <am-utility.h>
 
 using namespace SourceMod;
 
-class CompatMutex : public IMutex
-{
-public:
-	bool TryLock() {
-		return mutex_.TryLock();
-	}
-	void Lock() {
-		mutex_.Lock();
-	}
-	void Unlock() {
-		mutex_.Unlock();
-	}
-	void DestroyThis() {
-		delete this;
-	}
-private:
-	ke::Mutex mutex_;
-};
-
-class CompatCondVar : public IEventSignal
-{
-public:
-	void Wait() {
-		ke::AutoLock lock(&cv_);
-		cv_.Wait();
-	}
-	void Signal() {
-		ke::AutoLock lock(&cv_);
-		cv_.Notify();
-	}
-	void DestroyThis() {
-		delete this;
-	}
-private:
-	ke::ConditionVariable cv_;
-};
-
 extern IThreader *g_pThreader;
 
 #endif //_INCLUDE_SOURCEMOD_THREAD_SUPPORT_H

core/logic/common_logic.cpp

@@ -56,6 +56,7 @@
 #include "LibrarySys.h"
 #include "RootConsoleMenu.h"
 #include "CellArray.h"
+#include "smn_entitylump.h"
 #include <bridge/include/BridgeAPI.h>
 #include <bridge/include/IProviderCallbacks.h>
 
@@ -89,6 +90,8 @@ CNativeOwner g_CoreNatives;
 PseudoAddressManager pseudoAddr;
 #endif
 
+EntityLumpParseResult lastParseResult;
+
 static void AddCorePhraseFile(const char *filename)
 {
 	g_pCorePhrases->AddPhraseFile(filename);
@@ -135,6 +138,35 @@ static uint32_t ToPseudoAddress(void *addr)
 #endif
 }
 
+static void SetEntityLumpWritable(bool writable)
+{
+	g_bLumpAvailableForWriting = writable;
+	
+	// write-lock causes the map entities to be serialized out to string
+	if (!writable)
+	{
+		g_strMapEntities = lumpmanager->Dump();
+	}
+}
+
+static bool ParseEntityLumpString(const char *pMapEntities, int &status, size_t &position)
+{
+	lastParseResult = lumpmanager->Parse(pMapEntities);
+	status = static_cast<int>(lastParseResult.m_Status);
+	position = static_cast<size_t>(lastParseResult.m_Position);
+	return lastParseResult;
+}
+
+// returns nullptr if the original lump failed to parse
+static const char* GetEntityLumpString()
+{
+	if (!lastParseResult)
+	{
+		return nullptr;
+	}
+	return g_strMapEntities.c_str();
+}
+
 // Defined in smn_filesystem.cpp.
 extern bool OnLogPrint(const char *msg);
 
@@ -170,6 +202,9 @@ static sm_logic_t logic =
 	CellArray::Free,
 	FromPseudoAddress,
 	ToPseudoAddress,
+	SetEntityLumpWritable,
+	ParseEntityLumpString,
+	GetEntityLumpString,
 	&g_PluginSys,
 	&g_ShareSys,
 	&g_Extensions,

core/logic/frame_tasks.cpp

@@ -26,16 +26,17 @@
 // or <http://www.sourcemod.net/license.php>.
 #include "frame_tasks.h"
 #include <am-vector.h>
+#include <utility>
 
 using namespace SourceMod;
 
-ke::Vector<ke::Lambda<void()>> sNextTasks;
-ke::Vector<ke::Lambda<void()>> sWorkTasks;
+std::vector<ke::Function<void()>> sNextTasks;
+std::vector<ke::Function<void()>> sWorkTasks;
 
 void
-SourceMod::ScheduleTaskForNextFrame(ke::Lambda<void()>&& task)
+SourceMod::ScheduleTaskForNextFrame(ke::Function<void()>&& task)
 {
-	sNextTasks.append(ke::Forward<decltype(task)>(task));
+	sNextTasks.push_back(std::forward<decltype(task)>(task));
 }
 
 void
@@ -45,11 +46,11 @@ SourceMod::RunScheduledFrameTasks(bool simulating)
 		return;
 
 	// Swap.
-	ke::Vector<ke::Lambda<void()>> temp(ke::Move(sNextTasks));
-	sNextTasks = ke::Move(sWorkTasks);
-	sWorkTasks = ke::Move(temp);
+	std::vector<ke::Function<void()>> temp(std::move(sNextTasks));
+	sNextTasks = std::move(sWorkTasks);
+	sWorkTasks = std::move(temp);
 
-	for (size_t i = 0; i < sWorkTasks.length(); i++)
+	for (size_t i = 0; i < sWorkTasks.size(); i++)
 		sWorkTasks[i]();
 	sWorkTasks.clear();
-}
+}

core/logic/frame_tasks.h

@@ -31,10 +31,10 @@
 
 namespace SourceMod {
 
-void ScheduleTaskForNextFrame(ke::Lambda<void()>&& task);
+void ScheduleTaskForNextFrame(ke::Function<void()>&& task);
 
 void RunScheduledFrameTasks(bool simulating);
 
 }
 
-#endif // _include_sourcemod_logic_frame_tasks_h_
+#endif // _include_sourcemod_logic_frame_tasks_h_

core/logic/sm_crc32.cpp

@@ -89,6 +89,6 @@ unsigned int UTIL_CRC32(const void *pdata, size_t data_length)
 		crc = CRCTable[c] ^ (crc >> 8);
 	}
 
-	return crc;
+	return ~crc;
 }
 

core/logic/smn_adt_array.cpp

@@ -75,7 +75,11 @@ static cell_t CreateArray(IPluginContext *pContext, const cell_t *params)
 
 	if (params[2])
 	{
-		array->resize(params[2]);
+		if (!array->resize(params[2]))
+		{
+			delete array;
+			return pContext->ThrowNativeError("Failed to resize array to startsize \"%u\".", params[2]);
+		}
 	}
 
 	Handle_t hndl = handlesys->CreateHandle(htCellArray, array, pContext->GetIdentity(), g_pCoreIdent, NULL);

core/logic/smn_adt_stack.cpp

@@ -83,6 +83,48 @@ static cell_t CreateStack(IPluginContext *pContext, const cell_t *params)
 	return hndl;
 }
 
+static cell_t ClearStack(IPluginContext *pContext, const cell_t *params)
+{
+	CellArray *array;
+	HandleError err;
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+
+	if ((err = handlesys->ReadHandle(params[1], htCellStack, &sec, (void **)&array)) != HandleError_None)
+	{
+		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);
+	}
+
+	array->clear();
+
+	return 1;
+}
+
+static cell_t CloneStack(IPluginContext *pContext, const cell_t *params)
+{
+	CellArray *oldArray;
+	HandleError err;
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+
+	if ((err = handlesys->ReadHandle(params[1], htCellStack, &sec, (void **)&oldArray)) != HandleError_None)
+	{
+		return pContext->ThrowNativeError("Invalid Handle %x (error: %d)", params[1], err);
+	}
+
+	ICellArray *array = oldArray->clone();
+	if (!array)
+	{
+		return pContext->ThrowNativeError("Failed to clone stack. Out of memory.");
+	}
+
+	Handle_t hndl = handlesys->CreateHandle(htCellStack, array, pContext->GetIdentity(), g_pCoreIdent, NULL);
+	if (!hndl)
+	{
+		delete array;
+	}
+
+	return hndl;
+}
+
 static cell_t PushStackCell(IPluginContext *pContext, const cell_t *params)
 {
 	CellArray *array;
@@ -387,6 +429,7 @@ static cell_t GetStackBlockSize(IPluginContext *pContext, const cell_t *params)
 REGISTER_NATIVES(cellStackNatives)
 {
 	{"CreateStack",					CreateStack},
+	{"CloneStack",					CloneStack},
 	{"IsStackEmpty",				IsStackEmpty},
 	{"PopStackArray",				PopStackArray},
 	{"PopStackCell",				PopStackCell},
@@ -398,6 +441,8 @@ REGISTER_NATIVES(cellStackNatives)
 
 	// Transitional syntax support.
 	{"ArrayStack.ArrayStack",		CreateStack},
+	{"ArrayStack.Clear",			ClearStack},
+	{"ArrayStack.Clone",			CloneStack},
 	{"ArrayStack.Pop",				ArrayStack_Pop},
 	{"ArrayStack.PopString",		ArrayStack_PopString},
 	{"ArrayStack.PopArray",			ArrayStack_PopArray},

core/logic/smn_adt_trie.cpp

@@ -30,9 +30,10 @@
  */
 
 #include <stdlib.h>
+
+#include <memory>
+
 #include "common_logic.h"
-#include <am-autoptr.h>
-#include <am-moveable.h>
 #include <am-refcounting.h>
 #include <sm_stringhashmap.h>
 #include "sm_memtable.h"
@@ -103,7 +104,7 @@ public:
 		assert(isArray());
 		return reinterpret_cast<cell_t *>(raw()->base());
 	}
-	char *chars() const {
+	char *c_str() const {
 		assert(isString());
 		return reinterpret_cast<char *>(raw()->base());
 	}
@@ -182,7 +183,7 @@ struct TrieSnapshot
 	}
 
 	size_t length;
-	ke::AutoPtr<int[]> keys;
+	std::unique_ptr<int[]> keys;
 	BaseStringTable strings;
 };
 
@@ -349,6 +350,27 @@ static cell_t SetTrieString(IPluginContext *pContext, const cell_t *params)
 	return 1;
 }
 
+static cell_t ContainsKeyInTrie(IPluginContext *pContext, const cell_t *params)
+{
+	CellTrie *pTrie;
+	HandleError err;
+	HandleSecurity sec = HandleSecurity(pContext->GetIdentity(), g_pCoreIdent);
+
+	Handle_t hndl = params[1];
+
+	if ((err = handlesys->ReadHandle(hndl, htCellTrie, &sec, (void **)&pTrie)) != HandleError_None)
+	{
+		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", hndl, err);
+	}
+
+	char *key;
+	pContext->LocalToString(params[2], &key);
+
+	StringHashMap<Entry>::Result r = pTrie->map.find(key);
+
+	return r.found() ? 1 : 0;
+}
+
 static cell_t RemoveFromTrie(IPluginContext *pContext, const cell_t *params)
 {
 	CellTrie *pTrie;
@@ -517,7 +539,7 @@ static cell_t GetTrieString(IPluginContext *pContext, const cell_t *params)
 		return 0;
 
 	size_t written;
-	pContext->StringToLocalUTF8(params[3], params[4], r->value.chars(), &written);
+	pContext->StringToLocalUTF8(params[3], params[4], r->value.c_str(), &written);
 
 	*pSize = (cell_t)written;
 	return 1;
@@ -557,10 +579,10 @@ static cell_t CreateTrieSnapshot(IPluginContext *pContext, const cell_t *params)
 
 	TrieSnapshot *snapshot = new TrieSnapshot;
 	snapshot->length = pTrie->map.elements();
-	snapshot->keys = ke::MakeUnique<int[]>(snapshot->length);
+	snapshot->keys = std::make_unique<int[]>(snapshot->length);
 	size_t i = 0;
 	for (StringHashMap<Entry>::iterator iter = pTrie->map.iter(); !iter.empty(); iter.next(), i++)
-		snapshot->keys[i] = snapshot->strings.AddString(iter->key.chars(), iter->key.length());
+		 snapshot->keys[i] = snapshot->strings.AddString(iter->key.c_str(), iter->key.length());
 	assert(i == snapshot->length);
 
 	if ((hndl = handlesys->CreateHandle(htSnapshot, snapshot, pContext->GetIdentity(), g_pCoreIdent, NULL))
@@ -635,6 +657,56 @@ static cell_t GetTrieSnapshotKey(IPluginContext *pContext, const cell_t *params)
 	return written;
 }
 
+static cell_t CloneTrie(IPluginContext *pContext, const cell_t *params)
+{
+	HandleError err;
+	HandleSecurity sec = HandleSecurity(pContext->GetIdentity(), g_pCoreIdent);
+
+	CellTrie *pOldTrie;
+	if ((err = handlesys->ReadHandle(params[1], htCellTrie, &sec, (void **)&pOldTrie))
+		!= HandleError_None)
+	{
+		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
+	}
+
+	CellTrie *pNewTrie = new CellTrie;
+	Handle_t hndl = handlesys->CreateHandle(htCellTrie, pNewTrie, pContext->GetIdentity(), g_pCoreIdent, NULL);
+	if (!hndl)
+	{
+		delete pNewTrie;
+		return hndl;
+	}
+
+	for (StringHashMap<Entry>::iterator it = pOldTrie->map.iter(); !it.empty(); it.next())
+	{
+		const char *key = it->key.c_str();
+		StringHashMap<Entry>::Insert insert = pNewTrie->map.findForAdd(key);
+		if (pNewTrie->map.add(insert, key))
+		{
+			StringHashMap<Entry>::Result result = pOldTrie->map.find(key);
+			if (result->value.isCell())
+			{
+				insert->value.setCell(result->value.cell());
+			}
+			else if (result->value.isString())
+			{
+				insert->value.setString(result->value.c_str());
+			}
+			else if (result->value.isArray())
+			{
+				insert->value.setArray(result->value.array(), result->value.arrayLength());
+			}
+			else
+			{
+				handlesys->FreeHandle(hndl, NULL);
+				return pContext->ThrowNativeError("Unhandled data type encountered, file a bug and reference pr #852");
+			}
+		}
+	}
+
+	return hndl;
+}
+
 REGISTER_NATIVES(trieNatives)
 {
 	{"ClearTrie",				ClearTrie},
@@ -659,12 +731,14 @@ REGISTER_NATIVES(trieNatives)
 	{"StringMap.GetArray",		GetTrieArray},
 	{"StringMap.GetString",		GetTrieString},
 	{"StringMap.GetValue",		GetTrieValue},
+	{"StringMap.ContainsKey",	ContainsKeyInTrie},
 	{"StringMap.Remove",		RemoveFromTrie},
 	{"StringMap.SetArray",		SetTrieArray},
 	{"StringMap.SetString",		SetTrieString},
 	{"StringMap.SetValue",		SetTrieValue},
 	{"StringMap.Size.get",		GetTrieSize},
 	{"StringMap.Snapshot",		CreateTrieSnapshot},
+	{"StringMap.Clone",			CloneTrie},
 
 	{"StringMapSnapshot.Length.get",	TrieSnapshotLength},
 	{"StringMapSnapshot.KeyBufferSize", TrieSnapshotKeyBufferSize},

core/logic/smn_console.cpp

@@ -127,6 +127,8 @@ static cell_t sm_PrintToConsole(IPluginContext *pCtx, const cell_t *params)
 		}
 	}
 
+	g_pSM->SetGlobalTarget(index);
+
 	char buffer[1024];
 	char *fmt;
 	int arg = 3;

core/logic/smn_database.cpp

@@ -29,6 +29,8 @@
  * Version: $Id$
  */
 
+#include <memory>
+
 #include "common_logic.h"
 #include "Database.h"
 #include "ExtensionSys.h"
@@ -62,11 +64,11 @@ struct Transaction
 {
 	struct Entry
 	{
-		ke::AString query;
+		std::string query;
 		cell_t data;
 	};
 
-	ke::Vector<Entry> entries;
+	std::vector<Entry> entries;
 };
 
 class DatabaseHelpers : 
@@ -455,7 +457,7 @@ static cell_t ConnectToDbAsync(IPluginContext *pContext, const cell_t *params, A
 			g_pSM->Format(error, 
 				sizeof(error), 
 				"Could not find driver \"%s\"", 
-				pInfo->driver[0] == '\0' ? g_DBMan.GetDefaultDriverName().chars() : pInfo->driver);
+				pInfo->driver[0] == '\0' ? g_DBMan.GetDefaultDriverName().c_str() : pInfo->driver);
 		} else if (!driver->IsThreadSafe()) {
 			g_pSM->Format(error,
 				sizeof(error),
@@ -1538,9 +1540,9 @@ static cell_t SQL_AddQuery(IPluginContext *pContext, const cell_t *params)
 	Transaction::Entry entry;
 	entry.query = query;
 	entry.data = params[3];
-	txn->entries.append(ke::Move(entry));
+	txn->entries.push_back(std::move(entry));
 
-	return cell_t(txn->entries.length() - 1);
+	return cell_t(txn->entries.size() - 1);
 }
 
 class TTransactOp : public IDBThreadOperation
@@ -1562,7 +1564,7 @@ public:
 
 	~TTransactOp()
 	{
-		for (size_t i = 0; i < results_.length(); i++)
+		for (size_t i = 0; i < results_.size(); i++)
 			results_[i]->Destroy();
 		results_.clear();
 	}
@@ -1583,7 +1585,7 @@ public:
 private:
 	bool Succeeded() const
 	{
-		return error_.length() == 0;
+		return error_.size() == 0;
 	}
 
 	void SetDbError()
@@ -1615,16 +1617,16 @@ private:
 			return;
 		}
 
-		for (size_t i = 0; i < txn_->entries.length(); i++)
+		for (size_t i = 0; i < txn_->entries.size(); i++)
 		{
 			Transaction::Entry &entry = txn_->entries[i];
-			IQuery *result = Exec(entry.query.chars());
+			IQuery *result = Exec(entry.query.c_str());
 			if (!result)
 			{
 				failIndex_ = (cell_t)i;
 				return;
 			}
-			results_.append(result);
+			results_.push_back(result);
 		}
 
 		if (!db_->DoSimpleQuery("COMMIT"))
@@ -1665,11 +1667,11 @@ private:
 		// Add an extra refcount for the handle.
 		db_->AddRef();
 
-		assert(results_.length() == txn_->entries.length());
+		assert(results_.size() == txn_->entries.size());
 
-		ke::AutoPtr<cell_t[]> data = ke::MakeUnique<cell_t[]>(results_.length());
-		ke::AutoPtr<cell_t[]> handles = ke::MakeUnique<cell_t[]>(results_.length());
-		for (size_t i = 0; i < results_.length(); i++)
+		std::unique_ptr<cell_t[]> data = std::make_unique<cell_t[]>(results_.size());
+		std::unique_ptr<cell_t[]> handles = std::make_unique<cell_t[]>(results_.size());
+		for (size_t i = 0; i < results_.size(); i++)
 		{
 			CombinedQuery *obj = new CombinedQuery(results_[i], db_);
 			Handle_t rh = CreateLocalHandle(hCombinedQueryType, obj, &sec);
@@ -1680,7 +1682,7 @@ private:
 				delete obj;
 				for (size_t iter = 0; iter < i; iter++)
 					handlesys->FreeHandle(handles[iter], &sec);
-				for (size_t iter = i; iter < results_.length(); iter++)
+				for (size_t iter = i; iter < results_.size(); iter++)
 					results_[iter]->Destroy();
 				handlesys->FreeHandle(dbh, &sec);
 				results_.clear();
@@ -1696,15 +1698,15 @@ private:
 		{
 			success_->PushCell(dbh);
 			success_->PushCell(data_);
-			success_->PushCell(txn_->entries.length());
-			success_->PushArray(handles.get(), results_.length());
-			success_->PushArray(data.get(), results_.length());
+			success_->PushCell(txn_->entries.size());
+			success_->PushArray(handles.get(), results_.size());
+			success_->PushArray(data.get(), results_.size());
 			success_->Execute(NULL);
 		}
 
 		// Cleanup. Note we clear results_, since freeing their handles will
 		// call Destroy(), and we don't want to double-free in ~TTransactOp.
-		for (size_t i = 0; i < results_.length(); i++)
+		for (size_t i = 0; i < results_.size(); i++)
 			handlesys->FreeHandle(handles[i], &sec);
 		handlesys->FreeHandle(dbh, &sec);
 		results_.clear();
@@ -1728,8 +1730,8 @@ public:
 		{
 			HandleSecurity sec(ident_, g_pCoreIdent);
 
-			ke::AutoPtr<cell_t[]> data = ke::MakeUnique<cell_t[]>(txn_->entries.length());
-			for (size_t i = 0; i < txn_->entries.length(); i++)
+			std::unique_ptr<cell_t[]> data = std::make_unique<cell_t[]>(txn_->entries.size());
+			for (size_t i = 0; i < txn_->entries.size(); i++)
 				data[i] = txn_->entries[i].data;
 
 			Handle_t dbh = CreateLocalHandle(g_DBMan.GetDatabaseType(), db_, &sec);
@@ -1743,10 +1745,10 @@ public:
 			{
 				failure_->PushCell(dbh);
 				failure_->PushCell(data_);
-				failure_->PushCell(txn_->entries.length());
-				failure_->PushString(error_.chars());
+				failure_->PushCell(txn_->entries.size());
+				failure_->PushString(error_.c_str());
 				failure_->PushCell(failIndex_);
-				failure_->PushArray(data.get(), txn_->entries.length());
+				failure_->PushArray(data.get(), txn_->entries.size());
 				failure_->Execute(NULL);
 			}
 
@@ -1762,8 +1764,8 @@ private:
 	IPluginFunction *failure_;
 	cell_t data_;
 	AutoHandleRooter autoHandle_;
-	ke::AString error_;
-	ke::Vector<IQuery *> results_;
+	std::string error_;
+	std::vector<IQuery *> results_;
 	cell_t failIndex_;
 };
 

core/logic/smn_datapacks.cpp

@@ -61,7 +61,7 @@ public:
 	}
 	void OnHandleDestroy(HandleType_t type, void *object)
 	{
-		CDataPack::Free(reinterpret_cast<CDataPack *>(object));
+		delete reinterpret_cast<CDataPack *>(object);
 	}
 	bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)
 	{
@@ -73,7 +73,7 @@ public:
 
 static cell_t smn_CreateDataPack(IPluginContext *pContext, const cell_t *params)
 {
-	CDataPack *pDataPack = CDataPack::New();
+	CDataPack *pDataPack = new CDataPack();
 
 	if (!pDataPack)
 	{
@@ -166,6 +166,62 @@ static cell_t smn_WritePackString(IPluginContext *pContext, const cell_t *params
 	return 1;
 }
 
+static cell_t smn_WritePackCellArray(IPluginContext *pContext, const cell_t *params)
+{
+	HandleError herr;
+	HandleSecurity sec;
+	sec.pOwner = pContext->GetIdentity();
+	sec.pIdentity = g_pCoreIdent;
+
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	CDataPack *pDataPack = nullptr;
+	if ((herr = handlesys->ReadHandle(hndl, g_DataPackType, &sec, (void **)&pDataPack))
+		!= HandleError_None)
+	{
+		pContext->ReportError("Invalid data pack handle %x (error %d).", hndl, herr);
+		return 0;
+	}
+
+	if (!params[4])
+	{
+		pDataPack->RemoveItem();
+	}
+
+	cell_t *pArray;
+	pContext->LocalToPhysAddr(params[2], &pArray);
+	pDataPack->PackCellArray(pArray, params[3]);
+
+	return 1;
+}
+
+static cell_t smn_WritePackFloatArray(IPluginContext *pContext, const cell_t *params)
+{
+	HandleError herr;
+	HandleSecurity sec;
+	sec.pOwner = pContext->GetIdentity();
+	sec.pIdentity = g_pCoreIdent;
+
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	CDataPack *pDataPack = nullptr;
+	if ((herr = handlesys->ReadHandle(hndl, g_DataPackType, &sec, (void **)&pDataPack))
+		!= HandleError_None)
+	{
+		pContext->ReportError("Invalid data pack handle %x (error %d).", hndl, herr);
+		return 0;
+	}
+
+	if (!params[4])
+	{
+		pDataPack->RemoveItem();
+	}
+
+	cell_t *pArray;
+	pContext->LocalToPhysAddr(params[2], &pArray);
+	pDataPack->PackFloatArray(pArray, params[3]);
+
+	return 1;
+}
+
 static cell_t smn_WritePackFunction(IPluginContext *pContext, const cell_t *params)
 {
 	Handle_t hndl = static_cast<Handle_t>(params[1]);
@@ -312,6 +368,108 @@ static cell_t smn_ReadPackFunction(IPluginContext *pContext, const cell_t *param
 	return pDataPack->ReadFunction();
 }
 
+static cell_t smn_ReadPackCellArray(IPluginContext *pContext, const cell_t *params)
+{
+	HandleError herr; 
+	HandleSecurity sec;
+	sec.pOwner = pContext->GetIdentity();
+	sec.pIdentity = g_pCoreIdent;
+
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	CDataPack *pDataPack = nullptr;
+	if ((herr = handlesys->ReadHandle(hndl, g_DataPackType, &sec, (void **)&pDataPack))
+		!= HandleError_None)
+	{
+		pContext->ReportError("Invalid data pack handle %x (error %d).", hndl, herr);
+		return 0;
+	}
+
+	if (!pDataPack->IsReadable())
+	{
+		pContext->ReportError("Data pack operation is out of bounds.");
+		return 0;
+	}
+
+	if (pDataPack->GetCurrentType() != CDataPackType::CellArray)
+	{
+		pContext->ReportError("Invalid data pack type (got %d / expected %d).", pDataPack->GetCurrentType(), CDataPackType::CellArray);
+		return 0;
+	}
+
+	cell_t packCount = 0;
+	cell_t *pData = pDataPack->ReadCellArray(&packCount);
+	if(pData == nullptr || packCount == 0)
+	{
+		pContext->ReportError("Invalid data pack operation: current position isn't an array!");
+		return 0;
+	}
+
+	cell_t count = params[3];
+	if(packCount > count)
+	{
+		pContext->ReportError("Input buffer too small (needed %d, got %d).", packCount, count);
+		return 0;
+	}
+	
+	cell_t *pArray;
+	pContext->LocalToPhysAddr(params[2], &pArray);
+
+	memcpy(pArray, pData, sizeof(cell_t) * count);
+
+	return 1;
+}
+
+static cell_t smn_ReadPackFloatArray(IPluginContext *pContext, const cell_t *params)
+{
+	HandleError herr;
+	HandleSecurity sec;
+	sec.pOwner = pContext->GetIdentity();
+	sec.pIdentity = g_pCoreIdent;
+
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	CDataPack *pDataPack = nullptr;
+	if ((herr = handlesys->ReadHandle(hndl, g_DataPackType, &sec, (void **)&pDataPack))
+		!= HandleError_None)
+	{
+		pContext->ReportError("Invalid data pack handle %x (error %d).", hndl, herr);
+		return 0;
+	}
+
+	if (!pDataPack->IsReadable())
+	{
+		pContext->ReportError("Data pack operation is out of bounds.");
+		return 0;
+	}
+
+	if (pDataPack->GetCurrentType() != CDataPackType::FloatArray)
+	{
+		pContext->ReportError("Invalid data pack type (got %d / expected %d).", pDataPack->GetCurrentType(), CDataPackType::FloatArray);
+		return 0;
+	}
+
+	cell_t packCount = 0;
+	cell_t *pData = pDataPack->ReadFloatArray(&packCount);
+	if(pData == nullptr || packCount == 0)
+	{
+		pContext->ReportError("Invalid data pack operation: current position isn't an array!");
+		return 0;
+	}
+
+	cell_t count = params[3];
+	if(packCount > count)
+	{
+		pContext->ReportError("Input buffer too small (needed %d, got %d).", packCount, count);
+		return 0;
+	}
+
+	cell_t *pArray;
+	pContext->LocalToPhysAddr(params[2], &pArray);
+
+	memcpy(pArray, pData, sizeof(cell_t) * count);
+
+	return 1;
+}
+
 static cell_t smn_ResetPack(IPluginContext *pContext, const cell_t *params)
 {
 	Handle_t hndl = static_cast<Handle_t>(params[1]);
@@ -426,10 +584,14 @@ REGISTER_NATIVES(datapacknatives)
 	{"DataPack.WriteFloat",			smn_WritePackFloat},
 	{"DataPack.WriteString",		smn_WritePackString},
 	{"DataPack.WriteFunction",		smn_WritePackFunction},
+	{"DataPack.WriteCellArray",		smn_WritePackCellArray},
+	{"DataPack.WriteFloatArray",	smn_WritePackFloatArray},
 	{"DataPack.ReadCell",			smn_ReadPackCell},
 	{"DataPack.ReadFloat",			smn_ReadPackFloat},
 	{"DataPack.ReadString",			smn_ReadPackString},
 	{"DataPack.ReadFunction",		smn_ReadPackFunction},
+	{"DataPack.ReadCellArray",		smn_ReadPackCellArray},
+	{"DataPack.ReadFloatArray",		smn_ReadPackFloatArray},
 	{"DataPack.Reset",				smn_ResetPack},
 	{"DataPack.Position.get",		smn_GetPackPosition},
 	{"DataPack.Position.set",		smn_SetPackPosition},

core/logic/smn_entitylump.cpp

@@ -0,0 +1,367 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * Entity Lump Manager
+ * Copyright (C) 2021-2022 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include "HandleSys.h"
+#include "common_logic.h"
+
+#include "LumpManager.h"
+
+#include <algorithm>
+
+HandleType_t g_EntityLumpEntryType;
+
+std::string g_strMapEntities;
+bool g_bLumpAvailableForWriting = false;
+
+static EntityLumpManager s_LumpManager;
+EntityLumpManager *lumpmanager = &s_LumpManager;
+
+class LumpManagerNatives :
+	public IHandleTypeDispatch,
+	public SMGlobalClass
+{
+public: //SMGlobalClass
+	void OnSourceModAllInitialized()
+	{
+		g_EntityLumpEntryType = handlesys->CreateType("EntityLumpEntry", this, 0, NULL, NULL, g_pCoreIdent, NULL);
+	}
+	void OnSourceModShutdown()
+	{
+		handlesys->RemoveType(g_EntityLumpEntryType, g_pCoreIdent);
+	}
+public: //IHandleTypeDispatch
+	void OnHandleDestroy(HandleType_t type, void* object)
+	{
+		if (type == g_EntityLumpEntryType)
+		{
+			delete reinterpret_cast<std::weak_ptr<EntityLumpEntry>*>(object);
+		}
+	}
+};
+
+static LumpManagerNatives s_LumpManagerNatives;
+
+cell_t sm_LumpManagerGet(IPluginContext *pContext, const cell_t *params) {
+	int index = params[1];
+	if (index < 0 || index >= static_cast<int>(lumpmanager->Length())) {
+		return pContext->ThrowNativeError("Invalid index %d", index);
+	}
+	
+	std::weak_ptr<EntityLumpEntry>* pReference = new std::weak_ptr<EntityLumpEntry>;
+	*pReference = lumpmanager->Get(index);
+	
+	return handlesys->CreateHandle(g_EntityLumpEntryType, pReference,
+			pContext->GetIdentity(), g_pCoreIdent, NULL);
+}
+
+cell_t sm_LumpManagerErase(IPluginContext *pContext, const cell_t *params) {
+	if (!g_bLumpAvailableForWriting) {
+		return pContext->ThrowNativeError("Cannot use EntityLump.Erase() outside of OnMapInit");
+	}
+	
+	int index = params[1];
+	if (index < 0 || index >= static_cast<int>(lumpmanager->Length())) {
+		return pContext->ThrowNativeError("Invalid index %d", index);
+	}
+	
+	lumpmanager->Erase(index);
+	return 0;
+}
+
+cell_t sm_LumpManagerInsert(IPluginContext *pContext, const cell_t *params) {
+	if (!g_bLumpAvailableForWriting) {
+		return pContext->ThrowNativeError("Cannot use EntityLump.Insert() outside of OnMapInit");
+	}
+	
+	int index = params[1];
+	if (index < 0 || index > static_cast<int>(lumpmanager->Length())) {
+		return pContext->ThrowNativeError("Invalid index %d", index);
+	}
+	
+	lumpmanager->Insert(index);
+	return 0;
+}
+
+cell_t sm_LumpManagerAppend(IPluginContext *pContext, const cell_t *params) {
+	if (!g_bLumpAvailableForWriting) {
+		return pContext->ThrowNativeError("Cannot use EntityLump.Append() outside of OnMapInit");
+	}
+	return lumpmanager->Append();
+}
+
+cell_t sm_LumpManagerLength(IPluginContext *pContext, const cell_t *params) {
+	return lumpmanager->Length();
+}
+
+cell_t sm_LumpEntryGet(IPluginContext *pContext, const cell_t *params) {
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+	HandleError err;
+	
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	
+	std::weak_ptr<EntityLumpEntry>* entryref = nullptr;
+	if ((err = handlesys->ReadHandle(hndl, g_EntityLumpEntryType, &sec, (void**) &entryref)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (error: %d)", hndl, err);
+	}
+	
+	if (entryref->expired()) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (reference expired)", hndl);
+	}
+	
+	auto entry = entryref->lock();
+	
+	int index = params[2];
+	if (index < 0 || index >= static_cast<int>(entry->size())) {
+		return pContext->ThrowNativeError("Invalid index %d", index);
+	}
+	
+	const auto& pair = (*entry)[index];
+	
+	size_t nBytes;
+	pContext->StringToLocalUTF8(params[3], params[4], pair.first.c_str(), &nBytes);
+	pContext->StringToLocalUTF8(params[5], params[6], pair.second.c_str(), &nBytes);
+	
+	return 0;
+}
+
+cell_t sm_LumpEntryUpdate(IPluginContext *pContext, const cell_t *params) {
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+	HandleError err;
+	
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	
+	std::weak_ptr<EntityLumpEntry>* entryref = nullptr;
+	if ((err = handlesys->ReadHandle(hndl, g_EntityLumpEntryType, &sec, (void**) &entryref)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (error: %d)", hndl, err);
+	}
+	
+	if (entryref->expired()) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (reference expired)", hndl);
+	}
+	
+	if (!g_bLumpAvailableForWriting) {
+		return pContext->ThrowNativeError("Cannot use EntityLumpEntry.Update() outside of OnMapInit");
+	}
+	
+	auto entry = entryref->lock();
+	
+	int index = params[2];
+	if (index < 0 || index >= static_cast<int>(entry->size())) {
+		return pContext->ThrowNativeError("Invalid index %d", index);
+	}
+	
+	char *key, *value;
+	pContext->LocalToStringNULL(params[3], &key);
+	pContext->LocalToStringNULL(params[4], &value);
+	
+	auto& pair = (*entry)[index];
+	if (key != nullptr) {
+		pair.first = key;
+	}
+	if (value != nullptr) {
+		pair.second = value;
+	}
+	
+	return 0;
+}
+
+cell_t sm_LumpEntryInsert(IPluginContext *pContext, const cell_t *params) {
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+	HandleError err;
+	
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	
+	std::weak_ptr<EntityLumpEntry>* entryref = nullptr;
+	if ((err = handlesys->ReadHandle(hndl, g_EntityLumpEntryType, &sec, (void**) &entryref)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (error: %d)", hndl, err);
+	}
+	
+	if (entryref->expired()) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (reference expired)", hndl);
+	}
+	
+	if (!g_bLumpAvailableForWriting) {
+		return pContext->ThrowNativeError("Cannot use EntityLumpEntry.Insert() outside of OnMapInit");
+	}
+	
+	auto entry = entryref->lock();
+	
+	int index = params[2];
+	if (index < 0 || index > static_cast<int>(entry->size())) {
+		return pContext->ThrowNativeError("Invalid index %d", index);
+	}
+	
+	char *key, *value;
+	pContext->LocalToString(params[3], &key);
+	pContext->LocalToString(params[4], &value);
+	
+	entry->emplace(entry->begin() + index, key, value);
+	
+	return 0;
+}
+
+cell_t sm_LumpEntryErase(IPluginContext *pContext, const cell_t *params) {
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+	HandleError err;
+	
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	
+	std::weak_ptr<EntityLumpEntry>* entryref = nullptr;
+	if ((err = handlesys->ReadHandle(hndl, g_EntityLumpEntryType, &sec, (void**) &entryref)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (error: %d)", hndl, err);
+	}
+	
+	if (entryref->expired()) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (reference expired)", hndl);
+	}
+	
+	if (!g_bLumpAvailableForWriting) {
+		return pContext->ThrowNativeError("Cannot use EntityLumpEntry.Erase() outside of OnMapInit");
+	}
+	
+	auto entry = entryref->lock();
+	
+	int index = params[2];
+	if (index < 0 || index >= static_cast<int>(entry->size())) {
+		return pContext->ThrowNativeError("Invalid index %d", index);
+	}
+	
+	entry->erase(entry->begin() + index);
+	
+	return 0;
+}
+
+cell_t sm_LumpEntryAppend(IPluginContext *pContext, const cell_t *params) {
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+	HandleError err;
+	
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	
+	std::weak_ptr<EntityLumpEntry>* entryref = nullptr;
+	if ((err = handlesys->ReadHandle(hndl, g_EntityLumpEntryType, &sec, (void**) &entryref)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (error: %d)", hndl, err);
+	}
+	
+	if (entryref->expired()) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (reference expired)", hndl);
+	}
+	
+	if (!g_bLumpAvailableForWriting) {
+		return pContext->ThrowNativeError("Cannot use EntityLumpEntry.Append() outside of OnMapInit");
+	}
+	
+	auto entry = entryref->lock();
+	
+	char *key, *value;
+	pContext->LocalToString(params[2], &key);
+	pContext->LocalToString(params[3], &value);
+	
+	entry->emplace_back(key, value);
+	
+	return 0;
+}
+
+cell_t sm_LumpEntryFindKey(IPluginContext *pContext, const cell_t *params) {
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+	HandleError err;
+	
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	
+	std::weak_ptr<EntityLumpEntry>* entryref = nullptr;
+	if ((err = handlesys->ReadHandle(hndl, g_EntityLumpEntryType, &sec, (void**) &entryref)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (error: %d)", hndl, err);
+	}
+	
+	if (entryref->expired()) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (reference expired)", hndl);
+	}
+	
+	// start from the index after the current one
+	int start = params[3] + 1;
+	
+	auto entry = entryref->lock();
+	
+	if (start < 0 || start >= static_cast<int>(entry->size())) {
+		return -1;
+	}
+	
+	char *key;
+	pContext->LocalToString(params[2], &key);
+	
+	auto matches_key = [&key](std::pair<std::string,std::string> pair) {
+		return pair.first == key;
+	};
+	
+	auto result = std::find_if(entry->begin() + start, entry->end(), matches_key);
+	
+	if (result == entry->end()) {
+		return -1;
+	}
+	return std::distance(entry->begin(), result);
+}
+
+cell_t sm_LumpEntryLength(IPluginContext *pContext, const cell_t *params) {
+	HandleSecurity sec(pContext->GetIdentity(), g_pCoreIdent);
+	HandleError err;
+	
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	
+	std::weak_ptr<EntityLumpEntry>* entryref = nullptr;
+	if ((err = handlesys->ReadHandle(hndl, g_EntityLumpEntryType, &sec, (void**) &entryref)) != HandleError_None) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (error: %d)", hndl, err);
+	}
+	
+	if (entryref->expired()) {
+		return pContext->ThrowNativeError("Invalid EntityLumpEntry handle %x (reference expired)", hndl);
+	}
+	
+	auto entry = entryref->lock();
+	return entry->size();
+}
+
+REGISTER_NATIVES(entityLumpNatives)
+{
+	{ "EntityLump.Get", sm_LumpManagerGet },
+	{ "EntityLump.Erase", sm_LumpManagerErase },
+	{ "EntityLump.Insert", sm_LumpManagerInsert },
+	{ "EntityLump.Append", sm_LumpManagerAppend },
+	{ "EntityLump.Length", sm_LumpManagerLength },
+	
+	{ "EntityLumpEntry.Get", sm_LumpEntryGet },
+	{ "EntityLumpEntry.Update", sm_LumpEntryUpdate },
+	{ "EntityLumpEntry.Insert", sm_LumpEntryInsert },
+	{ "EntityLumpEntry.Erase", sm_LumpEntryErase },
+	{ "EntityLumpEntry.Append", sm_LumpEntryAppend },
+	{ "EntityLumpEntry.FindKey", sm_LumpEntryFindKey },
+	{ "EntityLumpEntry.Length.get", sm_LumpEntryLength },
+	
+	{NULL, NULL}
+};

core/logic/smn_entitylump.h

@@ -0,0 +1,44 @@
+/**
+* vim: set ts=4 :
+* =============================================================================
+* SourceMod
+* Copyright (C) 2022-2022 AlliedModders LLC.  All rights reserved.
+* =============================================================================
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License, version 3.0, as published by the
+* Free Software Foundation.
+*
+* 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.
+*
+* You should have received a copy of the GNU General Public License along with
+* this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* As a special exception, AlliedModders LLC gives you permission to link the
+* code of this program (as well as its derivative works) to "Half-Life 2," the
+* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+* by the Valve Corporation.  You must obey the GNU General Public License in
+* all respects for all other code used.  Additionally, AlliedModders LLC grants
+* this exception to all derivative works.  AlliedModders LLC defines further
+* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+* or <http://www.sourcemod.net/license.php>.
+*
+* Version: $Id$
+*/
+
+#ifndef _INCLUDE_SOURCEMOD_ENTITYLUMP_H_
+#define _INCLUDE_SOURCEMOD_ENTITYLUMP_H_
+
+#include <IHandleSys.h>
+#include "LumpManager.h"
+
+using namespace SourceMod;
+
+extern std::string g_strMapEntities;
+extern bool g_bLumpAvailableForWriting;
+extern EntityLumpManager *lumpmanager;
+
+#endif // _INCLUDE_SOURCEMOD_ENTITYLUMP_H_

core/logic/smn_fakenatives.cpp

@@ -414,7 +414,7 @@ static cell_t FormatNativeString(IPluginContext *pContext, const cell_t *params)
 		DetectExceptions eh(pContext);
 		written = atcprintf(output_buffer, maxlen, format_buffer, s_curcaller, s_curparams, &var_param);
 		if (eh.HasException())
-			return 0;
+			return pContext->GetLastNativeError();
 	}
 
 	cell_t *addr;

core/logic/smn_functions.cpp

@@ -29,12 +29,15 @@
  * Version: $Id$
  */
 
+#include <memory>
+
 #include "common_logic.h"
 #include <IPluginSys.h>
 #include <IHandleSys.h>
 #include <IForwardSys.h>
 #include <ISourceMod.h>
-#include <amtl/am-autoptr.h>
+#include "ShareSys.h"
+#include "NativeInvoker.h"
 
 HandleType_t g_GlobalFwdType = 0;
 HandleType_t g_PrivateFwdType = 0;
@@ -43,6 +46,7 @@ static bool s_CallStarted = false;
 static ICallable *s_pCallable = NULL;
 static IPluginFunction *s_pFunction = NULL;
 static IForward *s_pForward = NULL;
+static NativeInvoker *s_pInvoker = NULL;
 
 class ForwardNativeHelpers : 
 	public SMGlobalClass,
@@ -102,6 +106,9 @@ inline void ResetCall()
 	s_pFunction = NULL;
 	s_pForward = NULL;
 	s_pCallable = NULL;
+	if(s_pInvoker)
+		delete s_pInvoker;
+	s_pInvoker = NULL;
 }
 
 static cell_t sm_GetFunctionByName(IPluginContext *pContext, const cell_t *params)
@@ -366,6 +373,27 @@ static cell_t sm_CallStartForward(IPluginContext *pContext, const cell_t *params
 	return 1;
 }
 
+static cell_t sm_CallStartNative(IPluginContext *pContext, const cell_t *params)
+{
+	ResetCall();
+
+	char *name;
+	pContext->LocalToString(params[1], &name);
+
+	ke::RefPtr<Native> pNative = g_ShareSys.FindNative(name);
+
+	if (!pNative)
+		return 0;//pContext->ThrowNativeError("Invalid native \"%s\"", name);
+
+	s_pInvoker = new NativeInvoker(pContext, pNative);
+
+	s_pCallable = static_cast<ICallable *>(s_pInvoker);
+
+	s_CallStarted = true;
+
+	return 1;
+}
+
 static cell_t sm_CallPushCell(IPluginContext *pContext, const cell_t *params)
 {
 	int err;
@@ -656,6 +684,39 @@ static cell_t sm_CallFinish(IPluginContext *pContext, const cell_t *params)
 		IForward *pForward = s_pForward;
 		ResetCall();
 		err = pForward->Execute(result, NULL);
+	} else if (s_pInvoker) {
+		err = s_pInvoker->Execute(result);
+		ResetCall();
+	}
+
+	return err;
+}
+
+static cell_t sm_CallFinishEx(IPluginContext *pContext, const cell_t *params)
+{
+	int err = SP_ERROR_NOT_RUNNABLE;
+	cell_t *result;
+
+	if (!s_CallStarted)
+	{
+		return pContext->ThrowNativeError("Cannot finish call when there is no call in progress");
+	}
+
+	pContext->LocalToPhysAddr(params[1], &result);
+
+	// Note: Execute() swallows exceptions, so this is okay.
+	if (s_pFunction)
+	{
+		IPluginFunction *pFunction = s_pFunction;
+		ResetCall();
+		err = pFunction->Execute(result, params[2], params[3]);
+	} else if (s_pForward) {
+		IForward *pForward = s_pForward;
+		ResetCall();
+		err = pForward->Execute(result, NULL);
+	} else if (s_pInvoker) {
+		err = s_pInvoker->Execute(result, params[2], params[3]);
+		ResetCall();
 	}
 
 	return err;
@@ -686,7 +747,7 @@ struct SMFrameActionData
 
 static void PawnFrameAction(void *pData)
 {
-	ke::AutoPtr<SMFrameActionData> frame(reinterpret_cast<SMFrameActionData *>(pData));
+	std::unique_ptr<SMFrameActionData> frame(reinterpret_cast<SMFrameActionData *>(pData));
 	IPlugin *pPlugin = pluginsys->PluginFromHandle(frame->ownerhandle, NULL);
 	if (!pPlugin)
 	{
@@ -742,6 +803,7 @@ REGISTER_NATIVES(functionNatives)
 	{"RemoveAllFromForward",                sm_RemoveAllFromForward},
 	{"Call_StartFunction",                  sm_CallStartFunction},
 	{"Call_StartForward",                   sm_CallStartForward},
+	{"Call_StartNative",                    sm_CallStartNative},
 	{"Call_PushCell",                       sm_CallPushCell},
 	{"Call_PushCellRef",                    sm_CallPushCellRef},
 	{"Call_PushFloat",                      sm_CallPushFloat},
@@ -753,6 +815,7 @@ REGISTER_NATIVES(functionNatives)
 	{"Call_PushNullVector",                 sm_CallPushNullVector},
 	{"Call_PushNullString",                 sm_CallPushNullString},
 	{"Call_Finish",                         sm_CallFinish},
+	{"Call_FinishEx",                       sm_CallFinishEx},
 	{"Call_Cancel",                         sm_CallCancel},
 	{"RequestFrame",                        sm_AddFrameAction},
 

core/logic/smn_gameconfigs.cpp

@@ -162,6 +162,38 @@ static cell_t smn_GameConfGetAddress(IPluginContext *pCtx, const cell_t *params)
 #endif
 }
 
+static cell_t smn_GameConfGetMemSig(IPluginContext *pCtx, const cell_t *params)
+{
+	Handle_t hndl = static_cast<Handle_t>(params[1]);
+	HandleError herr;
+	HandleSecurity sec;
+	IGameConfig *gc;
+
+	sec.pOwner = NULL;
+	sec.pIdentity = g_pCoreIdent;
+
+	if ((herr=handlesys->ReadHandle(hndl, g_GameConfigsType, &sec, (void **)&gc))
+		!= HandleError_None)
+	{
+		return pCtx->ThrowNativeError("Invalid game config handle %x (error %d)", hndl, herr);
+	}
+
+	char *key;
+	void *val;
+	pCtx->LocalToString(params[2], &key);
+
+	if (!gc->GetMemSig(key, &val))
+	{
+		return 0;
+	}
+
+#ifdef PLATFORM_X86
+	return (cell_t)val;
+#else
+	return pseudoAddr.ToPseudoAddress(val);
+#endif
+}
+
 static GameConfigsNatives s_GameConfigsNatives;
 
 REGISTER_NATIVES(gameconfignatives)
@@ -176,5 +208,6 @@ REGISTER_NATIVES(gameconfignatives)
 	{"GameData.GetOffset",			smn_GameConfGetOffset},
 	{"GameData.GetKeyValue",		smn_GameConfGetKeyValue},
 	{"GameData.GetAddress",			smn_GameConfGetAddress},
+	{"GameData.GetMemSig", 			smn_GameConfGetMemSig},
 	{NULL,							NULL}
 };