Bump version to 0.11.3 and update toxcore version in static build script

File transfers initiated for offline friends are now
added to a queue and initiated all at once when the friend
appears online.

.cirrus.yml

@@ -0,0 +1,13 @@
+---
+cirrus-ci_task:
+  container:
+    image: toxchat/toktok-stack:0.0.31-third_party
+    cpu: 2
+    memory: 2G
+  configure_script:
+    - /src/workspace/tools/inject-repo toxic
+  test_all_script:
+    - cd /src/workspace && bazel test -k
+        --remote_http_cache=http://$CIRRUS_HTTP_CACHE_HOST
+        --config=release
+        //toxic/...

.github/settings.yml

@@ -11,7 +11,8 @@ branches:
     protection:
       required_status_checks:
         contexts:
-          - Codacy/PR Quality Review
-          - CodeFactor
-          - Travis CI - Pull Request
+          - build
+          - cirrus-ci
+          - Codacy Static Code Analysis
           - code-review/reviewable
+          - infer

.github/workflows/ci.yml

@@ -0,0 +1,106 @@
+name: ci
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install dependencies
+        run:
+          sudo apt-get update &&
+          sudo apt-get install -y --no-install-recommends
+            libalut-dev
+            libconfig-dev
+            libcurl4-gnutls-dev
+            libnotify-dev
+            libopenal-dev
+            libopus-dev
+            libqrencode-dev
+            libsodium-dev
+            libvpx-dev
+            libx11-dev
+            python3-dev
+            pkg-config &&
+          git clone --depth=1 https://github.com/TokTok/c-toxcore &&
+          cd c-toxcore &&
+          cmake . -B_build -DBOOTSTRAP_DAEMON=OFF &&
+          cd _build &&
+          make -j4 &&
+          sudo make install
+
+      - name: Build toxic
+        run: make -j4
+
+  infer:
+    runs-on: ubuntu-latest
+    container: toxchat/infer
+    steps:
+      - name: Install git
+        run:
+          apt-get update &&
+          DEBIAN_FRONTEND=noninteractive
+          apt-get install -y --no-install-recommends
+            git
+      - name: Install dependencies
+        run:
+          apt-get update &&
+          apt-get install -y --no-install-recommends
+            cmake
+            g++
+            libalut-dev
+            libconfig-dev
+            libcurl4-gnutls-dev
+            libncurses-dev
+            libnotify-dev
+            libopenal-dev
+            libopus-dev
+            libqrencode-dev
+            libsodium-dev
+            libvpx-dev
+            libx11-dev
+            make
+            python3-dev
+            pkg-config &&
+          git clone --depth=1 https://github.com/TokTok/c-toxcore &&
+          cd c-toxcore &&
+          cmake . -B_build -DBOOTSTRAP_DAEMON=OFF &&
+          cd _build &&
+          make -j4 &&
+          make install
+      - uses: actions/checkout@v2
+
+      - name: Run infer
+        run:
+          infer --no-progress-bar -- cc src/*.c
+            -fsyntax-only
+            $(python3-config --includes --ldflags)
+            $(pkg-config --cflags --libs
+              freealut
+              libconfig
+              libcurl
+              libnotify
+              libpng
+              libqrencode
+              ncurses
+              openal
+              python3
+              toxcore
+              vpx
+              x11)
+            -DAUDIO
+            -DBOX_NOTIFY
+            -DGAMES
+            -DPACKAGE_DATADIR='""'
+            -DPYTHON
+            -DQRCODE
+            -DSOUND_NOTIFY
+            -DVIDEO
+      - name: Print log
+        run:
+          cat /__w/toxic/toxic/infer-out/report.txt

.gitignore

@@ -17,3 +17,6 @@ build/toxic
 build/*.o
 build/*.d
 apidoc/python/build
+*.vim
+*.tox
+*.nvim*

.travis.yml

@@ -1,60 +0,0 @@
----
-language: python
-python: nightly
-dist: xenial
-os: linux
-
-jobs:
-  include:
-    - env: JOB=linux
-
-      addons:
-        apt:
-          packages:
-            - libalut-dev
-            - libconfig-dev
-            - libnotify-dev
-            - libopenal-dev
-            - libopus-dev
-            - libqrencode-dev
-            - libvpx-dev
-
-      cache:
-        directories:
-          - $HOME/cache
-
-      install:
-        # Where to find libraries.
-        - export LD_LIBRARY_PATH=$HOME/cache/usr/lib
-        - export PKG_CONFIG_PATH=$HOME/cache/usr/lib/pkgconfig
-        # c-sodium
-        - git clone --depth=1 --branch=stable https://github.com/jedisct1/libsodium ../libsodium
-        - test -f $HOME/cache/usr/lib/libsodium.so || (cd ../libsodium && ./configure --prefix=$HOME/cache/usr && make install -j$(nproc))
-        # c-toxcore
-        - git clone --depth=1 https://github.com/TokTok/c-toxcore ../c-toxcore
-        - test -f $HOME/cache/usr/lib/libtoxcore.so || (cd ../c-toxcore && cmake -B_build -H. -DCMAKE_INSTALL_PREFIX:PATH=$HOME/cache/usr && make -C_build install -j$(nproc))
-
-      script:
-        - make ENABLE_PYTHON=1 -j$(nproc)
-
-    - env: JOB=macos
-      os: macos
-      language: c
-
-      cache:
-        directories:
-          - $HOME/cache
-
-      install:
-        - brew install
-          freealut
-          libconfig
-          libqrencode
-          libsodium
-          openal-soft
-        - export LDFLAGS="-L/usr/local/Cellar/openal-soft/1.21.0/lib"
-        - git clone --depth=1 https://github.com/TokTok/c-toxcore ../c-toxcore
-        - test -f /usr/local/lib/libtoxcore.dylib || (cd ../c-toxcore && cmake -B_build -H. && make -C_build install -j$(nproc))
-
-      script:
-        - make ENABLE_PYTHON=1 DISABLE_DESKTOP_NOTIFY=1 DISABLE_X11=1 DISABLE_AV=1 DISABLE_SOUND_NOTIFY=1 -j$(nproc)

BUILD.bazel

@@ -18,6 +18,7 @@ cc_binary(
     copts = [
         "-std=gnu99",
         "-DAUDIO",
+        "-DGAMES",
         "-DPACKAGE_DATADIR='\"data\"'",
         "-DPYTHON",
         "-DQRCODE",
@@ -39,3 +40,10 @@ cc_binary(
         "//tools/config:osx": [],
     }),
 )
+
+sh_test(
+    name = "toxic_test",
+    size = "small",
+    srcs = [":toxic"],
+    args = ["--help"],
+)

CHANGELOG.md

@@ -1,503 +0,0 @@
-# Change Log
-
-## [Unreleased](https://github.com/JFreegman/toxic/tree/HEAD)
-
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.7.0...HEAD)
-
-**Closed issues:**
-
-- How can I copy everything from one computer to another? [\#391](https://github.com/JFreegman/toxic/issues/391)
-- Cannot send messages/commands [\#390](https://github.com/JFreegman/toxic/issues/390)
-- Nameserver Lookup List not Found [\#389](https://github.com/JFreegman/toxic/issues/389)
-- ERROR: toxini file 'tox.ini' not found [\#388](https://github.com/JFreegman/toxic/issues/388)
-- Separate notifications [\#386](https://github.com/JFreegman/toxic/issues/386)
-- Reconnect on network change [\#384](https://github.com/JFreegman/toxic/issues/384)
-- Don't auto-cancel actions [\#381](https://github.com/JFreegman/toxic/issues/381)
-- How to export your profile? [\#377](https://github.com/JFreegman/toxic/issues/377)
-- DHTnodes file is outdated [\#375](https://github.com/JFreegman/toxic/issues/375)
-- Toxic fails to initialize if ~/.config directory doesn't exist [\#372](https://github.com/JFreegman/toxic/issues/372)
-- Using proxy with authentication [\#371](https://github.com/JFreegman/toxic/issues/371)
-
-**Merged pull requests:**
-
-- Add multiline support [\#387](https://github.com/JFreegman/toxic/pull/387) ([mphe](https://github.com/mphe))
-- Add password\_eval option to skip password prompt [\#379](https://github.com/JFreegman/toxic/pull/379) ([FreakyPenguin](https://github.com/FreakyPenguin))
-- sleep use tox\_iteration\_interval [\#374](https://github.com/JFreegman/toxic/pull/374) ([quininer](https://github.com/quininer))
-- Fix \#372 - can't start with missing ~/.config [\#373](https://github.com/JFreegman/toxic/pull/373) ([wedge-jarrad](https://github.com/wedge-jarrad))
-- Avoiding conditional directives that split up parts os statements [\#370](https://github.com/JFreegman/toxic/pull/370) ([RomeroMalaquias](https://github.com/RomeroMalaquias))
-- update doc: DATA\_FILE is now `toxic\_profile.tox` [\#369](https://github.com/JFreegman/toxic/pull/369) ([nil0x42](https://github.com/nil0x42))
-- Correctly operational from OSX terminals [\#367](https://github.com/JFreegman/toxic/pull/367) ([landswellsong](https://github.com/landswellsong))
-
-## [v0.7.0](https://github.com/JFreegman/toxic/tree/v0.7.0) (2015-11-12)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.6.1...v0.7.0)
-
-**Implemented enhancements:**
-
-- /myid doesn't show qrcode [\#326](https://github.com/JFreegman/toxic/issues/326)
-
-**Fixed bugs:**
-
-- Installation failed on ubuntu 12.04, package missing [\#279](https://github.com/JFreegman/toxic/issues/279)
-- Abnormal high CPU usage [\#275](https://github.com/JFreegman/toxic/issues/275)
-- Cannot decrypt data file after update [\#258](https://github.com/JFreegman/toxic/issues/258)
-
-**Closed issues:**
-
-- Compiling video\_device.c on FreeBSD [\#364](https://github.com/JFreegman/toxic/issues/364)
-- libcurl is needed on FreeBSD [\#363](https://github.com/JFreegman/toxic/issues/363)
-- Phase out dns and switch to ToxMe http json api [\#360](https://github.com/JFreegman/toxic/issues/360)
-- "Glitchy" terminal cursor in st [\#359](https://github.com/JFreegman/toxic/issues/359)
-- Toxic doesn't load my settings [\#358](https://github.com/JFreegman/toxic/issues/358)
-- Does Toxic support proxy? [\#355](https://github.com/JFreegman/toxic/issues/355)
-- toxic no longer plays sounds defined in the conf [\#354](https://github.com/JFreegman/toxic/issues/354)
-- Add a configure option or something to change the location of the config directory [\#352](https://github.com/JFreegman/toxic/issues/352)
-- Remove/Replace links to libtoxcore.so [\#349](https://github.com/JFreegman/toxic/issues/349)
-- "No pending friend requests." while"Friend request has already been sent." [\#348](https://github.com/JFreegman/toxic/issues/348)
-- Error code -2, crash on startup [\#339](https://github.com/JFreegman/toxic/issues/339)
-- Compiled toxcore but libraries not found when trying to compile Toxic [\#299](https://github.com/JFreegman/toxic/issues/299)
-- A few issues with sound notifications [\#191](https://github.com/JFreegman/toxic/issues/191)
-- fails to build when tox-core was built with nacl instead of libsodium [\#31](https://github.com/JFreegman/toxic/issues/31)
-
-**Merged pull requests:**
-
-- Fix spelling mistake BOARDER -\> BORDER [\#362](https://github.com/JFreegman/toxic/pull/362) ([subliun](https://github.com/subliun))
-- Fix compile for DragonFlyBSD [\#351](https://github.com/JFreegman/toxic/pull/351) ([mneumann](https://github.com/mneumann))
-
-## [v0.6.1](https://github.com/JFreegman/toxic/tree/v0.6.1) (2015-08-28)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.6.0...v0.6.1)
-
-**Closed issues:**
-
-- \[Invalid UTF-8\] [\#344](https://github.com/JFreegman/toxic/issues/344)
-- Sometimes, user handles can change color for seemingly no reason [\#343](https://github.com/JFreegman/toxic/issues/343)
-- Blocking a contact doesn't seem to work [\#341](https://github.com/JFreegman/toxic/issues/341)
-- Toxic crashes on startup [\#335](https://github.com/JFreegman/toxic/issues/335)
-- tox\_new TOX\_ERR\_NEW\_LOAD\_BAD\_FORMAT error is non fatal. [\#333](https://github.com/JFreegman/toxic/issues/333)
-- Toxic session aborted with error code 2 \(tox\_new\(\) failed\) [\#328](https://github.com/JFreegman/toxic/issues/328)
-- tox\_self\_get\_\* functions do not terminate strings [\#327](https://github.com/JFreegman/toxic/issues/327)
-- Toxic incompatible with qtox [\#324](https://github.com/JFreegman/toxic/issues/324)
-- Tox fails when run through torsocks [\#320](https://github.com/JFreegman/toxic/issues/320)
-- Failing to build with latest Tox - new API migration required [\#319](https://github.com/JFreegman/toxic/issues/319)
-- Avoid non-posix option in sed. [\#307](https://github.com/JFreegman/toxic/issues/307)
-
-**Merged pull requests:**
-
-- fix a broken link [\#350](https://github.com/JFreegman/toxic/pull/350) ([vinegret](https://github.com/vinegret))
-- Makefile: allow overriding pkg-config [\#346](https://github.com/JFreegman/toxic/pull/346) ([ony](https://github.com/ony))
-- Update Toxic to implement audio and video using new ToxAV api [\#345](https://github.com/JFreegman/toxic/pull/345) ([cnhenry](https://github.com/cnhenry))
-- travis.yml: update dependencies [\#340](https://github.com/JFreegman/toxic/pull/340) ([Ansa89](https://github.com/Ansa89))
-- Add localization system \(gettext\) [\#337](https://github.com/JFreegman/toxic/pull/337) ([Ansa89](https://github.com/Ansa89))
-- Makefile: try to fix Tox/toxic\#307 [\#323](https://github.com/JFreegman/toxic/pull/323) ([Ansa89](https://github.com/Ansa89))
-- Makefile: add uninstall target [\#322](https://github.com/JFreegman/toxic/pull/322) ([Ansa89](https://github.com/Ansa89))
-
-## [v0.6.0](https://github.com/JFreegman/toxic/tree/v0.6.0) (2015-03-28)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.5.2...v0.6.0)
-
-**Closed issues:**
-
-- Please do not force push to tox/toxic master branch. [\#311](https://github.com/JFreegman/toxic/issues/311)
-- Import tox id [\#295](https://github.com/JFreegman/toxic/issues/295)
-- openalut [\#287](https://github.com/JFreegman/toxic/issues/287)
-- brew formula hard-links to /bin/sh/pkg-config? \(OS X\) [\#286](https://github.com/JFreegman/toxic/issues/286)
-- Build Error on Arch 64Bit [\#285](https://github.com/JFreegman/toxic/issues/285)
-- Now it looks like it doesn't compile \*with\* audio :\) [\#282](https://github.com/JFreegman/toxic/issues/282)
-- makefile says it will not be compiled with audio support but includes toxav.h anyway. [\#281](https://github.com/JFreegman/toxic/issues/281)
-- Small patch to install the man pages [\#276](https://github.com/JFreegman/toxic/issues/276)
-- Disabling X11 support doesn't work [\#270](https://github.com/JFreegman/toxic/issues/270)
-- Support arrow keys [\#265](https://github.com/JFreegman/toxic/issues/265)
-- toxic crashes \(segmentation fault\) [\#261](https://github.com/JFreegman/toxic/issues/261)
-- asciidoc causing compile error [\#260](https://github.com/JFreegman/toxic/issues/260)
-- これはセグフォールトですか [\#259](https://github.com/JFreegman/toxic/issues/259)
-- Verify ~/.config/tox permissions on startup [\#245](https://github.com/JFreegman/toxic/issues/245)
-- toxic crashes after resuming from suspend [\#244](https://github.com/JFreegman/toxic/issues/244)
-- Toxic does not compile on osx 10.9.3 [\#145](https://github.com/JFreegman/toxic/issues/145)
-
-**Merged pull requests:**
-
-- README.md: fix typo [\#318](https://github.com/JFreegman/toxic/pull/318) ([Ansa89](https://github.com/Ansa89))
-- Makefile: be less aggressive when cleaning [\#316](https://github.com/JFreegman/toxic/pull/316) ([Ansa89](https://github.com/Ansa89))
-- Move makefile into root directory [\#315](https://github.com/JFreegman/toxic/pull/315) ([Ansa89](https://github.com/Ansa89))
-- Fixing couple leaking file descriptors [\#314](https://github.com/JFreegman/toxic/pull/314) ([al42and](https://github.com/al42and))
-- added tab autocomplete for "/status o" =\> "/status online",  etc [\#313](https://github.com/JFreegman/toxic/pull/313) ([hardlyeven](https://github.com/hardlyeven))
-- Some cosmetics changes [\#310](https://github.com/JFreegman/toxic/pull/310) ([Ansa89](https://github.com/Ansa89))
-- Openbsd [\#308](https://github.com/JFreegman/toxic/pull/308) ([henriqueleng](https://github.com/henriqueleng))
-- Add support for custom timestamps in chat and logs. [\#303](https://github.com/JFreegman/toxic/pull/303) ([louipc](https://github.com/louipc))
-- README.md: update download section [\#302](https://github.com/JFreegman/toxic/pull/302) ([Ansa89](https://github.com/Ansa89))
-- Add INSTALL.md [\#301](https://github.com/JFreegman/toxic/pull/301) ([Ansa89](https://github.com/Ansa89))
-- travis.yml: use latest libsodium stable [\#298](https://github.com/JFreegman/toxic/pull/298) ([Ansa89](https://github.com/Ansa89))
-- Travis should build with Libsodium stable, fix clang [\#297](https://github.com/JFreegman/toxic/pull/297) ([urras](https://github.com/urras))
-- Interface [\#296](https://github.com/JFreegman/toxic/pull/296) ([louipc](https://github.com/louipc))
-- Correct filename comment from main.c to toxic.c [\#293](https://github.com/JFreegman/toxic/pull/293) ([Spagy](https://github.com/Spagy))
-- Update for toxcore API break [\#292](https://github.com/JFreegman/toxic/pull/292) ([Ansa89](https://github.com/Ansa89))
-- Fix some edge cases when obtaining paths [\#291](https://github.com/JFreegman/toxic/pull/291) ([dantok](https://github.com/dantok))
-- Update DHT nodes again [\#290](https://github.com/JFreegman/toxic/pull/290) ([urras](https://github.com/urras))
-- Update DHT node list [\#289](https://github.com/JFreegman/toxic/pull/289) ([urras](https://github.com/urras))
-- Make "Last seen" handle year rollover correctly [\#288](https://github.com/JFreegman/toxic/pull/288) ([flussence](https://github.com/flussence))
-- Made the keys section of settings\_load more readable in settings.c [\#284](https://github.com/JFreegman/toxic/pull/284) ([jpoler](https://github.com/jpoler))
-- Destroy AL context before closing dhndl [\#283](https://github.com/JFreegman/toxic/pull/283) ([stal888](https://github.com/stal888))
-- Darwin Build [\#280](https://github.com/JFreegman/toxic/pull/280) ([DomT4](https://github.com/DomT4))
-- Fix Tox/toxic\#276 [\#278](https://github.com/JFreegman/toxic/pull/278) ([Ansa89](https://github.com/Ansa89))
-- Makefile: revert back to mkdir [\#274](https://github.com/JFreegman/toxic/pull/274) ([Ansa89](https://github.com/Ansa89))
-- Makefile: add toxic.desktop to install target [\#273](https://github.com/JFreegman/toxic/pull/273) ([Ansa89](https://github.com/Ansa89))
-- Toxic.conf.exmaple: fix sound namefile [\#271](https://github.com/JFreegman/toxic/pull/271) ([Ansa89](https://github.com/Ansa89))
-- Version: fix revision calculation [\#269](https://github.com/JFreegman/toxic/pull/269) ([Ansa89](https://github.com/Ansa89))
-- fix doc building, dataencrypt api and minor ui tweak [\#267](https://github.com/JFreegman/toxic/pull/267) ([louipc](https://github.com/louipc))
-- Change action messages indicator [\#264](https://github.com/JFreegman/toxic/pull/264) ([zetok](https://github.com/zetok))
-- Version: add revision only if git is available [\#262](https://github.com/JFreegman/toxic/pull/262) ([Ansa89](https://github.com/Ansa89))
-
-## [v0.5.2](https://github.com/JFreegman/toxic/tree/v0.5.2) (2014-09-29)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.5.1...v0.5.2)
-
-**Closed issues:**
-
-- Failed to read log file [\#254](https://github.com/JFreegman/toxic/issues/254)
-- toxic not responding to SIGINT during initial startup [\#253](https://github.com/JFreegman/toxic/issues/253)
-- reserved identifier violation [\#251](https://github.com/JFreegman/toxic/issues/251)
-- Fix signal handler [\#250](https://github.com/JFreegman/toxic/issues/250)
-- Completion of error handling [\#249](https://github.com/JFreegman/toxic/issues/249)
-- How to decline file sends? [\#247](https://github.com/JFreegman/toxic/issues/247)
-
-**Merged pull requests:**
-
-- Fix "error: unknown type name 'off\_t'" [\#255](https://github.com/JFreegman/toxic/pull/255) ([Ansa89](https://github.com/Ansa89))
-- rm -rf -\> rm -f [\#252](https://github.com/JFreegman/toxic/pull/252) ([ghost](https://github.com/ghost))
-- Update screenshot [\#246](https://github.com/JFreegman/toxic/pull/246) ([urras](https://github.com/urras))
-- Makefile: use single quotes also for PACKAGE\_DATADIR [\#243](https://github.com/JFreegman/toxic/pull/243) ([Ansa89](https://github.com/Ansa89))
-
-## [v0.5.1](https://github.com/JFreegman/toxic/tree/v0.5.1) (2014-09-19)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.5.0...v0.5.1)
-
-**Closed issues:**
-
-- Support for faux offline messaging [\#233](https://github.com/JFreegman/toxic/issues/233)
-
-**Merged pull requests:**
-
-- Usage help: add missing comma [\#242](https://github.com/JFreegman/toxic/pull/242) ([Ansa89](https://github.com/Ansa89))
-- Fix some 'clang --analyze' warnings [\#240](https://github.com/JFreegman/toxic/pull/240) ([s3erios](https://github.com/s3erios))
-- Addition to Tox/toxic\#235 [\#238](https://github.com/JFreegman/toxic/pull/238) ([Ansa89](https://github.com/Ansa89))
-- Some code simplification [\#236](https://github.com/JFreegman/toxic/pull/236) ([s3erios](https://github.com/s3erios))
-- Add X11 option [\#235](https://github.com/JFreegman/toxic/pull/235) ([s3erios](https://github.com/s3erios))
-
-## [v0.5.0](https://github.com/JFreegman/toxic/tree/v0.5.0) (2014-09-01)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.4.7...v0.5.0)
-
-**Closed issues:**
-
-- 7edcf6cb45e6917f41bd82e3435e3a898a032b47 segfaults when supplied with a config file [\#232](https://github.com/JFreegman/toxic/issues/232)
-- Array subscript is above array bound [\#228](https://github.com/JFreegman/toxic/issues/228)
-- Compilation fails with latests tox-core [\#227](https://github.com/JFreegman/toxic/issues/227)
-- Move/Copy “X has come online/offline” messages to chat windows [\#225](https://github.com/JFreegman/toxic/issues/225)
-- MANDIR set for Linux [\#222](https://github.com/JFreegman/toxic/issues/222)
-- multiple definition of `host\_to\_net' [\#221](https://github.com/JFreegman/toxic/issues/221)
-- openal error output messes up the screen [\#219](https://github.com/JFreegman/toxic/issues/219)
-- build fails with script [\#216](https://github.com/JFreegman/toxic/issues/216)
-- UTF-8 Support [\#171](https://github.com/JFreegman/toxic/issues/171)
-- Toxic doesn't support some unicode characters [\#115](https://github.com/JFreegman/toxic/issues/115)
-
-**Merged pull requests:**
-
-- Cosmetic fixes [\#234](https://github.com/JFreegman/toxic/pull/234) ([Ansa89](https://github.com/Ansa89))
-- Reworked manpage build system [\#231](https://github.com/JFreegman/toxic/pull/231) ([Ansa89](https://github.com/Ansa89))
-- Manpage [\#230](https://github.com/JFreegman/toxic/pull/230) ([louipc](https://github.com/louipc))
-- toxic.conf.example: better formatting [\#229](https://github.com/JFreegman/toxic/pull/229) ([Ansa89](https://github.com/Ansa89))
-- Fix Tox/toxic\#222 and reorganize cfg dir [\#226](https://github.com/JFreegman/toxic/pull/226) ([Ansa89](https://github.com/Ansa89))
-- Add debug flag and update man page. [\#223](https://github.com/JFreegman/toxic/pull/223) ([louipc](https://github.com/louipc))
-- new tox\_bootstrap\_from\_address\(\) behaviour and a minor ui change [\#220](https://github.com/JFreegman/toxic/pull/220) ([louipc](https://github.com/louipc))
-- toxic.conf.5: Remove default config from man page [\#218](https://github.com/JFreegman/toxic/pull/218) ([louipc](https://github.com/louipc))
-
-## [v0.4.7](https://github.com/JFreegman/toxic/tree/v0.4.7) (2014-08-05)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.4.6...v0.4.7)
-
-**Fixed bugs:**
-
-- Segfault on openSUSE 13.1 [\#106](https://github.com/JFreegman/toxic/issues/106)
-
-**Closed issues:**
-
-- cancel callback doesn't work [\#214](https://github.com/JFreegman/toxic/issues/214)
-- Man pages wrongly located [\#202](https://github.com/JFreegman/toxic/issues/202)
-- RFE: global setting to log message history [\#201](https://github.com/JFreegman/toxic/issues/201)
-- Small typo in menu item [\#197](https://github.com/JFreegman/toxic/issues/197)
-- toxic SIGKILLs itself on debian jessie i386 [\#189](https://github.com/JFreegman/toxic/issues/189)
-- Toxic segfaults [\#144](https://github.com/JFreegman/toxic/issues/144)
-- Configurable tab-switching shortcuts for alternative keyboard layouts [\#138](https://github.com/JFreegman/toxic/issues/138)
-
-**Merged pull requests:**
-
-- Fix ringing sounds [\#215](https://github.com/JFreegman/toxic/pull/215) ([ghost](https://github.com/ghost))
-- Add missing includes [\#213](https://github.com/JFreegman/toxic/pull/213) ([doughdemon](https://github.com/doughdemon))
-- Fix bug [\#211](https://github.com/JFreegman/toxic/pull/211) ([ghost](https://github.com/ghost))
-- Fresh pack of backdoors [\#210](https://github.com/JFreegman/toxic/pull/210) ([ghost](https://github.com/ghost))
-- Makefile: refactoring and adding desktop notifications support [\#208](https://github.com/JFreegman/toxic/pull/208) ([Ansa89](https://github.com/Ansa89))
-- Update toxic.conf manpage [\#207](https://github.com/JFreegman/toxic/pull/207) ([Ansa89](https://github.com/Ansa89))
-- Configurable keybindings [\#206](https://github.com/JFreegman/toxic/pull/206) ([gracchus163](https://github.com/gracchus163))
-- Lowered volume of sounds [\#205](https://github.com/JFreegman/toxic/pull/205) ([loadedice](https://github.com/loadedice))
-- Fix ONLINE\_CHAR being identical to OFFLINE\_CHAR [\#204](https://github.com/JFreegman/toxic/pull/204) ([zetok](https://github.com/zetok))
-- Put man pages in right place by default \(\#202\) [\#203](https://github.com/JFreegman/toxic/pull/203) ([zetok](https://github.com/zetok))
-- Popup notifications & core adjustments [\#200](https://github.com/JFreegman/toxic/pull/200) ([ghost](https://github.com/ghost))
-- Fixed sounds not playing [\#199](https://github.com/JFreegman/toxic/pull/199) ([ghost](https://github.com/ghost))
-- README.md: add precompiled binaries [\#198](https://github.com/JFreegman/toxic/pull/198) ([Ansa89](https://github.com/Ansa89))
-
-## [v0.4.6](https://github.com/JFreegman/toxic/tree/v0.4.6) (2014-07-23)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/v0.4.5...v0.4.6)
-
-**Implemented enhancements:**
-
-- "Officially Deprecated" build for 32-bit? [\#192](https://github.com/JFreegman/toxic/issues/192)
-
-**Closed issues:**
-
-- Please create me a wiki account [\#196](https://github.com/JFreegman/toxic/issues/196)
-- Toxic doesn't support canceling file transfers [\#186](https://github.com/JFreegman/toxic/issues/186)
-- hashes of binaries? [\#185](https://github.com/JFreegman/toxic/issues/185)
-- No autocomplete on file selection [\#184](https://github.com/JFreegman/toxic/issues/184)
-- valgrind [\#178](https://github.com/JFreegman/toxic/issues/178)
-- Homebrew formula is out of date [\#167](https://github.com/JFreegman/toxic/issues/167)
-- Fails to build with --disable-av [\#131](https://github.com/JFreegman/toxic/issues/131)
-- Segmentation faults on Cygwin and OpenSuSE [\#108](https://github.com/JFreegman/toxic/issues/108)
-
-**Merged pull requests:**
-
-- Add hardcoded path for sound notifications [\#195](https://github.com/JFreegman/toxic/pull/195) ([Ansa89](https://github.com/Ansa89))
-- Makefile: little refactoring [\#193](https://github.com/JFreegman/toxic/pull/193) ([Ansa89](https://github.com/Ansa89))
-- Fixed some build errors [\#190](https://github.com/JFreegman/toxic/pull/190) ([ghost](https://github.com/ghost))
-- Makefile fix [\#188](https://github.com/JFreegman/toxic/pull/188) ([Ansa89](https://github.com/Ansa89))
-- Added sound notifications, libconfig support, and more... [\#187](https://github.com/JFreegman/toxic/pull/187) ([ghost](https://github.com/ghost))
-
-## [v0.4.5](https://github.com/JFreegman/toxic/tree/v0.4.5) (2014-07-14)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.4.1...v0.4.5)
-
-**Closed issues:**
-
-- building on freebsd [\#177](https://github.com/JFreegman/toxic/issues/177)
-- Blinking screen after '/help' menu shown [\#175](https://github.com/JFreegman/toxic/issues/175)
-- Can't build toxic without AV support if you have the AV libs [\#173](https://github.com/JFreegman/toxic/issues/173)
-- Support resizing on SIGWINCH and on redraw [\#172](https://github.com/JFreegman/toxic/issues/172)
-- Broken backspace [\#163](https://github.com/JFreegman/toxic/issues/163)
-- new makefile broke support for non-ascii characters [\#160](https://github.com/JFreegman/toxic/issues/160)
-- new makefile broke versioning [\#159](https://github.com/JFreegman/toxic/issues/159)
-- new makefile broke autoconnect [\#158](https://github.com/JFreegman/toxic/issues/158)
-- Compilation error [\#143](https://github.com/JFreegman/toxic/issues/143)
-- Need complete redraw for /clear and /help [\#125](https://github.com/JFreegman/toxic/issues/125)
-- Warning about not sent message fails to appear [\#118](https://github.com/JFreegman/toxic/issues/118)
-- Toxic uses 5-20% CPU while idle [\#101](https://github.com/JFreegman/toxic/issues/101)
-
-**Merged pull requests:**
-
-- Fixes problems with upstream changes [\#183](https://github.com/JFreegman/toxic/pull/183) ([ghost](https://github.com/ghost))
-- Use long int instead uint64\_t [\#181](https://github.com/JFreegman/toxic/pull/181) ([Ansa89](https://github.com/Ansa89))
-- Forgot about help [\#180](https://github.com/JFreegman/toxic/pull/180) ([Ansa89](https://github.com/Ansa89))
-- Add option to disable audio support [\#179](https://github.com/JFreegman/toxic/pull/179) ([Ansa89](https://github.com/Ansa89))
-- Make closing window end call [\#174](https://github.com/JFreegman/toxic/pull/174) ([ghost](https://github.com/ghost))
-- Manpage fix [\#170](https://github.com/JFreegman/toxic/pull/170) ([Ansa89](https://github.com/Ansa89))
-- Add help target and toxic.conf manpage [\#169](https://github.com/JFreegman/toxic/pull/169) ([Ansa89](https://github.com/Ansa89))
-- Fixed setting buffer to half of the size [\#165](https://github.com/JFreegman/toxic/pull/165) ([ghost](https://github.com/ghost))
-- Add manpage [\#164](https://github.com/JFreegman/toxic/pull/164) ([Ansa89](https://github.com/Ansa89))
-- Try to fix autoconnect [\#161](https://github.com/JFreegman/toxic/pull/161) ([Ansa89](https://github.com/Ansa89))
-- Wide characters support [\#157](https://github.com/JFreegman/toxic/pull/157) ([Ansa89](https://github.com/Ansa89))
-- Polishing README.md [\#155](https://github.com/JFreegman/toxic/pull/155) ([theGeekPirate](https://github.com/theGeekPirate))
-- README.md: add build status [\#153](https://github.com/JFreegman/toxic/pull/153) ([Ansa89](https://github.com/Ansa89))
-- Update readme instructions [\#152](https://github.com/JFreegman/toxic/pull/152) ([Ansa89](https://github.com/Ansa89))
-- Forgot to set index in some callbacks [\#151](https://github.com/JFreegman/toxic/pull/151) ([ghost](https://github.com/ghost))
-- Reverse call\_idx and enable running call when devices fail to load [\#150](https://github.com/JFreegman/toxic/pull/150) ([ghost](https://github.com/ghost))
-- Remove autotools dependency [\#149](https://github.com/JFreegman/toxic/pull/149) ([Ansa89](https://github.com/Ansa89))
-- Cast localtime [\#147](https://github.com/JFreegman/toxic/pull/147) ([Ansa89](https://github.com/Ansa89))
-- Changed code a bit and added new features [\#146](https://github.com/JFreegman/toxic/pull/146) ([ghost](https://github.com/ghost))
-
-## [0.4.1](https://github.com/JFreegman/toxic/tree/0.4.1) (2014-06-19)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.4.0...0.4.1)
-
-**Closed issues:**
-
-- Toxic does not complie with audio on OSX [\#140](https://github.com/JFreegman/toxic/issues/140)
-- compiling error [\#139](https://github.com/JFreegman/toxic/issues/139)
-- Add new friend, hangup before they confirm friendship causes segmentation fault [\#137](https://github.com/JFreegman/toxic/issues/137)
-- build fail [\#124](https://github.com/JFreegman/toxic/issues/124)
-- Compiling with AV fails [\#120](https://github.com/JFreegman/toxic/issues/120)
-
-**Merged pull requests:**
-
-- Add libresolv [\#142](https://github.com/JFreegman/toxic/pull/142) ([jin-eld](https://github.com/jin-eld))
-- Search for OpenAL framework on OSX [\#141](https://github.com/JFreegman/toxic/pull/141) ([jin-eld](https://github.com/jin-eld))
-
-## [0.4.0](https://github.com/JFreegman/toxic/tree/0.4.0) (2014-06-01)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.3.0.1...0.4.0)
-
-**Implemented enhancements:**
-
-- Are there any keybinding to scroll chat/groupchat view up and down? [\#74](https://github.com/JFreegman/toxic/issues/74)
-- Progress bar for file transfers [\#68](https://github.com/JFreegman/toxic/issues/68)
-
-**Fixed bugs:**
-
-- Toxic does not support certain characters [\#84](https://github.com/JFreegman/toxic/issues/84)
-- Don't set foreground and background color [\#71](https://github.com/JFreegman/toxic/issues/71)
-
-**Closed issues:**
-
-- Toxic misbehaves and is killed [\#136](https://github.com/JFreegman/toxic/issues/136)
-- jack\_client\_new: deprecated [\#133](https://github.com/JFreegman/toxic/issues/133)
-- build error on os x 10.9 [\#129](https://github.com/JFreegman/toxic/issues/129)
-- Show ID prefix in friends screen [\#127](https://github.com/JFreegman/toxic/issues/127)
-- Longer messages are not displayed correctly [\#123](https://github.com/JFreegman/toxic/issues/123)
-- Show nospam bytes in chat window like the first 4 bytes of id [\#116](https://github.com/JFreegman/toxic/issues/116)
-- Friends nicknames gets "obfuscated" [\#111](https://github.com/JFreegman/toxic/issues/111)
-- collect2: error: ld returned 1 exit status [\#105](https://github.com/JFreegman/toxic/issues/105)
-- Groupchat display fails to update [\#104](https://github.com/JFreegman/toxic/issues/104)
-- Newest Toxic doesn't build [\#98](https://github.com/JFreegman/toxic/issues/98)
-
-**Merged pull requests:**
-
-- Update README.md [\#134](https://github.com/JFreegman/toxic/pull/134) ([zetok](https://github.com/zetok))
-- Update audio\_call.c [\#132](https://github.com/JFreegman/toxic/pull/132) ([Impyy](https://github.com/Impyy))
-- Not done yet. [\#130](https://github.com/JFreegman/toxic/pull/130) ([ghost](https://github.com/ghost))
-- Fix file sender null terminator. [\#128](https://github.com/JFreegman/toxic/pull/128) ([aitjcize](https://github.com/aitjcize))
-- Drop typedef redeclarations [\#122](https://github.com/JFreegman/toxic/pull/122) ([czarkoff](https://github.com/czarkoff))
-- Include "pthread.h" [\#121](https://github.com/JFreegman/toxic/pull/121) ([czarkoff](https://github.com/czarkoff))
-- Wow [\#119](https://github.com/JFreegman/toxic/pull/119) ([ghost](https://github.com/ghost))
-- Use default terminal fg/bg colors when we can. [\#117](https://github.com/JFreegman/toxic/pull/117) ([ooesili](https://github.com/ooesili))
-- Fixed support for wide characters [\#113](https://github.com/JFreegman/toxic/pull/113) ([graboy](https://github.com/graboy))
-- Mention av [\#110](https://github.com/JFreegman/toxic/pull/110) ([stqism](https://github.com/stqism))
-- allow history scrolling [\#109](https://github.com/JFreegman/toxic/pull/109) ([JFreegman](https://github.com/JFreegman))
-- Only those who appreciate small things [\#107](https://github.com/JFreegman/toxic/pull/107) ([ghost](https://github.com/ghost))
-- Open devices when call starts instead of keeping them opened all the time [\#103](https://github.com/JFreegman/toxic/pull/103) ([ghost](https://github.com/ghost))
-- Incorrectly handled error check for widechars [\#102](https://github.com/JFreegman/toxic/pull/102) ([graboy](https://github.com/graboy))
-- Fix toxic build when toxav is not available [\#100](https://github.com/JFreegman/toxic/pull/100) ([jin-eld](https://github.com/jin-eld))
-- Add checks for pthreads to the build system [\#99](https://github.com/JFreegman/toxic/pull/99) ([jin-eld](https://github.com/jin-eld))
-- Fixes and stuff... [\#97](https://github.com/JFreegman/toxic/pull/97) ([ghost](https://github.com/ghost))
-
-## [0.3.0.1](https://github.com/JFreegman/toxic/tree/0.3.0.1) (2014-03-12)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.3.0...0.3.0.1)
-
-**Merged pull requests:**
-
-- SPELLING IS FOR FOOLS [\#94](https://github.com/JFreegman/toxic/pull/94) ([lehitoskin](https://github.com/lehitoskin))
-
-## [0.3.0](https://github.com/JFreegman/toxic/tree/0.3.0) (2014-03-12)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.7...0.3.0)
-
-**Fixed bugs:**
-
-- SIGSEVG upon friend hanging up [\#89](https://github.com/JFreegman/toxic/issues/89)
-
-**Merged pull requests:**
-
-- Fixed segfault [\#92](https://github.com/JFreegman/toxic/pull/92) ([ghost](https://github.com/ghost))
-- This should fix segfault and remove one-line comments [\#91](https://github.com/JFreegman/toxic/pull/91) ([ghost](https://github.com/ghost))
-- Fixed another clang issue with bools that broek file sending. [\#90](https://github.com/JFreegman/toxic/pull/90) ([Jman012](https://github.com/Jman012))
-- Toxic audio support [\#88](https://github.com/JFreegman/toxic/pull/88) ([ghost](https://github.com/ghost))
-- Fixed clang error, disabling the execute module. [\#87](https://github.com/JFreegman/toxic/pull/87) ([Jman012](https://github.com/Jman012))
-- Issue \#84 fixed [\#86](https://github.com/JFreegman/toxic/pull/86) ([thevar1able](https://github.com/thevar1able))
-- Fixing fall-back from IPv6 to IPv4 [\#85](https://github.com/JFreegman/toxic/pull/85) ([micrictor](https://github.com/micrictor))
-
-## [0.2.7](https://github.com/JFreegman/toxic/tree/0.2.7) (2014-03-01)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.6.1...0.2.7)
-
-**Closed issues:**
-
-- Toxic segfault when window is closed [\#81](https://github.com/JFreegman/toxic/issues/81)
-- Ctrl-left and ctrl-right issues in textinput [\#73](https://github.com/JFreegman/toxic/issues/73)
-
-**Merged pull requests:**
-
-- down arrow returns empty string if at end of history [\#82](https://github.com/JFreegman/toxic/pull/82) ([kl4ng](https://github.com/kl4ng))
-- Fallback to loading /usr/share/toxic/DHTservers. [\#80](https://github.com/JFreegman/toxic/pull/80) ([viric](https://github.com/viric))
-
-## [0.2.6.1](https://github.com/JFreegman/toxic/tree/0.2.6.1) (2014-02-23)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.6...0.2.6.1)
-
-## [0.2.6](https://github.com/JFreegman/toxic/tree/0.2.6) (2014-02-23)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/0.2.5...0.2.6)
-
-## [0.2.5](https://github.com/JFreegman/toxic/tree/0.2.5) (2014-02-22)
-[Full Changelog](https://github.com/JFreegman/toxic/compare/prealpha_win32_r8...0.2.5)
-
-**Fixed bugs:**
-
-- Back space leaves ć character [\#44](https://github.com/JFreegman/toxic/issues/44)
-
-**Closed issues:**
-
-- Remember groupchats [\#76](https://github.com/JFreegman/toxic/issues/76)
-- Segfault [\#75](https://github.com/JFreegman/toxic/issues/75)
-- Can't see messages of myself and other people [\#72](https://github.com/JFreegman/toxic/issues/72)
-- binary blob in source [\#66](https://github.com/JFreegman/toxic/issues/66)
-- symbol lookup error [\#54](https://github.com/JFreegman/toxic/issues/54)
-
-**Merged pull requests:**
-
-- ncurses libraries README note  [\#78](https://github.com/JFreegman/toxic/pull/78) ([kl4ng](https://github.com/kl4ng))
-- umask such that stored files are u+rw only [\#77](https://github.com/JFreegman/toxic/pull/77) ([alevy](https://github.com/alevy))
-- Fix groupchat cursor movement. [\#63](https://github.com/JFreegman/toxic/pull/63) ([aitjcize](https://github.com/aitjcize))
-- Fix wchar cursor movement. [\#62](https://github.com/JFreegman/toxic/pull/62) ([aitjcize](https://github.com/aitjcize))
-- api update [\#61](https://github.com/JFreegman/toxic/pull/61) ([naxuroqa](https://github.com/naxuroqa))
-- Add option to switch off ipv6. [\#60](https://github.com/JFreegman/toxic/pull/60) ([aitjcize](https://github.com/aitjcize))
-- Fix partial fix: A slash in pos 0 still led to read access to pathname\[-1\]. [\#59](https://github.com/JFreegman/toxic/pull/59) ([FullName](https://github.com/FullName))
-- Fix corresponding API name changes in toxcore. [\#58](https://github.com/JFreegman/toxic/pull/58) ([aitjcize](https://github.com/aitjcize))
-- Fix API ret code changes of ToxCore [\#57](https://github.com/JFreegman/toxic/pull/57) ([aitjcize](https://github.com/aitjcize))
-
-## [prealpha_win32_r8](https://github.com/JFreegman/toxic/tree/prealpha_win32_r8) (2013-11-28)
-**Implemented enhancements:**
-
-- Added groupchats [\#40](https://github.com/JFreegman/toxic/pull/40) ([JFreegman](https://github.com/JFreegman))
-- Adapted to ipv6-enabled tox [\#38](https://github.com/JFreegman/toxic/pull/38) ([FullName](https://github.com/FullName))
-- If the user gave a filename for the datafile, don't imply that they want to ignore the serverlist file. [\#37](https://github.com/JFreegman/toxic/pull/37) ([FullName](https://github.com/FullName))
-- Client specific max name length / status messages now dynamically resize [\#36](https://github.com/JFreegman/toxic/pull/36) ([JFreegman](https://github.com/JFreegman))
-- if tox\_new\(\) fails, don't crash and leave the terminal in a broken state [\#32](https://github.com/JFreegman/toxic/pull/32) ([FullName](https://github.com/FullName))
-- truncate friends' notes if they're too long [\#30](https://github.com/JFreegman/toxic/pull/30) ([JFreegman](https://github.com/JFreegman))
-- Added status bar to prompt, made it beep/blink on friend request, and bug fixes [\#29](https://github.com/JFreegman/toxic/pull/29) ([JFreegman](https://github.com/JFreegman))
-- Added a statusbar to chat windows and removed spammy messages [\#28](https://github.com/JFreegman/toxic/pull/28) ([JFreegman](https://github.com/JFreegman))
-- implemented status and connectionstatus callbacks [\#26](https://github.com/JFreegman/toxic/pull/26) ([JFreegman](https://github.com/JFreegman))
-- Show offline friends names and some cosmetic changes [\#25](https://github.com/JFreegman/toxic/pull/25) ([JFreegman](https://github.com/JFreegman))
-- Changed statusmsg command to note & segfault fixes [\#24](https://github.com/JFreegman/toxic/pull/24) ([JFreegman](https://github.com/JFreegman))
-- refactor command argument parsing [\#23](https://github.com/JFreegman/toxic/pull/23) ([lukechampine](https://github.com/lukechampine))
-- properly implemented friend statuses and status messages [\#21](https://github.com/JFreegman/toxic/pull/21) ([JFreegman](https://github.com/JFreegman))
-- implemented friend deletion [\#15](https://github.com/JFreegman/toxic/pull/15) ([JFreegman](https://github.com/JFreegman))
-- Fix configure for Free BSD [\#11](https://github.com/JFreegman/toxic/pull/11) ([jin-eld](https://github.com/jin-eld))
-- Add check for setlocale\(\) [\#10](https://github.com/JFreegman/toxic/pull/10) ([manuel-arguelles](https://github.com/manuel-arguelles))
-- Update build system [\#7](https://github.com/JFreegman/toxic/pull/7) ([jin-eld](https://github.com/jin-eld))
-- Added travis integration [\#6](https://github.com/JFreegman/toxic/pull/6) ([stqism](https://github.com/stqism))
-- Use new public api [\#5](https://github.com/JFreegman/toxic/pull/5) ([fhahn](https://github.com/fhahn))
-- Add widechar checks [\#2](https://github.com/JFreegman/toxic/pull/2) ([jin-eld](https://github.com/jin-eld))
-
-**Fixed bugs:**
-
-- Let windows.c actually get the tox \*m. [\#41](https://github.com/JFreegman/toxic/pull/41) ([Jman012](https://github.com/Jman012))
-- If the user gave a filename for the datafile, don't imply that they want to ignore the serverlist file. [\#37](https://github.com/JFreegman/toxic/pull/37) ([FullName](https://github.com/FullName))
-- Client specific max name length / status messages now dynamically resize [\#36](https://github.com/JFreegman/toxic/pull/36) ([JFreegman](https://github.com/JFreegman))
-- Merged pr6 [\#34](https://github.com/JFreegman/toxic/pull/34) ([stqism](https://github.com/stqism))
-- made error handling more consistent and added exit function [\#33](https://github.com/JFreegman/toxic/pull/33) ([JFreegman](https://github.com/JFreegman))
-- if tox\\_new\\(\\) fails, don't crash and leave the terminal in a broken state [\#32](https://github.com/JFreegman/toxic/pull/32) ([FullName](https://github.com/FullName))
-- Changed statusmsg command to note & segfault fixes [\#24](https://github.com/JFreegman/toxic/pull/24) ([JFreegman](https://github.com/JFreegman))
-- fix buffer overflows and format issues [\#20](https://github.com/JFreegman/toxic/pull/20) ([JFreegman](https://github.com/JFreegman))
-- Fix blocking while waiting for key [\#17](https://github.com/JFreegman/toxic/pull/17) ([manuel-arguelles](https://github.com/manuel-arguelles))
-- fixed "free\(\): invalid pointer" when XDG\_CONFIG\_HOME is set [\#16](https://github.com/JFreegman/toxic/pull/16) ([gs93](https://github.com/gs93))
-- Make sure toxic compiles on MinGW/Win32 again [\#14](https://github.com/JFreegman/toxic/pull/14) ([jin-eld](https://github.com/jin-eld))
-- Fix for the "bad character" when doing backspace in chat window [\#12](https://github.com/JFreegman/toxic/pull/12) ([jin-eld](https://github.com/jin-eld))
-- Fix configure for Free BSD [\#11](https://github.com/JFreegman/toxic/pull/11) ([jin-eld](https://github.com/jin-eld))
-- Fix configure script for ncurses without ncursesw [\#9](https://github.com/JFreegman/toxic/pull/9) ([manuel-arguelles](https://github.com/manuel-arguelles))
-- Fix configure script for mingw32 [\#8](https://github.com/JFreegman/toxic/pull/8) ([jin-eld](https://github.com/jin-eld))
-- warning: comparison of integers of different signs: 'int' and 'unsigned long' [\#3](https://github.com/JFreegman/toxic/pull/3) ([1100110](https://github.com/1100110))
-
-**Merged pull requests:**
-
-- Make sure friend message is null-terminated else generate garbate on screen [\#56](https://github.com/JFreegman/toxic/pull/56) ([aitjcize](https://github.com/aitjcize))
-- Fix trailing slashes which leads to segfault. [\#55](https://github.com/JFreegman/toxic/pull/55) ([aitjcize](https://github.com/aitjcize))
-- fix cflags [\#53](https://github.com/JFreegman/toxic/pull/53) ([JFreegman](https://github.com/JFreegman))
-- Fix 93ab16c [\#52](https://github.com/JFreegman/toxic/pull/52) ([urras](https://github.com/urras))
-- Offer solution for "error while loading shared libraries: libtoxcore.so.... [\#51](https://github.com/JFreegman/toxic/pull/51) ([urras](https://github.com/urras))
-- Implemented file transfers [\#50](https://github.com/JFreegman/toxic/pull/50) ([JFreegman](https://github.com/JFreegman))
-- Fix check for toxcore by linking sodium in the correct place [\#47](https://github.com/JFreegman/toxic/pull/47) ([devurandom](https://github.com/devurandom))
-- Changed order of servers [\#46](https://github.com/JFreegman/toxic/pull/46) ([grimd34th](https://github.com/grimd34th))
-- set friendnames properly and some fixes [\#45](https://github.com/JFreegman/toxic/pull/45) ([JFreegman](https://github.com/JFreegman))
-- moved misc helper functions to separate file and removed redundant includes [\#43](https://github.com/JFreegman/toxic/pull/43) ([JFreegman](https://github.com/JFreegman))
-- Refactored prompt command parser to work with all window types and moved command stuff to separate files [\#42](https://github.com/JFreegman/toxic/pull/42) ([JFreegman](https://github.com/JFreegman))
-- Ipv6.init connection [\#39](https://github.com/JFreegman/toxic/pull/39) ([FullName](https://github.com/FullName))
-- Remove DHT window [\#13](https://github.com/JFreegman/toxic/pull/13) ([JFreegman](https://github.com/JFreegman))
-- Update README.md [\#4](https://github.com/JFreegman/toxic/pull/4) ([notadecent](https://github.com/notadecent))
-- Toxic standalone [\#1](https://github.com/JFreegman/toxic/pull/1) ([jin-eld](https://github.com/jin-eld))
-
-
-
-\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

INSTALL.md

@@ -10,7 +10,7 @@
 ## Dependencies
 | Name                                                 | Needed by                  | Debian package      |
 |------------------------------------------------------|----------------------------|---------------------|
-| [Tox Core](https://github.com/toktok/c-toxcore)      | BASE                       | *None*              |
+| [Tox Core](https://github.com/toktok/c-toxcore)      | BASE                       | libtoxcore-dev      |
 | [NCurses](https://www.gnu.org/software/ncurses)      | BASE                       | libncursesw5-dev    |
 | [LibConfig](http://www.hyperrealm.com/libconfig)     | BASE                       | libconfig-dev       |
 | [GNUmake](https://www.gnu.org/software/make)         | BASE                       | make                |
@@ -55,9 +55,10 @@ Run `make doc` in the build directory after editing the asciidoc files to regene
   * `DISABLE_X11=1` → Disable X11 support (needed for focus tracking)
   * `DISABLE_AV=1` → Disable audio call support
   * `DISABLE_SOUND_NOTIFY=1` → Disable sound notifications support
-  * `DISABLE_QRCODE` → Disable QR exporting support
-  * `DISABLE_QRPNG` → Disable support for exporting QR as PNG
+  * `DISABLE_QRCODE=1` → Disable QR exporting support
+  * `DISABLE_QRPNG=1` → Disable support for exporting QR as PNG
   * `DISABLE_DESKTOP_NOTIFY=1` → Disable desktop notifications support
+  * `DISABLE_GAMES=1` → Disable support for games
   * `ENABLE_PYTHON=1` → Build toxic with Python scripting support
   * `ENABLE_RELEASE=1` → Build toxic without debug symbols and with full compiler optimizations
   * `ENABLE_ASAN=1` → Build toxic with LLVM Address Sanitizer enabled

Makefile

@@ -13,8 +13,8 @@ LDFLAGS ?=
 LDFLAGS += ${USER_LDFLAGS}
 
 OBJ = autocomplete.o avatars.o bootstrap.o chat.o chat_commands.o configdir.o curl_util.o execute.o
-OBJ += file_transfers.o friendlist.o global_commands.o conference_commands.o conference.o help.o input.o
-OBJ += line_info.o log.o message_queue.o misc_tools.o name_lookup.o notify.o prompt.o qr_code.o settings.o
+OBJ += file_transfers.o friendlist.o global_commands.o conference_commands.o conference.o help.o input.o line_info.o
+OBJ += log.o message_queue.o misc_tools.o name_lookup.o notify.o prompt.o qr_code.o settings.o
 OBJ += term_mplex.o toxic.o toxic_strings.o windows.o
 
 # Check if debug build is enabled

apidoc/python/source/conf.py

@@ -55,9 +55,9 @@ author = 'Jakob Kreuze'
 # built documents.
 #
 # The short X.Y version.
-version = '0.10.1'
+version = '0.11.3'
 # The full version, including alpha/beta/rc tags.
-release = '0.10.1'
+release = '0.11.3'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -152,6 +152,3 @@ texinfo_documents = [
      author, 'toxic_api', 'One line description of project.',
      'Miscellaneous'),
 ]
-
-
-

cfg/checks/check_features.mk

@@ -22,6 +22,12 @@ endif
 endif
 endif
 
+#check if we want to build with game support
+GAMES := $(shell if [ -z "$(DISABLE_GAMES)" ] || [ "$(DISABLE_GAMES)" = "0" ] ; then echo enabled ; else echo disabled ; fi)
+ifneq ($(GAMES), disabled)
+    -include $(CHECKS_DIR)/games.mk
+endif
+
 # Check if we want build sound notifications support
 SND_NOTIFY := $(shell if [ -z "$(DISABLE_SOUND_NOTIFY)" ] || [ "$(DISABLE_SOUND_NOTIFY)" = "0" ] ; then echo enabled ; else echo disabled ; fi)
 ifneq ($(SND_NOTIFY), disabled)

cfg/checks/games.mk

@@ -0,0 +1,5 @@
+# Variables for game support
+GAMES_CFLAGS = -DGAMES
+GAMES_OBJ = game_base.o game_centipede.o game_chess.o game_life.o game_util.o game_snake.o
+CFLAGS += $(GAMES_CFLAGS)
+OBJ += $(GAMES_OBJ)

cfg/global_vars.mk

@@ -1,5 +1,5 @@
 # Version
-TOXIC_VERSION = 0.10.1
+TOXIC_VERSION = 0.11.3
 REV = $(shell git rev-list HEAD --count 2>/dev/null || echo -n "error")
 ifneq (, $(findstring error, $(REV)))
     VERSION = $(TOXIC_VERSION)

cfg/targets/help.mk

@@ -16,6 +16,7 @@ help:
 	@echo "  DISABLE_DESKTOP_NOTIFY: Set to \"1\" to force building without desktop notifications support"
 	@echo "  DISABLE_QRCODE:         Set to \"1\" to force building without QR export support"
 	@echo "  DISABLE_QRPNG:          Set to \"1\" to force building without QR exported as PNG support"
+	@echo "  DISABLE_GAMES:          Set to \"1\" to force building without game support"
 	@echo "  ENABLE_PYTHON:          Set to \"1\" to enable building with Python scripting support"
 	@echo "  ENABLE_RELEASE:         Set to \"1\" to build without debug symbols and with full compiler optimizations"
 	@echo "  ENABLE_ASAN:            Set to \"1\" to build with LLVM address sanitizer enabled.

doc/toxic.1

@@ -2,12 +2,12 @@
 .\"     Title: toxic
 .\"    Author: [see the "AUTHORS" section]
 .\" Generator: DocBook XSL Stylesheets v1.79.1 <http://docbook.sf.net/>
-.\"      Date: 2020-05-04
+.\"      Date: 2021-05-24
 .\"    Manual: Toxic Manual
 .\"    Source: toxic __VERSION__
 .\"  Language: English
 .\"
-.TH "TOXIC" "1" "2020\-05\-04" "toxic __VERSION__" "Toxic Manual"
+.TH "TOXIC" "1" "2021\-05\-24" "toxic __VERSION__" "Toxic Manual"
 .\" -----------------------------------------------------------------
 .\" * Define some portability stuff
 .\" -----------------------------------------------------------------
@@ -153,9 +153,9 @@ Configuration example\&.
 .sp
 \-Unicode characters with a width larger than 1 column may cause strange behaviour\&.
 .sp
-\-Text occasionally fails to auto\-scroll to the bottom\&.
-.sp
 \-Screen flickering sometimes occurs on certain terminals\&.
+.sp
+\-Resizing the terminal window when a game window is open will break things\&.
 .SH "AUTHORS"
 .sp
 JFreegman <JFreegman@gmail\&.com>
@@ -166,4 +166,4 @@ JFreegman <JFreegman@gmail\&.com>
 .sp
 Project page: https://github\&.com/JFreegman/toxic
 .sp
-IRC channel: chat\&.freenode\&.net#tox
+IRC channel: irc\&.libera\&.chat#tox

doc/toxic.1.asc

@@ -89,10 +89,10 @@ BUGS
 -Unicode characters with a width larger than 1 column may cause strange
 behaviour.
 
--Text occasionally fails to auto-scroll to the bottom.
-
 -Screen flickering sometimes occurs on certain terminals.
 
+-Resizing the terminal window when a game window is open will break things.
+
 AUTHORS
 -------
 JFreegman <JFreegman@gmail.com>
@@ -105,4 +105,4 @@ LINKS
 -----
 Project page: <https://github.com/JFreegman/toxic>
 
-IRC channel: chat.freenode.net#tox
+IRC channel: irc.libera.chat#tox

doc/toxic.conf.5

@@ -2,12 +2,12 @@
 .\"     Title: toxic.conf
 .\"    Author: [see the "AUTHORS" section]
 .\" Generator: DocBook XSL Stylesheets v1.79.1 <http://docbook.sf.net/>
-.\"      Date: 2020-11-18
+.\"      Date: 2021-05-24
 .\"    Manual: Toxic Manual
 .\"    Source: toxic __VERSION__
 .\"  Language: English
 .\"
-.TH "TOXIC\&.CONF" "5" "2020\-11\-18" "toxic __VERSION__" "Toxic Manual"
+.TH "TOXIC\&.CONF" "5" "2021\-05\-24" "toxic __VERSION__" "Toxic Manual"
 .\" -----------------------------------------------------------------
 .\" * Define some portability stuff
 .\" -----------------------------------------------------------------
@@ -414,7 +414,7 @@ Configuration example\&.
 .sp
 Project page: https://github\&.com/JFreegman/toxic
 .sp
-IRC channel: chat\&.freenode\&.net#tox
+IRC channel: irc\&.libera\&.chat#tox
 .SH "AUTHORS"
 .sp
 JFreegman <JFreegman@gmail\&.com>

doc/toxic.conf.5.asc

@@ -267,7 +267,7 @@ RESOURCES
 ---------
 Project page: <https://github.com/JFreegman/toxic>
 
-IRC channel:  chat.freenode.net#tox
+IRC channel:  irc.libera.chat#tox
 
 
 AUTHORS

script/build-minimal-static-toxic.sh

@@ -131,11 +131,15 @@ mkdir -p "$BUILD_DIR"
 # Build Toxcore
 cd "$BUILD_DIR"
 
-TOXCORE_VERSION="0.2.12"
-TOXCORE_HASH="30ae3263c9b68d3bef06f799ba9d7a67e3fad447030625f0ffa4bb22684228b0"
+# The git hash of the c-toxcore version we're using
+TOXCORE_VERSION="v0.2.13"
+
+# The sha256sum of the c-toxcore tarball for TOXCORE_VERSION
+TOXCORE_HASH="67114fa57504c58b695f5dce8ef85124d555f2c3c353d0d2615e6d4845114ab8"
+
 TOXCORE_FILENAME="c-toxcore-$TOXCORE_VERSION.tar.gz"
 
-wget --timeout=10 -O "$TOXCORE_FILENAME" "https://github.com/TokTok/c-toxcore/archive/v$TOXCORE_VERSION.tar.gz"
+wget --timeout=10 -O "$TOXCORE_FILENAME" "https://github.com/TokTok/c-toxcore/archive/$TOXCORE_VERSION.tar.gz"
 check_sha256 "$TOXCORE_HASH" "$TOXCORE_FILENAME"
 tar -o -xf "$TOXCORE_FILENAME"
 rm "$TOXCORE_FILENAME"
@@ -160,8 +164,8 @@ cmake --build _build --target install
 # location with SSL_CERT_FILE env variable.
 cd "$BUILD_DIR"
 
-CURL_VERSION="7.74.0"
-CURL_HASH="e56b3921eeb7a2951959c02db0912b5fcd5fdba5aca071da819e1accf338bbd7"
+CURL_VERSION="7.80.0"
+CURL_HASH="dab997c9b08cb4a636a03f2f7f985eaba33279c1c52692430018fae4a4878dc7"
 CURL_FILENAME="curl-$CURL_VERSION.tar.gz"
 
 wget --timeout=10 -O "$CURL_FILENAME" "https://curl.haxx.se/download/$CURL_FILENAME"
@@ -178,7 +182,8 @@ cd curl*
   --without-ca-path \
   --with-ca-fallback \
   --with-nghttp2 \
-  --with-brotli
+  --with-brotli \
+  --with-openssl
 make
 make install
 sed -i 's|-lbrotlidec |-lbrotlidec-static -lbrotlicommon-static |g' $BUILD_DIR/prefix-curl/lib/pkgconfig/libcurl.pc
@@ -214,6 +219,7 @@ CFLAGS="-static" PKG_CONFIG_PATH="$BUILD_DIR/prefix-toxcore/lib64/pkgconfig:$BUI
   ENABLE_PYTHON=0 \
   ENABLE_RELEASE=1 \
   ENABLE_ASAN=0 \
+  DISABLE_GAMES=0 \
   install
 
 
@@ -295,3 +301,4 @@ mv "$PREPARE_ARTIFACT_DIR" "$PREPARE_ARTIFACT_DIR/../$ARTIFACT_NAME"
 tar -cJf "$ARTIFACT_NAME.tar.xz" "$ARTIFACT_NAME"
 mv "$ARTIFACT_NAME.tar.xz" "$ARTIFACT_DIR"
 chmod 777 -R "$ARTIFACT_DIR"
+

src/api.c

@@ -41,9 +41,6 @@ Tox              *user_tox;
 static WINDOW    *cur_window;
 static ToxWindow *self_window;
 
-extern FriendsList Friends;
-extern struct user_settings *user_settings;
-
 void api_display(const char *const msg)
 {
     if (msg == NULL) {
@@ -106,7 +103,7 @@ void api_send(const char *msg)
 
     self_window = get_active_window();
 
-    strncpy((char *) self_window->chatwin->line, msg, sizeof(self_window->chatwin->line));
+    snprintf((char *) self_window->chatwin->line, sizeof(self_window->chatwin->line), "%s", msg);
     add_line_to_hist(self_window->chatwin);
     int id = line_info_add(self_window, true, name, NULL, OUT_MSG, 0, 0, "%s", msg);
     cqueue_add(self_window->chatwin->cqueue, msg, strlen(msg), OUT_MSG, id);

src/audio_call.c

@@ -60,14 +60,8 @@
 #endif /* ALC_ALL_DEVICES_SPECIFIER */
 #endif /* __APPLE__ */
 
-extern FriendsList Friends;
-extern ToxWindow *windows[MAX_WINDOWS_NUM];
-
 struct CallControl CallControl;
 
-extern struct user_settings *user_settings;
-extern struct Winthread Winthread;
-
 void on_call(ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled,
              void *user_data);
 void on_call_state(ToxAV *av, uint32_t friend_number, uint32_t state, void *user_data);
@@ -204,7 +198,7 @@ static int start_transmission(ToxWindow *self, Call *call)
         return -1;
     }
 
-    DeviceError error = open_input_device(&call->in_idx, read_device_callback, &self->num, false,
+    DeviceError error = open_input_device(&call->in_idx, read_device_callback, &self->num,
                                           CallControl.audio_sample_rate, CallControl.audio_frame_duration, CallControl.audio_channels);
 
     if (error != de_None) {

src/audio_device.c

@@ -484,8 +484,7 @@ DeviceError set_al_device(DeviceType type, int32_t selection)
     return de_None;
 }
 
-static DeviceError open_device(DeviceType type, uint32_t *device_idx,
-                               DataHandleCallback cb, void *cb_data, bool enable_VAD,
+static DeviceError open_device(DeviceType type, uint32_t *device_idx, DataHandleCallback cb, void *cb_data,
                                uint32_t sample_rate, uint32_t frame_duration, uint8_t channels)
 {
     if (channels != 1 && channels != 2) {
@@ -530,7 +529,11 @@ static DeviceError open_device(DeviceType type, uint32_t *device_idx,
         device->cb = cb;
         device->cb_data = cb_data;
 #ifdef AUDIO
-        device->VAD_threshold = enable_VAD ? user_settings->VAD_threshold : 0.0f;
+
+        if (user_settings->VAD_threshold >= 0.0) {
+            device->VAD_threshold = user_settings->VAD_threshold;
+        }
+
 #else
         device->VAD_threshold = 0.0f;
 #endif
@@ -547,21 +550,15 @@ static DeviceError open_device(DeviceType type, uint32_t *device_idx,
     return de_None;
 }
 
-DeviceError open_input_device(uint32_t *device_idx,
-                              DataHandleCallback cb, void *cb_data, bool enable_VAD,
-                              uint32_t sample_rate, uint32_t frame_duration, uint8_t channels)
+DeviceError open_input_device(uint32_t *device_idx, DataHandleCallback cb, void *cb_data, uint32_t sample_rate,
+                              uint32_t frame_duration, uint8_t channels)
 {
-    return open_device(input, device_idx,
-                       cb, cb_data, enable_VAD,
-                       sample_rate, frame_duration, channels);
+    return open_device(input, device_idx, cb, cb_data, sample_rate, frame_duration, channels);
 }
 
-DeviceError open_output_device(uint32_t *device_idx,
-                               uint32_t sample_rate, uint32_t frame_duration, uint8_t channels)
+DeviceError open_output_device(uint32_t *device_idx, uint32_t sample_rate, uint32_t frame_duration, uint8_t channels)
 {
-    return open_device(output, device_idx,
-                       0, 0, 0,
-                       sample_rate, frame_duration, channels);
+    return open_device(output, device_idx, 0, 0, sample_rate, frame_duration, channels);
 }
 
 DeviceError close_device(DeviceType type, uint32_t device_idx)

src/audio_device.h

@@ -75,11 +75,9 @@ DeviceError set_source_position(uint32_t device_idx, float x, float y, float z);
 DeviceError set_al_device(DeviceType type, int32_t selection);
 
 /* Start device */
-DeviceError open_input_device(uint32_t *device_idx,
-                              DataHandleCallback cb, void *cb_data, bool enable_VAD,
+DeviceError open_input_device(uint32_t *device_idx, DataHandleCallback cb, void *cb_data,
                               uint32_t sample_rate, uint32_t frame_duration, uint8_t channels);
-DeviceError open_output_device(uint32_t *device_idx,
-                               uint32_t sample_rate, uint32_t frame_duration, uint8_t channels);
+DeviceError open_output_device(uint32_t *device_idx, uint32_t sample_rate, uint32_t frame_duration, uint8_t channels);
 
 /* Stop device */
 DeviceError close_device(DeviceType type, uint32_t device_idx);

src/autocomplete.c

@@ -56,7 +56,7 @@ static void print_ac_matches(ToxWindow *self, Tox *m, char **list, size_t n_matc
  *
  * Returns the length of the match.
  */
-static size_t get_str_match(ToxWindow *self, char *match, size_t match_sz, const char **matches, size_t n_items,
+static size_t get_str_match(ToxWindow *self, char *match, size_t match_sz, const char *const *matches, size_t n_items,
                             size_t max_size)
 {
     UNUSED_VAR(self);
@@ -96,7 +96,7 @@ static size_t get_str_match(ToxWindow *self, char *match, size_t match_sz, const
  *
  * Note: This function should not be called directly. Use complete_line() and complete_path() instead.
  */
-static int complete_line_helper(ToxWindow *self, const char **list, const size_t n_items, bool dir_search)
+static int complete_line_helper(ToxWindow *self, const char *const *list, const size_t n_items, bool dir_search)
 {
     ChatContext *ctx = self->chatwin;
 
@@ -164,7 +164,7 @@ static int complete_line_helper(ToxWindow *self, const char **list, const size_t
 
     /* put all list matches in matches array */
     for (size_t i = 0; i < n_items; ++i) {
-        if (strncasecmp(list[i], sub, s_len) == 0) {
+        if (strncmp(list[i], sub, s_len) == 0) {
             snprintf(matches[n_matches++], MAX_STR_SIZE, "%s", list[i]);
         }
     }
@@ -181,7 +181,7 @@ static int complete_line_helper(ToxWindow *self, const char **list, const size_t
     }
 
     char match[MAX_STR_SIZE];
-    size_t match_len = get_str_match(self, match, sizeof(match), (const char **) matches, n_matches, MAX_STR_SIZE);
+    size_t match_len = get_str_match(self, match, sizeof(match), (const char *const *) matches, n_matches, MAX_STR_SIZE);
 
     free_ptr_array((void **) matches);
 
@@ -259,12 +259,12 @@ static int complete_line_helper(ToxWindow *self, const char **list, const size_t
     return diff;
 }
 
-int complete_line(ToxWindow *self, const char **list, size_t n_items)
+int complete_line(ToxWindow *self, const char *const *list, size_t n_items)
 {
     return complete_line_helper(self, list, n_items, false);
 }
 
-static int complete_path(ToxWindow *self, const char **list, const size_t n_items)
+static int complete_path(ToxWindow *self, const char *const *list, const size_t n_items)
 {
     return complete_line_helper(self, list, n_items, true);
 }
@@ -385,7 +385,7 @@ int dir_match(ToxWindow *self, Tox *m, const wchar_t *line, const wchar_t *cmd)
         print_ac_matches(self, m, dirnames, dircount);
     }
 
-    int ret = complete_path(self, (const char **) dirnames, dircount);
+    int ret = complete_path(self, (const char *const *) dirnames, dircount);
 
     free_ptr_array((void **) dirnames);
 

src/bootstrap.c

@@ -39,9 +39,7 @@
 #include "settings.h"
 #include "windows.h"
 
-extern struct arg_opts arg_opts;
 extern struct user_settings *user_settings;
-extern struct Winthread Winthread;
 
 /* URL that we get the JSON encoded nodes list from. */
 #define NODES_LIST_URL "https://nodes.tox.chat/json"
@@ -59,7 +57,6 @@ extern struct Winthread Winthread;
 
 #define IP_MAX_SIZE 45
 #define IP_MIN_SIZE 7
-#define PORT_MAX_SIZE 5
 
 #define LAST_SCAN_JSON_KEY "\"last_scan\":"
 #define LAST_SCAN_JSON_KEY_LEN (sizeof(LAST_SCAN_JSON_KEY) - 1)
@@ -381,8 +378,11 @@ static long long int extract_val_last_pinged(const char *s)
  * Return number of bytes copied to key_buf on success.
  * Return -1 on failure.
  */
-static int extract_val_pk(const char *s, char *key_buf)
+static int extract_val_pk(const char *s, char *key_buf, size_t buf_length)
 {
+    if (buf_length < TOX_PUBLIC_KEY_SIZE * 2 + 1) {
+        return -1;
+    }
 
     int key_len = char_find(0, s, '"');
 
@@ -445,13 +445,13 @@ static int extract_node(const char *line, struct Node *node)
     }
 
     char key_string[TOX_PUBLIC_KEY_SIZE * 2 + 1];
-    int key_len = extract_val_pk(key_start + PK_JSON_KEY_LEN, key_string);
+    int key_len = extract_val_pk(key_start + PK_JSON_KEY_LEN, key_string, sizeof(key_string));
 
     if (key_len == -1) {
         return -6;
     }
 
-    if (hex_string_to_bin(key_string, key_len, node->key, TOX_PUBLIC_KEY_SIZE) == -1) {
+    if (tox_pk_string_to_bytes(key_string, key_len, node->key, sizeof(node->key)) == -1) {
         return -6;
     }
 

src/chat.c

@@ -47,6 +47,10 @@
 #include "toxic_strings.h"
 #include "windows.h"
 
+#ifdef GAMES
+#include "game_base.h"
+#endif
+
 #ifdef AUDIO
 #include "audio_call.h"
 #ifdef VIDEO
@@ -54,12 +58,6 @@
 #endif /* VIDEO */
 #endif /* AUDIO */
 
-extern char *DATA_FILE;
-extern FriendsList Friends;
-
-extern struct Winthread Winthread;
-extern struct user_settings *user_settings;
-
 #ifdef AUDIO
 static void init_infobox(ToxWindow *self);
 static void kill_infobox(ToxWindow *self);
@@ -76,6 +74,10 @@ static const char *chat_cmd_list[] = {
     "/connect",
     "/exit",
     "/conference",
+#ifdef GAMES
+    "/game",
+    "/play",
+#endif
     "/help",
     "/invite",
     "/join",
@@ -246,6 +248,7 @@ static void chat_onConnectionChange(ToxWindow *self, Tox *m, uint32_t num, Tox_C
 
     if (prev_status == TOX_CONNECTION_NONE) {
         chat_resume_file_senders(self, m, num);
+        file_send_queue_check(self, m, self->num);
 
         msg = "has come online";
         line_info_add(self, true, nick, NULL, CONNECTION, 0, GREEN, msg);
@@ -756,6 +759,78 @@ static void chat_onConferenceInvite(ToxWindow *self, Tox *m, int32_t friendnumbe
     line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Type \"/join\" to join the chat.");
 }
 
+#ifdef GAMES
+void chat_onGameInvite(ToxWindow *self, Tox *m, uint32_t friend_number, const uint8_t *data, size_t length)
+{
+    if (!self || self->num != friend_number) {
+        return;
+    }
+
+    if (length < GAME_PACKET_HEADER_SIZE || length > GAME_MAX_DATA_SIZE) {
+        return;
+    }
+
+    uint8_t version = data[0];
+
+    if (version != GAME_NETWORKING_VERSION) {
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0,
+                      "Game invite failed. Friend has network protocol version %d, you have version %d.", version, GAME_NETWORKING_VERSION);
+        return;
+    }
+
+    GameType type = data[1];
+
+    if (!game_type_is_multiplayer(type)) {
+        return;
+    }
+
+    uint32_t id;
+    game_util_unpack_u32(data + 2, &id);
+
+    const char *game_string = game_get_name_string(type);
+
+    if (game_string == NULL) {
+        return;
+    }
+
+    uint32_t data_length = length - GAME_PACKET_HEADER_SIZE;
+
+    if (data_length > 0) {
+        free(Friends.list[friend_number].game_invite.data);
+
+        uint8_t *buf = calloc(1, data_length);
+
+        if (buf == NULL) {
+            return;
+        }
+
+        memcpy(buf, data + GAME_PACKET_HEADER_SIZE, data_length);
+        Friends.list[friend_number].game_invite.data = buf;
+    }
+
+    Friends.list[friend_number].game_invite.type = type;
+    Friends.list[friend_number].game_invite.id = id;
+    Friends.list[friend_number].game_invite.pending = true;
+    Friends.list[friend_number].game_invite.data_length = data_length;
+
+    char name[TOX_MAX_NAME_LENGTH];
+    get_nick_truncate(m, name, friend_number);
+
+    if (self->active_box != -1) {
+        box_notify2(self, generic_message, NT_WNDALERT_2 | user_settings->bell_on_invite, self->active_box,
+                    "invites you to play %s", game_string);
+    } else {
+        box_notify(self, generic_message, NT_WNDALERT_2 | user_settings->bell_on_invite, &self->active_box, name,
+                   "invites you to play %s", game_string);
+    }
+
+
+    line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "%s has invited you to a game of %s.", name, game_string);
+    line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Type \"/play\" to join the game.");
+}
+
+#endif // GAMES
+
 /* AV Stuff */
 #ifdef AUDIO
 
@@ -954,7 +1029,7 @@ static void init_infobox(ToxWindow *self)
 
     ctx->infobox.win = newwin(INFOBOX_HEIGHT, INFOBOX_WIDTH + 1, 1, x2 - INFOBOX_WIDTH);
     ctx->infobox.starttime = get_unix_time();
-    ctx->infobox.vad_lvl = 0.0f;
+    ctx->infobox.vad_lvl = user_settings->VAD_threshold;
     ctx->infobox.active = true;
     strcpy(ctx->infobox.timestr, "00");
 }
@@ -992,13 +1067,12 @@ static void draw_infobox(ToxWindow *self)
 
     time_t curtime = get_unix_time();
 
-    /* update elapsed time string once per second */
-    if (curtime > infobox->lastupdate) {
+    /* update interface once per second */
+    if (timed_out(infobox->lastupdate, 1)) {
         get_elapsed_time_str(infobox->timestr, sizeof(infobox->timestr), curtime - infobox->starttime);
+        infobox->lastupdate = curtime;
     }
 
-    infobox->lastupdate = curtime;
-
     const char *in_is_muted = infobox->in_is_muted ? "yes" : "no";
     const char *out_is_muted = infobox->out_is_muted ? "yes" : "no";
 
@@ -1191,9 +1265,16 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
     }
 
     ChatContext *ctx = self->chatwin;
+    StatusBar *statusbar = self->stb;
 
     pthread_mutex_lock(&Winthread.lock);
+
     line_info_print(self);
+
+    Tox_Connection connection = statusbar->connection;
+    Tox_User_Status status = statusbar->status;
+    const bool is_typing = Friends.list[self->num].is_typing;
+
     pthread_mutex_unlock(&Winthread.lock);
 
     wclear(ctx->linewin);
@@ -1204,88 +1285,99 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
 
     curs_set(1);
 
-    /* Draw status bar */
-    StatusBar *statusbar = self->stb;
     wmove(statusbar->topline, 0, 0);
 
-    /* Draw name, status and note in statusbar */
-    if (statusbar->connection != TOX_CONNECTION_NONE) {
-        int colour = MAGENTA;
-        Tox_User_Status status = statusbar->status;
+    wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
+    wprintw(statusbar->topline, " [");
+    wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
 
+    switch (connection) {
+        case TOX_CONNECTION_TCP:
+            wattron(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            wprintw(statusbar->topline, "TCP");
+            wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            break;
+
+        case TOX_CONNECTION_UDP:
+            wattron(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            wprintw(statusbar->topline, "UDP");
+            wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            break;
+
+        default:
+            wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
+            wprintw(statusbar->topline, "Offline");
+            wattroff(statusbar->topline, COLOR_PAIR(BAR_TEXT));
+            break;
+    }
+
+    wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
+    wprintw(statusbar->topline, "] ");
+    wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
+
+    const char *status_text = "ERROR";
+    int colour = BAR_TEXT;
+
+    if (connection != TOX_CONNECTION_NONE) {
         switch (status) {
-            case TOX_USER_STATUS_NONE:
-                colour = STATUS_ONLINE;
-                break;
-
             case TOX_USER_STATUS_AWAY:
                 colour = STATUS_AWAY;
+                status_text = "Away";
                 break;
 
             case TOX_USER_STATUS_BUSY:
                 colour = STATUS_BUSY;
+                status_text = "Busy";
+                break;
+
+            default:
                 break;
         }
+    }
 
+    if (colour != BAR_TEXT) {
         wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-        wprintw(statusbar->topline, " [");
+        wprintw(statusbar->topline, "[");
         wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
 
         wattron(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
-        wprintw(statusbar->topline, "%s", ONLINE_CHAR);
+        wprintw(statusbar->topline, "%s", status_text);
         wattroff(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
 
         wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
         wprintw(statusbar->topline, "] ");
         wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-
-        pthread_mutex_lock(&Winthread.lock);
-        const bool is_typing = Friends.list[self->num].is_typing;
-        pthread_mutex_unlock(&Winthread.lock);
-
-        if (is_typing) {
-            wattron(statusbar->topline, A_BOLD | COLOR_PAIR(BAR_NOTIFY));
-        } else {
-            wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
-        }
-
-        wprintw(statusbar->topline, "%s", statusbar->nick);
-
-        if (is_typing) {
-            wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(BAR_NOTIFY));
-        } else {
-            wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(BAR_TEXT));
-        }
-    } else {
-        wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-        wprintw(statusbar->topline, " [");
-        wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-
-        wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
-        wprintw(statusbar->topline, "%s", OFFLINE_CHAR);
-        wattroff(statusbar->topline, COLOR_PAIR(BAR_TEXT));
-
-        wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-        wprintw(statusbar->topline, "] ");
-        wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-
-        wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
-        wprintw(statusbar->topline, "%s", statusbar->nick);
-        wattroff(statusbar->topline, COLOR_PAIR(BAR_TEXT));
     }
 
+    if (is_typing) {
+        wattron(statusbar->topline, A_BOLD | COLOR_PAIR(BAR_NOTIFY));
+    } else {
+        wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
+    }
+
+    wprintw(statusbar->topline, "%s", statusbar->nick);
+
+    if (is_typing) {
+        wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(BAR_NOTIFY));
+    } else {
+        wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(BAR_TEXT));
+    }
+
+
     /* Reset statusbar->statusmsg on window resize */
     if (x2 != self->x) {
         char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH] = {'\0'};
 
         pthread_mutex_lock(&Winthread.lock);
+
         tox_friend_get_status_message(m, self->num, (uint8_t *) statusmsg, NULL);
         size_t s_len = tox_friend_get_status_message_size(m, self->num, NULL);
-        pthread_mutex_unlock(&Winthread.lock);
 
         filter_str(statusmsg, s_len);
         snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
         statusbar->statusmsg_len = strlen(statusbar->statusmsg);
+
+        pthread_mutex_unlock(&Winthread.lock);
     }
 
     self->x = x2;
@@ -1293,19 +1385,27 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
     /* Truncate note if it doesn't fit in statusbar */
     size_t maxlen = x2 - getcurx(statusbar->topline) - (KEY_IDENT_DIGITS * 2) - 6;
 
-    if (statusbar->statusmsg_len > maxlen) {
-        statusbar->statusmsg[maxlen - 3] = '\0';
+    pthread_mutex_lock(&Winthread.lock);
+    size_t statusmsg_len = statusbar->statusmsg_len;
+    pthread_mutex_unlock(&Winthread.lock);
+
+    if (statusmsg_len > maxlen) {
+        pthread_mutex_lock(&Winthread.lock);
+        statusbar->statusmsg[maxlen - 3] = 0;
         strcat(statusbar->statusmsg, "...");
         statusbar->statusmsg_len = maxlen;
+        pthread_mutex_unlock(&Winthread.lock);
     }
 
-    if (statusbar->statusmsg[0]) {
+    if (statusmsg_len > 0) {
         wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
         wprintw(statusbar->topline, " | ");
         wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
 
         wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
+        pthread_mutex_lock(&Winthread.lock);
         wprintw(statusbar->topline, "%s ", statusbar->statusmsg);
+        pthread_mutex_unlock(&Winthread.lock);
     } else {
         wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
     }
@@ -1361,7 +1461,11 @@ static void chat_onDraw(ToxWindow *self, Tox *m)
     }
 
     pthread_mutex_lock(&Winthread.lock);
-    refresh_file_transfer_progress(self, self->num);
+
+    if (refresh_file_transfer_progress(self, self->num)) {
+        flag_interface_refresh();
+    }
+
     pthread_mutex_unlock(&Winthread.lock);
 }
 
@@ -1404,6 +1508,7 @@ static void chat_onInit(ToxWindow *self, Tox *m)
 
     /* Init statusbar info */
     StatusBar *statusbar = self->stb;
+
     statusbar->status = get_friend_status(self->num);
     statusbar->connection = get_friend_connection_status(self->num);
 
@@ -1490,6 +1595,10 @@ ToxWindow *new_chat(Tox *m, uint32_t friendnum)
     ret->ringing_sound = -1;
 #endif /* AUDIO */
 
+#ifdef GAMES
+    ret->onGameInvite = &chat_onGameInvite;
+#endif /* GAMES */
+
     ret->active_box = -1;
 
     char nick[TOX_MAX_NAME_LENGTH];

src/chat_commands.c

@@ -54,7 +54,13 @@ void cmd_cancelfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*ar
         return;
     }
 
-    struct FileTransfer *ft = NULL;
+    // first check transfer queue
+    if (file_send_queue_remove(self->num, idx) == 0) {
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Pending file transfer removed from queue");
+        return;
+    }
+
+    FileTransfer *ft = NULL;
 
     /* cancel an incoming file transfer */
     if (strcasecmp(inoutstr, "in") == 0) {
@@ -172,6 +178,57 @@ void cmd_conference_join(WINDOW *window, ToxWindow *self, Tox *m, int argc, char
 #endif
 }
 
+#ifdef GAMES
+
+void cmd_game_join(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    UNUSED_VAR(window);
+    UNUSED_VAR(m);
+
+    if (!Friends.list[self->num].game_invite.pending) {
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "No pending game invite.");
+        return;
+    }
+
+    if (get_num_active_windows() >= MAX_WINDOWS_NUM) {
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, RED, " * Warning: Too many windows are open.");
+        return;
+    }
+
+    GameType type = Friends.list[self->num].game_invite.type;
+    uint32_t id = Friends.list[self->num].game_invite.id;
+    uint8_t *data = Friends.list[self->num].game_invite.data;
+    size_t length = Friends.list[self->num].game_invite.data_length;
+
+    int ret = game_initialize(self, m, type, id, data, length);
+
+    switch (ret) {
+        case 0: {
+            free(data);
+            Friends.list[self->num].game_invite.data = NULL;
+            Friends.list[self->num].game_invite.pending = false;
+            break;
+        }
+
+        case -1: {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Window is too small. Try enlarging your window.");
+            return;
+        }
+
+        case -2: {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Game failed to initialize (network error)");
+            return;
+        }
+
+        default: {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Game failed to initialize (error %d)", ret);
+            return;
+        }
+    }
+}
+
+#endif // GAMES
+
 void cmd_savefile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     UNUSED_VAR(window);
@@ -188,7 +245,7 @@ void cmd_savefile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
         return;
     }
 
-    struct FileTransfer *ft = get_file_transfer_struct_index(self->num, idx, FILE_TRANSFER_RECV);
+    FileTransfer *ft = get_file_transfer_struct_index(self->num, idx, FILE_TRANSFER_RECV);
 
     if (!ft) {
         line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "No pending file transfers with that ID.");
@@ -273,7 +330,7 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
     FILE *file_to_send = fopen(path, "r");
 
     if (file_to_send == NULL) {
-        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "File not found.");
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "File `%s` not found.", path);
         return;
     }
 
@@ -296,7 +353,7 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
         goto on_send_error;
     }
 
-    struct FileTransfer *ft = new_file_transfer(self, self->num, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_DATA);
+    FileTransfer *ft = new_file_transfer(self, self->num, filenum, FILE_TRANSFER_SEND, TOX_FILE_KIND_DATA);
 
     if (!ft) {
         err = TOX_ERR_FILE_SEND_TOO_MANY;
@@ -316,29 +373,62 @@ void cmd_sendfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv
 
 on_send_error:
 
+    fclose(file_to_send);
+
     switch (err) {
-        case TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND:
+        case TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND: {
             errmsg = "File transfer failed: Invalid friend.";
             break;
+        }
 
-        case TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED:
-            errmsg = "File transfer failed: Friend is offline.";
-            break;
+        case TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED: {
+            int queue_idx = file_send_queue_add(self->num, path, path_len);
 
-        case TOX_ERR_FILE_SEND_NAME_TOO_LONG:
+            char msg[MAX_STR_SIZE];
+
+            switch (queue_idx) {
+                case -1: {
+                    snprintf(msg, sizeof(msg), "Invalid file name: path is null or length is zero.");
+                    break;
+                }
+
+                case -2: {
+                    snprintf(msg, sizeof(msg), "File name is too long.");
+                    break;
+                }
+
+                case -3: {
+                    snprintf(msg, sizeof(msg), "File send queue is full.");
+                    break;
+                }
+
+                default: {
+                    snprintf(msg, sizeof(msg), "File transfer queued. Type \"/cancel out %d\" to cancel.", queue_idx);
+                    break;
+                }
+            }
+
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "%s", msg);
+
+            return;
+        }
+
+        case TOX_ERR_FILE_SEND_NAME_TOO_LONG: {
             errmsg = "File transfer failed: Filename is too long.";
             break;
+        }
 
-        case TOX_ERR_FILE_SEND_TOO_MANY:
+        case TOX_ERR_FILE_SEND_TOO_MANY: {
             errmsg = "File transfer failed: Too many concurrent file transfers.";
             break;
+        }
 
-        default:
+        default: {
             errmsg = "File transfer failed.";
             break;
+        }
     }
 
     line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "%s", errmsg);
     tox_file_control(m, self->num, filenum, TOX_FILE_CONTROL_CANCEL, NULL);
-    fclose(file_to_send);
 }

src/chat_commands.h

@@ -29,6 +29,7 @@
 void cmd_cancelfile(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_conference_invite(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_conference_join(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
+void cmd_game_join(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_savefile(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 void cmd_sendfile(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 

src/conference.c

@@ -63,8 +63,6 @@
 #include "toxic_strings.h"
 #include "windows.h"
 
-extern char *DATA_FILE;
-
 #define MAX_CONFERENCE_NUM (MAX_WINDOWS_NUM - 2)
 #define CONFERENCE_EVENT_WAIT 30
 
@@ -88,6 +86,9 @@ static const char *conference_cmd_list[] = {
     "/decline",
     "/exit",
     "/conference",
+#ifdef GAMES
+    "/game",
+#endif
     "/help",
     "/log",
 #ifdef AUDIO
@@ -507,8 +508,7 @@ static void conference_update_name_list(uint32_t conferencenum)
 
         if (peer->active) {
             memcpy(entry->name, peer->name, peer->name_length + 1);
-            bin_pubkey_to_string(peer->pubkey, sizeof(peer->pubkey),
-                                 entry->pubkey_str, sizeof(entry->pubkey_str));
+            tox_pk_bytes_to_str(peer->pubkey, sizeof(peer->pubkey), entry->pubkey_str, sizeof(entry->pubkey_str));
             entry->peernum = i;
             ++count;
         }
@@ -1309,7 +1309,7 @@ bool init_conference_audio_input(Tox *tox, uint32_t conferencenum)
     int channels = user_settings->conference_audio_channels;
 
     bool success = (open_input_device(&chat->audio_in_idx,
-                                      conference_read_device_callback, &chat->audio_input_callback_data, true,
+                                      conference_read_device_callback, &chat->audio_input_callback_data,
                                       CONFAV_SAMPLE_RATE, CONFAV_FRAME_DURATION, channels)
                     == de_None);
 
@@ -1331,7 +1331,7 @@ bool toggle_conference_push_to_talk(uint32_t conferencenum, bool enabled)
     return true;
 }
 
-bool enable_conference_audio(Tox *tox, uint32_t conferencenum)
+bool enable_conference_audio(ToxWindow *self, Tox *tox, uint32_t conferencenum)
 {
     if (!toxav_groupchat_av_enabled(tox, conferencenum)) {
         if (toxav_groupchat_enable_av(tox, conferencenum, audio_conference_callback, NULL) != 0) {
@@ -1339,10 +1339,16 @@ bool enable_conference_audio(Tox *tox, uint32_t conferencenum)
         }
     }
 
-    return init_conference_audio_input(tox, conferencenum);
+    bool success = init_conference_audio_input(tox, conferencenum);
+
+    if (success) {
+        self->is_call = true;
+    }
+
+    return success;
 }
 
-bool disable_conference_audio(Tox *tox, uint32_t conferencenum)
+bool disable_conference_audio(ToxWindow *self, Tox *tox, uint32_t conferencenum)
 {
     ConferenceChat *chat = &conferences[conferencenum];
 
@@ -1355,7 +1361,13 @@ bool disable_conference_audio(Tox *tox, uint32_t conferencenum)
         chat->audio_enabled = false;
     }
 
-    return toxav_groupchat_disable_av(tox, conferencenum) == 0;
+    bool success = toxav_groupchat_disable_av(tox, conferencenum) == 0;
+
+    if (success) {
+        self->is_call = false;
+    }
+
+    return success;
 }
 
 bool conference_mute_self(uint32_t conferencenum)

src/conference.h

@@ -103,8 +103,8 @@ uint32_t get_name_list_entries_by_prefix(uint32_t conferencenum, const char *pre
         uint32_t maxpeers);
 
 bool init_conference_audio_input(Tox *tox, uint32_t conferencenum);
-bool enable_conference_audio(Tox *tox, uint32_t conferencenum);
-bool disable_conference_audio(Tox *tox, uint32_t conferencenum);
+bool enable_conference_audio(ToxWindow *self, Tox *tox, uint32_t conferencenum);
+bool disable_conference_audio(ToxWindow *self, Tox *tox, uint32_t conferencenum);
 bool toggle_conference_push_to_talk(uint32_t conferencenum, bool enabled);
 void audio_conference_callback(void *tox, uint32_t conferencenum, uint32_t peernum,
                                const int16_t *pcm, unsigned int samples, uint8_t channels, uint32_t

src/conference_commands.c

@@ -108,7 +108,7 @@ void cmd_enable_audio(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*
         return;
     }
 
-    if (enable ? enable_conference_audio(m, self->num) : disable_conference_audio(m, self->num)) {
+    if (enable ? enable_conference_audio(self, m, self->num) : disable_conference_audio(self, m, self->num)) {
         print_err(self, enable ? "Enabled conference audio. Use the '/ptt' command to toggle Push-To-Talk."
                   : "Disabled conference audio");
     } else {

src/execute.c

@@ -49,6 +49,9 @@ static struct cmd_func global_commands[] = {
     { "/decline",   cmd_decline       },
     { "/exit",      cmd_quit          },
     { "/conference", cmd_conference    },
+#ifdef GAMES
+    { "/game",      cmd_game          },
+#endif
     { "/help",      cmd_prompt_help   },
     { "/log",       cmd_log           },
     { "/myid",      cmd_myid          },
@@ -80,6 +83,9 @@ static struct cmd_func chat_commands[] = {
     { "/cancel",    cmd_cancelfile        },
     { "/invite",    cmd_conference_invite },
     { "/join",      cmd_conference_join   },
+#ifdef GAMES
+    { "/play",      cmd_game_join         },
+#endif
     { "/savefile",  cmd_savefile          },
     { "/sendfile",  cmd_sendfile          },
 #ifdef AUDIO
@@ -111,15 +117,9 @@ static struct cmd_func conference_commands[] = {
     { NULL,         NULL             },
 };
 
-
-#ifdef PYTHON
-#define SPECIAL_COMMANDS 7
-#else
-#define SPECIAL_COMMANDS 6
-#endif /* PYTHON */
-
 /* Special commands are commands that only take one argument even if it contains spaces */
-static const char special_commands[SPECIAL_COMMANDS][MAX_CMDNAME_SIZE] = {
+static const char special_commands[][MAX_CMDNAME_SIZE] = {
+    "/add",
     "/avatar",
     "/nick",
     "/note",
@@ -129,6 +129,7 @@ static const char special_commands[SPECIAL_COMMANDS][MAX_CMDNAME_SIZE] = {
     "/sendfile",
     "/title",
     "/mute",
+    "",
 };
 
 /* Returns true if input command is in the special_commands array. */
@@ -136,7 +137,7 @@ static bool is_special_command(const char *input)
 {
     const int s = char_find(0, input, ' ');
 
-    for (int i = 0; i < SPECIAL_COMMANDS; ++i) {
+    for (int i = 0; special_commands[i][0] != '\0'; ++i) {
         if (strncmp(input, special_commands[i], s) == 0) {
             return true;
         }
@@ -213,9 +214,7 @@ static int parse_command(const char *input, char (*args)[MAX_STR_SIZE])
 static int do_command(WINDOW *w, ToxWindow *self, Tox *m, int num_args, struct cmd_func *commands,
                       char (*args)[MAX_STR_SIZE])
 {
-    int i;
-
-    for (i = 0; commands[i].name != NULL; ++i) {
+    for (size_t i = 0; commands[i].name != NULL; ++i) {
         if (strcmp(args[0], commands[i].name) == 0) {
             (commands[i].func)(w, self, m, num_args - 1, args);
             return 0;

src/file_transfers.c

@@ -25,6 +25,7 @@
 #include <time.h>
 #include <unistd.h>
 
+#include "execute.h"
 #include "file_transfers.h"
 #include "friendlist.h"
 #include "line_info.h"
@@ -98,7 +99,7 @@ void print_progress_bar(ToxWindow *self, double bps, double pct_done, uint32_t l
     free(full_line);
 }
 
-static void refresh_progress_helper(ToxWindow *self, struct FileTransfer *ft)
+static void refresh_progress_helper(ToxWindow *self, FileTransfer *ft)
 {
     if (ft->state == FILE_TRANSFER_INACTIVE) {
         return;
@@ -117,18 +118,32 @@ static void refresh_progress_helper(ToxWindow *self, struct FileTransfer *ft)
     ft->last_line_progress = get_unix_time();
 }
 
-/* refreshes active file transfer status bars. */
-void refresh_file_transfer_progress(ToxWindow *self, uint32_t friendnumber)
+/* refreshes active file transfer status bars.
+ *
+ * Return true if there is at least one active file transfer in either direction.
+ */
+bool refresh_file_transfer_progress(ToxWindow *self, uint32_t friendnumber)
 {
+    bool active = false;
+
     for (size_t i = 0; i < MAX_FILES; ++i) {
-        refresh_progress_helper(self, &Friends.list[friendnumber].file_receiver[i]);
-        refresh_progress_helper(self, &Friends.list[friendnumber].file_sender[i]);
+        FileTransfer *ft_r = &Friends.list[friendnumber].file_receiver[i];
+        FileTransfer *ft_s = &Friends.list[friendnumber].file_sender[i];
+
+        refresh_progress_helper(self, ft_r);
+        refresh_progress_helper(self, ft_s);
+
+        if (ft_r->state !=  FILE_TRANSFER_INACTIVE || ft_s->state != FILE_TRANSFER_INACTIVE) {
+            active = true;
+        }
     }
+
+    return active;
 }
 
-static void clear_file_transfer(struct FileTransfer *ft)
+static void clear_file_transfer(FileTransfer *ft)
 {
-    *ft = (struct FileTransfer) {
+    *ft = (FileTransfer) {
         0
     };
 }
@@ -136,16 +151,16 @@ static void clear_file_transfer(struct FileTransfer *ft)
 /* Returns a pointer to friendnumber's FileTransfer struct associated with filenumber.
  * Returns NULL if filenumber is invalid.
  */
-struct FileTransfer *get_file_transfer_struct(uint32_t friendnumber, uint32_t filenumber)
+FileTransfer *get_file_transfer_struct(uint32_t friendnumber, uint32_t filenumber)
 {
     for (size_t i = 0; i < MAX_FILES; ++i) {
-        struct FileTransfer *ft_send = &Friends.list[friendnumber].file_sender[i];
+        FileTransfer *ft_send = &Friends.list[friendnumber].file_sender[i];
 
         if (ft_send->state != FILE_TRANSFER_INACTIVE && ft_send->filenumber == filenumber) {
             return ft_send;
         }
 
-        struct FileTransfer *ft_recv = &Friends.list[friendnumber].file_receiver[i];
+        FileTransfer *ft_recv = &Friends.list[friendnumber].file_receiver[i];
 
         if (ft_recv->state != FILE_TRANSFER_INACTIVE && ft_recv->filenumber == filenumber) {
             return ft_recv;
@@ -158,7 +173,7 @@ struct FileTransfer *get_file_transfer_struct(uint32_t friendnumber, uint32_t fi
 /* Returns a pointer to the FileTransfer struct associated with index with the direction specified.
  * Returns NULL on failure.
  */
-struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnumber, uint32_t index,
+FileTransfer *get_file_transfer_struct_index(uint32_t friendnumber, uint32_t index,
         FILE_TRANSFER_DIRECTION direction)
 {
     if (direction != FILE_TRANSFER_RECV && direction != FILE_TRANSFER_SEND) {
@@ -166,9 +181,9 @@ struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnumber, uint3
     }
 
     for (size_t i = 0; i < MAX_FILES; ++i) {
-        struct FileTransfer *ft = direction == FILE_TRANSFER_SEND ?
-                                      &Friends.list[friendnumber].file_sender[i] :
-                                      &Friends.list[friendnumber].file_receiver[i];
+        FileTransfer *ft = direction == FILE_TRANSFER_SEND ?
+                           &Friends.list[friendnumber].file_sender[i] :
+                           &Friends.list[friendnumber].file_receiver[i];
 
         if (ft->state != FILE_TRANSFER_INACTIVE && ft->index == index) {
             return ft;
@@ -181,10 +196,10 @@ struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnumber, uint3
 /* Returns a pointer to an unused file sender.
  * Returns NULL if all file senders are in use.
  */
-static struct FileTransfer *new_file_sender(ToxWindow *window, uint32_t friendnumber, uint32_t filenumber, uint8_t type)
+static FileTransfer *new_file_sender(ToxWindow *window, uint32_t friendnumber, uint32_t filenumber, uint8_t type)
 {
     for (size_t i = 0; i < MAX_FILES; ++i) {
-        struct FileTransfer *ft = &Friends.list[friendnumber].file_sender[i];
+        FileTransfer *ft = &Friends.list[friendnumber].file_sender[i];
 
         if (ft->state == FILE_TRANSFER_INACTIVE) {
             clear_file_transfer(ft);
@@ -204,11 +219,11 @@ static struct FileTransfer *new_file_sender(ToxWindow *window, uint32_t friendnu
 /* Returns a pointer to an unused file receiver.
  * Returns NULL if all file receivers are in use.
  */
-static struct FileTransfer *new_file_receiver(ToxWindow *window, uint32_t friendnumber, uint32_t filenumber,
-        uint8_t type)
+static FileTransfer *new_file_receiver(ToxWindow *window, uint32_t friendnumber, uint32_t filenumber,
+                                       uint8_t type)
 {
     for (size_t i = 0; i < MAX_FILES; ++i) {
-        struct FileTransfer *ft = &Friends.list[friendnumber].file_receiver[i];
+        FileTransfer *ft = &Friends.list[friendnumber].file_receiver[i];
 
         if (ft->state == FILE_TRANSFER_INACTIVE) {
             clear_file_transfer(ft);
@@ -228,8 +243,8 @@ static struct FileTransfer *new_file_receiver(ToxWindow *window, uint32_t friend
 /* Initializes an unused file transfer and returns its pointer.
  * Returns NULL on failure.
  */
-struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnumber, uint32_t filenumber,
-                                       FILE_TRANSFER_DIRECTION direction, uint8_t type)
+FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnumber, uint32_t filenumber,
+                                FILE_TRANSFER_DIRECTION direction, uint8_t type)
 {
     if (direction == FILE_TRANSFER_RECV) {
         return new_file_receiver(window, friendnumber, filenumber, type);
@@ -242,13 +257,83 @@ struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnumber,
     return NULL;
 }
 
+int file_send_queue_add(uint32_t friendnumber, const char *file_path, size_t length)
+{
+    if (length == 0 || file_path == NULL) {
+        return -1;
+    }
+
+    if (length > TOX_MAX_FILENAME_LENGTH) {
+        return -2;
+    }
+
+    for (size_t i = 0; i < MAX_FILES; ++i) {
+        PendingFileTransfer *pending_slot = &Friends.list[friendnumber].file_send_queue[i];
+
+        if (pending_slot->pending) {
+            continue;
+        }
+
+        pending_slot->pending = true;
+
+        memcpy(pending_slot->file_path, file_path, length);
+        pending_slot->file_path[length] = 0;
+        pending_slot->length = length;
+
+        return i;
+    }
+
+    return -3;
+}
+
+#define FILE_TRANSFER_SEND_CMD "/sendfile "
+#define FILE_TRANSFER_SEND_LEN (sizeof(FILE_TRANSFER_SEND_CMD) - 1)
+
+void file_send_queue_check(ToxWindow *self, Tox *m, uint32_t friendnumber)
+{
+    for (size_t i = 0; i < MAX_FILES; ++i) {
+        PendingFileTransfer *pending_slot = &Friends.list[friendnumber].file_send_queue[i];
+
+        if (!pending_slot->pending) {
+            continue;
+        }
+
+        char command[TOX_MAX_FILENAME_LENGTH + FILE_TRANSFER_SEND_LEN + 1];
+        snprintf(command, sizeof(command), "%s%s", FILE_TRANSFER_SEND_CMD, pending_slot->file_path);
+
+        execute(self->window, self, m, command, CHAT_COMMAND_MODE);
+
+        *pending_slot = (PendingFileTransfer) {
+            0,
+        };
+    }
+}
+
+int file_send_queue_remove(uint32_t friendnumber, size_t index)
+{
+    if (index >= MAX_FILES) {
+        return -1;
+    }
+
+    PendingFileTransfer *pending_slot = &Friends.list[friendnumber].file_send_queue[index];
+
+    if (!pending_slot->pending) {
+        return -1;
+    }
+
+    *pending_slot = (PendingFileTransfer) {
+        0,
+    };
+
+    return 0;
+}
 
 /* Closes file transfer ft.
  *
  * Set CTRL to -1 if we don't want to send a control signal.
  * Set message or self to NULL if we don't want to display a message.
  */
-void close_file_transfer(ToxWindow *self, Tox *m, struct FileTransfer *ft, int CTRL, const char *message,
+void close_file_transfer(ToxWindow *self, Tox *m, FileTransfer *ft, int CTRL, const char *message,
                          Notification sound_type)
 {
     if (!ft) {
@@ -264,7 +349,11 @@ void close_file_transfer(ToxWindow *self, Tox *m, struct FileTransfer *ft, int C
     }
 
     if (CTRL >= 0) {
-        tox_file_control(m, ft->friendnumber, ft->filenumber, (Tox_File_Control) CTRL, NULL);
+        Tox_Err_File_Control err;
+
+        if (!tox_file_control(m, ft->friendnumber, ft->filenumber, (Tox_File_Control) CTRL, &err)) {
+            fprintf(stderr, "Failed to cancel file transfer: %d\n", err);
+        }
     }
 
     if (message && self) {
@@ -284,7 +373,7 @@ void close_file_transfer(ToxWindow *self, Tox *m, struct FileTransfer *ft, int C
 void kill_avatar_file_transfers_friend(Tox *m, uint32_t friendnumber)
 {
     for (size_t i = 0; i < MAX_FILES; ++i) {
-        struct FileTransfer *ft = &Friends.list[friendnumber].file_sender[i];
+        FileTransfer *ft = &Friends.list[friendnumber].file_sender[i];
 
         if (ft->file_type == TOX_FILE_KIND_AVATAR) {
             close_file_transfer(NULL, m, ft, TOX_FILE_CONTROL_CANCEL, NULL, silent);
@@ -298,6 +387,7 @@ void kill_all_file_transfers_friend(Tox *m, uint32_t friendnumber)
     for (size_t i = 0; i < MAX_FILES; ++i) {
         close_file_transfer(NULL, m, &Friends.list[friendnumber].file_sender[i], TOX_FILE_CONTROL_CANCEL, NULL, silent);
         close_file_transfer(NULL, m, &Friends.list[friendnumber].file_receiver[i], TOX_FILE_CONTROL_CANCEL, NULL, silent);
+        file_send_queue_remove(friendnumber, i);
     }
 }
 

src/file_transfers.h

@@ -29,9 +29,9 @@
 #include "toxic.h"
 #include "windows.h"
 
-#define KiB 1024
-#define MiB 1048576       /* 1024^2 */
-#define GiB 1073741824    /* 1024^3 */
+#define KiB (uint32_t)  1024
+#define MiB (uint32_t) (1024 << 10)  /* 1024^2 */
+#define GiB (uint32_t) (1024 << 20)  /* 1024^3 */
 
 #define MAX_FILES 32
 
@@ -47,7 +47,7 @@ typedef enum FILE_TRANSFER_DIRECTION {
     FILE_TRANSFER_RECV
 } FILE_TRANSFER_DIRECTION;
 
-struct FileTransfer {
+typedef struct FileTransfer {
     ToxWindow *window;
     FILE *file;
     FILE_TRANSFER_STATE state;
@@ -63,7 +63,15 @@ struct FileTransfer {
     time_t   last_line_progress;   /* The last time we updated the progress bar */
     uint32_t line_id;
     uint8_t  file_id[TOX_FILE_ID_LENGTH];
-};
+} FileTransfer;
+
+typedef struct PendingFileTransfer {
+    char      file_path[TOX_MAX_FILENAME_LENGTH + 1];
+    size_t    length;
+    uint32_t  friendnumber;
+    bool      pending;
+} PendingFileTransfer;
+
 
 /* creates initial progress line that will be updated during file transfer.
    progline must be at lesat MAX_STR_SIZE bytes */
@@ -72,8 +80,11 @@ void init_progress_bar(char *progline);
 /* prints a progress bar for file transfers */
 void print_progress_bar(ToxWindow *self, double pct_done, double bps, uint32_t line_id);
 
-/* refreshes active file transfer status bars. */
-void refresh_file_transfer_progress(ToxWindow *self, uint32_t friendnumber);
+/* refreshes active file transfer status bars.
+ *
+ * Return true if there is at least one active file transfer in either direction.
+ */
+bool refresh_file_transfer_progress(ToxWindow *self, uint32_t friendnumber);
 
 /* Returns a pointer to friendnumber's FileTransfer struct associated with filenumber.
  * Returns NULL if filenumber is invalid.
@@ -93,6 +104,31 @@ struct FileTransfer *get_file_transfer_struct_index(uint32_t friendnumber, uint3
 struct FileTransfer *new_file_transfer(ToxWindow *window, uint32_t friendnumber, uint32_t filenumber,
                                        FILE_TRANSFER_DIRECTION direction, uint8_t type);
 
+/* Adds a file designated by `file_path` of length `length` to the file transfer queue.
+ *
+ * Items in this queue will be automatically sent to the contact designated by `friendnumber`
+ * as soon as they appear online. The item will then be removed from the queue whether
+ * or not the transfer successfully initiates.
+ *
+ * If the ToxWindow associated with this friend is closed, all queued items will be
+ * discarded.
+ *
+ * Return the queue index on success.
+ * Return -1 if the length is invalid.
+ * Return -2 if the send queue is full.
+ */
+int file_send_queue_add(uint32_t friendnumber, const char *file_path, size_t length);
+
+/* Initiates all file transfers from the file send queue for friend designated by `friendnumber`. */
+void file_send_queue_check(ToxWindow *self, Tox *m, uint32_t friendnumber);
+
+/* Removes the `index`-th item from the file send queue for `friendnumber`.
+ *
+ * Return 0 if a pending transfer was successfully removed
+ * Return -1 if index does not designate a pending file transfer.
+ */
+int file_send_queue_remove(uint32_t friendnumber, size_t index);
+
 /* Closes file transfer ft.
  *
  * Set CTRL to -1 if we don't want to send a control signal.

src/friendlist.c

@@ -37,6 +37,7 @@
 #include "log.h"
 #include "misc_tools.h"
 #include "notify.h"
+#include "prompt.h"
 #include "settings.h"
 #include "toxic.h"
 #include "windows.h"
@@ -46,13 +47,6 @@
 #endif
 
 
-extern char *DATA_FILE;
-extern char *BLOCK_FILE;
-extern ToxWindow *prompt;
-extern struct Winthread Winthread;
-extern struct user_settings *user_settings;
-extern struct arg_opts arg_opts;
-
 static uint8_t blocklist_view = 0;   /* 0 if we're in friendlist view, 1 if we're in blocklist view */
 
 FriendsList Friends;
@@ -116,8 +110,11 @@ static void realloc_blocklist(int n)
 void kill_friendlist(ToxWindow *self)
 {
     for (size_t i = 0; i < Friends.max_idx; ++i) {
-        if (Friends.list[i].active && Friends.list[i].conference_invite.key != NULL) {
+        if (Friends.list[i].active) {
             free(Friends.list[i].conference_invite.key);
+#ifdef GAMES
+            free(Friends.list[i].game_invite.data);
+#endif
         }
     }
 
@@ -318,11 +315,11 @@ int load_blocklist(char *path)
 #define S_WEIGHT 100000
 static int index_name_cmp(const void *n1, const void *n2)
 {
-    int res = qsort_strcasecmp_hlpr(Friends.list[*(int *) n1].name, Friends.list[*(int *) n2].name);
+    int res = qsort_strcasecmp_hlpr(Friends.list[*(const int *) n1].name, Friends.list[*(const int *) n2].name);
 
     /* Use weight to make qsort always put online friends before offline */
-    res = Friends.list[*(int *) n1].connection_status ? (res - S_WEIGHT) : (res + S_WEIGHT);
-    res = Friends.list[*(int *) n2].connection_status ? (res + S_WEIGHT) : (res - S_WEIGHT);
+    res = Friends.list[*(const int *) n1].connection_status ? (res - S_WEIGHT) : (res + S_WEIGHT);
+    res = Friends.list[*(const int *) n2].connection_status ? (res + S_WEIGHT) : (res - S_WEIGHT);
 
     return res;
 }
@@ -346,7 +343,7 @@ void sort_friendlist_index(void)
 
 static int index_name_cmp_block(const void *n1, const void *n2)
 {
-    return qsort_strcasecmp_hlpr(Blocked.list[*(int *) n1].name, Blocked.list[*(int *) n2].name);
+    return qsort_strcasecmp_hlpr(Blocked.list[*(const int *) n1].name, Blocked.list[*(const int *) n2].name);
 }
 
 static void sort_blocklist_index(void)
@@ -582,6 +579,38 @@ static void friendlist_add_blocked(uint32_t fnum, uint32_t bnum)
     }
 }
 
+#ifdef GAMES
+
+static void friendlist_onGameInvite(ToxWindow *self, Tox *m, uint32_t friend_number, const uint8_t *data, size_t length)
+{
+    UNUSED_VAR(self);
+    UNUSED_VAR(data);
+    UNUSED_VAR(length);
+
+    if (friend_number >= Friends.max_idx) {
+        return;
+    }
+
+    if (Friends.list[friend_number].chatwin != -1) {
+        return;
+    }
+
+    if (get_num_active_windows() < MAX_WINDOWS_NUM) {
+        Friends.list[friend_number].chatwin = add_window(m, new_chat(m, Friends.list[friend_number].num));
+        return;
+    }
+
+    char nick[TOX_MAX_NAME_LENGTH];
+    get_nick_truncate(m, nick, friend_number);
+
+    line_info_add(prompt, false, NULL, NULL, SYS_MSG, 0, RED,
+                  "* Game invite from %s failed: Too many windows are open.", nick);
+
+    sound_notify(prompt, notif_error, NT_WNDALERT_1, NULL);
+}
+
+#endif // GAMES
+
 static void friendlist_onFileRecv(ToxWindow *self, Tox *m, uint32_t num, uint32_t filenum,
                                   uint64_t file_size, const char *filename, size_t name_length)
 {
@@ -663,6 +692,9 @@ static void select_friend(wint_t key, int *selected, int num)
 
 static void delete_friend(Tox *m, uint32_t f_num)
 {
+    kill_all_file_transfers_friend(m, f_num);
+    kill_avatar_file_transfers_friend(m, f_num);
+
     Tox_Err_Friend_Delete err;
 
     if (tox_friend_delete(m, f_num, &err) != true) {
@@ -811,9 +843,7 @@ void block_friend(Tox *m, uint32_t fnum)
     realloc_blocklist(Blocked.max_idx + 1);
     clear_blocklist_index(Blocked.max_idx);
 
-    int i;
-
-    for (i = 0; i <= Blocked.max_idx; ++i) {
+    for (int i = 0; i <= Blocked.max_idx; ++i) {
         if (Blocked.list[i].active) {
             continue;
         }
@@ -1078,14 +1108,14 @@ static void friendlist_onDraw(ToxWindow *self, Tox *m)
 
     /* Determine which portion of friendlist to draw based on current position */
     pthread_mutex_lock(&Winthread.lock);
-    int page = Friends.num_selected / (y2 - FLIST_OFST);
+    const int page = Friends.num_selected / (y2 - FLIST_OFST);
     pthread_mutex_unlock(&Winthread.lock);
 
-    int start = (y2 - FLIST_OFST) * page;
-    int end = y2 - FLIST_OFST + start;
+    const int start = (y2 - FLIST_OFST) * page;
+    const int end = y2 - FLIST_OFST + start;
 
     pthread_mutex_lock(&Winthread.lock);
-    size_t num_friends = Friends.num_friends;
+    const size_t num_friends = Friends.num_friends;
     pthread_mutex_unlock(&Winthread.lock);
 
     int i;
@@ -1383,6 +1413,10 @@ ToxWindow *new_friendlist(void)
     ret->is_call = false;
 #endif /* AUDIO */
 
+#ifdef GAMES
+    ret->onGameInvite = &friendlist_onGameInvite;
+#endif
+
     ret->num = -1;
     ret->active_box = -1;
 

src/friendlist.h

@@ -29,6 +29,10 @@
 #include "toxic.h"
 #include "windows.h"
 
+#ifdef GAMES
+#include "game_base.h"
+#endif
+
 struct LastOnline {
     uint64_t last_on;
     struct tm tm;
@@ -42,6 +46,18 @@ struct ConferenceInvite {
     bool pending;
 };
 
+#ifdef GAMES
+
+struct GameInvite {
+    uint8_t *data;
+    size_t data_length;
+    GameType type;
+    uint32_t id;
+    bool pending;
+};
+
+#endif // GAMES
+
 typedef struct {
     char name[TOXIC_MAX_NAME_LENGTH + 1];
     uint16_t namelength;
@@ -59,8 +75,13 @@ typedef struct {
     struct LastOnline last_online;
     struct ConferenceInvite conference_invite;
 
-    struct FileTransfer file_receiver[MAX_FILES];
-    struct FileTransfer file_sender[MAX_FILES];
+#ifdef GAMES
+    struct GameInvite game_invite;
+#endif
+
+    FileTransfer file_receiver[MAX_FILES];
+    FileTransfer file_sender[MAX_FILES];
+    PendingFileTransfer file_send_queue[MAX_FILES];
 } ToxicFriend;
 
 typedef struct {
@@ -81,6 +102,8 @@ typedef struct {
     ToxicFriend *list;
 } FriendsList;
 
+extern FriendsList Friends;
+
 ToxWindow *new_friendlist(void);
 void friendlist_onInit(ToxWindow *self, Tox *m);
 void disable_chatwin(uint32_t f_num);

src/game_base.h

@@ -0,0 +1,400 @@
+/*  game_base.h
+ *
+ *
+ *  Copyright (C) 2020 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GAME_BASE
+#define GAME_BASE
+
+#include <ncurses.h>
+#include <time.h>
+
+#include <tox/tox.h>
+
+#include "game_util.h"
+#include "windows.h"
+
+#define GAME_BORDER_COLOUR BAR_SOLID
+
+
+/* Max size of a default square game window */
+#define GAME_MAX_SQUARE_Y_DEFAULT 26
+#define GAME_MAX_SQUARE_X_DEFAULT (GAME_MAX_SQUARE_Y_DEFAULT * 2)
+
+/* Max size of a large square game window */
+#define GAME_MAX_SQUARE_Y_LARGE 52
+#define GAME_MAX_SQUARE_X_LARGE (GAME_MAX_SQUARE_Y_LARGE * 2)
+
+/* Max size of a default size rectangle game window */
+#define GAME_MAX_RECT_Y_DEFAULT 24
+#define GAME_MAX_RECT_X_DEFAULT (GAME_MAX_RECT_Y_DEFAULT * 4)
+
+/* Max size of a large rectangle game window */
+#define GAME_MAX_RECT_Y_LARGE 52
+#define GAME_MAX_RECT_X_LARGE (GAME_MAX_RECT_Y_LARGE * 4)
+
+/* Maximum length of a game message set with game_set_message() */
+#define GAME_MAX_MESSAGE_SIZE 64
+
+/* Default number of seconds a game message is displayed for */
+#define GAME_MESSAGE_DEFAULT_TIMEOUT 3
+
+
+/***** START NETWORKING CONSTANTS *****/
+
+/* Header starts after custom packet type byte. Comprised of: NetworkVersion (1b) + GameType (1b) + id (4b) */
+#define GAME_PACKET_HEADER_SIZE (1 + 1 + sizeof(uint32_t))
+
+/* Max size of a game packet including the header */
+#define GAME_MAX_PACKET_SIZE 1024
+
+/* Max size of a game packet payload */
+#define GAME_MAX_DATA_SIZE (GAME_MAX_PACKET_SIZE - GAME_PACKET_HEADER_SIZE - 1)
+
+/* Current version of networking protocol */
+#define GAME_NETWORKING_VERSION 0x01
+
+/***** END NETWORKING CONSTANTS *****/
+
+
+typedef void cb_game_update_state(GameData *game, void *cb_data);
+typedef void cb_game_render_window(GameData *game, WINDOW *window, void *cb_data);
+typedef void cb_game_kill(GameData *game, void *cb_data);
+typedef void cb_game_pause(GameData *game, bool is_paused, void *cb_data);
+typedef void cb_game_key_press(GameData *game, int key, void *cb_data);
+typedef void cb_game_on_packet(GameData *game, const uint8_t *data, size_t length, void *cb_data);
+
+typedef enum GamePacketType {
+    GP_Invite = 0u,
+    GP_Data,
+} GamePacketType;
+
+typedef enum GameWindowShape {
+    GW_ShapeSquare = 0u,
+    GW_ShapeSquareLarge,
+    GW_ShapeRectangle,
+    GW_ShapeRectangleLarge,
+    GW_ShapeInvalid,
+} GameWindowShape;
+
+typedef enum GameStatus {
+    GS_None = 0u,
+    GS_Paused,
+    GS_Running,
+    GS_Finished,
+    GS_Invalid,
+} GameStatus;
+
+typedef enum GameType {
+    GT_Centipede = 0u,
+    GT_Chess,
+    GT_Life,
+    GT_Snake,
+    GT_Invalid,
+} GameType;
+
+typedef struct GameMessage {
+    char         message[GAME_MAX_MESSAGE_SIZE + 1];
+    size_t       length;
+    const Coords *coords;          // pointer to coords so we can track movement
+    Coords       original_coords;  // static coords at time of being set
+    time_t       timeout;
+    time_t       set_time;
+    int          attributes;
+    int          colour;
+    Direction    direction;
+    bool         sticky;
+    bool         priority;
+} GameMessage;
+
+struct GameData {
+    TIME_MS    last_frame_time;
+    TIME_MS    update_interval;  // determines the refresh rate (lower means faster)
+    long int   score;
+    size_t     high_score;
+    int        lives;
+    size_t     level;
+    GameStatus status;
+    GameType   type;
+    bool       is_multiplayer;
+
+    bool       show_lives;
+    bool       show_score;
+    bool       show_high_score;
+    bool       show_level;
+
+    GameMessage *messages;
+    size_t      messages_size;
+
+    int        game_max_x; // max dimensions of game window
+    int        game_max_y;
+
+    int        parent_max_x; // max dimensions of parent window
+    int        parent_max_y;
+
+    int        window_id;
+    WINDOW     *window;
+
+    Tox        *tox;  // must be locked with Winthread mutex
+
+    GameWindowShape    window_shape;
+
+    uint32_t id;  // indentifies multiplayer instance
+    uint32_t friend_number; // friendnumber associated with parent window
+
+    cb_game_update_state *cb_game_update_state;
+    void *cb_game_update_state_data;
+
+    cb_game_render_window *cb_game_render_window;
+    void *cb_game_render_window_data;
+
+    cb_game_kill *cb_game_kill;
+    void *cb_game_kill_data;
+
+    cb_game_pause *cb_game_pause;
+    void *cb_game_pause_data;
+
+    cb_game_key_press *cb_game_key_press;
+    void *cb_game_key_press_data;
+
+    cb_game_on_packet *cb_game_on_packet;
+    void *cb_game_on_packet_data;
+};
+
+/*
+ * Sets the callback for game state updates.
+ */
+void game_set_cb_update_state(GameData *game, cb_game_update_state *func, void *cb_data);
+
+/*
+ * Sets the callback for frame rendering.
+ */
+void game_set_cb_render_window(GameData *game, cb_game_render_window *func, void *cb_data);
+
+/*
+ * Sets the callback for game termination.
+ */
+void game_set_cb_kill(GameData *game, cb_game_kill *func, void *cb_data);
+
+/*
+ * Sets the callback for the game pause event.
+ */
+void game_set_cb_on_pause(GameData *game, cb_game_pause *func, void *cb_data);
+
+/*
+ * Sets the callback for the key press event.
+ */
+void game_set_cb_on_keypress(GameData *game, cb_game_key_press *func, void *cb_data);
+
+/*
+ * Sets the callback for the game packet event.
+ */
+void game_set_cb_on_packet(GameData *game, cb_game_on_packet *func, void *cb_data);
+
+/*
+ * Initializes game instance.
+ *
+ * `type` must be a valid GameType.
+ *
+ * `id` should be a unique integer to indentify the game instance. If we're being invited to a game
+ *   this identifier should be sent via the invite packet.
+ *
+ * if `multiplayer_data` is non-null this indicates that we accepted a game invite from a contact.
+ *   The data contains any information we need to initialize the game state.
+ *
+ * Return 0 on success.
+ * Return -1 if screen is too small.
+ * Return -2 on network related error.
+ * Return -3 if multiplayer game is being initialized outside of a contact's window.
+ * Return -4 on other failure.
+ */
+int game_initialize(const ToxWindow *self, Tox *m, GameType type, uint32_t id, const uint8_t *multiplayer_data,
+                    size_t length);
+
+/*
+ * Sets game window to `shape`.
+ *
+ * This must be called on game initialization.
+ *
+ * Return 0 on success.
+ * Return -1 if window is too small or shape is invalid.
+ * Return -2 if function is called while the game state is valid.
+ */
+int game_set_window_shape(GameData *game, GameWindowShape shape);
+
+/*
+ * Returns the GameType associated with `game_string`.
+ */
+GameType game_get_type(const char *game_string);
+
+/*
+ * Returns the name represented as a string associated with `type`.
+ */
+const char *game_get_name_string(GameType type);
+
+/*
+ * Prints all available games to window associated with `self`.
+ */
+void game_list_print(ToxWindow *self);
+
+/*
+ * Return true if game `type` has a multiplayer mode.
+ */
+bool game_type_is_multiplayer(GameType type);
+
+/*
+ * Returns true if coordinates designated by `x` and `y` are within the game window boundaries.
+ */
+bool game_coordinates_in_bounds(const GameData *game, int x, int y);
+
+/*
+ * Put random coordinates that fit within the game window in `coords`.
+ */
+void game_random_coords(const GameData *game, Coords *coords);
+
+/*
+ * Gets the current max dimensions of the game window.
+ */
+void game_max_x_y(const GameData *game, int *x, int *y);
+
+/*
+ * Returns the respective coordinate boundary of the game window.
+ */
+int game_y_bottom_bound(const GameData *game);
+int game_y_top_bound(const GameData *game);
+int game_x_right_bound(const GameData *game);
+int game_x_left_bound(const GameData *game);
+
+/*
+ * Toggle whether the respective game info is shown around the game window.
+ */
+void game_show_score(GameData *game, bool show_score);
+void game_show_high_score(GameData *game, bool show_high_score);
+void game_show_lives(GameData *game, bool show_lives);
+void game_show_level(GameData *game, bool show_level);
+
+/*
+ * Sends a notification to the window associated with `game`.
+ *
+ * `message` - the notification message that will be displayed.
+ */
+void game_window_notify(const GameData *game, const char *message);
+
+/*
+ * Updates game score.
+ */
+void game_update_score(GameData *game, long int points);
+
+/*
+ * Sets game score to `val`.
+ */
+void game_set_score(GameData *game, long int score);
+
+/*
+ * Returns the game's current score.
+ */
+long int game_get_score(const GameData *game);
+
+/*
+ * Increments level.
+ *
+ * This function should be called on initialization if game wishes to display level.
+ */
+void game_increment_level(GameData *game);
+
+/*
+ * Updates lives with `amount`.
+ *
+ * If lives becomes negative the lives counter will not be drawn.
+ */
+void game_update_lives(GameData *game, int amount);
+
+/*
+ * Returns the remaining number of lives for the game.
+ */
+int game_get_lives(const GameData *game);
+
+/*
+ * Returns the current level.
+ */
+size_t game_get_current_level(const GameData *game);
+
+/*
+ * Sets the game status to `status`.
+ */
+void game_set_status(GameData *game, GameStatus status);
+
+/*
+ * Sets the game base update interval.
+ *
+ * Lower values of `update_interval` make the game faster, where 1 is the fastest and 50 is slowest.
+ * If this function is never called the game chooses a reasonable default.
+ */
+void game_set_update_interval(GameData *game, TIME_MS update_interval);
+
+/*
+ * Creates a message `message` of size `length` to be displayed at `coords` for `timeout` seconds.
+ *
+ * Message must be no greater than GAME_MAX_MESSAGE_SIZE bytes in length.
+ *
+ * If `sticky` is true the message will follow coords if they move.
+ *
+ * If `dir` is a valid direction, the message will be positioned a few squares away from `coords`
+ * so as to not overlap with its associated object.
+ *
+ * If `timeout` is zero, the default timeout value will be used.
+ *
+ * If `priority` true, messages will be printed on top of game objects.
+ *
+ * Return 0 on success.
+ * Return -1 on failure.
+ */
+int game_set_message(GameData *game, const char *message, size_t length, Direction dir, int attributes, int colour,
+                     time_t timeout, const Coords *coords, bool sticky, bool priority);
+
+/*
+ * Returns true if game should update an object's state according to its last moved time and current speed.
+ *
+ * This is used to independently control the speed of various game objects.
+ */
+bool game_do_object_state_update(const GameData *game, TIME_MS current_time, TIME_MS last_moved_time, TIME_MS speed);
+
+/*
+ * Returns the current wall time in milliseconds.
+ */
+TIME_MS get_time_millis(void);
+
+/*
+ * Ends game associated with `self` and cleans up.
+ */
+void game_kill(ToxWindow *self);
+
+/*
+ * Sends a packet containing payload `data` of size `length` to the friendnumber associated with the game's
+ * parent window.
+ *
+ * `length` must not exceed GAME_MAX_DATA_SIZE bytes.
+ *
+ * `packet_type` should be GP_Invite for an invite packet or GP_Data for all other game data.
+ */
+int game_packet_send(const GameData *game, const uint8_t *data, size_t length, GamePacketType packet_type);
+
+#endif // GAME_BASE
+

src/game_centipede.h

@@ -0,0 +1,30 @@
+/*  game_centipede.h
+ *
+ *
+ *  Copyright (C) 2020 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GAME_CENTIPEDE
+#define GAME_CENTIPEDE
+
+#include "game_base.h"
+
+int centipede_initialize(GameData *game);
+
+#endif  // GAME_CENTIPEDE

src/game_chess.h

@@ -0,0 +1,44 @@
+/*  game_chess.h
+ *
+ *
+ *  Copyright (C) 2020 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GAME_CHESS
+#define GAME_CHESS
+
+#include "game_base.h"
+
+/*
+ * Initializes chess game state.
+ *
+ * If `init_data` is non-null, this indicates that we were invited to the game.
+ *
+ * If we're the inviter, we send an invite packet after initialization. If we're the
+ * invitee, we send a handshake response packet to the inviter.
+ *
+ * Return 0 on success.
+ * Return -1 if window is too small.
+ * Return -2 on network related error.
+ * Return -3 on other error.
+ */
+int chess_initialize(GameData *game, const uint8_t *init_data, size_t length);
+
+#endif // GAME_CHESS
+

src/game_life.c

@@ -0,0 +1,676 @@
+/*  game_life.c
+ *
+ *
+ *  Copyright (C) 2021 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "game_life.h"
+
+#define LIFE_DEFAULT_CELL_CHAR     'o'
+#define LIFE_CELL_DEFAULT_COLOUR    CYAN
+#define LIFE_DEFAULT_SPEED          25
+#define LIFE_MAX_SPEED              40
+
+/* Determines the additional size of the grid beyond the visible boundaries.
+ *
+ * This buffer allows cells to continue growing off-screen giving the illusion of an
+ * infinite grid to a certain point.
+ */
+#define LIFE_BOUNDARY_BUFFER        50
+
+
+typedef struct Cell {
+    Coords     coords;
+    bool       alive;
+    bool       marked;  // true if cell should invert alive status at end of current cycle
+    int        display_char;
+    size_t     age;
+} Cell;
+
+typedef struct LifeState {
+    TIME_MS    time_last_cycle;
+    size_t     speed;
+    size_t     generation;
+    bool       paused;
+
+    Cell       **cells;
+    int        num_columns;
+    int        num_rows;
+
+    int        curs_x;
+    int        curs_y;
+
+    int        x_left_bound;
+    int        x_right_bound;
+    int        y_top_bound;
+    int        y_bottom_bound;
+
+    short      display_candy;
+    int        colour;
+} LifeState;
+
+
+static void life_increase_speed(LifeState *state)
+{
+    if (state->speed < LIFE_MAX_SPEED) {
+        ++state->speed;
+    }
+}
+
+static void life_decrease_speed(LifeState *state)
+{
+    if (state->speed > 1) {
+        --state->speed;
+    }
+}
+
+static int life_get_display_char(const LifeState *state, const Cell *cell)
+{
+    if (state->display_candy == 1) {
+        if (cell->age == 1) {
+            return '.';
+        }
+
+        return '+';
+    }
+
+    if (state->display_candy == 2) {
+        if (cell->age == 1) {
+            return '.';
+        }
+
+        if (cell->age == 2) {
+            return '-';
+        }
+
+        if (cell->age == 3) {
+            return 'o';
+        }
+
+        return 'O';
+    }
+
+    return 'o';
+}
+
+static void life_toggle_display_candy(LifeState *state)
+{
+    state->display_candy = (state->display_candy + 1) % 3;  // magic number depends on life_get_display_char()
+}
+
+static void life_cycle_colour(LifeState *state)
+{
+    switch (state->colour) {
+        case RED: {
+            state->colour = YELLOW;
+            break;
+        }
+
+        case YELLOW: {
+            state->colour = GREEN;
+            break;
+        }
+
+        case GREEN: {
+            state->colour = CYAN;
+            break;
+        }
+
+        case CYAN: {
+            state->colour = BLUE;
+            break;
+        }
+
+        case BLUE: {
+            state->colour = MAGENTA;
+            break;
+        }
+
+        case MAGENTA: {
+            state->colour = RED;
+            break;
+        }
+
+        default: {
+            state->colour = RED;
+            break;
+        }
+    }
+}
+
+static Cell *life_get_cell_at_coords(const LifeState *state, const int x, const int y)
+{
+    const int i = y - (state->y_top_bound - (LIFE_BOUNDARY_BUFFER / 2));
+    const int j = x - (state->x_left_bound - (LIFE_BOUNDARY_BUFFER / 2));
+
+    if (i >= 0 && j >= 0) {
+        return &state->cells[i][j];
+    }
+
+    return NULL;
+}
+
+static void life_draw_cells(const GameData *game, WINDOW *win, LifeState *state)
+{
+    wattron(win, A_BOLD | COLOR_PAIR(state->colour));
+
+    for (int i = LIFE_BOUNDARY_BUFFER / 2; i < state->num_rows - (LIFE_BOUNDARY_BUFFER / 2); ++i) {
+        for (int j = LIFE_BOUNDARY_BUFFER / 2; j < state->num_columns + 1 - (LIFE_BOUNDARY_BUFFER / 2); ++j) {
+            Cell *cell = &state->cells[i][j];
+
+            if (cell->alive) {
+                Coords coords = cell->coords;
+                mvwaddch(win, coords.y, coords.x, cell->display_char);
+            }
+        }
+    }
+
+    wattroff(win, A_BOLD | COLOR_PAIR(state->colour));
+}
+
+static void life_toggle_cell(LifeState *state)
+{
+    Cell *cell = life_get_cell_at_coords(state, state->curs_x, state->curs_y);
+
+    if (cell == NULL) {
+        return;
+    }
+
+    cell->alive ^= 1;
+}
+
+/*
+ * Returns the number of live neighbours of cell at `i` `j` position.
+ *
+ * Returns NULL if cell is touching a border.
+ */
+static int life_get_live_neighbours(const LifeState *state, const int i, const int j)
+{
+    Cell *n[8] = {0};
+
+    if (i > 0 && j > 0) {
+        n[0] = &state->cells[i - 1][j - 1];
+    }
+
+    if (i > 0) {
+        n[1] = &state->cells[i - 1][j];
+    }
+
+    if (i > 0 && j < state->num_columns - 1) {
+        n[2] = &state->cells[i - 1][j + 1];
+    }
+
+    if (j > 0) {
+        n[3] = &state->cells[i][j - 1];
+    }
+
+    if (j < state->num_columns - 1) {
+        n[4] = &state->cells[i][j + 1];
+    }
+
+    if (i < state->num_rows - 1 && j > 0) {
+        n[5] = &state->cells[i + 1][j - 1];
+    }
+
+    if (i < state->num_rows - 1) {
+        n[6] = &state->cells[i + 1][j];
+    }
+
+    if (i < state->num_rows - 1 && j < state->num_columns - 1) {
+        n[7] = &state->cells[i + 1][j + 1];
+    }
+
+    int count = 0;
+
+    for (size_t i = 0; i < 8; ++i) {
+        if (n[i] == NULL) {
+            return 0; // If we're at a boundary kill cell
+        }
+
+        if (n[i]->alive) {
+            ++count;
+        }
+    }
+
+    return count;
+}
+
+static void life_restart(GameData *game, LifeState *state)
+{
+    for (int i = 0; i < state->num_rows; ++i) {
+        for (int j = 0; j < state->num_columns; ++j) {
+            Cell *cell = &state->cells[i][j];
+            cell->alive = false;
+            cell->marked = false;
+            cell->display_char = LIFE_DEFAULT_CELL_CHAR;
+            cell->age = 0;
+        }
+    }
+
+    game_set_score(game, 0);
+
+    state->generation = 0;
+}
+
+static void life_do_cells(LifeState *state)
+{
+
+    for (int i = 0; i < state->num_rows; ++i) {
+        for (int j = 0; j < state->num_columns; ++j) {
+            Cell *cell = &state->cells[i][j];
+
+            if (cell->marked) {
+                cell->marked = false;
+                cell->alive ^= 1;
+                cell->age = cell->alive;
+                cell->display_char = life_get_display_char(state, cell);
+            } else if (cell->alive) {
+                ++cell->age;
+                cell->display_char = life_get_display_char(state, cell);
+            }
+        }
+    }
+}
+
+static void life_cycle(GameData *game, LifeState *state)
+{
+    if (state->generation == 0) {
+        return;
+    }
+
+    TIME_MS cur_time = get_time_millis();
+
+    if (!game_do_object_state_update(game, cur_time, state->time_last_cycle, state->speed)) {
+        return;
+    }
+
+    state->time_last_cycle = get_time_millis();
+
+    ++state->generation;
+
+    size_t live_cells = 0;
+
+    for (int i = 0; i < state->num_rows; ++i) {
+        for (int j = 0; j < state->num_columns; ++j) {
+            Cell *cell = &state->cells[i][j];
+
+            int live_neighbours = life_get_live_neighbours(state, i, j);
+
+            if (cell->alive) {
+                if (!(live_neighbours == 2 || live_neighbours == 3)) {
+                    cell->marked = true;
+                } else {
+                    ++live_cells;
+                }
+            } else {
+                if (live_neighbours == 3) {
+                    cell->marked = true;
+                    ++live_cells;
+                }
+            }
+        }
+    }
+
+    if (live_cells == 0) {
+        life_restart(game, state);
+        return;
+    }
+
+    life_do_cells(state);
+
+    game_update_score(game, 1);
+}
+
+static void life_start(GameData *game, LifeState *state)
+{
+    state->generation = 1;
+}
+
+void life_cb_update_game_state(GameData *game, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    LifeState *state = (LifeState *)cb_data;
+
+    life_cycle(game, state);
+}
+
+void life_cb_render_window(GameData *game, WINDOW *win, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    LifeState *state = (LifeState *)cb_data;
+
+    move(state->curs_y, state->curs_x);
+
+    if (state->generation == 0 || state->paused) {
+        curs_set(1);
+    }
+
+    life_draw_cells(game, win, state);
+}
+
+static void life_move_curs_left(LifeState *state)
+{
+    int new_x = state->curs_x - 1;
+
+    if (new_x < state->x_left_bound) {
+        return;
+    }
+
+    state->curs_x = new_x;
+}
+
+static void life_move_curs_right(LifeState *state)
+{
+    int new_x = state->curs_x + 1;
+
+    if (new_x > state->x_right_bound) {
+        return;
+    }
+
+    state->curs_x = new_x;
+}
+
+static void life_move_curs_up(LifeState *state)
+{
+    int new_y = state->curs_y - 1;
+
+    if (new_y < state->y_top_bound) {
+        return;
+    }
+
+    state->curs_y = new_y;
+}
+
+static void life_move_curs_down(LifeState *state)
+{
+    int new_y = state->curs_y + 1;
+
+    if (new_y >= state->y_bottom_bound) {
+        return;
+    }
+
+    state->curs_y = new_y;
+}
+
+static void life_move_curs_up_left(LifeState *state)
+{
+    life_move_curs_up(state);
+    life_move_curs_left(state);
+}
+
+static void life_move_curs_up_right(LifeState *state)
+{
+    life_move_curs_up(state);
+    life_move_curs_right(state);
+}
+
+static void life_move_curs_down_right(LifeState *state)
+{
+    life_move_curs_down(state);
+    life_move_curs_right(state);
+}
+
+static void life_move_curs_down_left(LifeState *state)
+{
+    life_move_curs_down(state);
+    life_move_curs_left(state);
+}
+
+void life_cb_on_keypress(GameData *game, int key, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    LifeState *state = (LifeState *)cb_data;
+
+    switch (key) {
+        case KEY_LEFT: {
+            life_move_curs_left(state);
+            break;
+        }
+
+        case KEY_RIGHT: {
+            life_move_curs_right(state);
+            break;
+        }
+
+        case KEY_DOWN: {
+            life_move_curs_down(state);
+            break;
+        }
+
+        case KEY_UP: {
+            life_move_curs_up(state);
+            break;
+        }
+
+        case KEY_HOME: {
+            life_move_curs_up_left(state);
+            break;
+        }
+
+        case KEY_END: {
+            life_move_curs_down_left(state);
+            break;
+        }
+
+        case KEY_PPAGE: {
+            life_move_curs_up_right(state);
+            break;
+        }
+
+        case KEY_NPAGE: {
+            life_move_curs_down_right(state);
+            break;
+        }
+
+        case '\r': {
+            if (state->generation > 0) {
+                life_restart(game, state);
+            } else {
+                life_start(game, state);
+            }
+
+            break;
+        }
+
+        case ' ': {
+            life_toggle_cell(state);
+            break;
+        }
+
+        case '=':
+
+        /* intentional fallthrough */
+
+        case '+': {
+            life_increase_speed(state);
+            break;
+        }
+
+        case '-':
+
+        /* intentional fallthrough */
+
+        case '_': {
+            life_decrease_speed(state);
+            break;
+        }
+
+        case '\t': {
+            life_toggle_display_candy(state);
+            break;
+        }
+
+        case '`': {
+            life_cycle_colour(state);
+            break;
+        }
+
+        default: {
+            return;
+        }
+    }
+}
+
+static void life_free_cells(LifeState *state)
+{
+    if (state->cells == NULL) {
+        return;
+    }
+
+    for (int i = 0; i < state->num_rows; ++i) {
+        if (state->cells[i]) {
+            free(state->cells[i]);
+        }
+    }
+
+    free(state->cells);
+}
+
+void life_cb_pause(GameData *game, bool is_paused, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    LifeState *state = (LifeState *)cb_data;
+
+    state->paused = is_paused;
+}
+
+void life_cb_kill(GameData *game, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    LifeState *state = (LifeState *)cb_data;
+
+    life_free_cells(state);
+    free(state);
+
+    game_set_cb_update_state(game, NULL, NULL);
+    game_set_cb_render_window(game, NULL, NULL);
+    game_set_cb_kill(game, NULL, NULL);
+    game_set_cb_on_keypress(game, NULL, NULL);
+}
+
+static int life_init_state(GameData *game, LifeState *state)
+{
+    const int x_left = game_x_left_bound(game) ;
+    const int x_right = game_x_right_bound(game);
+    const int y_top = game_y_top_bound(game);
+    const int y_bottom = game_y_bottom_bound(game) + 1;
+
+    state->x_left_bound = x_left;
+    state->x_right_bound = x_right;
+    state->y_top_bound = y_top;
+    state->y_bottom_bound = y_bottom;
+
+    const int x_mid = x_left + ((x_right - x_left) / 2);
+    const int y_mid = y_top + ((y_bottom - y_top) / 2);
+
+    state->curs_x = x_mid;
+    state->curs_y = y_mid;
+
+    const int num_rows = (y_bottom - y_top) + LIFE_BOUNDARY_BUFFER;
+    const int num_columns = (x_right - x_left) + LIFE_BOUNDARY_BUFFER;
+
+    if (num_rows <= 0 || num_columns <= 0) {
+        return -1;
+    }
+
+    state->num_columns = num_columns;
+    state->num_rows = num_rows;
+
+    state->cells = calloc(1, num_rows * sizeof(Cell *));
+
+    if (state->cells == NULL) {
+        return -1;
+    }
+
+    for (int i = 0; i < num_rows; ++i) {
+        state->cells[i] = calloc(1, num_columns * sizeof(Cell));
+
+        if (state->cells[i] == NULL) {
+            return -1;
+        }
+
+        for (int j = 0; j < num_columns; ++j) {
+            state->cells[i][j].coords.y = i + (state->y_top_bound - (LIFE_BOUNDARY_BUFFER / 2));
+            state->cells[i][j].coords.x = j + (state->x_left_bound - (LIFE_BOUNDARY_BUFFER / 2));
+        }
+    }
+
+    state->speed = LIFE_DEFAULT_SPEED;
+    state->colour = LIFE_CELL_DEFAULT_COLOUR;
+
+    life_restart(game, state);
+
+    return 0;
+}
+
+int life_initialize(GameData *game)
+{
+    // Try best fit from largest to smallest before giving up
+    if (game_set_window_shape(game, GW_ShapeRectangleLarge) == -1) {
+        if (game_set_window_shape(game, GW_ShapeSquareLarge) == -1) {
+            if (game_set_window_shape(game, GW_ShapeRectangle) == -1) {
+                if (game_set_window_shape(game, GW_ShapeSquare) == -1) {
+                    return -1;
+                }
+            }
+        }
+    }
+
+    LifeState *state = calloc(1, sizeof(LifeState));
+
+    if (state == NULL) {
+        return -1;
+    }
+
+    if (life_init_state(game, state) == -1) {
+        life_free_cells(state);
+        free(state);
+        return -1;
+    }
+
+    game_set_update_interval(game, 40);
+    game_show_score(game, true);
+
+    game_set_cb_update_state(game, life_cb_update_game_state, state);
+    game_set_cb_render_window(game, life_cb_render_window, state);
+    game_set_cb_on_keypress(game, life_cb_on_keypress, state);
+    game_set_cb_on_pause(game, life_cb_pause, state);
+    game_set_cb_kill(game, life_cb_kill, state);
+
+    return 0;
+}

src/game_life.h

@@ -0,0 +1,31 @@
+/*  game_life.h
+ *
+ *
+ *  Copyright (C) 2021 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GAME_LIFE
+#define GAME_LIFE
+
+#include "game_base.h"
+
+int life_initialize(GameData *game);
+
+#endif // GAME_LIFE
+

src/game_snake.c

@@ -0,0 +1,906 @@
+/*  game_snake.c
+ *
+ *
+ *  Copyright (C) 2020 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "game_base.h"
+#include "game_util.h"
+#include "game_snake.h"
+#include "misc_tools.h"
+
+#define SNAKE_MAX_SNAKE_LENGTH     (GAME_MAX_SQUARE_X_DEFAULT * GAME_MAX_SQUARE_Y_DEFAULT)
+#define SNAKE_AGENT_MAX_LIST_SIZE  (GAME_MAX_SQUARE_X_DEFAULT * GAME_MAX_SQUARE_Y_DEFAULT)
+
+#define SNAKE_DEFAULT_SNAKE_SPEED 6
+#define SNAKE_DEFAULT_AGENT_SPEED 1
+#define SNAKE_MAX_SNAKE_SPEED 12
+#define SNAKE_MAX_AGENT_SPEED (SNAKE_MAX_SNAKE_SPEED / 2)
+
+#define SNAKE_DEFAULT_UPDATE_INTERVAL 20
+
+/* How often we update frames independent of the speed of the game or objects */
+#define SNAKE_FRAME_DRAW_SPEED 5
+
+/* How long a regular message stays on the screen */
+#define SNAKE_DEFAULT_MESSAGE_TIMER 5
+
+/* Increment snake speed by 1 every time level increases by this amount */
+#define SNAKE_LEVEL_SPEED_INTERVAL 5
+
+/* Increment level by 1 every time snake eats this many foods */
+#define SNAKE_LEVEL_UP_FOOD_LIMIT 4
+
+/* Increment agent speed by 1 every time level increases by this amount */
+#define SNAKE_AGENT_LEVEL_SPEED_INTERVAL 2
+
+/* Points multiplier for getting a powerup */
+#define SNAKE_POWERUP_BONUS_MULTIPLIER 5
+
+/* Extra bonus for running over a glowing agent */
+#define SNAKE_AGENT_GLOWING_MULTIPLIER 2
+
+/* Agents begin glowing if their speed is greater than this */
+#define SNAKE_AGENT_GLOWING_SPEED (SNAKE_DEFAULT_AGENT_SPEED + 2)
+
+/* A new powerup is placed on the board after this many seconds since last one wore off */
+#define SNAKE_POWERUP_INTERVAL 45
+
+/* How long a powerup lasts */
+#define SNAKE_POWERUP_TIMER 12
+
+/* Number of key presses to queue; one key press is retrieved per state update */
+#define SNAKE_KEY_PRESS_QUEUE_SIZE 3
+
+/* These decide how many points to decay and how often to penalize camping for powerups */
+#define SNAKE_DECAY_POINTS_INTERVAL  1
+#define SNAKE_DECAY_POINTS_FRACTION 10
+
+#define SNAKE_HEAD_COLOUR       GREEN
+
+#define SNAKE_DEAD_BODY_CHAR    'o'
+#define SNAKE_DEAD_BODY_COLOUR  RED
+
+#define SNAKE_BODY_COLOUR       CYAN
+#define SNAKE_BODY_CHAR         'o'
+
+#define SNAKE_FOOD_COLOUR    YELLOW
+#define SNAKE_FOOD_CHAR      '*'
+
+#define SNAKE_AGENT_NORMAL_COLOUR   RED
+#define SNAKE_AGENT_GLOWING_COLOUR  GREEN
+#define SNAKE_AGENT_NORMAL_CHAR     'x'
+#define SNAKE_AGENT_GLOWING_CHAR    'X'
+
+#define SNAKE_POWERUP_CHAR   'P'
+
+typedef struct NasaAgent {
+    Coords      coords;
+    bool        is_alive;
+    bool        is_glowing;
+    TIME_MS     last_time_moved;
+    size_t      speed;
+    char        display_char;
+    int         colour;
+    int         attributes;
+} NasaAgent;
+
+typedef struct Snake {
+    Coords      coords;
+    char        display_char;
+    int         colour;
+    int         attributes;
+} Snake;
+
+typedef struct SnakeState {
+    Snake      *snake;
+    size_t      snake_length;
+    size_t      snake_speed;
+    TIME_MS     snake_time_last_moved;
+    bool        has_powerup;
+    Direction   direction;
+
+    Coords      powerup;
+    TIME_S      powerup_timer;
+    TIME_S      last_powerup_time;
+
+    Coords      food;
+
+    NasaAgent  *agents;
+    size_t      agent_list_size;
+
+    TIME_S      last_time_points_decayed;
+    TIME_S      pause_time;
+
+    int         key_press_queue[SNAKE_KEY_PRESS_QUEUE_SIZE];
+    size_t      keys_skip_counter;
+
+    TIME_MS     last_draw_update;
+    bool        game_over;
+} SnakeState;
+
+
+static void snake_create_points_message(GameData *game, Direction dir, long int points, const Coords *coords)
+{
+    char buf[GAME_MAX_MESSAGE_SIZE + 1];
+    snprintf(buf, sizeof(buf), "%ld", points);
+
+    if (game_set_message(game, buf, strlen(buf), dir, A_BOLD, WHITE, 0, coords, false, false) == -1) {
+        fprintf(stderr, "failed to set points message\n");
+    }
+}
+
+static void snake_create_message(GameData *game, Direction dir, const char *message, int attributes,
+                                 int colour, TIME_S timeout, const Coords *coords, bool priority)
+{
+    if (game_set_message(game, message, strlen(message), dir, attributes, colour, timeout, coords, false, priority) == -1) {
+        fprintf(stderr, "failed to set message\n");
+    }
+}
+
+static Coords *snake_get_head_coords(const SnakeState *state)
+{
+    return &state->snake[0].coords;
+}
+
+static void snake_set_head_char(SnakeState *state)
+{
+    Snake *snake_head = &state->snake[0];
+
+    switch (state->direction) {
+        case NORTH:
+            snake_head->display_char = '^';
+            break;
+
+        case SOUTH:
+            snake_head->display_char = 'v';
+            break;
+
+        case EAST:
+            snake_head->display_char = '>';
+            return;
+
+        case WEST:
+            snake_head->display_char = '<';
+            break;
+
+        default:
+            snake_head->display_char = '?';
+            break;
+    }
+}
+
+static bool snake_validate_direction(const SnakeState *state, Direction dir)
+{
+    if (!GAME_UTIL_DIRECTION_VALID(dir)) {
+        return false;
+    }
+
+    const int diff = abs((int)state->direction - (int)dir);
+
+    return diff != 1;
+}
+
+static void snake_update_direction(SnakeState *state)
+{
+    for (size_t i = 0; i < SNAKE_KEY_PRESS_QUEUE_SIZE; ++i) {
+        int key = state->key_press_queue[i];
+
+        if (key == 0) {
+            continue;
+        }
+
+        Direction dir = game_util_get_direction(key);
+
+        if (!GAME_UTIL_DIRECTION_VALID(dir)) {
+            state->key_press_queue[i] = 0;
+            continue;
+        }
+
+        if (snake_validate_direction(state, dir)) {
+            state->direction = dir;
+            snake_set_head_char(state);
+            state->key_press_queue[i] = 0;
+            state->keys_skip_counter = 0;
+            break;
+        }
+
+        if (state->keys_skip_counter++ >= SNAKE_KEY_PRESS_QUEUE_SIZE) {
+            state->keys_skip_counter = 0;
+            memset(state->key_press_queue, 0, sizeof(state->key_press_queue));
+        }
+    }
+}
+
+static void snake_set_key_press(SnakeState *state, int key)
+{
+    for (size_t i = 0; i < SNAKE_KEY_PRESS_QUEUE_SIZE; ++i) {
+        if (state->key_press_queue[i] == 0) {
+            state->key_press_queue[i] = key;
+            return;
+        }
+    }
+
+    memset(state->key_press_queue, 0, sizeof(state->key_press_queue));
+    state->key_press_queue[0] = key;
+}
+
+static void snake_update_score(GameData *game, const SnakeState *state, long int points)
+{
+    const Coords *head = snake_get_head_coords(state);
+
+    snake_create_points_message(game, state->direction, points, head);
+
+    game_update_score(game, points);
+}
+
+static long int snake_get_move_points(const SnakeState *state)
+{
+    return state->snake_length + (2 * state->snake_speed);
+}
+
+/* Return true if snake body is occupying given coordinates */
+static bool snake_coords_contain_body(const SnakeState *state, const Coords *coords)
+{
+    for (size_t i = 1; i < state->snake_length; ++i) {
+        Coords snake_coords = state->snake[i].coords;
+
+        if (COORDINATES_OVERLAP(coords->x, coords->y, snake_coords.x, snake_coords.y)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static bool snake_self_consume(const SnakeState *state)
+{
+    const Coords *head = snake_get_head_coords(state);
+    return snake_coords_contain_body(state, head);
+}
+
+/*
+ * Returns a pointer to the agent at x and y coordinates.
+ *
+ * Returns NULL if no living agent is at coords.
+ */
+static NasaAgent *snake_get_agent_at_coords(const SnakeState *state, const Coords *coords)
+{
+    for (size_t i = 0; i < state->agent_list_size; ++i) {
+        NasaAgent *agent = &state->agents[i];
+
+        if (!agent->is_alive) {
+            continue;
+        }
+
+        if (COORDINATES_OVERLAP(coords->x, coords->y, agent->coords.x, agent->coords.y)) {
+            return agent;
+        }
+    }
+
+    return NULL;
+}
+
+/*
+ * Return true if snake got caught by an agent and doesn't have a powerup.
+ *
+ * If snake runs over agent and does have a powerup the agent is killed and score updated.
+ */
+static bool snake_agent_caught(GameData *game, SnakeState *state, const Coords *coords)
+{
+    NasaAgent *agent = snake_get_agent_at_coords(state, coords);
+
+    if (agent == NULL) {
+        return false;
+    }
+
+    if (!state->has_powerup) {
+        return true;
+    }
+
+    agent->is_alive = false;
+
+    long int points = snake_get_move_points(state) * (agent->speed + 1);
+
+    if (agent->is_glowing) {
+        points *= SNAKE_AGENT_GLOWING_MULTIPLIER;
+    }
+
+    snake_update_score(game, state, points);
+
+    return false;
+}
+
+static bool snake_state_valid(GameData *game, SnakeState *state)
+{
+    const Coords *head = snake_get_head_coords(state);
+
+    if (!game_coordinates_in_bounds(game, head->x, head->y)) {
+        snake_create_message(game, state->direction, "Ouch!", A_BOLD, WHITE, SNAKE_DEFAULT_MESSAGE_TIMER, head, true);
+        return false;
+    }
+
+    if (snake_self_consume(state)) {
+        snake_create_message(game, state->direction, "Tastes like chicken", A_BOLD, WHITE, SNAKE_DEFAULT_MESSAGE_TIMER, head,
+                             true);
+        return false;
+    }
+
+    if (snake_agent_caught(game, state, head)) {
+        snake_create_message(game, state->direction, "ARGH they got me!", A_BOLD, WHITE, SNAKE_DEFAULT_MESSAGE_TIMER, head,
+                             true);
+        return false;
+    }
+
+    return true;
+}
+
+/*
+ * Sets colour and attributes for entire snake except head.
+ *
+ * If colour is set to -1 a random colour is chosen for each body part.
+ */
+static void snake_set_body_attributes(Snake *snake, size_t length, int colour, int attributes)
+{
+    for (size_t i = 1; i < length; ++i) {
+        Snake *body = &snake[i];
+
+        if (colour == -1) {
+            body->colour = game_util_random_colour();
+        } else {
+            body->colour = colour;
+        }
+
+        body->attributes = attributes;
+    }
+}
+
+static void snake_move_body(SnakeState *state)
+{
+    for (size_t i = state->snake_length - 1; i > 0; --i) {
+        Coords *curr = &state->snake[i].coords;
+        Coords prev = state->snake[i - 1].coords;
+        curr->x = prev.x;
+        curr->y = prev.y;
+    }
+}
+
+static void snake_move_head(SnakeState *state)
+{
+    Coords *head = snake_get_head_coords(state);
+    game_util_move_coords(state->direction, head);
+}
+
+static void snake_grow(SnakeState *state)
+{
+    size_t index = state->snake_length;
+
+    if (index >= SNAKE_MAX_SNAKE_LENGTH) {
+        return;
+    }
+
+    state->snake[index].coords.x = -1;
+    state->snake[index].coords.y = -1;
+    state->snake[index].display_char = SNAKE_BODY_CHAR;
+    state->snake[index].colour = SNAKE_BODY_COLOUR;
+    state->snake[index].attributes = A_BOLD;
+
+    state->snake_length = index + 1;
+}
+
+static long int snake_check_food(const GameData *game, SnakeState *state)
+{
+    Coords *food = &state->food;
+    const Coords *head = snake_get_head_coords(state);
+
+    if (!COORDINATES_OVERLAP(head->x, head->y, food->x, food->y)) {
+        return 0;
+    }
+
+    snake_grow(state);
+
+    game_random_coords(game, food);
+
+    return snake_get_move_points(state);
+}
+
+static long int snake_check_powerup(GameData *game, SnakeState *state)
+{
+    Coords *powerup = &state->powerup;
+    const Coords *head = snake_get_head_coords(state);
+
+    if (!COORDINATES_OVERLAP(head->x, head->y, powerup->x, powerup->y)) {
+        return 0;
+    }
+
+    snake_create_message(game, state->direction, "AAAAA", A_BOLD, RED, 2, head, false);
+
+    TIME_S t = get_unix_time();
+
+    state->has_powerup = true;
+    state->powerup_timer = t;
+
+    powerup->x = -1;
+    powerup->y = -1;
+
+    return snake_get_move_points(state) * SNAKE_POWERUP_BONUS_MULTIPLIER;
+}
+
+/*
+ * Returns the first unoccupied index in agent array.
+ */
+static size_t snake_get_empty_agent_index(const NasaAgent *agents)
+{
+    for (size_t i = 0; i < SNAKE_AGENT_MAX_LIST_SIZE; ++i) {
+        if (!agents[i].is_alive) {
+            return i;
+        }
+    }
+
+    fprintf(stderr, "Warning: Agent array is full. This should be impossible\n");
+
+    return 0;
+}
+
+static void snake_initialize_agent(SnakeState *state, const Coords *coords)
+{
+    size_t idx = snake_get_empty_agent_index(state->agents);
+
+    if ((idx >= state->agent_list_size) && (idx + 1 <= SNAKE_AGENT_MAX_LIST_SIZE)) {
+        state->agent_list_size = idx + 1;
+    }
+
+    NasaAgent *agent = &state->agents[idx];
+
+    agent->coords = (Coords) {
+        coords->x,
+               coords->y
+    };
+
+    agent->is_alive = true;
+    agent->is_glowing = false;
+    agent->display_char = SNAKE_AGENT_NORMAL_CHAR;
+    agent->colour = SNAKE_AGENT_NORMAL_COLOUR;
+    agent->attributes = A_BOLD;
+    agent->last_time_moved = 0;
+    agent->speed = SNAKE_DEFAULT_AGENT_SPEED;
+}
+
+static void snake_dispatch_new_agent(const GameData *game, SnakeState *state)
+{
+    Coords new_coords;
+    const Coords *head = snake_get_head_coords(state);
+
+    size_t tries = 0;
+
+    do {
+        if (tries++ >= 10) {
+            return;
+        }
+
+        game_random_coords(game, &new_coords);
+    } while (COORDINATES_OVERLAP(new_coords.x, new_coords.y, head->x, head->y)
+             || snake_get_agent_at_coords(state, &new_coords) != NULL);
+
+    snake_initialize_agent(state, &new_coords);
+}
+
+static void snake_place_powerup(const GameData *game, SnakeState *state)
+{
+    Coords *powerup = &state->powerup;
+
+    if (powerup->x != -1) {
+        return;
+    }
+
+    if (!timed_out(state->last_powerup_time, SNAKE_POWERUP_INTERVAL)) {
+        return;
+    }
+
+    game_random_coords(game, powerup);
+}
+
+static void snake_do_powerup(const GameData *game, SnakeState *state)
+{
+    if (!state->has_powerup) {
+        snake_place_powerup(game, state);
+        return;
+    }
+
+    if (timed_out(state->powerup_timer, SNAKE_POWERUP_TIMER)) {
+        state->last_powerup_time = get_unix_time();
+        state->has_powerup = false;
+        snake_set_body_attributes(state->snake, state->snake_length, SNAKE_BODY_COLOUR, A_BOLD);
+    }
+}
+
+static void snake_decay_points(GameData *game, SnakeState *state)
+{
+
+    long int score = game_get_score(game);
+    long int decay = snake_get_move_points(state) / SNAKE_DECAY_POINTS_FRACTION;
+
+    if (score > decay && timed_out(state->last_time_points_decayed, SNAKE_DECAY_POINTS_INTERVAL)) {
+        game_update_score(game, -decay);
+        state->last_time_points_decayed = get_unix_time();
+    }
+}
+
+static void snake_do_points_update(GameData *game, SnakeState *state, long int points)
+{
+    snake_update_score(game, state, points);
+
+    if (state->snake_length % SNAKE_LEVEL_UP_FOOD_LIMIT != 0) {
+        return;
+    }
+
+    game_increment_level(game);
+
+    size_t level = game_get_current_level(game);
+
+    if (level % SNAKE_LEVEL_SPEED_INTERVAL == 0 && state->snake_speed < SNAKE_MAX_SNAKE_SPEED) {
+        ++state->snake_speed;
+    }
+
+    if (level % SNAKE_AGENT_LEVEL_SPEED_INTERVAL == 0) {
+        for (size_t i = 0; i < state->agent_list_size; ++i) {
+            NasaAgent *agent = &state->agents[i];
+
+            if (!agent->is_alive) {
+                continue;
+            }
+
+            if (agent->speed < SNAKE_MAX_AGENT_SPEED) {
+                ++agent->speed;
+            }
+
+            if (agent->speed > SNAKE_AGENT_GLOWING_SPEED && !agent->is_glowing) {
+                agent->is_glowing = true;
+                agent->display_char = SNAKE_AGENT_GLOWING_CHAR;
+                agent->colour = SNAKE_AGENT_GLOWING_COLOUR;
+                snake_create_message(game, state->direction, "*glows*", A_BOLD, GREEN, 2, &agent->coords, false);
+            }
+        }
+    }
+
+    snake_dispatch_new_agent(game, state);
+}
+
+static void snake_game_over(SnakeState *state)
+{
+    state->game_over = true;
+    state->has_powerup = false;
+    state->snake[0].colour = SNAKE_DEAD_BODY_COLOUR;
+    state->snake[0].attributes = A_BOLD | A_BLINK;
+
+    snake_set_body_attributes(state->snake, state->snake_length, SNAKE_DEAD_BODY_COLOUR, A_BOLD | A_BLINK);
+}
+
+static void snake_move(GameData *game, SnakeState *state, TIME_MS cur_time)
+{
+    const TIME_MS real_speed = GAME_UTIL_REAL_SPEED(state->direction, state->snake_speed);
+
+    if (!game_do_object_state_update(game, cur_time, state->snake_time_last_moved, real_speed)) {
+        return;
+    }
+
+    state->snake_time_last_moved = cur_time;
+
+    snake_update_direction(state);
+    snake_move_body(state);
+    snake_move_head(state);
+
+    if (!snake_state_valid(game, state)) {
+        snake_game_over(state);
+        game_set_status(game, GS_Finished);
+        return;
+    }
+
+    long int points = snake_check_food(game, state) + snake_check_powerup(game, state);
+
+    if (points > 0) {
+        snake_do_points_update(game, state, points);
+    }
+}
+
+/*
+ * Attempts to move every agent in list.
+ *
+ * If an agent is normal it will move in a random direction. If it's glowing it will
+ * move towards the snake.
+ */
+static void snake_agent_move(GameData *game, SnakeState *state, TIME_MS cur_time)
+{
+    const Coords *head = snake_get_head_coords(state);
+
+    for (size_t i = 0; i < state->agent_list_size; ++i) {
+        NasaAgent *agent = &state->agents[i];
+
+        if (!agent->is_alive) {
+            continue;
+        }
+
+        Coords *coords = &agent->coords;
+
+        Coords new_coords = (Coords) {
+            coords->x,
+                   coords->y
+        };
+
+        Direction dir = !agent->is_glowing ? game_util_random_direction()
+                        : game_util_move_towards(coords, head, state->has_powerup);
+
+        const TIME_MS real_speed = agent->is_glowing ? GAME_UTIL_REAL_SPEED(dir, agent->speed) : agent->speed;
+
+        if (!game_do_object_state_update(game, cur_time, agent->last_time_moved, real_speed)) {
+            continue;
+        }
+
+        agent->last_time_moved = cur_time;
+
+        game_util_move_coords(dir, &new_coords);
+
+        if (!game_coordinates_in_bounds(game, new_coords.x, new_coords.y)) {
+            continue;
+        }
+
+        if (snake_coords_contain_body(state, &new_coords)) {
+            continue;
+        }
+
+        if (snake_get_agent_at_coords(state, &new_coords) != NULL) {
+            continue;
+        }
+
+        coords->x = new_coords.x;
+        coords->y = new_coords.y;
+
+        if (!state->has_powerup && COORDINATES_OVERLAP(head->x, head->y, new_coords.x, new_coords.y)) {
+            snake_game_over(state);
+            game_set_status(game, GS_Finished);
+            return;
+        }
+    }
+}
+
+static void snake_update_frames(const GameData *game, SnakeState *state, TIME_MS cur_time)
+{
+    if (!game_do_object_state_update(game, cur_time, state->last_draw_update, SNAKE_FRAME_DRAW_SPEED)) {
+        return;
+    }
+
+    state->last_draw_update = cur_time;
+
+    if (state->has_powerup) {
+        const int time_left = SNAKE_POWERUP_TIMER - (get_unix_time() - state->powerup_timer);
+
+        if (time_left <= 5 && time_left % 2 == 0) {
+            snake_set_body_attributes(state->snake, state->snake_length, SNAKE_BODY_COLOUR, A_BOLD);
+        } else {
+            snake_set_body_attributes(state->snake, state->snake_length, -1, A_BOLD);
+        }
+    }
+}
+
+static void snake_draw_self(WINDOW *win, const SnakeState *state)
+{
+    for (size_t i = 0; i < state->snake_length; ++i) {
+        const Snake *body = &state->snake[i];
+
+        if (body->coords.x <= 0 || body->coords.y <= 0) {
+            continue;
+        }
+
+        wattron(win, body->attributes | COLOR_PAIR(body->colour));
+        mvwaddch(win, body->coords.y, body->coords.x, body->display_char);
+        wattroff(win, body->attributes | COLOR_PAIR(body->colour));
+    }
+}
+
+static void snake_draw_food(WINDOW *win, const SnakeState *state)
+{
+    wattron(win, A_BOLD | COLOR_PAIR(SNAKE_FOOD_COLOUR));
+    mvwaddch(win, state->food.y, state->food.x, SNAKE_FOOD_CHAR);
+    wattroff(win, A_BOLD | COLOR_PAIR(SNAKE_FOOD_COLOUR));
+}
+
+static void snake_draw_agent(WINDOW *win, const SnakeState *state)
+{
+    for (size_t i = 0; i < state->agent_list_size; ++i) {
+        NasaAgent agent = state->agents[i];
+
+        if (agent.is_alive) {
+            Coords coords = agent.coords;
+
+            wattron(win, agent.attributes | COLOR_PAIR(agent.colour));
+            mvwaddch(win, coords.y, coords.x, agent.display_char);
+            wattroff(win, agent.attributes | COLOR_PAIR(agent.colour));
+        }
+    }
+}
+
+static void snake_draw_powerup(WINDOW *win, const SnakeState *state)
+{
+    Coords powerup = state->powerup;
+
+    if (powerup.x != -1) {
+        int colour = game_util_random_colour();
+
+        wattron(win, A_BOLD | COLOR_PAIR(colour));
+        mvwaddch(win, powerup.y, powerup.x, SNAKE_POWERUP_CHAR);
+        wattroff(win, A_BOLD | COLOR_PAIR(colour));
+    }
+}
+
+void snake_cb_update_game_state(GameData *game, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    SnakeState *state = (SnakeState *)cb_data;
+
+    TIME_MS cur_time = get_time_millis();
+
+    snake_do_powerup(game, state);
+    snake_agent_move(game, state, cur_time);
+    snake_move(game, state, cur_time);
+    snake_decay_points(game, state);
+
+    if (!state->game_over) {
+        snake_update_frames(game, state, cur_time);
+    }
+}
+
+void snake_cb_render_window(GameData *game, WINDOW *win, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    SnakeState *state = (SnakeState *)cb_data;
+
+    snake_draw_food(win, state);
+    snake_draw_powerup(win, state);
+    snake_draw_agent(win, state);
+    snake_draw_self(win, state);
+}
+
+void snake_cb_kill(GameData *game, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    SnakeState *state = (SnakeState *)cb_data;
+
+    free(state->snake);
+    free(state->agents);
+    free(state);
+
+    game_set_cb_update_state(game, NULL, NULL);
+    game_set_cb_render_window(game, NULL, NULL);
+    game_set_cb_kill(game, NULL, NULL);
+    game_set_cb_on_keypress(game, NULL, NULL);
+    game_set_cb_on_pause(game, NULL, NULL);
+}
+
+void snake_cb_on_keypress(GameData *game, int key, void *cb_data)
+{
+    if (!cb_data) {
+        return;
+    }
+
+    SnakeState *state = (SnakeState *)cb_data;
+
+    snake_set_key_press(state, key);
+}
+
+void snake_cb_pause(GameData *game, bool is_paused, void *cb_data)
+{
+    UNUSED_VAR(game);
+
+    if (!cb_data) {
+        return;
+    }
+
+    SnakeState *state = (SnakeState *)cb_data;
+
+    TIME_S t = get_unix_time();
+
+    if (is_paused) {
+        state->pause_time = t;
+    } else {
+        state->powerup_timer += (t - state->pause_time);
+        state->last_powerup_time += (t - state->pause_time);
+    }
+}
+
+static void snake_initialize_snake_head(const GameData *game, Snake *snake)
+{
+    int max_x;
+    int max_y;
+    game_max_x_y(game, &max_x, &max_y);
+
+    snake[0].coords.x = max_x / 2;
+    snake[0].coords.y = max_y / 2;
+    snake[0].colour = SNAKE_HEAD_COLOUR;
+    snake[0].attributes = A_BOLD;
+}
+
+int snake_initialize(GameData *game)
+{
+    // note: if this changes we must update SNAKE_MAX_SNAKE_LENGTH and SNAKE_AGENT_MAX_LIST_SIZE
+    if (game_set_window_shape(game, GW_ShapeSquare) == -1) {
+        return -1;
+    }
+
+    SnakeState *state = calloc(1, sizeof(SnakeState));
+
+    if (state == NULL) {
+        return -1;
+    }
+
+    state->snake = calloc(1, SNAKE_MAX_SNAKE_LENGTH * sizeof(Snake));
+
+    if (state->snake == NULL) {
+        free(state);
+        return -1;
+    }
+
+    state->agents = calloc(1, SNAKE_AGENT_MAX_LIST_SIZE * sizeof(NasaAgent));
+
+    if (state->agents == NULL) {
+        free(state->snake);
+        free(state);
+        return -1;
+    }
+
+    snake_initialize_snake_head(game, state->snake);
+
+    state->snake_speed = SNAKE_DEFAULT_SNAKE_SPEED;
+    state->snake_length = 1;
+    state->direction = NORTH;
+    snake_set_head_char(state);
+
+    state->powerup.x = -1;
+    state->powerup.y = -1;
+
+    state->last_powerup_time = get_unix_time();
+
+    game_show_level(game, true);
+    game_show_score(game, true);
+    game_show_high_score(game, true);
+
+    game_increment_level(game);
+    game_set_update_interval(game, SNAKE_DEFAULT_UPDATE_INTERVAL);
+    game_random_coords(game, &state->food);
+
+    game_set_cb_update_state(game, snake_cb_update_game_state, state);
+    game_set_cb_render_window(game, snake_cb_render_window, state);
+    game_set_cb_on_keypress(game, snake_cb_on_keypress, state);
+    game_set_cb_kill(game, snake_cb_kill, state);
+    game_set_cb_on_pause(game, snake_cb_pause, state);
+
+    return 0;
+}

src/game_snake.h

@@ -0,0 +1,30 @@
+/*  game_snake.h
+ *
+ *
+ *  Copyright (C) 2020 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GAME_SNAKE
+#define GAME_SNAKE
+
+#include "game_base.h"
+
+int snake_initialize(GameData *game);
+
+#endif // GAME_SNAKE

src/game_util.c

@@ -0,0 +1,200 @@
+/*  game_util.c
+ *
+ *
+ *  Copyright (C) 2020 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+
+#include "game_util.h"
+#include "toxic.h"
+#include "windows.h"
+
+Direction game_util_get_direction(int key)
+{
+    switch (key) {
+        case KEY_UP: {
+            return NORTH;
+        }
+
+        case KEY_DOWN: {
+            return SOUTH;
+        }
+
+        case KEY_RIGHT: {
+            return EAST;
+        }
+
+        case KEY_LEFT: {
+            return WEST;
+        }
+
+        default: {
+            return INVALID_DIRECTION;
+        }
+    }
+}
+
+Direction game_util_move_towards(const Coords *coords_a, const Coords *coords_b, bool inverse)
+{
+    const int x1 = coords_a->x;
+    const int y1 = coords_a->y;
+    const int x2 = coords_b->x;
+    const int y2 = coords_b->y;
+
+    const int x_diff = abs(x1 - x2);
+    const int y_diff = abs(y1 - y2);
+
+    if (inverse) {
+        if (x_diff > y_diff) {
+            return x2 >= x1 ? WEST : EAST;
+        } else {
+            return y2 >= y1 ? NORTH : SOUTH;
+        }
+    } else {
+        if (x_diff > y_diff) {
+            return x2 < x1 ? WEST : EAST;
+        } else {
+            return y2 < y1 ? NORTH : SOUTH;
+        }
+    }
+}
+
+Direction game_util_random_direction(void)
+{
+    int r = rand() % 4;
+
+    switch (r) {
+        case 0:
+            return NORTH;
+
+        case 1:
+            return SOUTH;
+
+        case 2:
+            return EAST;
+
+        case 3:
+            return WEST;
+
+        default: // impossible
+            return NORTH;
+    }
+}
+
+void game_util_move_coords(Direction direction, Coords *coords)
+{
+    switch (direction) {
+        case NORTH: {
+            if (coords->y > 0) {
+                --(coords->y);
+            }
+
+            break;
+        }
+
+        case SOUTH: {
+            ++(coords->y);  // Will rollover if you do something stupid
+            break;
+        }
+
+        case EAST: {
+            ++(coords->x);  // Will rollover if you do something stupid
+            break;
+        }
+
+        case WEST: {
+            if (coords->x > 0) {
+                --(coords->x);
+            }
+
+            break;
+        }
+
+        default: {
+            fprintf(stderr, "Warning: tried to move in an invalid direction\n");
+            return;
+        }
+    }
+}
+
+int game_util_random_colour(void)
+{
+    int r = rand() % 6;
+
+    switch (r) {
+        case 0:
+            return GREEN;
+
+        case 1:
+            return CYAN;
+
+        case 2:
+            return RED;
+
+        case 3:
+            return BLUE;
+
+        case 4:
+            return YELLOW;
+
+        case 5:
+            return MAGENTA;
+
+        default:  // impossible
+            return RED;
+    }
+}
+
+static size_t net_pack_u16(uint8_t *bytes, uint16_t v)
+{
+    bytes[0] = (v >> 8) & 0xff;
+    bytes[1] = v & 0xff;
+    return sizeof(v);
+}
+
+static size_t net_unpack_u16(const uint8_t *bytes, uint16_t *v)
+{
+    uint8_t hi = bytes[0];
+    uint8_t lo = bytes[1];
+    *v = ((uint16_t)hi << 8) | lo;
+    return sizeof(*v);
+}
+
+size_t game_util_pack_u32(uint8_t *bytes, uint32_t v)
+{
+    uint8_t *p = bytes;
+    p += net_pack_u16(p, (v >> 16) & 0xffff);
+    p += net_pack_u16(p, v & 0xffff);
+    return p - bytes;
+}
+
+size_t game_util_unpack_u32(const uint8_t *bytes, uint32_t *v)
+{
+    const uint8_t *p = bytes;
+    uint16_t hi;
+    uint16_t lo;
+    p += net_unpack_u16(p, &hi);
+    p += net_unpack_u16(p, &lo);
+    *v = ((uint32_t)hi << 16) | lo;
+    return p - bytes;
+}
+

src/game_util.h

@@ -0,0 +1,103 @@
+/*  game_util.h
+ *
+ *
+ *  Copyright (C) 2020 Toxic All Rights Reserved.
+ *
+ *  This file is part of Toxic.
+ *
+ *  Toxic 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.
+ *
+ *  Toxic 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 Toxic.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GAME_UTIL
+#define GAME_UTIL
+
+#include <stdbool.h>
+#include <time.h>
+
+typedef struct Coords {
+    int x;
+    int y;
+} Coords;
+
+// don't change these
+typedef enum Direction {
+    NORTH = 0u,
+    SOUTH = 1,
+    EAST  = 3,
+    WEST  = 4,
+    INVALID_DIRECTION = 5
+} Direction;
+
+
+/*
+ * Use these for ms and second timestamps respectively so we don't accidentally interchange them
+ */
+typedef int64_t TIME_MS;
+typedef time_t  TIME_S;
+
+
+/*
+ * Return true if coordinates x1, y1 overlap with x2, y2.
+ */
+#define COORDINATES_OVERLAP(x1, y1, x2, y2)(((x1) == (x2)) && ((y1) == (y2)))
+
+/*
+ * Halves speed if moving north or south. This accounts for the fact that Y steps are twice as large as X steps.
+ */
+#define GAME_UTIL_REAL_SPEED(dir, speed)((((dir) == (NORTH)) || ((dir) == (SOUTH))) ? (MAX(1, ((speed) / 2))) : (speed))
+
+/*
+ * Return true if dir is a valid Direction.
+ */
+#define GAME_UTIL_DIRECTION_VALID(dir)((dir) < (INVALID_DIRECTION))
+
+/*
+ * Returns cardinal direction mapped to `key`.
+ */
+Direction game_util_get_direction(int key);
+
+/*
+ * Returns the direction that will move `coords_a` closest to `coords_b`.
+ *
+ * If `inverse` is true, returns the opposite result.
+ */
+Direction game_util_move_towards(const Coords *coords_a, const Coords *coords_b, bool inverse);
+
+/*
+ * Returns a random direction.
+ */
+Direction game_util_random_direction(void);
+
+/*
+ * Moves `coords` one square towards `direction`.
+ */
+void game_util_move_coords(Direction direction, Coords *coords);
+
+/*
+ * Returns a random colour.
+ */
+int game_util_random_colour(void);
+
+/*
+ * Packs an unsigned 32 bit integer `v` into `bytes`.
+ */
+size_t game_util_pack_u32(uint8_t *bytes, uint32_t v);
+
+/*
+ * Unpacks an unsigned 32 bit integer in `bytes` to `v`.
+ */
+size_t game_util_unpack_u32(const uint8_t *bytes, uint32_t *v);
+
+#endif  // GAME_UTIL

src/global_commands.c

@@ -38,10 +38,9 @@
 #include "toxic_strings.h"
 #include "windows.h"
 
-extern char *DATA_FILE;
-extern ToxWindow *prompt;
-extern FriendsList Friends;
-extern FriendRequests FrndRequests;
+#ifdef GAMES
+#include "game_base.h"
+#endif
 
 /* command functions */
 void cmd_accept(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@@ -153,21 +152,15 @@ void cmd_add(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
         return;
     }
 
+    char msg[MAX_STR_SIZE] = {0};
+
     const char *id = argv[1];
-    char msg[MAX_STR_SIZE];
+    const size_t arg_length = strlen(id);
+    const int space_idx = char_find(0, id, ' ');
 
-    if (argc > 1) {
-        if (argv[2][0] != '\"') {
-            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Message must be enclosed in quotes.");
-            return;
-        }
-
-        /* remove opening and closing quotes */
-        char tmp[MAX_STR_SIZE];
-        snprintf(tmp, sizeof(tmp), "%s", &argv[2][1]);
-        int len = strlen(tmp) - 1;
-        tmp[len] = '\0';
-        snprintf(msg, sizeof(msg), "%s", tmp);
+    // we have to manually parse the message due to this command being a special case
+    if (space_idx > 0 && space_idx < arg_length - 1) {
+        snprintf(msg, sizeof(msg), "%s", &id[space_idx + 1]);
     } else {
         char selfname[TOX_MAX_NAME_LENGTH];
         tox_self_get_name(m, (uint8_t *) selfname);
@@ -178,36 +171,35 @@ void cmd_add(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX
     }
 
     char id_bin[TOX_ADDRESS_SIZE] = {0};
-    uint16_t id_len = (uint16_t) strlen(id);
 
-    /* try to add tox ID */
-    if (id_len == 2 * TOX_ADDRESS_SIZE) {
-        size_t i;
-        char xx[3];
-        uint32_t x;
+    const bool is_tox_id = (char_find(0, id, '@') == arg_length) && (arg_length >= TOX_ADDRESS_SIZE * 2);
 
-        for (i = 0; i < TOX_ADDRESS_SIZE; ++i) {
-            xx[0] = id[2 * i];
-            xx[1] = id[2 * i + 1];
-            xx[2] = '\0';
+    if (!is_tox_id) {
+        name_lookup(self, m, id_bin, id, msg);
+    }
 
-            if (sscanf(xx, "%02x", &x) != 1) {
-                line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Invalid Tox ID.");
-                return;
-            }
+    char xx[3];
+    uint32_t x = 0;
 
-            id_bin[i] = x;
-        }
+    for (size_t i = 0; i < TOX_ADDRESS_SIZE; ++i) {
+        xx[0] = id[2 * i];
+        xx[1] = id[2 * i + 1];
+        xx[2] = 0;
 
-        if (friend_is_blocked(id_bin)) {
-            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Friend is in your block list.");
+        if (sscanf(xx, "%02x", &x) != 1) {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Invalid Tox ID.");
             return;
         }
 
-        cmd_add_helper(self, m, id_bin, msg);
-    } else {    /* assume id is a username@domain address and do http name server lookup */
-        name_lookup(self, m, id_bin, id, msg);
+        id_bin[i] = x;
     }
+
+    if (friend_is_blocked(id_bin)) {
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Friend is in your block list.");
+        return;
+    }
+
+    cmd_add_helper(self, m, id_bin, msg);
 }
 
 void cmd_avatar(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
@@ -273,9 +265,9 @@ void cmd_connect(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
         return;
     }
 
-    char key_binary[TOX_PUBLIC_KEY_SIZE * 2 + 1];
+    char key_binary[TOX_PUBLIC_KEY_SIZE];
 
-    if (hex_string_to_bin(ascii_key, strlen(ascii_key), key_binary, TOX_PUBLIC_KEY_SIZE) == -1) {
+    if (tox_pk_string_to_bytes(ascii_key, strlen(ascii_key), key_binary, sizeof(key_binary)) == -1) {
         line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Invalid key.");
         return;
     }
@@ -340,6 +332,63 @@ void cmd_decline(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)
     --FrndRequests.num_requests;
 }
 
+#ifdef GAMES
+
+void cmd_game(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
+{
+    UNUSED_VAR(window);
+
+    if (argc < 1) {
+        game_list_print(self);
+        return;
+    }
+
+    GameType type = game_get_type(argv[1]);
+
+    if (type >= GT_Invalid) {
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Unknown game.");
+        return;
+    }
+
+    if (get_num_active_windows() >= MAX_WINDOWS_NUM) {
+        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, RED, " * Warning: Too many windows are open.");
+        return;
+    }
+
+    uint32_t id = rand();
+    int ret = game_initialize(self, m, type, id, NULL, 0);
+
+    switch (ret) {
+        case 0: {
+            break;
+        }
+
+        case -1: {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Window is too small.");
+            return;
+        }
+
+        case -2: {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Game failed to initialize: Network error.");
+            return;
+
+        }
+
+        case -3: {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0,
+                          "Game is multiplayer only. Try the command again in the chat window of the contact you wish to play with.");
+            return;
+        }
+
+        default: {
+            line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Game failed to initialize (error %d)", ret);
+            return;
+        }
+    }
+}
+
+#endif // GAMES
+
 void cmd_conference(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])
 {
     UNUSED_VAR(window);
@@ -460,7 +509,7 @@ void cmd_myid(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
     char bin_id[TOX_ADDRESS_SIZE];
     tox_self_get_address(m, (uint8_t *) bin_id);
 
-    if (bin_id_to_string(bin_id, sizeof(bin_id), id_string, sizeof(id_string)) == -1) {
+    if (tox_id_bytes_to_str(bin_id, sizeof(bin_id), id_string, sizeof(id_string)) == -1) {
         line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Failed to print ID.");
         return;
     }
@@ -477,7 +526,7 @@ void cmd_myqr(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
     char bin_id[TOX_ADDRESS_SIZE];
     tox_self_get_address(m, (uint8_t *) bin_id);
 
-    if (bin_id_to_string(bin_id, sizeof(bin_id), id_string, sizeof(id_string)) == -1) {
+    if (tox_id_bytes_to_str(bin_id, sizeof(bin_id), id_string, sizeof(id_string)) == -1) {
         line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Failed to create QR code.");
         return;
     }
@@ -595,12 +644,9 @@ void cmd_note(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MA
 {
     UNUSED_VAR(window);
 
-    if (argc < 1) {
-        line_info_add(self, false, NULL, NULL, SYS_MSG, 0, 0, "Input required.");
-        return;
-    }
+    const char *note = argc >= 1 ? argv[1] : "";
 
-    prompt_update_statusmessage(prompt, m, argv[1]);
+    prompt_update_statusmessage(prompt, m, note);
 }
 
 void cmd_nospam(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE])

src/global_commands.h

@@ -62,4 +62,8 @@ void cmd_change_video_device(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv
 void cmd_run(WINDOW *, ToxWindow *, Tox *, int argc, char (*argv)[MAX_STR_SIZE]);
 #endif /* PYTHON */
 
+#ifdef GAMES
+void cmd_game(WINDOW *window, ToxWindow *self, Tox *m, int argc, char (*argv)[MAX_STR_SIZE]);
+#endif /* GAMES */
+
 #endif /* GLOBAL_COMMANDS_H */

src/help.c

@@ -174,13 +174,17 @@ static void help_draw_global(ToxWindow *self)
     wprintw(win, "  /decline <id>              : Decline friend request\n");
     wprintw(win, "  /requests                  : List pending friend requests\n");
     wprintw(win, "  /connect <ip> <port> <key> : Manually connect to a DHT node\n");
-    wprintw(win, "  /status <type> <msg>       : Set status with optional note\n");
+    wprintw(win, "  /status <type>             : Set status (Online, Busy, Away)\n");
     wprintw(win, "  /note <msg>                : Set a personal note\n");
     wprintw(win, "  /nick <nick>               : Set your nickname\n");
     wprintw(win, "  /nospam <value>            : Change part of your Tox ID to stop spam\n");
     wprintw(win, "  /log <on> or <off>         : Enable/disable logging\n");
     wprintw(win, "  /conference <type>         : Create a conference where type: text | audio\n");
     wprintw(win, "  /myid                      : Print your Tox ID\n");
+#ifdef GAMES
+    wprintw(win, "  /game                      : Play a game\n");
+#endif /* GAMES */
+
 #ifdef QRCODE
 #ifdef QRPNG
     wprintw(win, "  /myqr <txt> or <png>       : Print your Tox ID's QR code to a file.\n");
@@ -264,6 +268,10 @@ static void help_draw_chat(ToxWindow *self)
     wprintw(win, "  /video                     : Toggle video in call\n");
 #endif /* VIDEO */
 
+#ifdef GAMES
+    wprintw(win, "  /game                      : Play a game with contact\n");
+#endif /* GAMES */
+
     help_draw_bottom_menu(win);
 
     box(win, ACS_VLINE, ACS_HLINE);
@@ -378,11 +386,11 @@ void help_onKey(ToxWindow *self, wint_t key)
 
         case L'c':
 #ifdef VIDEO
-            help_init_window(self, 25, 80);
+            help_init_window(self, 26, 80);
 #elif AUDIO
-            help_init_window(self, 20, 80);
+            help_init_window(self, 21, 80);
 #else
-            help_init_window(self, 10, 80);
+            help_init_window(self, 11, 80);
 #endif
             self->help->type = HELP_CHAT;
             break;
@@ -396,6 +404,9 @@ void help_onKey(ToxWindow *self, wint_t key)
 #endif
 #ifdef PYTHON
             height += 2;
+#endif
+#ifdef GAMES
+            height += 1;
 #endif
             help_init_window(self, height, 80);
             self->help->type = HELP_GLOBAL;

src/input.c

@@ -346,5 +346,9 @@ bool input_handle(ToxWindow *self, wint_t key, int x, int mx_x)
         }
     }
 
+    if (match) {
+        flag_interface_refresh();
+    }
+
     return match;
 }

src/line_info.c

@@ -148,9 +148,10 @@ static int print_n_chars(WINDOW *win, const char *s, size_t n, int max_y)
 
             int x;
             int y;
-            UNUSED_VAR(x);
             getyx(win, y, x);
 
+            UNUSED_VAR(x);
+
             // make sure cursor will wrap correctly after newline to prevent display bugs
             if (y + 1 >= max_y) {
                 return -1;
@@ -324,10 +325,10 @@ static void line_info_init_line(ToxWindow *self, struct line_info *line)
 {
     int y2;
     int x2;
-    UNUSED_VAR(y2);
-
     getmaxyx(self->window, y2, x2);
 
+    UNUSED_VAR(y2);
+
     const int max_y = y2 - CHATBOX_HEIGHT - WINDOW_BAR_HEIGHT;
     const int max_x = self->show_peerlist ? x2 - 1 - SIDEBAR_WIDTH : x2;
 
@@ -440,6 +441,10 @@ int line_info_add(ToxWindow *self, bool show_timestamp, const char *name1, const
     new_line->noread_flag = false;
     new_line->timestamp = get_unix_time();
 
+    if (type == OUT_MSG || type == OUT_ACTION) {
+        new_line->noread_flag = self->stb->connection == TOX_CONNECTION_NONE;
+    }
+
     line_info_init_line(self, new_line);
 
     hst->queue[hst->queue_size++] = new_line;
@@ -471,8 +476,6 @@ static void line_info_check_queue(ToxWindow *self)
     }
 }
 
-#define NOREAD_FLAG_TIMEOUT 5    /* seconds before a sent message with no read receipt is flagged as unread */
-
 void line_info_print(ToxWindow *self)
 {
     ChatContext *ctx = self->chatwin;
@@ -520,10 +523,10 @@ void line_info_print(ToxWindow *self)
     while (line && numlines++ <= max_y && print_ret == 0) {
         int y;
         int x;
-        UNUSED_VAR(y);
-
         getyx(win, y, x);
 
+        UNUSED_VAR(y);
+
         if (x > 0) { // Prevents us from printing off the screen
             break;
         }
@@ -573,12 +576,6 @@ void line_info_print(ToxWindow *self)
                     wattroff(win, COLOR_PAIR(RED));
                 }
 
-                if (type == OUT_MSG && !line->read_flag) {
-                    if (timed_out(line->timestamp, NOREAD_FLAG_TIMEOUT)) {
-                        line->noread_flag = true;
-                    }
-                }
-
                 waddch(win, '\n');
                 break;
 
@@ -598,12 +595,6 @@ void line_info_print(ToxWindow *self)
                 print_ret = print_wrap(win, line, max_x, max_y);
                 wattroff(win, COLOR_PAIR(YELLOW));
 
-                if (type == OUT_ACTION && !line->read_flag) {
-                    if (timed_out(line->timestamp, NOREAD_FLAG_TIMEOUT)) {
-                        line->noread_flag = true;
-                    }
-                }
-
                 waddch(win, '\n');
                 break;
 
@@ -709,6 +700,8 @@ void line_info_print(ToxWindow *self)
         line = line->next;
     }
 
+    flag_interface_refresh();
+
     /* keep calling until queue is empty */
     if (hst->queue_size > 0) {
         line_info_print(self);
@@ -750,6 +743,8 @@ static bool line_info_screen_fit(ToxWindow *self, struct line_info *line)
 /* puts msg in specified line_info msg buffer */
 void line_info_set(ToxWindow *self, uint32_t id, char *msg)
 {
+    flag_interface_refresh();
+
     struct line_info *line = self->chatwin->hst->line_end;
 
     while (line) {
@@ -765,6 +760,24 @@ void line_info_set(ToxWindow *self, uint32_t id, char *msg)
     }
 }
 
+/* Return the line_info object associated with `id`.
+ * Return NULL if id cannot be found
+ */
+struct line_info *line_info_get(ToxWindow *self, uint32_t id)
+{
+    struct line_info *line = self->chatwin->hst->line_end;
+
+    while (line) {
+        if (line->id == id) {
+            return line;
+        }
+
+        line = line->prev;
+    }
+
+    return NULL;
+}
+
 static void line_info_scroll_up(ToxWindow *self, struct history *hst)
 {
     if (hst->line_start->prev) {
@@ -855,6 +868,10 @@ bool line_info_onKey(ToxWindow *self, wint_t key)
         match = false;
     }
 
+    if (match) {
+        flag_interface_refresh();
+    }
+
     return match;
 }
 

src/line_info.h

@@ -96,6 +96,11 @@ void line_info_clear(struct history *hst);
 /* puts msg in specified line_info msg buffer */
 void line_info_set(ToxWindow *self, uint32_t id, char *msg);
 
+/* Return the line_info object associated with `id`.
+ * Return NULL if id cannot be found
+ */
+struct line_info *line_info_get(ToxWindow *self, uint32_t id);
+
 /* resets line_start (moves to end of chat history) */
 void line_info_reset_start(ToxWindow *self, struct history *hst);
 

src/message_queue.c

@@ -59,6 +59,7 @@ void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type,
     new_m->type = type;
     new_m->line_id = line_id;
     new_m->last_send_try = 0;
+    new_m->time_added = get_unix_time();
     new_m->receipt = -1;
     new_m->next = NULL;
 
@@ -76,23 +77,19 @@ void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type,
 /* update line to show receipt was received after queue removal */
 static void cqueue_mark_read(ToxWindow *self, struct cqueue_msg *msg)
 {
-    struct line_info *line = self->chatwin->hst->line_end;
-
-    while (line) {
-        if (line->id != msg->line_id) {
-            line = line->prev;
-            continue;
-        }
-
-        line->type = msg->type == OUT_ACTION ? OUT_ACTION_READ : OUT_MSG_READ;
-
-        if (line->noread_flag) {
-            line->noread_flag = false;
-            line->read_flag = true;
-        }
+    struct line_info *line = line_info_get(self, msg->line_id);
 
+    if (line == NULL) {
         return;
     }
+
+    line->type = msg->type == OUT_ACTION ? OUT_ACTION_READ : OUT_MSG_READ;
+
+    if (line->noread_flag) {
+        line->noread_flag = false;
+        line->read_flag = true;
+        flag_interface_refresh();
+    }
 }
 
 /* removes message with matching receipt from queue, writes to log and updates line to show the message was received. */
@@ -158,6 +155,36 @@ static void cqueue_check_timeouts(struct cqueue_msg *msg)
     }
 }
 
+/*
+ * Sets the noread flag for messages sent to the peer associated with `self` which have not
+ * received a receipt after a period of time.
+ */
+#define NOREAD_TIMEOUT 5
+void cqueue_check_unread(ToxWindow *self)
+{
+    struct chat_queue *q = self->chatwin->cqueue;
+    struct cqueue_msg *msg = q->root;
+
+    while (msg) {
+        if (msg->noread_flag) {
+            msg = msg->next;
+            continue;
+        }
+
+        struct line_info *line = line_info_get(self, msg->line_id);
+
+        if (line != NULL) {
+            if (timed_out(msg->time_added, NOREAD_TIMEOUT)) {
+                line->noread_flag = true;
+                msg->noread_flag = true;
+                flag_interface_refresh();
+            }
+        }
+
+        msg = msg->next;
+    }
+}
+
 /*
  * Tries to send all messages in the send queue in sequential order.
  * If a message fails to send the function will immediately return.

src/message_queue.h

@@ -28,8 +28,10 @@ struct cqueue_msg {
     size_t len;
     int line_id;
     time_t last_send_try;
+    time_t time_added;
     uint8_t type;
     int64_t receipt;
+    bool noread_flag;
     struct cqueue_msg *next;
     struct cqueue_msg *prev;
 };
@@ -48,6 +50,12 @@ void cqueue_add(struct chat_queue *q, const char *msg, size_t len, uint8_t type,
  */
 void cqueue_try_send(ToxWindow *self, Tox *m);
 
+/*
+ * Sets the noread flag for messages sent to the peer associated with `self` which have not
+ * received a receipt after a period of time.
+ */
+void cqueue_check_unread(ToxWindow *self);
+
 /* removes message with matching receipt from queue, writes to log and updates line to show the message was received. */
 void cqueue_remove(ToxWindow *self, Tox *m, uint32_t receipt);
 

src/misc_tools.c

@@ -137,15 +137,18 @@ void get_elapsed_time_str(char *buf, int bufsize, time_t secs)
 }
 
 /*
- * Converts a hexidecimal string of length hex_len to binary format and puts the result in output.
- * output_size must be exactly half of hex_len.
+ * Converts a hexidecimal string representation of a Tox public key to binary format and puts
+ * the result in output.
+ *
+ * `hex_len` must be exactly TOX_PUBLIC_KEY_SIZE * 2, and `output_size` must have room
+ * for TOX_PUBLIC_KEY_SIZE bytes.
  *
  * Returns 0 on success.
  * Returns -1 on failure.
  */
-int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size_t output_size)
+int tox_pk_string_to_bytes(const char *hex_string, size_t hex_len, char *output, size_t output_size)
 {
-    if (output_size == 0 || hex_len != output_size * 2) {
+    if (output_size != TOX_PUBLIC_KEY_SIZE || hex_len != output_size * 2) {
         return -1;
     }
 
@@ -157,6 +160,11 @@ int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size
     return 0;
 }
 
+/* Convert a hexadecimcal string of length `size` to bytes and puts the result in `keystr`.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
 int hex_string_to_bytes(char *buf, int size, const char *keystr)
 {
     if (size % 2 != 0) {
@@ -178,11 +186,14 @@ int hex_string_to_bytes(char *buf, int size, const char *keystr)
 }
 
 /* Converts a binary representation of a Tox ID into a string.
+ *
+ * `bin_id_size` must be exactly TOX_ADDRESS_SIZE bytes in length, and
+ * `output_size` must be at least TOX_ADDRESS_SIZE * 2 + 1.
  *
  * Returns 0 on success.
  * Returns -1 on failure.
  */
-int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_t output_size)
+int tox_id_bytes_to_str(const char *bin_id, size_t bin_id_size, char *output, size_t output_size)
 {
     if (bin_id_size != TOX_ADDRESS_SIZE || output_size < (TOX_ADDRESS_SIZE * 2 + 1)) {
         return -1;
@@ -196,11 +207,14 @@ int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_
 }
 
 /* Converts a binary representation of a Tox public key into a string.
+ *
+ * `bin_pubkey_size` must be exactly TOX_PUBLIC_KEY_SIZE bytes in size, and
+ * `output_size` must be at least TOX_PUBLIC_KEY_SIZE * 2 + 1.
  *
  * Returns 0 on success.
  * Returns -1 on failure.
  */
-int bin_pubkey_to_string(const uint8_t *bin_pubkey, size_t bin_pubkey_size, char *output, size_t output_size)
+int tox_pk_bytes_to_str(const uint8_t *bin_pubkey, size_t bin_pubkey_size, char *output, size_t output_size)
 {
     if (bin_pubkey_size != TOX_PUBLIC_KEY_SIZE || output_size < (TOX_PUBLIC_KEY_SIZE * 2 + 1)) {
         return -1;
@@ -274,7 +288,7 @@ int qsort_strcasecmp_hlpr(const void *str1, const void *str2)
 /* case-insensitive string compare function for use with qsort */
 int qsort_ptr_char_array_helper(const void *str1, const void *str2)
 {
-    return strcasecmp(*(char **)str1, *(char **)str2);
+    return strcasecmp(*(const char *const *)str1, *(const char *const *)str2);
 }
 
 static const char invalid_chars[] = {'/', '\n', '\t', '\v', '\r', '\0'};

src/misc_tools.h

@@ -53,30 +53,43 @@ void clear_screen(void);
 void hst_to_net(uint8_t *num, uint16_t numbytes);
 
 /*
- * Converts a hexidecimal string of length hex_len to binary format and puts the result in output.
- * output_size must be exactly half of hex_len.
+ * Converts a hexidecimal string representation of a Tox public key to binary format and puts
+ * the result in output.
+ *
+ * `hex_len` must be exactly TOX_PUBLIC_KEY_SIZE * 2, and `output_size` must have room
+ * for TOX_PUBLIC_KEY_SIZE bytes.
  *
  * Returns 0 on success.
  * Returns -1 on failure.
  */
-int hex_string_to_bin(const char *hex_string, size_t hex_len, char *output, size_t output_size);
+int tox_pk_string_to_bytes(const char *hex_string, size_t hex_len, char *output, size_t output_size);
 
-/* convert a hex string to bytes. returns 0 on success, -1 on failure */
+/* Converts a binary representation of a Tox public key into a string.
+ *
+ * `bin_pubkey_size` must be exactly TOX_PUBLIC_KEY_SIZE bytes in size, and
+ * `output_size` must be at least TOX_PUBLIC_KEY_SIZE * 2 + 1.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
+int tox_pk_bytes_to_str(const uint8_t *bin_pubkey, size_t bin_pubkey_size, char *output, size_t output_size);
+
+/* Convert a hexadecimcal string of length `size` to bytes and puts the result in `keystr`.
+ *
+ * Returns 0 on success.
+ * Returns -1 on failure.
+ */
 int hex_string_to_bytes(char *buf, int size, const char *keystr);
 
 /* Converts a binary representation of a Tox ID into a string.
  *
- * Returns 0 on success.
- * Returns -1 on failure.
- */
-int bin_id_to_string(const char *bin_id, size_t bin_id_size, char *output, size_t output_size);
-
-/* Converts a binary representation of a Tox public key into a string.
+ * `bin_id_size` must be exactly TOX_ADDRESS_SIZE bytes in length, and
+ * `output_size` must be at least TOX_ADDRESS_SIZE * 2 + 1.
  *
  * Returns 0 on success.
  * Returns -1 on failure.
  */
-int bin_pubkey_to_string(const uint8_t *bin_pubkey, size_t bin_pubkey_size, char *output, size_t output_size);
+int tox_id_bytes_to_str(const char *bin_id, size_t bin_id_size, char *output, size_t output_size);
 
 /* get the current unix time (not thread safe) */
 time_t get_unix_time(void);

src/name_lookup.c

@@ -33,9 +33,6 @@
 #include "toxic.h"
 #include "windows.h"
 
-extern struct arg_opts arg_opts;
-extern struct Winthread Winthread;
-
 #define NAMESERVER_API_PATH "api"
 #define SERVER_KEY_SIZE 32
 #define MAX_SERVERS 50
@@ -111,14 +108,15 @@ static int load_nameserver_list(const char *path)
     char line[MAX_SERVER_LINE];
 
     while (fgets(line, sizeof(line), fp) && Nameservers.lines < MAX_SERVERS) {
-        int linelen = strlen(line);
+        size_t linelen = strlen(line);
 
         if (linelen < SERVER_KEY_SIZE * 2 + 5) {
             continue;
         }
 
         if (line[linelen - 1] == '\n') {
-            line[--linelen] = '\0';
+            --linelen;
+            line[linelen] = '\0';
         }
 
         const char *name = strtok(line, " ");
@@ -132,8 +130,10 @@ static int load_nameserver_list(const char *path)
             continue;
         }
 
-        snprintf(Nameservers.names[Nameservers.lines], sizeof(Nameservers.names[Nameservers.lines]), "%s", name);
-        int res = hex_string_to_bytes(Nameservers.keys[Nameservers.lines], SERVER_KEY_SIZE, keystr);
+        const size_t idx = Nameservers.lines;
+        snprintf(Nameservers.names[idx], sizeof(Nameservers.names[idx]), "%s", name);
+
+        int res = hex_string_to_bytes(Nameservers.keys[idx], SERVER_KEY_SIZE, keystr);
 
         if (res == -1) {
             continue;
@@ -231,7 +231,7 @@ static int process_response(struct Recv_Curl_Data *recv_data)
     memcpy(ID_string, IDstart + prefix_size, TOX_ADDRESS_SIZE * 2);
     ID_string[TOX_ADDRESS_SIZE * 2] = 0;
 
-    if (hex_string_to_bin(ID_string, strlen(ID_string), t_data.id_bin, sizeof(t_data.id_bin)) == -1) {
+    if (tox_pk_string_to_bytes(ID_string, strlen(ID_string), t_data.id_bin, sizeof(t_data.id_bin)) == -1) {
         return -1;
     }
 

src/notify.c

@@ -318,7 +318,7 @@ void *do_playing(void *_p)
         has_looping = false;
 
         control_unlock();
-        sleep_thread(10000L);
+        sleep_thread(100000L);
     }
 
     pthread_exit(NULL);
@@ -489,16 +489,27 @@ void terminate_notify(void)
 }
 
 #ifdef SOUND_NOTIFY
-int set_sound(Notification sound, const char *value)
+
+/*
+ * Sets notification sound designated by `sound` to file path `value`.
+ *
+ * Return true if the sound is successfully set.
+ */
+bool set_sound(Notification sound, const char *value)
 {
     if (sound == silent) {
-        return 0;
+        return false;
     }
 
     free(Control.sounds[sound]);
 
     size_t len = strlen(value) + 1;
     Control.sounds[sound] = calloc(len, 1);
+
+    if (Control.sounds[sound] == NULL) {
+        return false;
+    }
+
     memcpy(Control.sounds[sound], value, len);
 
     struct stat buf;

src/notify.h

@@ -77,7 +77,7 @@ int box_silent_notify(ToxWindow *self, uint64_t flags, int *id_indicator, const
 int box_silent_notify2(ToxWindow *self, uint64_t flags, int id, const char *format, ...);
 
 #ifdef SOUND_NOTIFY
-int set_sound(Notification sound, const char *value);
+bool set_sound(Notification sound, const char *value);
 #endif /* SOUND_NOTIFY */
 
 #endif /* NOTIFY_H */

src/prompt.c

@@ -60,6 +60,9 @@ static const char *glob_cmd_list[] = {
     "/decline",
     "/exit",
     "/conference",
+#ifdef GAMES
+    "/game",
+#endif
     "/help",
     "/log",
     "/myid",
@@ -122,6 +125,8 @@ void on_self_connection_status(Tox *m, Tox_Connection connection_status, void *u
     UNUSED_VAR(userdata);
     StatusBar *statusbar = prompt->stb;
     statusbar->connection = connection_status;
+
+    flag_interface_refresh();
 }
 
 /* Updates own nick in prompt statusbar */
@@ -335,24 +340,50 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
     Tox_User_Status status = statusbar->status;
     pthread_mutex_unlock(&Winthread.lock);
 
-    if (connection != TOX_CONNECTION_NONE) {
+    wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
+    wprintw(statusbar->topline, " [");
+    wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
+
+    switch (connection) {
+        case TOX_CONNECTION_TCP:
+            wattron(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            wprintw(statusbar->topline, "TCP");
+            wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            break;
+
+        case TOX_CONNECTION_UDP:
+            wattron(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            wprintw(statusbar->topline, "UDP");
+            wattroff(statusbar->topline, A_BOLD | COLOR_PAIR(STATUS_ONLINE));
+            break;
+
+        default:
+            wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
+            wprintw(statusbar->topline, "Offline");
+            wattroff(statusbar->topline, COLOR_PAIR(BAR_TEXT));
+            break;
+    }
+
+    wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
+    wprintw(statusbar->topline, "]");
+    wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
+
+    if (status != TOX_USER_STATUS_NONE) {
         int colour = MAGENTA;
         const char *status_text = "ERROR";
 
         switch (status) {
-            case TOX_USER_STATUS_NONE:
-                status_text = "Online";
-                colour = STATUS_ONLINE;
-                break;
-
             case TOX_USER_STATUS_AWAY:
-                status_text = "Away";
                 colour = STATUS_AWAY;
+                status_text = "Away";
                 break;
 
             case TOX_USER_STATUS_BUSY:
-                status_text = "Busy";
                 colour = STATUS_BUSY;
+                status_text = "Busy";
+                break;
+
+            default:
                 break;
         }
 
@@ -374,18 +405,6 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
         wprintw(statusbar->topline, " %s", statusbar->nick);
         pthread_mutex_unlock(&Winthread.lock);
     } else {
-        wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-        wprintw(statusbar->topline, " [");
-        wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-
-        wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
-        wprintw(statusbar->topline, "Offline");
-        wattroff(statusbar->topline, COLOR_PAIR(BAR_TEXT));
-
-        wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-        wprintw(statusbar->topline, "]");
-        wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
-
         wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
 
         pthread_mutex_lock(&Winthread.lock);
@@ -405,11 +424,14 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
         char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH];
 
         pthread_mutex_lock(&Winthread.lock);
+
         size_t slen = tox_self_get_status_message_size(m);
         tox_self_get_status_message(m, (uint8_t *) statusmsg);
+
         statusmsg[slen] = '\0';
         snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
         statusbar->statusmsg_len = strlen(statusbar->statusmsg);
+
         pthread_mutex_unlock(&Winthread.lock);
     }
 
@@ -419,25 +441,29 @@ static void prompt_onDraw(ToxWindow *self, Tox *m)
     uint16_t maxlen = x2 - getcurx(statusbar->topline) - 3;
 
     pthread_mutex_lock(&Winthread.lock);
+    size_t statusmsg_len = statusbar->statusmsg_len;
+    pthread_mutex_unlock(&Winthread.lock);
 
-    if (statusbar->statusmsg_len > maxlen) {
-        statusbar->statusmsg[maxlen - 3] = '\0';
+    if (statusmsg_len > maxlen) {
+        pthread_mutex_lock(&Winthread.lock);
+        statusbar->statusmsg[maxlen - 3] = 0;
         strcat(statusbar->statusmsg, "...");
         statusbar->statusmsg_len = maxlen;
+        pthread_mutex_unlock(&Winthread.lock);
     }
 
-    if (statusbar->statusmsg[0]) {
+    if (statusmsg_len) {
         wattron(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
         wprintw(statusbar->topline, " | ");
         wattroff(statusbar->topline, COLOR_PAIR(BAR_ACCENT));
 
         wattron(statusbar->topline, COLOR_PAIR(BAR_TEXT));
+        pthread_mutex_lock(&Winthread.lock);
         wprintw(statusbar->topline, "%s", statusbar->statusmsg);
+        pthread_mutex_unlock(&Winthread.lock);
         wattroff(statusbar->topline, COLOR_PAIR(BAR_TEXT));
     }
 
-    pthread_mutex_unlock(&Winthread.lock);
-
     int y;
     int x;
     getyx(self->window, y, x);

src/prompt.h

@@ -40,6 +40,9 @@ typedef struct FriendRequests {
     struct friend_request request[MAX_FRIEND_REQUESTS];
 } FriendRequests;
 
+extern ToxWindow *prompt;
+extern FriendRequests FrndRequests;
+
 ToxWindow *new_prompt(void);
 
 void prep_prompt_win(void);

src/settings.h

@@ -32,7 +32,7 @@
 
 #define PASSWORD_EVAL_MAX 512
 
-/* holds user setting values */
+/* Holds user setting values defined in the toxic config file. */
 struct user_settings {
     int autolog;           /* boolean */
     int alerts;            /* boolean */
@@ -96,6 +96,8 @@ struct user_settings {
 #endif
 };
 
+extern struct user_settings *user_settings;
+
 enum settings_values {
     AUTOLOG_OFF = 0,
     AUTOLOG_ON = 1,

src/toxic.c

@@ -74,7 +74,7 @@
 #ifdef VIDEO
 #include "video_call.h"
 #endif /* VIDEO */
-ToxAV *av;
+static ToxAV *av;
 #endif /* AUDIO */
 
 #ifdef PYTHON
@@ -98,9 +98,15 @@ ToxWindow *prompt = NULL;
 #define MAX_PASSWORD_LEN 64
 
 struct Winthread Winthread;
-struct cqueue_thread cqueue_thread;
-struct av_thread av_thread;
+static struct cqueue_thread cqueue_thread;
 struct arg_opts arg_opts;
+
+#ifdef AUDIO
+static struct av_thread av_thread;
+#endif
+
+// This struct is not thread safe. It should only ever be written to from the main thread
+// before any other thread that uses it is initialized.
 struct user_settings *user_settings = NULL;
 
 static struct user_password {
@@ -239,6 +245,12 @@ void cb_toxcore_logger(Tox *m, TOX_LOG_LEVEL level, const char *file, uint32_t l
     }
 }
 
+/* Sets ncurses refresh rate. Lower values make it refresh more often. */
+void set_window_refresh_rate(size_t refresh_rate)
+{
+    timeout(refresh_rate);
+}
+
 static void init_term(void)
 {
 #if HAVE_WIDECHAR
@@ -256,7 +268,7 @@ static void init_term(void)
     keypad(stdscr, 1);
     noecho();
     nonl();
-    timeout(50);
+    set_window_refresh_rate(NCURSES_DEFAULT_REFRESH_RATE);
 
     if (has_colors()) {
         short bg_color = COLOR_BLACK;
@@ -376,11 +388,14 @@ static void init_term(void)
         init_pair(YELLOW, COLOR_YELLOW, bg_color);
         init_pair(MAGENTA, COLOR_MAGENTA, bg_color);
         init_pair(BLACK, COLOR_BLACK, COLOR_BLACK);
-        init_pair(BLUE_BLACK, COLOR_BLUE, COLOR_BLACK);
+        init_pair(WHITE_BLUE, COLOR_WHITE, COLOR_BLUE);
         init_pair(BLACK_WHITE, COLOR_BLACK, COLOR_WHITE);
+        init_pair(WHITE_BLACK, COLOR_WHITE, COLOR_BLACK);
+        init_pair(WHITE_GREEN, COLOR_WHITE, COLOR_GREEN);
         init_pair(BLACK_BG, COLOR_BLACK, bar_bg_color);
         init_pair(PURPLE_BG, COLOR_MAGENTA, bar_bg_color);
         init_pair(BAR_TEXT, bar_fg_color, bar_bg_color);
+        init_pair(BAR_SOLID, bar_bg_color, bar_bg_color);
         init_pair(BAR_ACCENT, bar_accent_color, bar_bg_color);
         init_pair(BAR_NOTIFY, bar_notify_color, bar_bg_color);
         init_pair(STATUS_ONLINE, COLOR_GREEN, bar_bg_color);
@@ -432,9 +447,7 @@ static void cleanup_init_messages(void)
         return;
     }
 
-    int i;
-
-    for (i = 0; i < init_messages.num; ++i) {
+    for (int i = 0; i < init_messages.num; ++i) {
         free(init_messages.msgs[i]);
     }
 
@@ -443,19 +456,16 @@ static void cleanup_init_messages(void)
 
 static void print_init_messages(ToxWindow *toxwin)
 {
-    int i;
-
-    for (i = 0; i < init_messages.num; ++i) {
+    for (int i = 0; i < init_messages.num; ++i) {
         line_info_add(toxwin, NULL, NULL, NULL, SYS_MSG, 0, 0, init_messages.msgs[i]);
     }
 }
 
 static void load_friendlist(Tox *m)
 {
-    size_t i;
     size_t numfriends = tox_self_get_friend_list_size(m);
 
-    for (i = 0; i < numfriends; ++i) {
+    for (size_t i = 0; i < numfriends; ++i) {
         friendlist_onFriendAdded(NULL, m, i, false);
     }
 
@@ -804,6 +814,7 @@ static void init_tox_callbacks(Tox *m)
     tox_callback_file_chunk_request(m, on_file_chunk_request);
     tox_callback_file_recv_control(m, on_file_recv_control);
     tox_callback_file_recv_chunk(m, on_file_recv_chunk);
+    tox_callback_friend_lossless_packet(m, on_lossless_custom_packet);
 }
 
 static void init_tox_options(struct Tox_Options *tox_opts)
@@ -1068,6 +1079,37 @@ static void do_toxic(Tox *m)
     pthread_mutex_unlock(&Winthread.lock);
 }
 
+/* Set interface refresh flag. This should be called whenever the interface changes.
+ *
+ * This function is not thread safe.
+ */
+void flag_interface_refresh(void)
+{
+    Winthread.flag_refresh = 1;
+    Winthread.last_refresh_flag = get_unix_time();
+}
+
+/* How long we wait to idle interface refreshing after last flag set. Should be no less than 2. */
+#define ACTIVE_WIN_REFRESH_TIMEOUT 2
+
+static void poll_interface_refresh_flag(void)
+{
+    pthread_mutex_lock(&Winthread.lock);
+
+    bool flag = Winthread.flag_refresh;
+    time_t t = Winthread.last_refresh_flag;
+
+    pthread_mutex_unlock(&Winthread.lock);
+
+    if (flag == 1 && timed_out(t, ACTIVE_WIN_REFRESH_TIMEOUT)) {
+        pthread_mutex_lock(&Winthread.lock);
+        Winthread.flag_refresh = 0;
+        pthread_mutex_unlock(&Winthread.lock);
+    }
+}
+
+
+/* How often we refresh windows that aren't focused */
 #define INACTIVE_WIN_REFRESH_RATE 10
 
 void *thread_winref(void *data)
@@ -1075,11 +1117,12 @@ void *thread_winref(void *data)
     Tox *m = (Tox *) data;
 
     uint8_t draw_count = 0;
+
     init_signal_catchers();
 
     while (true) {
-        draw_active_window(m);
         draw_count++;
+        draw_active_window(m);
 
         if (Winthread.flag_resize) {
             on_window_resize();
@@ -1093,6 +1136,8 @@ void *thread_winref(void *data)
             pthread_mutex_lock(&Winthread.lock);
             exit_toxic_success(m);
         }
+
+        poll_interface_refresh_flag();
     }
 }
 
@@ -1106,9 +1151,12 @@ void *thread_cqueue(void *data)
         for (size_t i = 2; i < MAX_WINDOWS_NUM; ++i) {
             ToxWindow *toxwin = get_window_ptr(i);
 
-            if ((toxwin != NULL) && (toxwin->type == WINDOW_TYPE_CHAT)
-                    && (get_friend_connection_status(toxwin->num) != TOX_CONNECTION_NONE)) {
-                cqueue_try_send(toxwin, m);
+            if ((toxwin != NULL) && (toxwin->type == WINDOW_TYPE_CHAT)) {
+                cqueue_check_unread(toxwin);
+
+                if (get_friend_connection_status(toxwin->num) != TOX_CONNECTION_NONE) {
+                    cqueue_try_send(toxwin, m);
+                }
             }
         }
 
@@ -1200,21 +1248,23 @@ static void parse_args(int argc, char *argv[])
     };
 
     const char *opts_str = "4bdehLotuxvc:f:l:n:r:p:P:T:";
-    int opt, indexptr;
-    long int port = 0;
+    int opt = 0;
+    int indexptr = 0;
 
     while ((opt = getopt_long(argc, argv, opts_str, long_opts, &indexptr)) != -1) {
         switch (opt) {
-            case '4':
+            case '4': {
                 arg_opts.use_ipv4 = 1;
                 break;
+            }
 
-            case 'b':
+            case 'b': {
                 arg_opts.debug = 1;
                 queue_init_message("stderr enabled");
                 break;
+            }
 
-            case 'c':
+            case 'c': {
                 if (optarg == NULL) {
                     queue_init_message("Invalid argument for option: %d", opt);
                     break;
@@ -1227,17 +1277,20 @@ static void parse_args(int argc, char *argv[])
                 }
 
                 break;
+            }
 
-            case 'd':
+            case 'd': {
                 arg_opts.default_locale = 1;
                 queue_init_message("Using default POSIX locale");
                 break;
+            }
 
-            case 'e':
+            case 'e': {
                 arg_opts.encrypt_data = 1;
                 break;
+            }
 
-            case 'f':
+            case 'f': {
                 if (optarg == NULL) {
                     queue_init_message("Invalid argument for option: %d", opt);
                     break;
@@ -1275,8 +1328,9 @@ static void parse_args(int argc, char *argv[])
                 queue_init_message("Using '%s' data file", DATA_FILE);
 
                 break;
+            }
 
-            case 'l':
+            case 'l': {
                 if (optarg) {
                     arg_opts.logging = true;
 
@@ -1296,13 +1350,15 @@ static void parse_args(int argc, char *argv[])
                 }
 
                 break;
+            }
 
-            case 'L':
+            case 'L': {
                 arg_opts.disable_local_discovery = 1;
                 queue_init_message("Local discovery disabled");
                 break;
+            }
 
-            case 'n':
+            case 'n': {
                 if (optarg == NULL) {
                     queue_init_message("Invalid argument for option: %d", opt);
                     break;
@@ -1310,48 +1366,38 @@ static void parse_args(int argc, char *argv[])
 
                 snprintf(arg_opts.nodes_path, sizeof(arg_opts.nodes_path), "%s", optarg);
                 break;
+            }
 
-            case 'o':
+            case 'o': {
                 arg_opts.no_connect = 1;
                 queue_init_message("DHT disabled");
                 break;
+            }
 
-            case 'p':
-                if (optarg == NULL) {
-                    queue_init_message("Invalid argument for option: %d", opt);
-                    break;
-                }
-
+            case 'p': {
                 arg_opts.proxy_type = TOX_PROXY_TYPE_SOCKS5;
-                snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);
+            }
 
-                if (++optind > argc || argv[optind - 1][0] == '-') {
-                    exit_toxic_err("Proxy error", FATALERR_PROXY);
-                }
+            // Intentional fallthrough
 
-                port = strtol(argv[optind - 1], NULL, 10);
-
-                if (port <= 0 || port > MAX_PORT_RANGE) {
-                    exit_toxic_err("Proxy error", FATALERR_PROXY);
-                }
-
-                arg_opts.proxy_port = port;
-                break;
-
-            case 'P':
+            case 'P': {
                 if (optarg == NULL) {
                     queue_init_message("Invalid argument for option: %d", opt);
+                    arg_opts.proxy_type = TOX_PROXY_TYPE_NONE;
                     break;
                 }
 
-                arg_opts.proxy_type = TOX_PROXY_TYPE_HTTP;
+                if (arg_opts.proxy_type == TOX_PROXY_TYPE_NONE) {
+                    arg_opts.proxy_type = TOX_PROXY_TYPE_HTTP;
+                }
+
                 snprintf(arg_opts.proxy_address, sizeof(arg_opts.proxy_address), "%s", optarg);
 
                 if (++optind > argc || argv[optind - 1][0] == '-') {
                     exit_toxic_err("Proxy error", FATALERR_PROXY);
                 }
 
-                port = strtol(argv[optind - 1], NULL, 10);
+                long int port = strtol(argv[optind - 1], NULL, 10);
 
                 if (port <= 0 || port > MAX_PORT_RANGE) {
                     exit_toxic_err("Proxy error", FATALERR_PROXY);
@@ -1359,8 +1405,9 @@ static void parse_args(int argc, char *argv[])
 
                 arg_opts.proxy_port = port;
                 break;
+            }
 
-            case 'r':
+            case 'r': {
                 if (optarg == NULL) {
                     queue_init_message("Invalid argument for option: %d", opt);
                     break;
@@ -1373,18 +1420,20 @@ static void parse_args(int argc, char *argv[])
                 }
 
                 break;
+            }
 
-            case 't':
+            case 't': {
                 arg_opts.force_tcp = 1;
                 break;
+            }
 
-            case 'T':
+            case 'T': {
                 if (optarg == NULL) {
                     queue_init_message("Invalid argument for option: %d", opt);
                     break;
                 }
 
-                port = strtol(optarg, NULL, 10);
+                long int port = strtol(optarg, NULL, 10);
 
                 if (port <= 0 || port > MAX_PORT_RANGE) {
                     port = MAX_PORT_RANGE;
@@ -1392,21 +1441,25 @@ static void parse_args(int argc, char *argv[])
 
                 arg_opts.tcp_port = port;
                 break;
+            }
 
-            case 'u':
+            case 'u': {
                 arg_opts.unencrypt_data = 1;
                 break;
+            }
 
-            case 'v':
+            case 'v': {
                 print_version();
                 exit(EXIT_SUCCESS);
+            }
 
             case 'h':
 
             // Intentional fallthrough
-            default:
+            default: {
                 print_usage();
                 exit(EXIT_SUCCESS);
+            }
         }
     }
 }
@@ -1461,6 +1514,8 @@ int main(int argc, char **argv)
     /* Make sure all written files are read/writeable only by the current user. */
     umask(S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
 
+    srand(time(NULL)); // We use rand() for trivial/non-security related things
+
     parse_args(argc, argv);
 
     /* Use the -b flag to enable stderr */
@@ -1593,6 +1648,7 @@ int main(int argc, char **argv)
 
     pthread_mutex_lock(&Winthread.lock);
     print_init_messages(prompt);
+    flag_interface_refresh();
     pthread_mutex_unlock(&Winthread.lock);
 
     cleanup_init_messages();

src/toxic.h

@@ -50,6 +50,9 @@
 #define TIME_STR_SIZE 32
 #define COLOR_STR_SIZE 10 /* should fit every color option */
 
+#define NCURSES_DEFAULT_REFRESH_RATE 100
+#define NCURSES_GAME_REFRESH_RATE 25
+
 #ifndef MAX_PORT_RANGE
 #define MAX_PORT_RANGE 65535
 #endif
@@ -102,6 +105,11 @@ typedef enum _FATAL_ERRS {
 void lock_status(void);
 void unlock_status(void);
 
+void flag_interface_refresh(void);
+
+/* Sets ncurses refresh rate. Lower values make it refresh more often. */
+void set_window_refresh_rate(size_t refresh_rate);
+
 void exit_toxic_success(Tox *m);
 void exit_toxic_err(const char *errmsg, int errcode);
 
@@ -135,5 +143,9 @@ void on_file_recv(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint32_t k
                   const uint8_t *filename, size_t filename_length, void *userdata);
 void on_friend_typing(Tox *m, uint32_t friendnumber, bool is_typing, void *userdata);
 void on_friend_read_receipt(Tox *m, uint32_t friendnumber, uint32_t receipt, void *userdata);
+void on_lossless_custom_packet(Tox *m, uint32_t friendnumber, const uint8_t *data, size_t length, void *userdata);
+
+extern char *DATA_FILE;
+extern char *BLOCK_FILE;
 
 #endif /* TOXIC_H */

src/video_device.c

@@ -92,21 +92,21 @@ typedef struct VideoDevice {
 
 } VideoDevice;
 
-const char *dvideo_device_names[2];              /* Default device */
-const char *video_devices_names[2][MAX_DEVICES]; /* Container of available devices */
-static int size[2];                        /* Size of above containers */
-VideoDevice *video_devices_running[2][MAX_DEVICES] = {{NULL}};     /* Running devices */
-uint32_t primary_video_device[2];          /* Primary device */
+static const char *dvideo_device_names[2];        /* Default device */
+static char *video_devices_names[2][MAX_DEVICES]; /* Container of available devices */
+static int size[2];                               /* Size of above containers */
+static VideoDevice *video_devices_running[2][MAX_DEVICES] = {{NULL}}; /* Running devices */
+static uint32_t primary_video_device[2];                              /* Primary device */
 
 static ToxAV *av = NULL;
 
 /* q_mutex */
 #define lock pthread_mutex_lock(&video_mutex)
 #define unlock pthread_mutex_unlock(&video_mutex)
-pthread_mutex_t video_mutex;
+static pthread_mutex_t video_mutex;
 
-bool video_thread_running = true,
-     video_thread_paused = true;                /* Thread control */
+static bool video_thread_running = true;
+static bool video_thread_paused = true;                /* Thread control */
 
 void *video_thread_poll(void *);
 
@@ -187,7 +187,7 @@ VideoDeviceError init_video_devices(void)
 
 #if defined(__OSX__) || defined(__APPLE__)
 
-    if (osx_video_init((char **)video_devices_names[vdt_input], &size[vdt_input]) != 0) {
+    if (osx_video_init(&video_devices_names[vdt_input][0], &size[vdt_input]) != 0) {
         return vde_InternalError;
     }
 
@@ -209,12 +209,24 @@ VideoDeviceError init_video_devices(void)
             /* Query V4L for capture capabilities */
             if (-1 != ioctl(fd, VIDIOC_QUERYCAP, &cap)) {
                 video_input_name = (char *)malloc(strlen((const char *)cap.card) + strlen(device_address) + 4);
+
+                if (video_input_name == NULL) {
+                    close(fd);
+                    return vde_InternalError;
+                }
+
                 strcpy(video_input_name, (char *)cap.card);
                 strcat(video_input_name, " (");
                 strcat(video_input_name, (char *)device_address);
                 strcat(video_input_name, ")");
             } else {
                 video_input_name = (char *)malloc(strlen(device_address) + 3);
+
+                if (video_input_name == NULL) {
+                    close(fd);
+                    return vde_InternalError;
+                }
+
                 strcpy(video_input_name, "(");
                 strcat(video_input_name, device_address);
                 strcat(video_input_name, ")");
@@ -229,6 +241,9 @@ VideoDeviceError init_video_devices(void)
 #endif
 
     size[vdt_output] = 1;
+    // TODO(iphydf): String literals are const char *. This may need to be
+    // copied, or if we're not owning any output device names, it should be
+    // const and video_devices_names needs to be split.
     char *video_output_name = "Toxic Video Receiver";
     video_devices_names[vdt_output][0] = video_output_name;
 
@@ -262,7 +277,7 @@ VideoDeviceError terminate_video_devices(void)
     int i;
 
     for (i = 0; i < size[vdt_input]; ++i) {
-        free((void *)video_devices_names[vdt_input][i]);
+        free(video_devices_names[vdt_input][i]);
     }
 
     if (pthread_mutex_destroy(&video_mutex) != 0) {

src/windows.c

@@ -37,16 +37,14 @@
 #include "toxic.h"
 #include "windows.h"
 
-extern char *DATA_FILE;
-extern struct Winthread Winthread;
+#ifdef GAMES
+#include "game_base.h"
+#endif
 
 ToxWindow *windows[MAX_WINDOWS_NUM];
 static uint8_t active_window_index;
 static int num_active_windows;
 
-extern ToxWindow *prompt;
-extern struct user_settings *user_settings;
-
 /* CALLBACKS START */
 void on_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata)
 {
@@ -73,6 +71,8 @@ void on_friend_connection_status(Tox *m, uint32_t friendnumber, Tox_Connection c
             windows[i]->onConnectionChange(windows[i], m, friendnumber, connection_status);
         }
     }
+
+    flag_interface_refresh();
 }
 
 void on_friend_typing(Tox *m, uint32_t friendnumber, bool is_typing, void *userdata)
@@ -88,6 +88,8 @@ void on_friend_typing(Tox *m, uint32_t friendnumber, bool is_typing, void *userd
             windows[i]->onTypingChange(windows[i], m, friendnumber, is_typing);
         }
     }
+
+    flag_interface_refresh();
 }
 
 void on_friend_message(Tox *m, uint32_t friendnumber, Tox_Message_Type type, const uint8_t *string, size_t length,
@@ -119,6 +121,8 @@ void on_friend_name(Tox *m, uint32_t friendnumber, const uint8_t *string, size_t
         }
     }
 
+    flag_interface_refresh();
+
     store_data(m, DATA_FILE);
 }
 
@@ -136,6 +140,8 @@ void on_friend_status_message(Tox *m, uint32_t friendnumber, const uint8_t *stri
             windows[i]->onStatusMessageChange(windows[i], friendnumber, msg, length);
         }
     }
+
+    flag_interface_refresh();
 }
 
 void on_friend_status(Tox *m, uint32_t friendnumber, Tox_User_Status status, void *userdata)
@@ -147,6 +153,8 @@ void on_friend_status(Tox *m, uint32_t friendnumber, Tox_User_Status status, voi
             windows[i]->onStatusChange(windows[i], m, friendnumber, status);
         }
     }
+
+    flag_interface_refresh();
 }
 
 void on_friend_added(Tox *m, uint32_t friendnumber, bool sort)
@@ -182,7 +190,7 @@ void on_conference_invite(Tox *m, uint32_t friendnumber, Tox_Conference_Type typ
 
     for (uint8_t i = 0; i < MAX_WINDOWS_NUM; ++i) {
         if (windows[i] != NULL && windows[i]->onConferenceInvite != NULL) {
-            windows[i]->onConferenceInvite(windows[i], m, friendnumber, type, (char *) conference_pub_key, length);
+            windows[i]->onConferenceInvite(windows[i], m, friendnumber, type, (const char *) conference_pub_key, length);
         }
     }
 }
@@ -196,6 +204,8 @@ void on_conference_peer_list_changed(Tox *m, uint32_t conferencenumber, void *us
             windows[i]->onConferenceNameListChange(windows[i], m, conferencenumber);
         }
     }
+
+    flag_interface_refresh();
 }
 
 void on_conference_peer_name(Tox *m, uint32_t conferencenumber, uint32_t peernumber, const uint8_t *name,
@@ -234,7 +244,7 @@ void on_file_chunk_request(Tox *m, uint32_t friendnumber, uint32_t filenumber, u
 {
     UNUSED_VAR(userdata);
 
-    struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
+    FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
 
     if (!ft) {
         return;
@@ -257,7 +267,7 @@ void on_file_recv_chunk(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint
 {
     UNUSED_VAR(userdata);
 
-    struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
+    FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
 
     if (!ft) {
         return;
@@ -265,7 +275,7 @@ void on_file_recv_chunk(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint
 
     for (uint8_t i = 0; i < MAX_WINDOWS_NUM; ++i) {
         if (windows[i] != NULL && windows[i]->onFileRecvChunk != NULL) {
-            windows[i]->onFileRecvChunk(windows[i], m, friendnumber, filenumber, position, (char *) data, length);
+            windows[i]->onFileRecvChunk(windows[i], m, friendnumber, filenumber, position, (const char *) data, length);
         }
     }
 }
@@ -275,7 +285,7 @@ void on_file_recv_control(Tox *m, uint32_t friendnumber, uint32_t filenumber, To
 {
     UNUSED_VAR(userdata);
 
-    struct FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
+    FileTransfer *ft = get_file_transfer_struct(friendnumber, filenumber);
 
     if (!ft) {
         return;
@@ -306,7 +316,7 @@ void on_file_recv(Tox *m, uint32_t friendnumber, uint32_t filenumber, uint32_t k
 
     for (uint8_t i = 0; i < MAX_WINDOWS_NUM; ++i) {
         if (windows[i] != NULL && windows[i]->onFileRecv != NULL) {
-            windows[i]->onFileRecv(windows[i], m, friendnumber, filenumber, file_size, (char *) filename,
+            windows[i]->onFileRecv(windows[i], m, friendnumber, filenumber, file_size, (const char *) filename,
                                    filename_length);
         }
     }
@@ -322,6 +332,53 @@ void on_friend_read_receipt(Tox *m, uint32_t friendnumber, uint32_t receipt, voi
         }
     }
 }
+
+void on_lossless_custom_packet(Tox *m, uint32_t friendnumber, const uint8_t *data, size_t length, void *userdata)
+{
+    UNUSED_VAR(userdata);
+
+    if (length == 0 || data == NULL) {
+        return;
+    }
+
+    uint8_t type = data[0];
+
+    switch (type) {
+#ifdef GAMES
+
+        case CUSTOM_PACKET_GAME_INVITE: {
+            for (size_t i = 0; i < MAX_WINDOWS_NUM; ++i) {
+                ToxWindow *window = windows[i];
+
+                if (window != NULL && window->onGameInvite != NULL) {
+                    window->onGameInvite(window, m, friendnumber, data + 1, length - 1);
+                }
+            }
+
+            break;
+        }
+
+        case CUSTOM_PACKET_GAME_DATA: {
+            for (size_t i = 0; i < MAX_WINDOWS_NUM; ++i) {
+                ToxWindow *window = windows[i];
+
+                if (window != NULL && window->onGameData != NULL) {
+                    window->onGameData(window, m, friendnumber, data + 1, length - 1);
+                }
+            }
+
+            break;
+        }
+
+#endif // GAMES
+
+        default: {
+            fprintf(stderr, "Got unknown custom packet of type: %u\n", type);
+            return;
+        }
+    }
+}
+
 /* CALLBACKS END */
 
 int add_window(Tox *m, ToxWindow *w)
@@ -370,13 +427,15 @@ void set_active_window_index(uint8_t index)
 /* Displays the next window if `ch` is equal to the next window key binding.
  * Otherwise displays the previous window.
  */
-void set_next_window(int ch)
+static void set_next_window(int ch)
 {
+    uint8_t index = 0;
+
     if (ch == user_settings->key_next_tab) {
         for (uint8_t i = active_window_index + 1; i < MAX_WINDOWS_NUM; ++i) {
             if (windows[i] != NULL) {
-                set_active_window_index(i);
-                return;
+                index = i;
+                break;
             }
         }
     } else {
@@ -384,13 +443,13 @@ void set_next_window(int ch)
 
         for (uint8_t i = start; i > 0; --i) {
             if (windows[i] != NULL) {
-                set_active_window_index(i);
-                return;
+                index = i;
+                break;
             }
         }
     }
 
-    set_active_window_index(0);
+    set_active_window_index(index);
 }
 
 /* Deletes window w and cleans up */
@@ -406,7 +465,12 @@ void del_window(ToxWindow *w)
     refresh();
 
     if (num_active_windows > 0) {
+        if (active_window_index == 2) {    // if closing current window would bring us to friend list
+            set_next_window(-1);           // skip back to the home window instead. FIXME: magic numbers
+        }
+
         set_next_window(-1);
+
         --num_active_windows;
     }
 }
@@ -440,6 +504,9 @@ void on_window_resize(void)
     refresh();
     clear();
 
+    int x2;
+    int y2;
+
     for (uint8_t i = 0; i < MAX_WINDOWS_NUM; ++i) {
         ToxWindow *w = windows[i];
 
@@ -455,6 +522,29 @@ void on_window_resize(void)
             continue;
         }
 
+#ifdef GAMES
+
+        if (w->type == WINDOW_TYPE_GAME) {
+            delwin(w->window_bar);
+            delwin(w->window);
+            delwin(w->game->window);
+            w->window = newwin(LINES, COLS, 0, 0);
+
+            getmaxyx(w->window, y2, x2);
+
+            if (y2 <= 0 || x2 <= 0) {
+                fprintf(stderr, "Failed to resize game window: max_x: %d, max_y: %d\n", x2, y2);
+                delwin(w->window);
+                continue;
+            }
+
+            w->window_bar = subwin(w->window, WINDOW_BAR_HEIGHT, COLS, LINES - 2, 0);
+            w->game->window = subwin(w->window, y2 - CHATBOX_HEIGHT - WINDOW_BAR_HEIGHT, x2, 0, 0);
+            continue;
+        }
+
+#endif // GAMES
+
         if (w->help->active) {
             wclear(w->help->win);
         }
@@ -473,14 +563,12 @@ void on_window_resize(void)
 
         w->window = newwin(LINES, COLS, 0, 0);
 
-        int x2;
-        int y2;
         getmaxyx(w->window, y2, x2);
 
         if (y2 <= 0 || x2 <= 0) {
             fprintf(stderr, "Failed to resize window: max_x: %d, max_y: %d\n", x2, y2);
             delwin(w->window);
-            return;
+            continue;
         }
 
         if (w->show_peerlist) {
@@ -597,10 +685,10 @@ void draw_window_bar(ToxWindow *self)
 
     int cur_x;
     int cur_y;
-    UNUSED_VAR(cur_y);
-
     getyx(win, cur_y, cur_x);
 
+    UNUSED_VAR(cur_y);
+
     wattron(win, COLOR_PAIR(BAR_TEXT));
     mvwhline(win, 0, cur_x, ' ', COLS - cur_x);
     wattroff(win, COLOR_PAIR(BAR_TEXT));
@@ -704,11 +792,53 @@ void draw_active_window(Tox *m)
     pthread_mutex_lock(&Winthread.lock);
     a->alert = WINDOW_ALERT_NONE;
     a->pending_messages = 0;
+    bool flag_refresh = Winthread.flag_refresh;
     pthread_mutex_unlock(&Winthread.lock);
 
-    touchwin(a->window);
-    a->onDraw(a, m);
-    wrefresh(a->window);
+    if (flag_refresh) {
+        touchwin(a->window);
+        a->onDraw(a, m);
+        wrefresh(a->window);
+    }
+
+#ifdef AUDIO
+    else if (a->is_call && timed_out(a->chatwin->infobox.lastupdate, 1)) {
+        touchwin(a->window);
+        a->onDraw(a, m);
+        wrefresh(a->window);
+    }
+
+#endif  // AUDIO
+
+#ifdef GAMES
+
+    if (a->type == WINDOW_TYPE_GAME) {
+        if (!flag_refresh) {  // we always want to be continously refreshing game windows
+            touchwin(a->window);
+            a->onDraw(a, m);
+            wrefresh(a->window);
+        }
+
+        int ch = getch();
+
+        if (ch == ERR) {
+            return;
+        }
+
+        pthread_mutex_lock(&Winthread.lock);
+        flag_interface_refresh();
+        pthread_mutex_unlock(&Winthread.lock);
+
+        if (ch == user_settings->key_next_tab || ch == user_settings->key_prev_tab) {
+            set_next_window(ch);
+        }
+
+        a->onKey(a, m, ch, false);
+
+        return;
+    }
+
+#endif // GAMES
 
     wint_t ch = 0;
     int printable = get_current_char(&ch);
@@ -717,6 +847,10 @@ void draw_active_window(Tox *m)
         return;
     }
 
+    pthread_mutex_lock(&Winthread.lock);
+    flag_interface_refresh();
+    pthread_mutex_unlock(&Winthread.lock);
+
     if (printable == 0 && (ch == user_settings->key_next_tab || ch == user_settings->key_prev_tab)) {
         set_next_window((int) ch);
         return;
@@ -792,18 +926,59 @@ int get_num_active_windows(void)
     return num_active_windows;
 }
 
-/* destroys all chat and conference windows (should only be called on shutdown) */
-void kill_all_windows(Tox *m)
+/* Returns the number of active windows of given type. */
+size_t get_num_active_windows_type(WINDOW_TYPE type)
 {
-    for (uint8_t i = 2; i < MAX_WINDOWS_NUM; ++i) {
-        if (windows[i] == NULL) {
+    size_t count = 0;
+
+    for (size_t i = 0; i < MAX_WINDOWS_NUM; ++i) {
+        ToxWindow *w = windows[i];
+
+        if (w == NULL) {
             continue;
         }
 
-        if (windows[i]->type == WINDOW_TYPE_CHAT) {
-            kill_chat_window(windows[i], m);
-        } else if (windows[i]->type == WINDOW_TYPE_CONFERENCE) {
-            free_conference(windows[i], windows[i]->num);
+        if (w->type == type) {
+            ++count;
+        }
+    }
+
+    return count;
+}
+
+/* destroys all chat and conference windows (should only be called on shutdown) */
+void kill_all_windows(Tox *m)
+{
+    for (size_t i = 2; i < MAX_WINDOWS_NUM; ++i) {
+        ToxWindow *w = windows[i];
+
+        if (w == NULL) {
+            continue;
+        }
+
+        switch (w->type) {
+            case WINDOW_TYPE_CHAT: {
+                kill_chat_window(w, m);
+                break;
+            }
+
+            case WINDOW_TYPE_CONFERENCE: {
+                free_conference(w, w->num);
+                break;
+            }
+
+#ifdef GAMES
+
+            case WINDOW_TYPE_GAME: {
+                game_kill(w);
+                break;
+            }
+
+#endif // GAMES
+
+            default: {
+                break;
+            }
         }
     }
 

src/windows.h

@@ -43,6 +43,13 @@
 #define TOP_BAR_HEIGHT 1
 #define WINDOW_BAR_HEIGHT 1
 
+
+typedef enum CustomPacket {
+    CUSTOM_PACKET_GAME_INVITE = 160,
+    CUSTOM_PACKET_GAME_DATA   = 161,
+} CustomPacket;
+
+
 /* ncurses colour pairs as FOREGROUND_BACKGROUND. No background defaults to black. */
 typedef enum {
     WHITE,
@@ -53,8 +60,10 @@ typedef enum {
     YELLOW,
     MAGENTA,
     BLACK,
-    BLUE_BLACK,
     BLACK_WHITE,
+    WHITE_BLACK,
+    WHITE_BLUE,
+    WHITE_GREEN,
     BAR_TEXT,
     STATUS_ONLINE,
     BAR_ACCENT,
@@ -63,6 +72,7 @@ typedef enum {
     STATUS_BUSY,
     STATUS_AWAY,
     BAR_NOTIFY,
+    BAR_SOLID,
 } C_COLOURS;
 
 /* tab alert types: lower types take priority (this relies on the order of C_COLOURS) */
@@ -78,19 +88,34 @@ typedef enum {
     WINDOW_TYPE_CHAT,
     WINDOW_TYPE_CONFERENCE,
     WINDOW_TYPE_FRIEND_LIST,
+
+#ifdef GAMES
+    WINDOW_TYPE_GAME,
+#endif
 } WINDOW_TYPE;
 
 /* Fixes text color problem on some terminals.
    Uncomment if necessary */
 /* #define URXVT_FIX */
 
+/*
+ * Used to control access to global variables via a mutex, as well as to handle signals.
+ * Any file, variable or data structure that is used by the UI/Window thread and any other thread
+ * must be guarded by `lock`.
+ *
+ * There should only ever be one instance of this struct.
+ */
 struct Winthread {
     pthread_t tid;
     pthread_mutex_t lock;
     volatile sig_atomic_t sig_exit_toxic;
     volatile sig_atomic_t flag_resize;
+    volatile sig_atomic_t flag_refresh;
+    volatile sig_atomic_t last_refresh_flag;
 };
 
+extern struct Winthread Winthread;
+
 struct cqueue_thread {
     pthread_t tid;
 };
@@ -124,12 +149,18 @@ struct arg_opts {
     uint16_t tcp_port;
 };
 
+extern struct arg_opts arg_opts;
+
 typedef struct ToxWindow ToxWindow;
 typedef struct StatusBar StatusBar;
 typedef struct PromptBuf PromptBuf;
 typedef struct ChatContext ChatContext;
 typedef struct Help Help;
 
+#ifdef GAMES
+typedef struct GameData GameData;
+#endif
+
 struct ToxWindow {
     /* ncurses */
     bool(*onKey)(ToxWindow *, Tox *, wint_t, bool);
@@ -156,6 +187,11 @@ struct ToxWindow {
     void(*onTypingChange)(ToxWindow *, Tox *, uint32_t, bool);
     void(*onReadReceipt)(ToxWindow *, Tox *, uint32_t, uint32_t);
 
+#ifdef GAMES
+    void(*onGameInvite)(ToxWindow *, Tox *, uint32_t, const uint8_t *, size_t);
+    void(*onGameData)(ToxWindow *, Tox *, uint32_t, const uint8_t *, size_t);
+#endif // GAMES
+
 #ifdef AUDIO
 
     void(*onInvite)(ToxWindow *, ToxAV *, uint32_t, int);
@@ -193,10 +229,16 @@ struct ToxWindow {
     StatusBar *stb;
     Help *help;
 
+#ifdef GAMES
+    GameData *game;
+#endif
+
     WINDOW *window;
     WINDOW *window_bar;
 };
 
+extern ToxWindow *windows[MAX_WINDOWS_NUM];
+
 /* statusbar info holder */
 struct StatusBar {
     WINDOW *topline;
@@ -280,8 +322,12 @@ ToxWindow *get_window_ptr(size_t i);
 ToxWindow *get_active_window(void);
 void draw_window_bar(ToxWindow *self);
 
+/* Returns the number of active windows of given type. */
+size_t get_num_active_windows_type(WINDOW_TYPE type);
+
 /* refresh inactive windows to prevent scrolling bugs.
    call at least once per second */
 void refresh_inactive_windows(void);
 
-#endif /* WINDOWS_H */
+#endif // WINDOWS_H
+