moveAPItide

gone but not forgotten

.gitignore

@@ -7,8 +7,14 @@ config.ini
 # virtualenv
 venv/
 
+# logs
+logs/*.log
+
 # modified .service files
 etc/*.service
 
 # Python cache
 __pycache__/
+
+# rag data
+data/rag/*

Dockerfile

@@ -1,8 +1,14 @@
 FROM python:3.10-slim
 ENV PYTHONUNBUFFERED=1
 
-RUN apt-get update && apt-get install -y gettext && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y gettext tzdata locales && rm -rf /var/lib/apt/lists/*
 
+# Set the locale default to en_US.UTF-8
+RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && \
+    dpkg-reconfigure --frontend=noninteractive locales && \
+    update-locale LANG=en_US.UTF-8
+ENV LANG en_US.UTF-8 
+ENV TZ="America/Los_Angeles"
 
 WORKDIR /app
 COPY . /app

README.md

@@ -1,90 +1,101 @@
-# meshing-around
-Random Mesh Scripts for Network Testing and BBS Activities for Use with [Meshtastic](https://meshtastic.org/docs/introduction/) Nodes
+# Mesh Bot for Network Testing and BBS Activities
 
-![alt text](etc/pong-bot.jpg "Example Use")
+Welcome to the Mesh Bot project! This feature-rich bot is designed to enhance your [Meshtastic](https://meshtastic.org/docs/introduction/) network experience with a variety of powerful tools and fun features, connectivity and utility through text-based message delivery. Whether you're looking to perform network tests, send messages, or even play games, this bot has you covered.
 
-## mesh_bot.sh
-The feature-rich bot requires the internet for full functionality. These responder bots will trap keywords like ping and respond to a DM (direct message) with pong! The script will also monitor the group channels for keywords to trap. You can also `Ping @Data to Echo` as an example.
+![Example Use](etc/pong-bot.jpg "Example Use")
 
-Along with network testing, this bot has a lot of other fun features, like simple mail messaging you can leave for another device, and when that device is seen, it can send the mail as a DM. Or a scheduler to send weather or a reminder weekly for the VHF net.
+## Key Features
 
-The bot is also capable of using dual radio/nodes, so you can monitor two networks at the same time and send messages to nodes using the same `bbspost @nodeNumber #message` or `bbspost @nodeShortName #message` function. There is a small message board to fit in the constraints of Meshtastic for posting bulletin messages with `bbspost $subject #message`.
+### Intelligent Keyword Responder
+- **Automated Responses**: The bot traps keywords like "ping" and responds with "pong" in direct messages (DMs) or group channels.
+- **Customizable Triggers**: Monitor group channels for specific keywords and set custom responses.
 
-Look up data using wiki results, or interact with [Ollama](https://ollama.com) LLM AI see the [OllamaDocs](https://github.com/ollama/ollama/tree/main/docs) If Ollama is enabled you can DM the bot directly. The default model for mesh-bot which is currently `gemma2:2b`
+### Dual Radio/Node Support
+- **Simultaneous Monitoring**: Monitor two networks at the same time.
+- **Flexible Messaging**: send mail and messages, between networks.
 
-The bot will report on anyone who is getting close to the configured lat/long, if in a remote location.
+### Advanced Messaging Capabilities
+- **Mail Messaging**: Leave messages for other devices, which are sent as DMs when the device is seen.
+- **Scheduler**: Schedule messages like weather updates or reminders for weekly VHF nets.
+- **Store and Forward**: Replay messages with the `messages` command, and log messages locally to disk.
+- **Send Mail**: Send mail to nodes using `bbspost @nodeNumber #message` or `bbspost @nodeShortName #message`.
 
-Store and forward-like message re-play with `messages`, and there is a repeater module for dual radio bots to cross post messages. Messages are also logged locally to disk.
+### Interactive AI and Data Lookup
+- **NOAA location Data**: Get localized weather(alerts) and Tide information. Open-Meteo is used for wx only outside NOAA coverage. 
+- **Wiki Integration**: Look up data using Wikipedia results.
+- **Ollama LLM AI**: Interact with the [Ollama](https://github.com/ollama/ollama/tree/main/docs) LLM AI for advanced queries and responses.
 
-There is a small collection of games to play like DopeWars, Lemonade Stand, and BlackJack or VideoPoker to name a few, issuing `games` displays help
+### Proximity Alerts
+- **Location-Based Alerts**: Get notified when members arrive back at a configured lat/long, perfect for remote locations like campsites.
 
-The bot can also be used to monitor a radio frequency and let you know when high SNR RF activity is seen. Using Hamlib(rigctld) to watch the S meter on a connected radio. You can send alerts to channels when a frequency is detected for 20 seconds within the thresholds set in config.ini
+### Fun and Games
+- **Built-in Games**: Enjoy games like DopeWars, Lemonade Stand, BlackJack, and VideoPoker.
+- **Command-Based Gameplay**: Issue `games` to display help and start playing.
 
-Any messages that are over 160 characters are chunked into 160 message bytes to help traverse hops, in testing, this keeps delivery success higher.
+### Radio Frequency Monitoring
+- **SNR RF Activity Alerts**: Monitor a radio frequency and get alerts when high SNR RF activity is detected.
+- **Hamlib Integration**: Use Hamlib (rigctld) to watch the S meter on a connected radio.
 
-## Full list of commands for the bot
+### Data Reporting
+- **HTML Generator**: Visualize bot traffic and data flows with a built-in HTML generator for [data reporting](logs/README.md).
 
-- Various solar details for radio propagation (spaceWeather module)
-  - `sun` and `moon` return info on rise and set local time
-  - `solar` gives an idea of the x-ray flux
-  - `hfcond` returns a table of HF solar conditions
-- Bulletin Board (BBS) functions
-  - `bbshelp` returns the following
-  - `bbslist` list the messages by ID and subject
-  - `bbsread` read a message example use: `bbsread #1`
-  - `bbspost` post a message to public board or send a DM example use: `bbspost $subject #message, or bbspost @nodeNumber #message or bbspost @nodeShortName #message`
-  - `bbsdelete` delete a message example use: `bbsdelete #4`
-- Other functions
-  - `whereami` returns the address of location of sender if known
-  - `whoami` returns some details of the node asking
-  - `tide` returns the local tides, NOAA data source
-  - `wx` and `wxc` returns local weather forecast, (wxc is metric value), NOAA or Open Meteo for weather forecasting.
-  - `wxa` and `wxalert` return NOAA alerts. Short title or expanded details
-  - `joke` tells a joke
-  - `wiki: ` will search wikipedia, return the first few sentances of first result if a match `wiki: lora radio`
-  - `askai` and `ask:` will ask Ollama LLM AI for a response `askai what temp do I cook chicken`
-  - `messages` Replay the last messages heard, like Store and Forward
-  - `motd` or to set the message `motd $New Message Of the day`
-  - `lheard` returns the last 5 heard nodes with SNR, can also use `sitrep`
-  - `history` returns the last commands ran by user(s)
-  - `cmd` returns the list of commands (the help message)
-- Games
-  - `lemonstand` plays the classic Lemonade Stand Finance game via DM
-  - `dopewars` plays the classic drug trader game via DM
-  - `blackjack` BlackJack
-  - `videopoker` Video Poker
+### Robust Message Handling
+- **Message Chunking**: Automatically chunk messages over 160 characters to ensure higher delivery success across hops.
 
-## pong_bot.sh
-Stripped-down bot, mostly around for archive purposes. The mesh-bot enhanced modules can be disabled by config to disable features.
+## Getting Started
+This project is developed on Linux (specifically a Raspberry Pi) but should work on any platform where the [Meshtastic protobuf API](https://meshtastic.org/docs/software/python/cli/) modules are supported, and with any compatible [Meshtastic](https://meshtastic.org/docs/getting-started/) hardware.
 
-## Hardware
-The project is written on Linux on a Pi and should work anywhere [Meshtastic](https://meshtastic.org/docs/software/python/cli/) Python modules will function, with any supported [Meshtastic](https://meshtastic.org/docs/getting-started/) hardware. While BLE and TCP will work, they are not as reliable as serial connections.
-
-## Install
-Clone the project with `git clone https://github.com/spudgunman/meshing-around`
-code is under a lot of development, so check back often with `git pull`
-Copy [config.template](config.template) to `config.ini` and edit for your needs.
-`pip install -r requirements.txt` 
-
-Optionally:
-- `install.sh` will automate optional venv and requirements installation.
-- `launch.sh` will activate and launch the app in the venv if built.
-
-For Docker:
-Check you have serial port properly shared and the GPU if using LLM with [NVidia](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html)
-- `git clone https://github.com/spudgunman/meshing-around`
-- `cd meshing-around && docker build -t meshing-around`
-- `docker run meshing-around`
-
-### Configurations
-Copy the [config.template](config.template) to `config.ini` and set the appropriate interface for your method (serial/ble/tcp). While BLE and TCP will work, they are not as reliable as serial connections. There is a watchdog to reconnect tcp if possible. To get BLE mac `meshtastic --ble-scan` **NOTE** I have only tested with a single BLE device and the code is written to only have one interface be a BLE port
+### Installation
 
+#### Clone the Repository
+```sh
+git clone https://github.com/spudgunman/meshing-around
 ```
-#config.ini
+The code is under active development, so make sure to pull the latest changes regularly!
+
+#### Optional Automation of setup
+- **Automated Installation**: `install.sh` will automate optional venv and requirements installation.
+- **Launch Script**: `launch.sh` will activate and launch the app in the venv
+
+#### Docker Installation
+If you prefer to use Docker, follow these steps:
+
+1. Ensure your serial port is properly shared and the GPU is configured if using LLM with [NVIDIA](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html).
+2. Build the Docker image:
+    ```sh
+    cd meshing-around
+    docker build -t meshing-around .
+    ```
+3. Run the Docker container:
+    ```sh
+    docker run --rm -it --device=/dev/ttyUSB0 meshing-around
+    ```
+
+#### Custom Install
+Install the required dependencies using pip:
+```sh
+pip install -r requirements.txt
+```
+
+Copy the configuration template to `config.ini` and edit it to suit your needs:
+```sh
+cp config.template config.ini
+```
+
+### Configuration
+Copy the [config.template](config.template) to `config.ini` and set the appropriate interface for your method (serial/ble/tcp). While BLE and TCP will work, they are not as reliable as serial connections. There is a watchdog to reconnect TCP if possible. To get the BLE MAC address, use:
+```sh
+meshtastic --ble-scan
+```
+
+**Note**: The code has been tested with a single BLE device and is written to support only one BLE port.
+
+```ini
+# config.ini
 # type can be serial, tcp, or ble.
 # port is the serial port to use; commented out will try to auto-detect
 # hostname is the IP address of the device to connect to for TCP type
-# mac is the MAC address of the device to connect to for ble type
+# mac is the MAC address of the device to connect to for BLE type
 
 [interface]
 type = serial
@@ -92,20 +103,24 @@ type = serial
 # hostname = 192.168.0.1
 # mac = 00:11:22:33:44:55
 
-# Additional interface for dual radio support See config.template for more.
+# Additional interface for dual radio support. See config.template for more.
 [interface2]
 enabled = False
 ```
-The following pair of settings determine how to respond: The default action is to not spam the default channel. Setting'respond_by_DM_only'` will force all messages to be sent to DM, which may not be wanted. Setting the value to False will allow responses in the channel for all to see.
 
-Setting the default channel is the channel that won't be spammed by the bot. It's the public default channel 0 on the new Meshtastic firmware. Anti-Spam is hard-coded into the responder to prevent abuse of the public channel.
-```
+### General Settings
+The following settings determine how the bot responds. By default, the bot will not spam the default channel. Setting `respond_by_dm_only` to `True` will force all messages to be sent via DM, which may not be desired. Setting it to [`False`] will allow responses in the channel for all to see. If you have no default channel you can set this value to `-1` or any unused channel index.
+
+```ini
 [general]
 respond_by_dm_only = True
 defaultChannel = 0
 ```
-The weather forecasting defaults to NOAA but for outside the USA you can set UseMeteoWxAPI `True` to use a world weather API. The lat and lon are for defaults when a node has no location data to use.
-```
+
+### Location Settings
+The weather forecasting defaults to NOAA, but for locations outside the USA, you can set `UseMeteoWxAPI` "Go to definition") to `True` to use a global weather API. The `lat` and `lon` are default values when a node has no location data. It is also the default used for Sentry.
+
+```ini
 [location]
 enabled = True
 lat = 48.50
@@ -113,8 +128,10 @@ lon = -123.0
 UseMeteoWxAPI = True
 ```
 
-Modules can be disabled or enabled.
-```
+### Module Settings
+Modules can be enabled or disabled as needed.
+
+```ini
 [bbs]
 enabled = False
 
@@ -122,111 +139,94 @@ enabled = False
 DadJokes = False
 StoreForward = False
 ```
-History command is like a linix terminal, shows the last commands the user ran and the `lheard` reflects last users on the bot.
-```
-# history command 
-enableCmdHistory = True
-# command history ignore list ex: 2813308004,4258675309
-lheardCmdIgnoreNodes =
-```
-Sentry Bot detects anyone coming close to the bot-node
-```
-# detect anyone close to the bot
-SentryEnabled = True
-# radius in meters to detect someone close to the bot
-SentryRadius = 100
-# holdoff time multiplied by seconds(20) of the watchdog
-SentryChannel = 9
-# channel to send a message to when the watchdog is triggered
-SentryHoldoff = 2
-# list of ignored nodes numbers ex: 2813308004,4258675309
-sentryIgnoreList = 
-```
-The BBS has admin and block lists; see the [config.template](config.template)
 
-A repeater function for two different nodes and cross-posting messages. The'repeater_channels` is a list of repeater channel(s) that will be consumed and rebroadcast on the same number channel on the other device, node, or interface. Each node should have matching channel numbers. The channel names and PSK do not need to be the same on the nodes. With great power comes great responsibility; danger could lurk in the use of this feature! If you have the two nodes in the same radio configuration, you could create a feedback loop!!!
+### History 
+The history command shows the last commands the user ran, and [`lheard`] reflects the last users on the bot.
 
+```ini
+enableCmdHistory = True # history command enabler
+lheardCmdIgnoreNodes = # command history ignore list ex: 2813308004,4258675309
 ```
-# repeater module
-[repeater]
+
+### Sentry Settings
+
+Sentry Bot detects anyone coming close to the bot-node.
+
+```ini
+SentryEnabled = True # detect anyone close to the bot
+SentryRadius = 100 # radius in meters to detect someone close to the bot
+SentryChannel = 9 # holdoff time multiplied by seconds(20) of the watchdog
+SentryHoldoff = 2 # channel to send a message to when the watchdog is triggered
+sentryIgnoreList = # list of ignored nodes numbers ex: 2813308004,4258675309
+```
+
+### Repeater Settings
+A repeater function for two different nodes and cross-posting messages. The [`repeater_channels`] is a list of repeater channels that will be consumed and rebroadcast on the same number channel on the other device, node, or interface. Each node should have matching channel numbers. The channel names and PSK do not need to be the same on the nodes. Use this feature responsibly to avoid creating a feedback loop.
+
+```ini
+[repeater] # repeater module
 enabled = True
 repeater_channels = [2, 3]
 ```
-A module allowing a Hamlib compatible radio to connect to the bot, when functioning it will message the channel configured with a message of in use. **Requires hamlib/rigctld to be running as a service.**
 
-```
+### Radio Monitoring
+A module allowing a Hamlib compatible radio to connect to the bot. When functioning, it will message the configured channel with a message of in use. **Requires hamlib/rigctld to be running as a service.**
+
+```ini
 [radioMon]
 enabled = False
 rigControlServerAddress = localhost:4532
-# channel to broadcast to can be 2,3
-sigWatchBroadcastCh = 2
-# minimum SNR as reported by radio via hamlib
-signalDetectionThreshold = -10
-# hold time for high SNR
-signalHoldTime = 10
-# the following are combined to reset the monitor
-signalCooldown = 5
+sigWatchBroadcastCh = 2 # channel to broadcast to can be 2,3
+signalDetectionThreshold = -10 # minimum SNR as reported by radio via hamlib
+signalHoldTime = 10 # hold time for high SNR
+signalCooldown = 5 # the following are combined to reset the monitor
 signalCycleLimit = 5
 ```
-Ollama Settings, for Ollama to work the command line `ollama run 'model'` needs to work properly. Check that you have enough RAM and your GPU are working as expected. The default model for this project, is set to `gemma2:2b` (run `ollama pull gemma2:2b` on command line, to download and setup) 
- - From the command terminal of your system with mesh-bot, download the default model for mesh-bot which is currently `ollama pull gemma2:2b`
 
-Enable History, set via code readme Ollama Config in [Settings](https://github.com/SpudGunMan/meshing-around?tab=readme-ov-file#configurations) and [llm.py](https://github.com/SpudGunMan/meshing-around/blob/eb3bbdd3c5e0f16fe3c465bea30c781bd132d2d3/modules/llm.py#L12)
+### Ollama (LLM/AI) Settings
+For Ollama to work, the command line `ollama run 'model'` needs to work properly. Ensure you have enough RAM and your GPU is working as expected. The default model for this project is set to `gemma2:2b`. Ollama can be remote [Ollama Server](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-do-i-configure-ollama-server)
 
-Tested models are `llama3.1, gemma2 (and variants), phi3.5, mistrial` other models may not handle the template as well.
-
-```
+```ini
 # Enable ollama LLM see more at https://ollama.com
-ollama = True
-# Ollama model to use (defaults to gemma2:2b)
-ollamaModel = gemma2
-#ollamaModel = llama3.1
+ollama = True # Ollama model to use (defaults to gemma2:2b)
+ollamaModel = gemma2 #ollamaModel = llama3.1
+ollamaHostName = http://localhost:11434 # server instance to use (defaults to local machine install)
 ```
 
-also see llm.py for changing the defaults of
-```
+Also see `llm.py` for changing the defaults of:
+
+```ini
 # LLM System Variables
-llmEnableHistory = False # enable history for the LLM model to use in responses adds to compute time
-llmContext_fromGoogle = True # enable context from google search results adds to compute time but really helps with responses accuracy
+llmEnableHistory = True # enable history for the LLM model to use in responses adds to compute time
+llmContext_fromGoogle = True # enable context from google search results helps with responses accuracy
 googleSearchResults = 3 # number of google search results to include in the context more results = more compute time
-llm_history_limit = 6 # limit the history to 3 messages (come in pairs) more results = more compute time
 ```
 
-Logging messages to disk or Syslog to disk uses the python native logging function. Take a look at the [/modules/log.py](/modules/log.py) you can set the file logger for syslog to INFO for example to not log DEBUG messages to file log, or modify the stdOut level.
-```
-[general]
-# logging to file of the non Bot messages
-LogMessagesToFile = True
-# Logging of system messages to file
-SyslogToFile = True
-```
-Example to log to disk only INFO and higher (ignore DEBUG)
-```
-*log.py
-file_handler.setLevel(logging.INFO) # DEBUG used by default for system logs to disk example here shows INFO
+### Scheduler
+The Scheduler is enabled in the `settings.py` by setting `scheduler_enabled = True`. The actions and settings are via code only at this time. See mesh_bot.py around line [425](https://github.com/SpudGunMan/meshing-around/blob/22983133ee4db3df34f66699f565e506de296197/mesh_bot.py#L425-L435) to edit the schedule. See [schedule documentation](https://schedule.readthedocs.io/en/stable/) for more.
+
+```python
+#Send WX every Morning at 08:00 using handle_wxc function to channel 2 on device 1
+schedule.every().day.at("08:00").do(lambda: send_message(handle_wxc(0, 1, 'wx'), 2, 0, 1))
+
+#Send a Net Starting Now Message Every Wednesday at 19:00 using send_message function to channel 2 on device 1
+schedule.every().wednesday.at("19:00").do(lambda: send_message("Net Starting Now", 2, 0, 1))
 ```
 
-The Scheduler is enabled in the [settings.py](modules/settings.py) by setting `scheduler_enabled = True` the actions and settings are via code only at this time. see [mesh_bot.py](mesh_bot.py) around line [425](https://github.com/SpudGunMan/meshing-around/blob/22983133ee4db3df34f66699f565e506de296197/mesh_bot.py#L425-L435) to edit schedule its most flexible to edit raw code right now.  See https://schedule.readthedocs.io/en/stable/ for more.
+### MQTT Notes
+There is no direct support for MQTT in the code, however, reports from Discord are that using [meshtasticd](https://meshtastic.org/docs/hardware/devices/linux-native-hardware/) with no radio and attaching the bot to the software node, which is MQTT-linked, allows routing. There also seems to be a quicker way to enable MQTT by having your bot node with the enabled [serial](https://meshtastic.org/docs/configuration/module/serial/) module with echo enabled and MQTT uplink and downlink. These two methods have been mentioned as allowing MQTT routing for the project. 
 
-```
-# Send WX every Morning at 08:00 using handle_wxc function to channel 2 on device 1
-#schedule.every().day.at("08:00").do(lambda: send_message(handle_wxc(0, 1, 'wx'), 2, 0, 1))
+### Requirements
+Python 3.8? or later is needed (dev on latest). The following can be installed with `pip install -r requirements.txt` or using the [install.sh](install.sh) script for venv and automation:
 
-# Send a Net Starting Now Message Every Wednesday at 19:00 using send_message function to channel 2 on device 1
-#schedule.every().wednesday.at("19:00").do(lambda: send_message("Net Starting Now", 2, 0, 1))
-```
-# requirements
-Python 3.10 minimally is needed, developed on latest release.
-
-The following can also be installed with `pip install -r requirements.txt` or using the install.sh script for venv and automation
-
-```
+```sh
 pip install meshtastic
 pip install pubsub
 ```
-mesh-bot enhancements
 
-```
+Mesh-bot enhancements:
+
+```sh
 pip install pyephem
 pip install requests
 pip install geopy
@@ -237,34 +237,110 @@ pip install geopy
 pip install schedule
 pip install wikipedia
 ```
-The following is needed for open-meteo use
-```
+
+For open-meteo use:
+
+```sh
 pip install openmeteo_requests
 pip install retry_requests
 pip install numpy
 ```
-The following is for the Ollama LLM
-```
+
+For the Ollama LLM:
+
+```sh
+pip install ollama
 pip install langchain
 pip install langchain-ollama
-pip install ollama
 pip install googlesearch-python
 ```
 
-To enable emoji in the Debian console, install the fonts `sudo apt-get install fonts-noto-color-emoji`
+To enable emoji in the Debian console, install the fonts:
+
+```sh
+sudo apt-get install fonts-noto-color-emoji
+```
+
+## Full list of commands for the bot
+
+### Networking
+| Command | Description | ✅ Works Off-Grid |
+|---------|-------------|-
+| `ping`, `ack`, `test` | Return data for signal. Example: `ping 15 #DrivingI5` (activates auto-ping every 20 seconds for count 15) | ✅ |
+| `whereami` | Returns the address of the sender's location if known |
+| `whoami` | Returns details of the node asking, also returned when position exchanged 📍 | ✅ |
+| `motd` | Displays the message of the day or sets it. Example: `motd $New Message Of the day` | ✅ |
+| `lheard` | Returns the last 5 heard nodes with SNR. Can also use `sitrep` | ✅ |
+| `history` | Returns the last commands run by user(s) | ✅ |
+| `cmd` | Returns the list of commands (the help message) | ✅ |
+
+### Radio Propagation & Weather Forcasting
+| Command | Description | |
+|---------|-------------|-------------------
+| `sun` and `moon` | Return info on rise and set local time | ✅ |
+| `solar` | Gives an idea of the x-ray flux | |
+| `hfcond` | Returns a table of HF solar conditions | |
+| `tide` | Returns the local tides (NOAA data source) |
+| `rlist` | Returns a table of nearby repeaters from RepeaterBook | |
+| `wx` and `wxc` | Return local weather forecast (wxc is metric value), NOAA or Open Meteo for weather forecasting |
+| `wxa` and `wxalert` | Return NOAA alerts. Short title or expanded details |
+
+### Bulletin Board & Mail
+| Command | Description | |
+|---------|-------------|-
+| `bbshelp` | Returns the following help message | ✅ |
+| `bbslist` | Lists the messages by ID and subject | ✅ |
+| `bbsread` | Reads a message. Example: `bbsread #1` | ✅ |
+| `bbspost` | Posts a message to the public board or sends a DM(Mail) Examples: `bbspost $subject #message`, `bbspost @nodeNumber #message`, `bbspost @nodeShortName #message` | ✅ |
+| `bbsdelete` | Deletes a message. Example: `bbsdelete #4` | ✅ |
+| `bbsinfo` | Provides stats on BBS delivery and messages (sysop) | ✅ |
+
+### Data Lookup 
+| Command | Description | |
+|---------|-------------|-
+| `wiki:` | Searches Wikipedia and returns the first few sentences of the first result if a match. Example: `wiki: lora radio` |
+| `askai` and `ask:` | Ask Ollama LLM AI for a response. Example: `askai what temp do I cook chicken` | ✅ |
+| `messages` | Replays the last messages heard, like Store and Forward | ✅ |
+
+
+
+### Games (via DM)
+| Command | Description | |
+|---------|-------------|-
+| `joke` | Tells a joke | ✅ |
+| `lemonstand` | Plays the classic Lemonade Stand finance game | ✅ |
+| `dopewars` | Plays the classic drug trader game | ✅ |
+| `blackjack` | Plays Blackjack (Casino 21) | ✅ |
+| `videopoker` | Plays basic 5-card hold Video Poker | ✅ |
+| `mastermind` | Plays the classic code-breaking game | ✅ |
+| `golfsim` | Plays a 9-hole Golf Simulator | ✅ |
 
 # Recognition
+
 I used ideas and snippets from other responder bots and want to call them out!
-- https://github.com/Murturtle/MeshLink
-- https://github.com/pdxlocations/meshtastic-Python-Examples
-- https://github.com/geoffwhittington/meshtastic-matrix-relay
 
-Games Ported from..
-- https://github.com/tigerpointe/Lemonade-Stand/
-- https://github.com/Reconfirefly/drugwars
-- https://github.com/Himan10/BlackJack
-- https://github.com/devtronvarma/Video-Poker-Terminal-Game
+### Inspiration and Code Snippets
+- [MeshLink](https://github.com/Murturtle/MeshLink)
+- [Meshtastic Python Examples](https://github.com/pdxlocations/meshtastic-Python-Examples)
+- [Meshtastic Matrix Relay](https://github.com/geoffwhittington/meshtastic-matrix-relay)
+
+### Games Ported From
+- [Lemonade Stand](https://github.com/tigerpointe/Lemonade-Stand/)
+- [Drug Wars](https://github.com/Reconfirefly/drugwars)
+- [BlackJack](https://github.com/Himan10/BlackJack)
+- [Video Poker Terminal Game](https://github.com/devtronvarma/Video-Poker-Terminal-Game)
+- [Python Mastermind](https://github.com/pwdkramer/pythonMastermind/)
+- [Golf](https://github.com/danfriedman30/pythongame)
+
+### Special Thanks
+- **xdep**: For the reporting tools.
+- **Nestpebble**: For new ideas and enhancements.
+- **mrpatrick1991**: For Docker configurations.
+- **PiDiBi**: For looking at test functions and other suggestions like wxc, CPU use, and alerting ideas.
+- **Cisien, bitflip, and Hailo1999**: For testing and feature ideas on Discord and GitHub.
+- **Meshtastic Discord Community**: For tossing out ideas and testing code.
+
+### Tools
+- **Node Backup Management**: [Node Slurper](https://github.com/SpudGunMan/node-slurper)
 
-GitHub user Nestpebble, for new ideas and enhancments, mrpatrick1991 For Docker configs, PiDiBi looking at test functions and other suggestions like wxc, CPU use, and alerting ideas
-Discord and Mesh user Cisien, bitflip, and github Hailo1999, for testing and feature ideas! Lots of individuals on the Meshtastic discord who have tossed out ideas and tested code!
 

config.template

@@ -25,8 +25,10 @@ port = /dev/ttyUSB0
 [general]
 # if False will respond on all channels but the default channel
 respond_by_dm_only = True
-# defaultChannel is the meshtastic default public channel
+# defaultChannel is the meshtastic default public channel, e.g. LongFast (if none use -1)
 defaultChannel = 0
+# ignoreDefaultChannel, the bot will ignore the default channel set above
+ignoreDefaultChannel = False
 # motd is reset to this value on boot
 motd = Thanks for using MeshBOT! Have a good day!
 welcome_message = MeshBot, here for you like a friend who is not. Try sending: ping @foo or, cmd
@@ -42,6 +44,8 @@ wikipedia = True
 ollama = False
 # Ollama model to use (defaults to gemma2:2b)
 # ollamaModel = llama3.1
+# server instance to use (defaults to local machine install)
+ollamaHostName = http://localhost:11434
 # StoreForward Enabled and Limits
 StoreForward = True
 StoreLimit = 3
@@ -56,14 +60,18 @@ urlTimeout = 10
 # logging to file of the non Bot messages
 LogMessagesToFile = False
 # Logging of system messages to file
-SyslogToFile = False
+SyslogToFile = True
 
 [games]
+# if hop limit for the user exceeds this value, the message will be dropped
+game_hop_limit = 5
 # enable or disable the games module(s)
 dopeWars = True
 lemonade = True
 blackjack = True
 videopoker = True
+mastermind = True
+golfsim = True
 
 [sentry]
 # detect anyone close to the bot
@@ -97,6 +105,8 @@ NOAAalertCount = 2
 UseMeteoWxAPI = False
 # Default to metric units rather than imperial
 useMetric = False
+# repeaterList lookup location (rbook / artsci)
+repeaterLookup = rbook
 
 # repeater module
 [repeater]
@@ -128,3 +138,4 @@ responseDelay = 0.7
 splitDelay = 0.0
 # message chunk size for sending at high success rate
 MESSAGE_CHUNK_SIZE = 160
+

data/README.md

@@ -0,0 +1 @@
+database admin tool is in [./etc/db_admin.py](../etc/db_admin.py)

etc/bbsdb_admin.py

@@ -1,54 +0,0 @@
-# Load the bbs messages from the database file to screen for admin functions
-import pickle # pip install pickle
-
-
-# load the bbs messages from the database file
-try:
-    with open('../bbsdb.pkl', 'rb') as f:
-        bbs_messages = pickle.load(f)
-except Exception as e:
-    try:
-        with open('bbsdb.pkl', 'rb') as f:
-            bbs_messages = pickle.load(f)
-    except Exception as e:
-        print ("\nSystem: bbsdb.pkl not found")
-
-try:
-    with open('../bbsdm.pkl', 'rb') as f:
-        bbs_dm = pickle.load(f)
-except Exception as e:
-    try:
-        with open('bbsdm.pkl', 'rb') as f:
-            bbs_dm = pickle.load(f)
-    except Exception as e:
-        print ("\nSystem: bbsdm.pkl not found")
-
-# Game HS tables
-try:
-    with open('../lemonade_hs.pkl', 'rb') as f:
-       lemon_score = pickle.load(f)
-except Exception as e:
-    try:
-        with open('lemonade_hs.pkl', 'rb') as f:
-            lemon_score = pickle.load(f)
-    except Exception as e:
-        print ("\nSystem: lemonade_hs.pkl not found")
-
-try:
-    with open('../dopewar_hs.pkl', 'rb') as f:
-        dopewar_score = pickle.load(f)
-except Exception as e:
-    try:
-        with open('dopewar_hs.pkl', 'rb') as f:
-            dopewar_score = pickle.load(f)
-    except Exception as e:
-        print ("\nSystem: dopewar_hs.pkl not found")
-
-
-print ("\nSystem: bbs_messages")
-print (bbs_messages)
-print ("\nSystem: bbs_dm")
-print (bbs_dm)
-print ("Game HS tables")
-print (f"lemon:{lemon_score}")
-print (f"dopewar:{dopewar_score}")

etc/db_admin.py

@@ -0,0 +1,100 @@
+# Load the bbs messages from the database file to screen for admin functions
+import pickle # pip install pickle
+
+
+# load the bbs messages from the database file
+try:
+    with open('../data/bbsdb.pkl', 'rb') as f:
+        bbs_messages = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/bbsdb.pkl', 'rb') as f:
+            bbs_messages = pickle.load(f)
+    except Exception as e:
+        bbs_messages = "System: data/bbsdb.pkl not found"
+
+try:
+    with open('../data/bbsdm.pkl', 'rb') as f:
+        bbs_dm = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/bbsdm.pkl', 'rb') as f:
+            bbs_dm = pickle.load(f)
+    except Exception as e:
+        bbs_dm = "System: data/bbsdm.pkl not found"
+
+# Game HS tables
+try:
+    with open('../data/lemonstand.pkl', 'rb') as f:
+       lemon_score = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/lemonstand.pkl', 'rb') as f:
+            lemon_score = pickle.load(f)
+    except Exception as e:
+        lemon_score = "System: data/lemonstand.pkl not found"
+
+try:
+    with open('../data/dopewar_hs.pkl', 'rb') as f:
+        dopewar_score = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/dopewar_hs.pkl', 'rb') as f:
+            dopewar_score = pickle.load(f)
+    except Exception as e:
+        dopewar_score = "System: data/dopewar_hs.pkl not found"
+
+try:
+    with open('../data/blackjack_hs.pkl', 'rb') as f:
+        blackjack_score = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/blackjack_hs.pkl', 'rb') as f:
+            blackjack_score = pickle.load(f)
+    except Exception as e:
+        blackjack_score = "System: data/blackjack_hs.pkl not found"
+
+try:
+    with open('../data/videopoker_hs.pkl', 'rb') as f:
+        videopoker_score = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/videopoker_hs.pkl', 'rb') as f:
+            videopoker_score = pickle.load(f)
+    except Exception as e:
+        videopoker_score = "System: data/videopoker_hs.pkl not found"
+
+try:
+    with open('../mmind_hs.pkl', 'rb') as f:
+        mmind_score = pickle.load(f)
+except Exception as e:
+    try:
+        with open('mmind_hs.pkl', 'rb') as f:
+            mmind_score = pickle.load(f)
+    except Exception as e:
+        mmind_score = "System: mmind_hs.pkl not found"
+
+try:
+    with open('../data/golfsim_hs.pkl', 'rb') as f:
+        golfsim_score = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/golfsim_hs.pkl', 'rb') as f:
+            golfsim_score = pickle.load(f)
+    except Exception as e:
+        golfsim_score = "System: data/golfsim_hs.pkl not found"
+
+
+print ("\n Meshing-Around Database Admin Tool\n")
+print ("System: bbs_messages")
+print (bbs_messages)
+print ("\nSystem: bbs_dm")
+print (bbs_dm)
+print (f"\n\nGame HS tables\n")
+print (f"lemon:{lemon_score}")
+print (f"dopewar:{dopewar_score}")
+print (f"blackjack:{blackjack_score}")
+print (f"videopoker:{videopoker_score}")
+print (f"mmind:{mmind_score}")
+print (f"golfsim:{golfsim_score}")
+print ("\n")

etc/mesh_bot_reporting.timer

@@ -0,0 +1,10 @@
+[Unit]
+Description=MeshingAround-ReportingTask
+
+[Timer]
+OnUnitActiveSec=1h
+OnbootSec=5min
+Unit=mesh_bot_reporting.service
+
+[Install]
+WantedBy=timers.target

etc/mesh_bot_reporting.tmp

@@ -0,0 +1,25 @@
+# /etc/systemd/system/mesh_bot.service
+# sudo systemctl daemon-reload
+# sudo systemctl start mesh_bot.service
+
+[Unit]
+Description=MeshingAround-Reporting
+After=network.target
+
+[Service]
+Type=oneshot
+User=pi
+Group=pi
+WorkingDirectory=/dir/
+ExecStart=python3 etc/report_generator5.py
+ExecStop=pkill -f report_generator5.py
+
+# Disable Python's buffering of STDOUT and STDERR, so that output from the
+# service shows up immediately in systemd's logs
+Environment=PYTHONUNBUFFERED=1
+
+Restart=on-failure
+Type=notify #try simple if any problems
+
+[Install]
+WantedBy=default.target

etc/report_generator.py

@@ -0,0 +1,990 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+import sys
+import glob
+import json
+import pickle
+import platform
+import requests
+import subprocess
+import configparser
+from string import Template
+from datetime import datetime
+from importlib.metadata import version
+from collections import Counter, defaultdict
+
+# global variables
+LOG_PATH = '/opt/meshing-around/logs' # override path to log files (defaults to ../log)
+W3_PATH = '/var/www/html/' # override path to web server root (defaults to ../www)
+multiLogReader = False # set to True to read all logs in ../log
+shameWordList = ['password', 'combo', 'key', 'hidden', 'secret', 'pass', 'token', 'login', 'username', 'admin', 'root', 'base64:', '==' ]
+
+# system variables
+script_dir = os.path.dirname(os.path.realpath(__file__))
+www_dir = os.path.join(script_dir, 'www')
+config_file = os.path.join(script_dir, 'web_reporter.cfg')
+
+# set up report.cfg as ini file
+config = configparser.ConfigParser()
+try:
+    config.read(config_file)
+except Exception as e:
+    print(f"Error reading web_reporter.cfg: {str(e)} generating default config")
+
+if config.sections() == []:
+    print(f"web_reporter.cfg is empty or does not exist, generating default config")
+    shameWordList = shameWordList_str = ', '.join(shameWordList)
+    config['reporting'] = {'log_path': script_dir, 'w3_path': www_dir, 'multi_log_reader': 'False', 'shame_word_list': shameWordList}
+    with open(config_file, 'w') as configfile:
+        config.write(configfile)
+
+# read config file
+LOG_PATH = config['reporting'].get('log_path', LOG_PATH)
+W3_PATH = config['reporting'].get('w3_path', W3_PATH)
+multiLogReader = config['reporting'].getboolean('multi_log_reader', multiLogReader)
+# config['reporting']['shame_word_list'] is a comma-separated string
+shameWordList = config['reporting'].get('shame_word_list', '')
+if isinstance(shameWordList, str):
+    shameWordList = shameWordList.split(', ')
+    
+
+def parse_log_file(file_path):
+    global log_data
+    lines = ['']
+
+    # see if many logs are present
+    if multiLogReader:
+        # set file_path to the cwd of the default project ../log
+        log_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'logs')
+        log_files = glob.glob(os.path.join(log_dir, 'meshbot*.log'))
+        print(f"Checking log files: {log_files}")
+
+        if log_files:
+            log_files.sort()
+
+            for logFile in log_files:
+                with open(os.path.join(log_dir, logFile), 'r') as file:
+                    lines += file.readlines()
+    else:
+        try:
+            print(f"Checking log file: {file_path}")
+            with open(file_path, 'r') as file:
+                lines = file.readlines()
+        except FileNotFoundError:
+            print(f"Error: File not found at {file_path}")
+            sys.exit(1)
+
+    if multiLogReader:
+        print(f"Consumed {len(lines)} lines from {len(log_files)} log files")
+    else:
+        print(f"Consumed {len(lines)} lines from {file_path}")
+
+    log_data = {
+        'command_counts': Counter(),
+        'message_types': Counter(),
+        'llm_queries': Counter(),
+        'unique_users': set(),
+        'warnings': [],
+        'errors': [],
+        'hourly_activity': defaultdict(int),
+        'bbs_messages': 0,
+        'messages_waiting': 0,
+        'total_messages': 0,
+        'gps_coordinates': defaultdict(list),
+        'command_timestamps': [],
+        'message_timestamps': [],
+        'firmware1_version': "N/A",
+        'firmware2_version': "N/A",
+        'node1_uptime': "N/A",
+        'node2_uptime': "N/A",
+        'node1_name': "N/A",
+        'node2_name': "N/A",
+        'node1_ID': "N/A",
+        'node2_ID': "N/A",
+        'shameList': []
+    }
+
+    for line in lines:
+        timestamp_match = re.match(r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}),\d+', line)
+        if timestamp_match:
+            timestamp = datetime.strptime(timestamp_match.group(1), '%Y-%m-%d %H:%M:%S')
+            log_data['hourly_activity'][timestamp.strftime('%Y-%m-%d %H:00:00')] += 1
+
+        if 'Bot detected Commands' in line or 'LLM Query:' in line or 'PlayingGame' in line:
+            # get the command and user from the line
+            command = re.search(r"'cmd': '(\w+)'", line)
+            user = re.search(r"From: (.+)$", line)
+
+            if 'LLM Query:' in line:
+                log_data['command_counts']['LLM Query'] += 1
+                log_data['command_timestamps'].append((timestamp.isoformat(), 'LLM Query'))
+
+            if 'PlayingGame' in line:
+                #log line looks like this. 2024-10-04 20:24:53,381 |    DEBUG | System: 862418040 PlayingGame BlackJack last_cmd: new
+                game = re.search(r'PlayingGame (\w+)', line)
+                user = re.search(r'System: (\d+)', line)
+                log_data['command_counts'][game.group(1)] += 1
+                log_data['command_timestamps'].append((timestamp.isoformat(), game))
+
+        if 'Sending DM:' in line or 'Sending Multi-Chunk DM:' in line or 'SendingChannel:' in line or 'Sending Multi-Chunk Message:' in line:
+            log_data['message_types']['Outgoing DM'] += 1
+            log_data['total_messages'] += 1
+            log_data['message_timestamps'].append((timestamp.isoformat(), 'Outgoing DM'))
+
+        if 'Received DM:' in line or 'Ignoring DM:' in line or 'Ignoring Message:' in line or 'ReceivedChannel:' in line or 'LLM Query:' in line:
+            log_data['message_types']['Incoming DM'] += 1
+            log_data['total_messages'] += 1
+            # include a little of the message
+            if 'Ignoring Message:' in line:
+                log_data['message_timestamps'].append((timestamp.isoformat(), f'Incoming: {line.split("Ignoring Message:")[1][:90]}'))
+            elif 'Ignoring DM:' in line:
+                log_data['message_timestamps'].append((timestamp.isoformat(), f'Incoming: {line.split("Ignoring DM:")[1][:90]}'))
+            elif 'LLM Query:' in line:
+                log_data['message_timestamps'].append((timestamp.isoformat(), f'Incoming: {line.split("LLM Query:")[1][:90]}'))
+            else:
+                log_data['message_timestamps'].append((timestamp.isoformat(), 'Incoming:'))
+            # check for shame words in the message
+            for word in shameWordList:
+                if word in line.lower():
+                    if line not in log_data['shameList']:
+                        line = line.replace('Ignoring Message:', '')
+                        line = line.replace('|', '')
+                        line = line.replace('INFO', '')
+                        line = line.replace('DEBUG', '')
+                        log_data['shameList'].insert(0, line)
+                        
+        # get the user who sent the message
+        if 'To: ' in line:
+            user_match = re.search(r"From: '([^']+)'(?: To:|$)", line)
+        else:
+            user_match = re.search(r"From: (.+)$", line)
+        if user_match:
+            log_data['unique_users'].add(user_match.group(1))
+        
+        # Error Logs
+        if 'WARNING |' in line:
+            # remove some junk from the line
+            line = line.replace('|', '')
+            line = line.replace('  ', ' ')
+            log_data['warnings'].insert(0, line)
+
+        if 'ERROR |' in line or 'CRITICAL |' in line:
+            # remove some junk from the line
+            line = line.replace('System:', '')
+            line = line.replace('|', '')
+            line = line.replace('  ', ' ')
+            log_data['errors'].insert(0, line)
+
+        # bbs messages
+        bbs_match = re.search(r'📡BBSdb has (\d+) messages.*?Messages waiting: (\d+)', line)
+        if bbs_match:
+            bbs_messages = int(bbs_match.group(1))
+            messages_waiting = int(bbs_match.group(2))
+            log_data['bbs_messages'] = bbs_messages
+            log_data['messages_waiting'] = messages_waiting
+
+        gps_match = re.search(r'location data for (\d+) is ([-\d.]+),([-\d.]+)', line)
+        if gps_match:
+            node_id = None
+            node_id, lat, lon = gps_match.groups()
+            log_data['gps_coordinates'][node_id].append((float(lat), float(lon)))
+        
+        # get telemetry data
+        if '| Telemetry:' in line:
+            telemetry_match = re.search(r'Telemetry:(\d+) numPacketsRx:(\d+) numPacketsRxErr:(\d+) numPacketsTx:(\d+) numPacketsTxErr:(\d+) ChUtil%:(\d+\.\d+) AirTx%:(\d+\.\d+) totalNodes:(\d+) Online:(\d+) Uptime:(\d+d) Volt:(\d+\.\d+) Firmware:(\d+\.\d+\.\d+\.\w+)', line)
+            if telemetry_match:
+                interface_number, numPacketsRx, numPacketsRxErr, numPacketsTx, numPacketsTxErr, ChUtil, AirTx, totalNodes, online, uptime, volt, firmware_version = telemetry_match.groups()
+                data = f"Tx: {numPacketsTx} Rx: {numPacketsRx} Uptime: {uptime} Volt: {volt} numPacketsRxErr: {numPacketsRxErr} numPacketsTxErr: {numPacketsTxErr} ChUtil: {ChUtil} AirTx: {AirTx} totalNodes: {totalNodes} Online: {online}"
+                if interface_number == '1':
+                    log_data['firmware1_version'] = firmware_version
+                    log_data['node1_uptime'] = data
+                    log_data['nodeCount1'] = totalNodes
+                    log_data['nodeCountOnline1'] = online
+                    log_data['tx1'] = numPacketsTx
+                    log_data['rx1'] = numPacketsRx
+                elif interface_number == '2':
+                    log_data['firmware2_version'] = firmware_version
+                    log_data['node2_uptime'] = data
+                    log_data['nodeCount2'] = totalNodes
+                    log_data['nodeCountOnline2'] = online
+                    log_data['tx2'] = numPacketsTx
+                    log_data['rx2'] = numPacketsRx
+        
+        # get name and nodeID for devices
+        if 'Autoresponder Started for Device' in line:
+            device_match = re.search(r'Autoresponder Started for Device(\d+)\s+([^\s,]+).*?NodeID: (\d+)', line)
+            if device_match:
+                device_id = device_match.group(1)
+                device_name = device_match.group(2)
+                node_id = device_match.group(3)
+                if device_id == '1':
+                    log_data['node1_name'] = device_name
+                    log_data['node1_ID'] = node_id
+                elif device_id == '2':
+                    log_data['node2_name'] = device_name
+                    log_data['node2_ID'] = node_id
+
+    log_data['unique_users'] = list(log_data['unique_users'])
+    log_data['unique_users'].reverse()
+    return log_data
+
+def get_system_info():
+    def get_command_output(command):
+        try:
+            return subprocess.check_output(command, shell=True).decode('utf-8').strip()
+        except subprocess.CalledProcessError:
+            return "N/A"
+        
+    # Capture some system information from log_data
+    firmware1_version = log_data['firmware1_version']
+    firmware2_version = log_data['firmware2_version']
+    node1_uptime = log_data['node1_uptime']
+    node2_uptime = log_data['node2_uptime']
+    node1_name = log_data['node1_name']
+    node2_name = log_data['node2_name']
+    node1_ID = log_data['node1_ID']
+    node2_ID = log_data['node2_ID']
+
+    print(f"Node1: {node1_name} {node1_ID} {firmware1_version}")
+    print(f"Node2: {node2_name} {node2_ID} {firmware2_version}")
+
+    # get Meshtastic CLI version on web
+    try:
+        url = "https://pypi.org/pypi/meshtastic/json"
+        data = requests.get(url, timeout=5).json()
+        pypi_version = data["info"]["version"]
+        cli_web = f"v{pypi_version}"
+    except Exception:
+        pass
+    # get Meshtastic CLI version on local
+    try:
+        if "importlib.metadata" in sys.modules:
+            cli_local = version("meshtastic")
+    except:
+        pass # Python 3.7 and below, meh.. 
+
+
+    if platform.system() == "Linux":
+        uptime = get_command_output("uptime -p")
+        memory_total = get_command_output("free -m | awk '/Mem:/ {print $2}'")
+        memory_available = get_command_output("free -m | awk '/Mem:/ {print $7}'")
+        disk_total = get_command_output("df -h / | awk 'NR==2 {print $2}'")
+        disk_free = get_command_output("df -h / | awk 'NR==2 {print $4}'")
+    elif platform.system() == "Darwin":  # macOS
+        uptime = get_command_output("uptime | awk '{print $3,$4,$5}'")
+        memory_total = get_command_output("sysctl -n hw.memsize | awk '{print $0/1024/1024}'")
+        memory_available = "N/A"  # Not easily available on macOS without additional tools
+        disk_total = get_command_output("df -h / | awk 'NR==2 {print $2}'")
+        disk_free = get_command_output("df -h / | awk 'NR==2 {print $4}'")
+    else:
+        return {
+            'uptime': "N/A",
+            'memory_total': "N/A",
+            'memory_available': "N/A",
+            'disk_total': "N/A",
+            'disk_free': "N/A",
+            'interface1_version': "N/A",
+            'interface2_version': "N/A",
+            'node1_uptime': "N/A",
+            'node2_uptime': "N/A",
+            'node1_name': "N/A",
+            'node2_name': "N/A",
+            'node1_ID': "N/A",
+            'node2_ID': "N/A",
+            'cli_web': "N/A",
+            'cli_local': "N/A"
+        }
+
+    return {
+        'uptime': uptime,
+        'memory_total': f"{memory_total} MB",
+        'memory_available': f"{memory_available} MB" if memory_available != "N/A" else "N/A",
+        'disk_total': disk_total,
+        'disk_free': disk_free,
+        'interface1_version': firmware1_version,
+        'interface2_version': firmware2_version,
+        'node1_uptime': node1_uptime,
+        'node2_uptime': node2_uptime,
+        'node1_name': node1_name,
+        'node2_name': node2_name,
+        'node1_ID': node1_ID,
+        'node2_ID': node2_ID,
+        'cli_web': cli_web,
+        'cli_local': cli_local
+    }
+
+def get_wall_of_shame():
+    # Get the wall of shame out of the log data
+    logShameList = log_data['shameList']
+
+    # future space for other ideas
+
+    return {
+        'shame': ', '.join(shameWordList),
+        'shameList': '\n'.join(f'<li>{line}</li>' for line in logShameList),
+    }
+
+def get_database_info():
+    # ../config.ini location to script path
+    config_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'config.ini')
+    # get config.ini variables
+    config = configparser.ConfigParser()
+    config.read(config_path)
+    # for section in config.sections():
+    #     print(f"Section: {section}")
+    #     for key in config[section]:
+    #         print(f"Key: {key}, Value: {config[section][key]}")
+    banList = config['bbs'].get('bbs_ban_list', 'none')
+    adminList = config['bbs'].get('bbs_admin_list', 'none')
+    sentryIgnoreList = config['sentry'].get('sentryIgnoreList', 'none')
+
+  # Define the base directory
+    base_dir = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'data'))
+
+    # data files
+    databaseFiles = [os.path.join(base_dir, 'lemonstand_hs.pkl'),
+                     os.path.join(base_dir, 'dopewar_hs.pkl'),
+                     os.path.join(base_dir, 'blackjack_hs.pkl'),
+                     os.path.join(base_dir, 'videopoker_hs.pkl'),
+                     os.path.join(base_dir, 'mmind_hs.pkl'),
+                     os.path.join(base_dir, 'golfsim_hs.pkl'),
+                     os.path.join(base_dir, 'bbsdb.pkl'),
+                     os.path.join(base_dir, 'bbsdm.pkl')]
+    
+    for file in databaseFiles:
+        try:
+            with open(file, 'rb') as f:
+                if 'lemonstand' in file:
+                    lemon_score = pickle.load(f)
+                elif 'dopewar' in file:
+                    dopewar_score = pickle.load(f)
+                elif 'blackjack' in file:
+                    blackjack_score = pickle.load(f)
+                elif 'videopoker' in file:
+                    videopoker_score = pickle.load(f)
+                elif 'mmind' in file:
+                    mmind_score = pickle.load(f)
+                elif 'golfsim' in file:
+                    golfsim_score = pickle.load(f)
+                elif 'bbsdb' in file:
+                    bbsdb = pickle.load(f)
+                elif 'bbsdm' in file:
+                    bbsdm = pickle.load(f)
+        except Exception as e:
+            print(f"Error reading database file: {str(e)}")
+            if 'lemonstand' in file:
+                lemon_score = "no data"
+            elif 'dopewar' in file:
+                dopewar_score = "no data"
+            elif 'blackjack' in file:
+                blackjack_score = "no data"
+            elif 'videopoker' in file:
+                videopoker_score = "no data"
+            elif 'mmind' in file:
+                mmind_score = "no data"
+            elif 'golfsim' in file:
+                golfsim_score = "no data"
+            elif 'bbsdb' in file:
+                bbsdb = "no data"
+            elif 'bbsdm' in file:
+                bbsdm = "no data"
+
+    # pretty print the bbsdb
+    prettyBBSdb = ""
+    try:
+        for i in range(len(bbsdb)):
+            prettyBBSdb += f'<li>{bbsdb[i]}</li>'
+    except Exception as e:
+        print(f"Error with database: {str(e)}")
+        pass
+
+    # pretty print the bbsdm
+    prettyBBSdm = ""
+    try:
+        for i in range(len(bbsdm)):
+            prettyBBSdm += f'<li>{bbsdm[i]}</li>'
+    except Exception as e:
+        print(f"Error with database: {str(e)}")
+        pass
+
+    if 'no data' in [lemon_score, dopewar_score, blackjack_score, videopoker_score, mmind_score, golfsim_score]:
+        database = "Error(s) Detected"
+    else:
+        database = " Online"
+
+    return {
+        'database': database,
+        "bbsdb": prettyBBSdb,
+        "bbsdm": prettyBBSdm,
+        'lemon_score': lemon_score,
+        'dopewar_score': dopewar_score,
+        'blackjack_score': blackjack_score,
+        'videopoker_score': videopoker_score,
+        'mmind_score': mmind_score,
+        'golfsim_score': golfsim_score,
+        'banList': banList,
+        'adminList': adminList,
+        'sentryIgnoreList': sentryIgnoreList
+    }
+
+def generate_main_html(log_data, system_info):
+    html_template = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>MeshBot (BBS) Web Dashboard</title>
+        <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+        <script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-date-fns/dist/chartjs-adapter-date-fns.bundle.min.js"></script>
+        <link rel="stylesheet" href="https://unpkg.com/leaflet@1.7.1/dist/leaflet.css" />
+        <script src="https://unpkg.com/leaflet@1.7.1/dist/leaflet.js"></script>
+        <style>
+            body {
+                font-family: Arial, sans-serif;
+                margin: 0;
+                padding: 0;
+                background-color: #f0f0f0;
+                display: flex;
+            }
+            .header {
+                background-color: #333;
+                color: white;
+                padding: 10px;
+                font-size: 24px;
+                position: fixed;
+                top: 0;
+                left: 0;
+                right: 0;
+                z-index: 1000;
+            }
+            .sidebar {
+                width: 200px;
+                background-color: #ddd;
+                padding: 10px;
+                height: 100vh;
+                position: fixed;
+                top: 50px;
+                left: 0;
+                overflow-y: auto;
+            }
+            .content {
+                margin-left: 220px;
+                margin-top: 60px;
+                padding: 20px;
+                display: grid;
+                grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
+                gap: 20px;
+                flex-grow: 1;
+            }
+            .chart-container {
+                background-color: white;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                padding: 10px;
+                height: 400px;
+                display: flex;
+                flex-direction: column;
+            }
+            .chart-title {
+                font-size: 16px;
+                font-weight: bold;
+                margin-bottom: 10px;
+            }
+            #map, .chart-content {
+                flex-grow: 1;
+                width: 100%;
+            }
+            .list-container {
+                background-color: white;
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                padding: 10px;
+                height: 400px;
+                overflow-y: auto;
+            }
+            ul {
+                list-style-type: none;
+                padding: 0;
+                margin: 0;
+            }
+            li {
+                padding: 5px 0;
+                border-bottom: 1px solid #eee;
+            }
+            li:last-child {
+                border-bottom: none;
+            }
+            #iframe-content {
+                display: none;
+                position: fixed;
+                top: 50px;
+                left: 220px;
+                right: 0;
+                bottom: 0;
+                background: white;
+                z-index: 900;
+            }
+            iframe {
+                width: 100%;
+                height: 100%;
+                border: none;
+            }
+            .timestamp-list {
+                height: 400px;
+                overflow-y: auto;
+                font-size: 12px;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="header">MeshBot (BBS) Web Dashboard</div>
+        <div class="sidebar">
+            <ul>
+                <li><a href="#" onclick="showDashboard(); return false;">Dashboard</a></li>
+                <li><a href="#" onclick="showIframe('network_map_${date}.html'); return false;">Network Map</a></li>
+                <li><a href="#" onclick="showIframe('wall_of_shame_${date}.html'); return false;">Wall of Shame</a></li>
+                <li><a href="#" onclick="showIframe('database_${date}.html'); return false;">Database</a></li>
+                <li><a href="#" onclick="showIframe('hosts_${date}.html'); return false;">System Host</a></li>
+            </ul>
+        </div>
+        <div class="content" id="dashboard-content">
+            <div class="chart-container">
+                <div class="chart-title">Node Locations</div>
+                <div id="map"></div>
+            </div>
+            <div class="chart-container">
+                <div class="chart-title">Network Activity</div>
+                <div class="chart-content">
+                    <canvas id="activityChart"></canvas>
+                </div>
+            </div>
+            <div class="chart-container">
+                <div class="chart-title">Command Usage</div>
+                <div class="chart-content">
+                    <canvas id="commandChart"></canvas>
+                </div>
+            </div>
+            <div class="chart-container">
+                <div class="chart-title">Message Types</div>
+                <div class="chart-content">
+                    <canvas id="messageChart"></canvas>
+                </div>
+            </div>
+            <div class="chart-container">
+                <div class="chart-title">BBS Stored Message Counts</div>
+                <div class="chart-content">
+                    <canvas id="messageCountChart"></canvas>
+                </div>
+            </div>
+            <div class="chart-container">
+                <div class="chart-title">Recent Commands</div>
+                <div class="timestamp-list">
+                    <ul>
+                        ${command_timestamps}
+                    </ul>
+                </div>
+            </div>
+            <div class="chart-container">
+                <div class="chart-title">Recent Messages</div>
+                <div class="timestamp-list">
+                    <ul>
+                        ${message_timestamps}
+                    </ul>
+                </div>
+            </div>
+            <div class="list-container">
+                <div class="chart-title">Unique Users</div>
+                <ul>
+                    ${unique_users}
+                </ul>
+            </div>
+            <div class="list-container">
+                <div class="chart-title">Warnings</div>
+                <ul>
+                    ${warnings}
+                </ul>
+            </div>
+            <div class="list-container">
+                <div class="chart-title">Errors</div>
+                <ul>
+                    ${errors}
+                </ul>
+            </div>
+        </div>
+        <div id="iframe-content">
+            <iframe id="content-iframe" src=""></iframe>
+        </div>
+        <script>
+            const commandData = ${command_data};
+            const messageData = ${message_data};
+            const activityData = ${activity_data};
+            const messageCountData = {
+                labels: ['BBSdm Messages', 'BBSdb Messages', 'Channel Messages'],
+                datasets: [{
+                    label: 'Message Counts',
+                    data: [${messages_waiting}, ${bbs_messages}, ${total_messages}],
+                    backgroundColor: ['rgba(255, 206, 86, 0.6)', 'rgba(75, 192, 192, 0.6)', 'rgba(54, 162, 235, 0.6)']
+                }]
+            };
+
+            const chartOptions = {
+                responsive: true,
+                maintainAspectRatio: false
+            };
+
+            new Chart(document.getElementById('commandChart'), {
+                type: 'bar',
+                data: {
+                    labels: Object.keys(commandData),
+                    datasets: [{
+                        label: 'Command Usage',
+                        data: Object.values(commandData),
+                        backgroundColor: 'rgba(75, 192, 192, 0.6)'
+                    }]
+                },
+                options: chartOptions
+            });
+
+            new Chart(document.getElementById('messageChart'), {
+                type: 'pie',
+                data: {
+                    labels: Object.keys(messageData),
+                    datasets: [{
+                        data: Object.values(messageData),
+                        backgroundColor: ['rgba(255, 99, 132, 0.6)', 'rgba(54, 162, 235, 0.6)']
+                    }]
+                },
+                options: chartOptions
+            });
+
+            new Chart(document.getElementById('activityChart'), {
+                type: 'line',
+                data: {
+                    labels: Object.keys(activityData),
+                    datasets: [{
+                        label: 'Hourly Activity',
+                        data: Object.entries(activityData).map(([time, count]) => ({x: new Date(time), y: count})),
+                        borderColor: 'rgba(153, 102, 255, 1)',
+                        fill: false
+                    }]
+                },
+                options: {
+                    ...chartOptions,
+                    scales: {
+                        x: {
+                            type: 'time',
+                            time: {
+                                unit: 'hour',
+                                displayFormats: {
+                                    hour: 'MMM d, HH:mm'
+                                }
+                            },
+                            title: {
+                                display: true,
+                                text: 'Time'
+                            }
+                        },
+                        y: {
+                            beginAtZero: true,
+                            title: {
+                                display: true,
+                                text: 'Activity Count'
+                            }
+                        }
+                    }
+                }
+            });
+
+            new Chart(document.getElementById('messageCountChart'), {
+                type: 'bar',
+                data: messageCountData,
+                options: {
+                    ...chartOptions,
+                    scales: {
+                        y: {
+                            beginAtZero: true
+                        }
+                    }
+                }
+            });
+
+            var map = L.map('map').setView([0, 0], 2);
+            L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+                attribution: '© OpenStreetMap contributors'
+            }).addTo(map);
+
+            var gpsCoordinates = ${gps_coordinates};
+            for (var nodeId in gpsCoordinates) {
+                var coords = gpsCoordinates[nodeId][0];
+                L.marker(coords).addTo(map)
+                    .bindPopup("Node ID: " + nodeId);
+            }
+
+            var bounds = [];
+            for (var nodeId in gpsCoordinates) {
+                bounds.push(gpsCoordinates[nodeId][0]);
+            }
+            map.fitBounds(bounds);
+
+            function showIframe(src) {
+                document.getElementById('dashboard-content').style.display = 'none';
+                document.getElementById('iframe-content').style.display = 'block';
+                document.getElementById('content-iframe').src = src;
+            }
+
+            function showDashboard() {
+                document.getElementById('dashboard-content').style.display = 'grid';
+                document.getElementById('iframe-content').style.display = 'none';
+                document.getElementById('content-iframe').src = '';
+            }
+        </script>
+    </body>
+    </html>
+    """
+    template = Template(html_template)
+    return template.safe_substitute(
+        date=datetime.now().strftime('%Y_%m_%d'),
+        command_data=json.dumps(log_data['command_counts']),
+        message_data=json.dumps(log_data['message_types']),
+        activity_data=json.dumps(log_data['hourly_activity']),
+        bbs_messages=log_data['bbs_messages'],
+        messages_waiting=log_data['messages_waiting'],
+        total_messages=log_data['total_messages'],
+        total_llm_queries=log_data['message_types']['LLM Query'],
+        gps_coordinates=json.dumps(log_data['gps_coordinates']),
+        unique_users='\n'.join(f'<li>{user}</li>' for user in log_data['unique_users']),
+        warnings='\n'.join(f'<li>{warning}</li>' for warning in log_data['warnings']),
+        errors='\n'.join(f'<li>{error}</li>' for error in log_data['errors']),
+        command_timestamps='\n'.join(f'<li>{timestamp}: {cmd}</li>' for timestamp, cmd in reversed(log_data['command_timestamps'][-50:])),
+        message_timestamps='\n'.join(f'<li>{timestamp}: {msg_type}</li>' for timestamp, msg_type in reversed(log_data['message_timestamps'][-50:]))
+    )
+
+def generate_network_map_html(log_data):
+    html_template = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Network Map</title>
+        <link rel="stylesheet" href="https://unpkg.com/leaflet@1.7.1/dist/leaflet.css" />
+        <script src="https://unpkg.com/leaflet@1.7.1/dist/leaflet.js"></script>
+        <style>
+            body { margin: 0; padding: 0; }
+            #map { position: absolute; top: 0; bottom: 0; width: 100%; }
+        </style>
+    </head>
+    <body>
+        <div id="map"></div>
+        <script>
+            var map = L.map('map').setView([0, 0], 2);
+            L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
+                attribution: '© OpenStreetMap contributors'
+            }).addTo(map);
+
+            var gpsCoordinates = ${gps_coordinates};
+            for (var nodeId in gpsCoordinates) {
+                var coords = gpsCoordinates[nodeId][0];
+                L.marker(coords).addTo(map)
+                    .bindPopup("Node ID: " + nodeId);
+            }
+
+            var bounds = [];
+            for (var nodeId in gpsCoordinates) {
+                bounds.push(gpsCoordinates[nodeId][0]);
+            }
+            map.fitBounds(bounds);
+        </script>
+    </body>
+    </html>
+    """
+
+    template = Template(html_template)
+    return template.safe_substitute(gps_coordinates=json.dumps(log_data['gps_coordinates']))
+
+def generate_sys_hosts_html(system_info):
+    html_template = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>System Host Information</title>
+        <style>
+            body { font-family: Arial, sans-serif; line-height: 1.6; padding: 20px; }
+            h1 { color: #00ff00; }
+            table { border-collapse: collapse; width: 100%; background-color: #d3d3d3; }
+            th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+            th { background-color: #f2f2f2; }
+        </style>
+    </head>
+    <body>
+        <h1>System Host Information</h1>
+        <table>
+            <tr><th>OS Metric</th><th>Value</th></tr>
+            <tr><td>Uptime</td><td>${uptime}</td></tr>
+            <tr><td>Total Memory</td><td>${memory_total}</td></tr>
+            <tr><td>Available Memory</td><td>${memory_available}</td></tr>
+            <tr><td>Total Disk Space</td><td>${disk_total}</td></tr>
+            <tr><td>Free Disk Space</td><td>${disk_free}</td></tr>
+            <tr><th>Meshtastic Metric</th><th>Value</th></tr>
+            <tr><td>API Version/Latest</td><td>${cli_local} / ${cli_web}</td></tr>
+            <tr><td>Int1 Name ID</td><td>${node1_name} (${node1_ID})</td></tr>
+            <tr><td>Int1 Stat</td><td>${node1_uptime}</td></tr>
+            <tr><td>Int1 FW Version</td><td>${interface1_version}</td></tr>
+            <tr><td>Int2 Name ID</td><td>${node2_name} (${node2_ID})</td></tr>
+            <tr><td>Int2 Stat</td><td>${node2_uptime}</td></tr>
+            <tr><td>Int2 FW Version</td><td>${interface2_version}</td></tr>
+        </table>
+    </body>
+    </html>
+    """
+
+    template = Template(html_template)
+    return template.safe_substitute(system_info)
+
+def generate_wall_of_shame_html(shame_info):
+    html_template = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Wall Of Shame</title>
+        <style>
+            body { font-family: Arial, sans-serif; line-height: 1.6; padding: 20px; }
+            h1 { color: #00ff00; }
+            table { border-collapse: collapse; width: 100%; background-color: #d3d3d3; }
+            th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+            th { background-color: #f2f2f2; }
+        </style>
+    </head>
+    <body>
+        <h1>Collected Shame</h1>
+        <table>
+            <tr><th>Shame Metric</th><th>Value</th></tr>
+            <tr><td>Shamefull words</td><td>${shame}</td></tr>
+            <tr><td>Shamefull messages</td><td>${shameList}</td></tr>
+        </table>
+    </body>
+    </html>
+    """
+
+    template = Template(html_template)
+    return template.safe_substitute(shame_info)
+
+def generate_database_html(database_info):
+    html_template = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Database Information</title>
+        <style>
+            body { font-family: Arial, sans-serif; line-height: 1.6; padding: 20px; }
+            h1 { color: #00ff00; }
+            table { border-collapse: collapse; width: 100%; background-color: #d3d3d3; }
+            th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+            th { background-color: #f2f2f2; }
+        </style>
+    </head>
+    <body>
+        <h1>Database Information</h1>
+        <p>Connection ${database}</p>
+        <table>
+            <tr><th>config.ini Settings</th><th>Value</th></tr>
+            <tr><td>Admin List</td><td>${adminList}</td></tr>
+            <tr><td>Ban List</td><td>${banList}</td></tr>
+            <tr><td>Sentry Ignore List</td><td>${sentryIgnoreList}</td></tr>
+        </table>
+        <h1>BBS Message Database</h1>
+        <p>BBSdb: ${bbsdb}</p>
+        <p>BBSdm: ${bbsdm}</p>
+        <h1>High Scores</h1>
+        <table>
+            <tr><th>Game</th><th>High Score</th></tr>
+            <tr><td>Lemonade Stand</td><td>${lemon_score}</td></tr>
+            <tr><td>Dopewars</td><td>${dopewar_score}</td></tr>
+            <tr><td>Blackjack</td><td>${blackjack_score}</td></tr>
+            <tr><td>Video Poker</td><td>${videopoker_score}</td></tr>
+            <tr><td>Mastermind</td><td>${mmind_score}</td></tr>
+            <tr><td>Golf Simulator</td><td>${golfsim_score}</td></tr>
+        </table>
+    </body>
+    </html>
+    """
+
+    template = Template(html_template)
+    return template.safe_substitute(database_info)
+
+def main():
+    log_dir = LOG_PATH
+    today = datetime.now().strftime('%Y_%m_%d')
+    log_file = f'meshbot{today}.log'
+    log_path = os.path.join(log_dir, log_file)
+
+    if not os.path.exists(log_path):
+        # set file_path to the cwd of the default project ../log
+        file_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'logs')
+        file_path = os.path.abspath(file_path)
+        log_path = os.path.join(file_path, log_file)
+
+    log_data = parse_log_file(log_path)
+    system_info = get_system_info()
+    shame_info = get_wall_of_shame()
+    database_info = get_database_info()
+
+    main_html = generate_main_html(log_data, system_info)
+    network_map_html = generate_network_map_html(log_data)
+    hosts_html = generate_sys_hosts_html(system_info)
+    wall_of_shame = generate_wall_of_shame_html(shame_info)
+    database_html = generate_database_html(database_info)
+
+    output_dir = W3_PATH
+    index_path = os.path.join(output_dir, 'index.html')
+
+    print(f"\n\nMeshBot (BBS) Web Dashboard Report Generator")
+    print(f"\nMain dashboard: file://{index_path}\n")
+    
+    try:
+        if not os.path.exists(output_dir):
+            output_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'www')
+            output_dir = os.path.abspath(output_dir)
+            index_path = os.path.join(output_dir, 'index.html')
+
+        # Create backup of existing index.html if it exists
+        if os.path.exists(index_path):
+            backup_path = os.path.join(output_dir, f'index_backup_{today}.html')
+            os.rename(index_path, backup_path)
+            print(f"Existing index.html backed up to {backup_path}")
+
+        # Write main HTML to index.html
+        with open(index_path, 'w') as f:
+            f.write(main_html)
+        print(f"Main dashboard written to {index_path}")
+
+        # Write other HTML files
+        with open(os.path.join(output_dir, f'network_map_{today}.html'), 'w') as f:
+            f.write(network_map_html)
+        
+        with open(os.path.join(output_dir, f'hosts_{today}.html'), 'w') as f:
+            f.write(hosts_html)
+
+        with open(os.path.join(output_dir, f'wall_of_shame_{today}.html'), 'w') as f:
+            f.write(wall_of_shame)
+        
+        with open(os.path.join(output_dir, f'database_{today}.html'), 'w') as f:
+            f.write(database_html)
+
+        print(f"HTML reports generated for {today} in {output_dir}")
+
+    except PermissionError:
+        print("Error: Permission denied. Please run the script with appropriate permissions (e.g., using sudo).")
+    except Exception as e:
+        print(f"An error occurred while writing the output: {str(e)}")
+
+if __name__ == "__main__":
+    main()

etc/simulator.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # # Simulate meshing-around de K7MHI 2024
-from modules.log import * # err? Move .py out of etc/ and place it in the root of the project
+from modules.log import * # Import the logger
 import time
 import random
 
@@ -8,6 +8,7 @@ import random
 projectName = "example_handler" # name of _handler function to match the function name under test
 randomNode = False # Set to True to use random node IDs
 
+# bot.py Simulated functions
 def get_NodeID():
     nodeList = [4258675309, 1212121212, 1234567890, 9876543210]
     if randomNode: 
@@ -15,12 +16,16 @@ def get_NodeID():
     else:
         nodeID = nodeList[0]
     return nodeID
+def get_name_from_number(nodeID, length='short', interface=1):
+    # return random name for nodeID
+    names = ["Max","Molly","Jake","Kelly"]
+    return names[nodeID % len(names)]
 # # end Initialization of the tool
 
 # # Function to handle, or the project in test
 
 
-def example_handler(nodeID, message):
+def example_handler(message, nodeID, deviceID):
     readableTime = time.ctime(time.time())
     msg = "Hello World! "
     msg += f" You are Node ID: {nodeID} "
@@ -37,7 +42,7 @@ if __name__ == '__main__': # represents the bot's main loop
     nodeInt = 1 # represents the device/node number
     logger.info(f"System: Meshing-Around Simulator Starting for {projectName}")
     nodeID = get_NodeID() # assign a nodeID
-    projectResponse = globals()[projectName](nodeID, " ") # Call the project handler under test
+    projectResponse = globals()[projectName]("", nodeID, nodeInt) # Call the project handler under test
     while True: # represents the onReceive() loop in the bot.py
         projectResponse = ""
         responseLength = 0
@@ -46,7 +51,7 @@ if __name__ == '__main__': # represents the bot's main loop
         packet = input(f"CLIENT {nodeID} INPUT: " ) # Emulate the client input
         if packet != "":
             #try:
-            projectResponse = globals()[projectName](nodeID, packet) # Call the project handler under test
+            projectResponse = globals()[projectName](message = packet, nodeID = nodeID, deviceID = nodeInt)
             # except Exception as e:
             #     logger.error(f"System: Handler: {e}")
             #     projectResponse = "Error in handler"

etc/www/localscripts/css2

@@ -0,0 +1,252 @@
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}

etc/www/localscripts/leaflet.css

@@ -0,0 +1,640 @@
+/* required styles */
+
+.leaflet-pane,
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow,
+.leaflet-tile-container,
+.leaflet-pane > svg,
+.leaflet-pane > canvas,
+.leaflet-zoom-box,
+.leaflet-image-layer,
+.leaflet-layer {
+	position: absolute;
+	left: 0;
+	top: 0;
+	}
+.leaflet-container {
+	overflow: hidden;
+	}
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+	-webkit-user-select: none;
+	   -moz-user-select: none;
+	        user-select: none;
+	  -webkit-user-drag: none;
+	}
+/* Prevents IE11 from highlighting tiles in blue */
+.leaflet-tile::selection {
+	background: transparent;
+}
+/* Safari renders non-retina tile on retina better with this, but Chrome is worse */
+.leaflet-safari .leaflet-tile {
+	image-rendering: -webkit-optimize-contrast;
+	}
+/* hack that prevents hw layers "stretching" when loading new tiles */
+.leaflet-safari .leaflet-tile-container {
+	width: 1600px;
+	height: 1600px;
+	-webkit-transform-origin: 0 0;
+	}
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+	display: block;
+	}
+/* .leaflet-container svg: reset svg max-width decleration shipped in Joomla! (joomla.org) 3.x */
+/* .leaflet-container img: map is broken in FF if you have max-width: 100% on tiles */
+.leaflet-container .leaflet-overlay-pane svg,
+.leaflet-container .leaflet-marker-pane img,
+.leaflet-container .leaflet-shadow-pane img,
+.leaflet-container .leaflet-tile-pane img,
+.leaflet-container img.leaflet-image-layer,
+.leaflet-container .leaflet-tile {
+	max-width: none !important;
+	max-height: none !important;
+	}
+
+.leaflet-container.leaflet-touch-zoom {
+	-ms-touch-action: pan-x pan-y;
+	touch-action: pan-x pan-y;
+	}
+.leaflet-container.leaflet-touch-drag {
+	-ms-touch-action: pinch-zoom;
+	/* Fallback for FF which doesn't support pinch-zoom */
+	touch-action: none;
+	touch-action: pinch-zoom;
+}
+.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom {
+	-ms-touch-action: none;
+	touch-action: none;
+}
+.leaflet-container {
+	-webkit-tap-highlight-color: transparent;
+}
+.leaflet-container a {
+	-webkit-tap-highlight-color: rgba(51, 181, 229, 0.4);
+}
+.leaflet-tile {
+	filter: inherit;
+	visibility: hidden;
+	}
+.leaflet-tile-loaded {
+	visibility: inherit;
+	}
+.leaflet-zoom-box {
+	width: 0;
+	height: 0;
+	-moz-box-sizing: border-box;
+	     box-sizing: border-box;
+	z-index: 800;
+	}
+/* workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=888319 */
+.leaflet-overlay-pane svg {
+	-moz-user-select: none;
+	}
+
+.leaflet-pane         { z-index: 400; }
+
+.leaflet-tile-pane    { z-index: 200; }
+.leaflet-overlay-pane { z-index: 400; }
+.leaflet-shadow-pane  { z-index: 500; }
+.leaflet-marker-pane  { z-index: 600; }
+.leaflet-tooltip-pane   { z-index: 650; }
+.leaflet-popup-pane   { z-index: 700; }
+
+.leaflet-map-pane canvas { z-index: 100; }
+.leaflet-map-pane svg    { z-index: 200; }
+
+.leaflet-vml-shape {
+	width: 1px;
+	height: 1px;
+	}
+.lvml {
+	behavior: url(#default#VML);
+	display: inline-block;
+	position: absolute;
+	}
+
+
+/* control positioning */
+
+.leaflet-control {
+	position: relative;
+	z-index: 800;
+	pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
+	pointer-events: auto;
+	}
+.leaflet-top,
+.leaflet-bottom {
+	position: absolute;
+	z-index: 1000;
+	pointer-events: none;
+	}
+.leaflet-top {
+	top: 0;
+	}
+.leaflet-right {
+	right: 0;
+	}
+.leaflet-bottom {
+	bottom: 0;
+	}
+.leaflet-left {
+	left: 0;
+	}
+.leaflet-control {
+	float: left;
+	clear: both;
+	}
+.leaflet-right .leaflet-control {
+	float: right;
+	}
+.leaflet-top .leaflet-control {
+	margin-top: 10px;
+	}
+.leaflet-bottom .leaflet-control {
+	margin-bottom: 10px;
+	}
+.leaflet-left .leaflet-control {
+	margin-left: 10px;
+	}
+.leaflet-right .leaflet-control {
+	margin-right: 10px;
+	}
+
+
+/* zoom and fade animations */
+
+.leaflet-fade-anim .leaflet-tile {
+	will-change: opacity;
+	}
+.leaflet-fade-anim .leaflet-popup {
+	opacity: 0;
+	-webkit-transition: opacity 0.2s linear;
+	   -moz-transition: opacity 0.2s linear;
+	        transition: opacity 0.2s linear;
+	}
+.leaflet-fade-anim .leaflet-map-pane .leaflet-popup {
+	opacity: 1;
+	}
+.leaflet-zoom-animated {
+	-webkit-transform-origin: 0 0;
+	    -ms-transform-origin: 0 0;
+	        transform-origin: 0 0;
+	}
+.leaflet-zoom-anim .leaflet-zoom-animated {
+	will-change: transform;
+	}
+.leaflet-zoom-anim .leaflet-zoom-animated {
+	-webkit-transition: -webkit-transform 0.25s cubic-bezier(0,0,0.25,1);
+	   -moz-transition:    -moz-transform 0.25s cubic-bezier(0,0,0.25,1);
+	        transition:         transform 0.25s cubic-bezier(0,0,0.25,1);
+	}
+.leaflet-zoom-anim .leaflet-tile,
+.leaflet-pan-anim .leaflet-tile {
+	-webkit-transition: none;
+	   -moz-transition: none;
+	        transition: none;
+	}
+
+.leaflet-zoom-anim .leaflet-zoom-hide {
+	visibility: hidden;
+	}
+
+
+/* cursors */
+
+.leaflet-interactive {
+	cursor: pointer;
+	}
+.leaflet-grab {
+	cursor: -webkit-grab;
+	cursor:    -moz-grab;
+	cursor:         grab;
+	}
+.leaflet-crosshair,
+.leaflet-crosshair .leaflet-interactive {
+	cursor: crosshair;
+	}
+.leaflet-popup-pane,
+.leaflet-control {
+	cursor: auto;
+	}
+.leaflet-dragging .leaflet-grab,
+.leaflet-dragging .leaflet-grab .leaflet-interactive,
+.leaflet-dragging .leaflet-marker-draggable {
+	cursor: move;
+	cursor: -webkit-grabbing;
+	cursor:    -moz-grabbing;
+	cursor:         grabbing;
+	}
+
+/* marker & overlays interactivity */
+.leaflet-marker-icon,
+.leaflet-marker-shadow,
+.leaflet-image-layer,
+.leaflet-pane > svg path,
+.leaflet-tile-container {
+	pointer-events: none;
+	}
+
+.leaflet-marker-icon.leaflet-interactive,
+.leaflet-image-layer.leaflet-interactive,
+.leaflet-pane > svg path.leaflet-interactive,
+svg.leaflet-image-layer.leaflet-interactive path {
+	pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
+	pointer-events: auto;
+	}
+
+/* visual tweaks */
+
+.leaflet-container {
+	background: #ddd;
+	outline: 0;
+	}
+.leaflet-container a {
+	color: #0078A8;
+	}
+.leaflet-container a.leaflet-active {
+	outline: 2px solid orange;
+	}
+.leaflet-zoom-box {
+	border: 2px dotted #38f;
+	background: rgba(255,255,255,0.5);
+	}
+
+
+/* general typography */
+.leaflet-container {
+	font: 12px/1.5 "Helvetica Neue", Arial, Helvetica, sans-serif;
+	}
+
+
+/* general toolbar styles */
+
+.leaflet-bar {
+	box-shadow: 0 1px 5px rgba(0,0,0,0.65);
+	border-radius: 4px;
+	}
+.leaflet-bar a,
+.leaflet-bar a:hover {
+	background-color: #fff;
+	border-bottom: 1px solid #ccc;
+	width: 26px;
+	height: 26px;
+	line-height: 26px;
+	display: block;
+	text-align: center;
+	text-decoration: none;
+	color: black;
+	}
+.leaflet-bar a,
+.leaflet-control-layers-toggle {
+	background-position: 50% 50%;
+	background-repeat: no-repeat;
+	display: block;
+	}
+.leaflet-bar a:hover {
+	background-color: #f4f4f4;
+	}
+.leaflet-bar a:first-child {
+	border-top-left-radius: 4px;
+	border-top-right-radius: 4px;
+	}
+.leaflet-bar a:last-child {
+	border-bottom-left-radius: 4px;
+	border-bottom-right-radius: 4px;
+	border-bottom: none;
+	}
+.leaflet-bar a.leaflet-disabled {
+	cursor: default;
+	background-color: #f4f4f4;
+	color: #bbb;
+	}
+
+.leaflet-touch .leaflet-bar a {
+	width: 30px;
+	height: 30px;
+	line-height: 30px;
+	}
+.leaflet-touch .leaflet-bar a:first-child {
+	border-top-left-radius: 2px;
+	border-top-right-radius: 2px;
+	}
+.leaflet-touch .leaflet-bar a:last-child {
+	border-bottom-left-radius: 2px;
+	border-bottom-right-radius: 2px;
+	}
+
+/* zoom control */
+
+.leaflet-control-zoom-in,
+.leaflet-control-zoom-out {
+	font: bold 18px 'Lucida Console', Monaco, monospace;
+	text-indent: 1px;
+	}
+
+.leaflet-touch .leaflet-control-zoom-in, .leaflet-touch .leaflet-control-zoom-out  {
+	font-size: 22px;
+	}
+
+
+/* layers control */
+
+.leaflet-control-layers {
+	box-shadow: 0 1px 5px rgba(0,0,0,0.4);
+	background: #fff;
+	border-radius: 5px;
+	}
+.leaflet-control-layers-toggle {
+	background-image: url(images/layers.png);
+	width: 36px;
+	height: 36px;
+	}
+.leaflet-retina .leaflet-control-layers-toggle {
+	background-image: url(images/layers-2x.png);
+	background-size: 26px 26px;
+	}
+.leaflet-touch .leaflet-control-layers-toggle {
+	width: 44px;
+	height: 44px;
+	}
+.leaflet-control-layers .leaflet-control-layers-list,
+.leaflet-control-layers-expanded .leaflet-control-layers-toggle {
+	display: none;
+	}
+.leaflet-control-layers-expanded .leaflet-control-layers-list {
+	display: block;
+	position: relative;
+	}
+.leaflet-control-layers-expanded {
+	padding: 6px 10px 6px 6px;
+	color: #333;
+	background: #fff;
+	}
+.leaflet-control-layers-scrollbar {
+	overflow-y: scroll;
+	overflow-x: hidden;
+	padding-right: 5px;
+	}
+.leaflet-control-layers-selector {
+	margin-top: 2px;
+	position: relative;
+	top: 1px;
+	}
+.leaflet-control-layers label {
+	display: block;
+	}
+.leaflet-control-layers-separator {
+	height: 0;
+	border-top: 1px solid #ddd;
+	margin: 5px -10px 5px -6px;
+	}
+
+/* Default icon URLs */
+.leaflet-default-icon-path {
+	background-image: url(images/marker-icon.png);
+	}
+
+
+/* attribution and scale controls */
+
+.leaflet-container .leaflet-control-attribution {
+	background: #fff;
+	background: rgba(255, 255, 255, 0.7);
+	margin: 0;
+	}
+.leaflet-control-attribution,
+.leaflet-control-scale-line {
+	padding: 0 5px;
+	color: #333;
+	}
+.leaflet-control-attribution a {
+	text-decoration: none;
+	}
+.leaflet-control-attribution a:hover {
+	text-decoration: underline;
+	}
+.leaflet-container .leaflet-control-attribution,
+.leaflet-container .leaflet-control-scale {
+	font-size: 11px;
+	}
+.leaflet-left .leaflet-control-scale {
+	margin-left: 5px;
+	}
+.leaflet-bottom .leaflet-control-scale {
+	margin-bottom: 5px;
+	}
+.leaflet-control-scale-line {
+	border: 2px solid #777;
+	border-top: none;
+	line-height: 1.1;
+	padding: 2px 5px 1px;
+	font-size: 11px;
+	white-space: nowrap;
+	overflow: hidden;
+	-moz-box-sizing: border-box;
+	     box-sizing: border-box;
+
+	background: #fff;
+	background: rgba(255, 255, 255, 0.5);
+	}
+.leaflet-control-scale-line:not(:first-child) {
+	border-top: 2px solid #777;
+	border-bottom: none;
+	margin-top: -2px;
+	}
+.leaflet-control-scale-line:not(:first-child):not(:last-child) {
+	border-bottom: 2px solid #777;
+	}
+
+.leaflet-touch .leaflet-control-attribution,
+.leaflet-touch .leaflet-control-layers,
+.leaflet-touch .leaflet-bar {
+	box-shadow: none;
+	}
+.leaflet-touch .leaflet-control-layers,
+.leaflet-touch .leaflet-bar {
+	border: 2px solid rgba(0,0,0,0.2);
+	background-clip: padding-box;
+	}
+
+
+/* popup */
+
+.leaflet-popup {
+	position: absolute;
+	text-align: center;
+	margin-bottom: 20px;
+	}
+.leaflet-popup-content-wrapper {
+	padding: 1px;
+	text-align: left;
+	border-radius: 12px;
+	}
+.leaflet-popup-content {
+	margin: 13px 19px;
+	line-height: 1.4;
+	}
+.leaflet-popup-content p {
+	margin: 18px 0;
+	}
+.leaflet-popup-tip-container {
+	width: 40px;
+	height: 20px;
+	position: absolute;
+	left: 50%;
+	margin-left: -20px;
+	overflow: hidden;
+	pointer-events: none;
+	}
+.leaflet-popup-tip {
+	width: 17px;
+	height: 17px;
+	padding: 1px;
+
+	margin: -10px auto 0;
+
+	-webkit-transform: rotate(45deg);
+	   -moz-transform: rotate(45deg);
+	    -ms-transform: rotate(45deg);
+	        transform: rotate(45deg);
+	}
+.leaflet-popup-content-wrapper,
+.leaflet-popup-tip {
+	background: white;
+	color: #333;
+	box-shadow: 0 3px 14px rgba(0,0,0,0.4);
+	}
+.leaflet-container a.leaflet-popup-close-button {
+	position: absolute;
+	top: 0;
+	right: 0;
+	padding: 4px 4px 0 0;
+	border: none;
+	text-align: center;
+	width: 18px;
+	height: 14px;
+	font: 16px/14px Tahoma, Verdana, sans-serif;
+	color: #c3c3c3;
+	text-decoration: none;
+	font-weight: bold;
+	background: transparent;
+	}
+.leaflet-container a.leaflet-popup-close-button:hover {
+	color: #999;
+	}
+.leaflet-popup-scrolled {
+	overflow: auto;
+	border-bottom: 1px solid #ddd;
+	border-top: 1px solid #ddd;
+	}
+
+.leaflet-oldie .leaflet-popup-content-wrapper {
+	-ms-zoom: 1;
+	}
+.leaflet-oldie .leaflet-popup-tip {
+	width: 24px;
+	margin: 0 auto;
+
+	-ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";
+	filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678);
+	}
+.leaflet-oldie .leaflet-popup-tip-container {
+	margin-top: -1px;
+	}
+
+.leaflet-oldie .leaflet-control-zoom,
+.leaflet-oldie .leaflet-control-layers,
+.leaflet-oldie .leaflet-popup-content-wrapper,
+.leaflet-oldie .leaflet-popup-tip {
+	border: 1px solid #999;
+	}
+
+
+/* div icon */
+
+.leaflet-div-icon {
+	background: #fff;
+	border: 1px solid #666;
+	}
+
+
+/* Tooltip */
+/* Base styles for the element that has a tooltip */
+.leaflet-tooltip {
+	position: absolute;
+	padding: 6px;
+	background-color: #fff;
+	border: 1px solid #fff;
+	border-radius: 3px;
+	color: #222;
+	white-space: nowrap;
+	-webkit-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+	pointer-events: none;
+	box-shadow: 0 1px 3px rgba(0,0,0,0.4);
+	}
+.leaflet-tooltip.leaflet-clickable {
+	cursor: pointer;
+	pointer-events: auto;
+	}
+.leaflet-tooltip-top:before,
+.leaflet-tooltip-bottom:before,
+.leaflet-tooltip-left:before,
+.leaflet-tooltip-right:before {
+	position: absolute;
+	pointer-events: none;
+	border: 6px solid transparent;
+	background: transparent;
+	content: "";
+	}
+
+/* Directions */
+
+.leaflet-tooltip-bottom {
+	margin-top: 6px;
+}
+.leaflet-tooltip-top {
+	margin-top: -6px;
+}
+.leaflet-tooltip-bottom:before,
+.leaflet-tooltip-top:before {
+	left: 50%;
+	margin-left: -6px;
+	}
+.leaflet-tooltip-top:before {
+	bottom: 0;
+	margin-bottom: -12px;
+	border-top-color: #fff;
+	}
+.leaflet-tooltip-bottom:before {
+	top: 0;
+	margin-top: -12px;
+	margin-left: -6px;
+	border-bottom-color: #fff;
+	}
+.leaflet-tooltip-left {
+	margin-left: -6px;
+}
+.leaflet-tooltip-right {
+	margin-left: 6px;
+}
+.leaflet-tooltip-left:before,
+.leaflet-tooltip-right:before {
+	top: 50%;
+	margin-top: -6px;
+	}
+.leaflet-tooltip-left:before {
+	right: 0;
+	margin-right: -12px;
+	border-left-color: #fff;
+	}
+.leaflet-tooltip-right:before {
+	left: 0;
+	margin-left: -12px;
+	border-right-color: #fff;
+	}

install.sh

@@ -5,6 +5,7 @@ cd "$(dirname "$0")"
 program_path=$(pwd)
 cp etc/pong_bot.tmp etc/pong_bot.service
 cp etc/mesh_bot.tmp etc/mesh_bot.service
+cp etc/mesh_bot_reporting.tmp etc/mesh_bot_reporting.service
 
 printf "\nMeshing Around Installer\n"
 printf "\nThis script will install the Meshing Around bot and its dependencies works best in debian/ubuntu\n"
@@ -15,6 +16,7 @@ printf "\nChecking for dependencies\n"
 printf "\nAdding user to dialout and tty groups for serial access\n"
 sudo usermod -a -G dialout $USER
 sudo usermod -a -G tty $USER
+sudo usermod -a -G bluetooth $USER
 
 # check for pip
 if ! command -v pip &> /dev/null
@@ -57,7 +59,7 @@ if [ $venv == "y" ]; then
         else
             sudo apt-get install python3-venv
             printf "\nPython3 venv module not found, please install python3-venv with your OS if not already done. re-run the script\n"
-            exxt 1
+            exit 1
         fi
 
         # config service files for virtual environment
@@ -89,14 +91,17 @@ read bot
 replace="s|/dir/|$program_path/|g"
 sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
+sed -i $replace etc/mesh_bot_reporting.service
 # set the correct user in the service file?
 whoami=$(whoami)
 replace="s|User=pi|User=$whoami|g"
 sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
+sed -i $replace etc/mesh_bot_reporting.service
 replace="s|Group=pi|Group=$whoami|g"
 sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
+sed -i $replace etc/mesh_bot_reporting.service
 sudo systemctl daemon-reload
 printf "\n service files updated\n"
 

launch.sh

@@ -3,22 +3,31 @@
 # launch.sh
 cd "$(dirname "$0")"
 
-# activate the virtual environment if it exists
-if [ -d "venv" ]; then
-    source venv/bin/activate
-fi
 
 if [ ! -f "config.ini" ]; then
     cp config.template config.ini
 fi
 
-# launch the application
-if [ "$1" == "pong" ]; then
-    python3 pong_bot.py
-elif [ "$1" == "mesh" ]; then
-    python3 mesh_bot.py
+# activate the virtual environment if it exists
+if [ -d "venv" ]; then
+    source venv/bin/activate
 else
-    printf "\nPlease provide a bot to launch (pong/mesh)"
+    echo "Virtual environment not found, this tool just launches the .py in venv"
+    exit 1
+fi
+
+# launch the application
+if [[ "$1" == pong* ]]; then
+    python3 pong_bot.py
+elif [[ "$1" == mesh* ]]; then
+    python3 mesh_bot.py
+elif [ "$1" == "html" ]; then
+    python3 etc/report_generator.py
+elif [ "$1" == "html5" ]; then
+    python3 etc/report_generator5.py
+else
+    echo "Please provide a bot to launch (pong/mesh) or a report to generate (html/html5)"
+    exit 1
 fi
 
 deactivate

logs/README.md

@@ -0,0 +1,24 @@
+Logs will collect here. Give a day of logs or a bunch of messages to have good reports.
+
+Reporting is via [../etc/report_generator5.py](../etc/report_generator5.py). The report_generator5 has newer feel and HTML5 coding. The index.html output is published in [../etc/www](../etc/www) there is a .cfg file created on first run for configuring values as needed.
+ - `multi_log_reader = True` on by default will read all logs (or set to false to return daily logs)
+ - Make sure to have `SyslogToFile = True` and default of DEBUG log level to fully enable reporting! ‼️
+ - provided serviceTimer templates in etc/
+
+![reportView](../etc/reporting.jpg)
+
+Logging messages to disk or 'Syslog' to disk uses the python native logging function.
+```
+[general]
+# logging to file of the non Bot messages only
+LogMessagesToFile = False
+# Logging of system messages to file, needed for reporting engine
+SyslogToFile = True
+```
+
+To change the stdout (what you see on the console) logging level (default is DEBUG) see the following example, line is in [../modules/log.py](../modules/log.py)
+
+```
+# Set level for stdout handler
+stdout_handler.setLevel(logging.INFO)
+```

modules/bbstools.py

@@ -4,7 +4,7 @@
 import pickle # pip install pickle
 from modules.log import *
 
-trap_list_bbs = ("bbslist", "bbspost", "bbsread", "bbsdelete", "bbshelp")
+trap_list_bbs = ("bbslist", "bbspost", "bbsread", "bbsdelete", "bbshelp", "bbsinfo", "bbslink", "bbsack")
 
 # global message list, later we will use a pickle on disk
 bbs_messages = []
@@ -14,19 +14,19 @@ def load_bbsdb():
     global bbs_messages
     # load the bbs messages from the database file
     try:
-        with open('bbsdb.pkl', 'rb') as f:
+        with open('data/bbsdb.pkl', 'rb') as f:
             bbs_messages = pickle.load(f)
     except Exception as e:
         bbs_messages = [[1, "Welcome to meshBBS", "Welcome to the BBS, please post a message!",0]]
-        logger.debug("System: Creating new bbsdb.pkl")
-        with open('bbsdb.pkl', 'wb') as f:
+        logger.debug("System: Creating new data/bbsdb.pkl")
+        with open('data/bbsdb.pkl', 'wb') as f:
             pickle.dump(bbs_messages, f)
 
 def save_bbsdb():
     global bbs_messages
     # save the bbs messages to the database file
-    logger.debug("System: Saving bbsdb.pkl")
-    with open('bbsdb.pkl', 'wb') as f:
+    logger.debug("System: Saving data/bbsdb.pkl")
+    with open('data/bbsdb.pkl', 'wb') as f:
         pickle.dump(bbs_messages, f)
 
 def bbs_help():
@@ -77,6 +77,12 @@ def bbs_post_message(subject, message, fromNode):
     if str(fromNode) in bbs_ban_list:
         logger.warning(f"System: Naughty node {fromNode}, tried to post a message: {subject}, {message} and was dropped.")
         return "Message posted. ID is: " + str(messageID)
+    
+    # validate not a duplicate message
+    for msg in bbs_messages:
+        if msg[1].strip().lower() == subject.strip().lower() and msg[2].strip().lower() == message.strip().lower():
+            messageID = msg[0]
+            return "Message posted. ID is: " + str(messageID)
 
     # append the message to the list
     bbs_messages.append([messageID, subject, message, fromNode])
@@ -100,20 +106,20 @@ def bbs_read_message(messageID = 0):
 def save_bbsdm():
     global bbs_dm
     # save the bbs messages to the database file
-    logger.debug("System: Saving Updated BBS Direct Messages bbsdm.pkl")
-    with open('bbsdm.pkl', 'wb') as f:
+    logger.debug("System: Saving Updated BBS Direct Messages data/bbsdm.pkl")
+    with open('data/bbsdm.pkl', 'wb') as f:
         pickle.dump(bbs_dm, f)
 
 def load_bbsdm():
     global bbs_dm
     # load the bbs messages from the database file
     try:
-        with open('bbsdm.pkl', 'rb') as f:
+        with open('data/bbsdm.pkl', 'rb') as f:
             bbs_dm = pickle.load(f)
     except:
         bbs_dm = [[1234567890, "Message", 1234567890]]
-        logger.debug("System: Creating new bbsdm.pkl")
-        with open('bbsdm.pkl', 'wb') as f:
+        logger.debug("System: Creating new data/bbsdm.pkl")
+        with open('data/bbsdm.pkl', 'wb') as f:
             pickle.dump(bbs_dm, f)
 
 def bbs_post_dm(toNode, message, fromNode):
@@ -130,6 +136,11 @@ def bbs_post_dm(toNode, message, fromNode):
     save_bbsdm()
     return "BBS DM Posted for node " + str(toNode)
 
+def get_bbs_stats():
+    global bbs_messages, bbs_dm
+    # Return some stats on the bbs pending messages and total posted messages
+    return f"📡BBSdb has {len(bbs_messages)} messages.\nDirect ✉️ Messages waiting: {(len(bbs_dm) - 1)}"
+
 def bbs_check_dm(toNode):
     global bbs_dm
     # Check for any messages for toNode
@@ -151,6 +162,29 @@ def bbs_delete_dm(toNode, message):
             return "System: cleared mail for" + str(toNode)
     return "System: No DM found for node " + str(toNode)
 
+def bbs_sync_posts(input, peerNode, RxNode):
+    messageID =  0
+    # respond when another bot asks for the bbs posts to sync
+    if "bbslink" in input.lower():
+        if "$" in input and "#" in input:
+            #store the message
+            subject = input.split("$")[1].split("#")[0]
+            body = input.split("#")[1]
+            bbs_post_message(subject, body, peerNode)
+            messageID = input.split(" ")[1]
+            return f"bbsack {messageID}"
+    elif "bbsack" in input.lower():
+        # increment the messageID
+        ack = int(input.split(" ")[1])
+        messageID = int(ack) + 1
+
+    # send message
+    if messageID < len(bbs_messages):
+        return f"bbslink {messageID} ${bbs_messages[messageID][1]} #{bbs_messages[messageID][2]}"
+    else:
+        logger.debug("System: bbslink sync complete with peer " + str(peerNode))
+
+
 #initialize the bbsdb's
 load_bbsdb()
 load_bbsdm()

modules/games/blackjack.py

@@ -4,6 +4,7 @@
 from random import choices, shuffle
 from modules.log import *
 import time
+import pickle
 
 jack_starting_cash = 100  # Replace 100 with your desired starting cash value
 jackTracker= [{'nodeID': 0, 'cmd': 'new', 'time': time.time(), 'cash': jack_starting_cash,\
@@ -113,15 +114,6 @@ class jackChips:
         self.total -= self.bet
         self.winnings -= 1
 
-def take_bet(bet_amount, player_money):
-    try:
-        if bet_amount >= player_money or bet_amount <= 0:
-            return f"Enter a bet amount between 1 and {player_money}"
-        return bet_amount
-
-    except TypeError:
-        return "Invalid bet amount"
-
 def success_rate(card, obj_h):
     """ Calculate Success rate of 'HIT' new cards """
     msg = ""
@@ -132,13 +124,11 @@ def success_rate(card, obj_h):
 
     if rate < 100:
         msg += f"If Hit, chance {int(rate)}% failure, {100-int(rate)}% success."
-    elif rate > 100:
+    else:
         l_rate = int(rate - (rate - 99))  # Round to 99
         if card[0][1] == "A":
             l_rate -= 99
         msg += f"If Hit, chance {100-l_rate}% failure, and {l_rate}% success"
-    else:
-        msg += "If Hit, a low chance of success."
     return msg
 
 def hits(obj_de):
@@ -216,9 +206,33 @@ def setLastCmdJack(nodeID, cmd):
             return True
     return False
 
+def saveHSJack(nodeID, highScore):
+    # Save the game state to pickle
+    highScore = {'nodeID': nodeID, 'highScore': highScore}
+    try:
+        with open('data/blackjack_hs.pkl', 'wb') as file:
+            pickle.dump(highScore, file)
+    except FileNotFoundError:
+        logger.debug("System: BlackJack: Creating new data/blackjack_hs.pkl file")
+        with open('data/blackjack_hs.pkl', 'wb') as file:
+            pickle.dump(highScore, file)
+
+def loadHSJack():
+    try:
+        with open('data/blackjack_hs.pkl', 'rb') as file:
+            highScore = pickle.load(file)
+            return highScore
+    except FileNotFoundError:
+        logger.debug("System: BlackJack: Creating new data/blackjack_hs.pkl file")
+        highScore = {'nodeID': 0, 'highScore': 0}
+        with open('data/blackjack_hs.pkl', 'wb') as file:
+            pickle.dump(highScore, file)
+        return 0
+
 def playBlackJack(nodeID, message):
     # Initalize the Game
     msg, last_cmd = '', None
+    blackJack = False
     p_win, d_win, draw = 0, 0, 0
     p_chips = jackChips()
     p_hand = jackHand()
@@ -243,8 +257,8 @@ def playBlackJack(nodeID, message):
             d_win = jackTracker[i]['gameStats']['d_win']
             draw = jackTracker[i]['gameStats']['draw']
             bet_money = jackTracker[i]['bet']
-            p_chips.bet = bet_money
             if last_cmd == "playing":
+                p_chips.bet = bet_money
                 p_cards = jackTracker[i]['p_cards']
                 d_cards = jackTracker[i]['d_cards']
                 p_hand = jackTracker[i]['p_hand']
@@ -256,39 +270,44 @@ def playBlackJack(nodeID, message):
         logger.debug(f"System: BlackJack: New Player {nodeID}")
         jackTracker.append({'nodeID': nodeID, 'cmd': 'new', 'time': time.time(), 'cash': jack_starting_cash,\
             'bet': 0, 'gameStats': {'p_win': p_win, 'd_win': d_win, 'draw': draw}, 'p_cards':p_cards, 'd_cards':d_cards, 'p_hand':p_hand.cards, 'd_hand':d_hand.cards, 'next_card':next_card})
-        return f"Welcome to BlackJack!♠️♥️♣️♦️ you have {p_chips.total} chips. Game Played via Direct Message.   Whats your bet?"
+        return f"Welcome to ♠️♥️BlackJack♣️♦️ you have {p_chips.total} chips.   Whats your bet?"
 
     if getLastCmdJack(nodeID) == "new":
         # Place Bet
         try:
             # handle B letter
-            if message == "b":
+            if message.lower() == "b":
                 if bet_money == 0:
                     bet_money = 5
-                else:
-                    bet_money = bet_money
+            elif message.lower() == "r":
+                #resend the hand
+                msg += show_some(p_cards, d_cards, p_hand)
+                return msg
             else:
-                bet_money = int(message)
+                try:
+                    bet_money = int(message)
+                except ValueError:
+                    return "Invalid Bet, please enter a valid number."
 
-            if bet_money <= p_chips.total or bet_money <= 1:
-                p_chips.bet = take_bet(bet_money, p_chips.total)
+            if bet_money <= p_chips.total and bet_money >= 1:
+                p_chips.bet = bet_money
             else:
-                return f"Invalid Bet, the maximum bet you can place is {p_chips.total}"
+                return f"Invalid Bet, the maximum bet you can place is {p_chips.total} and the minimum bet is 1."
         except ValueError:
             return f"Invalid Bet, the maximum bet, {p_chips.total}"
 
         # Show the cards
         msg += show_some(p_cards, d_cards, p_hand)
-
         # check for blackjack 21 and only two cards
         if p_hand.value == 21 and len(p_hand.cards) == 2:
             msg += "Player 🎰 BLAAAACKJACKKKK 💰"
             p_chips.total += round(p_chips.bet * 1.5)
             setLastCmdJack(nodeID, "dealerTurn")
+            blackJack = True
             # Save the game state
             for i in range(len(jackTracker)):
                 if jackTracker[i]['nodeID'] == nodeID:
-                    jackTracker[i]['cash'] = p_chips.total
+                    jackTracker[i]['cash'] = int(p_chips.total)
                     break
         else:
             # Display the statistics
@@ -296,10 +315,9 @@ def playBlackJack(nodeID, message):
             msg += stats
             setLastCmdJack(nodeID, "betPlaced")
 
-
     if getLastCmdJack(nodeID) == "betPlaced":
         setLastCmdJack(nodeID, "playing")
-        msg += "(H)it,(S)tand,(F)orfit,(D)ouble"
+        msg += "(H)it,(S)tand,(F)orfit,(D)ouble,(R)esend,(L)eave table"
 
         # save the game state
         for i in range(len(jackTracker)):
@@ -341,27 +359,29 @@ def playBlackJack(nodeID, message):
                 setLastCmdJack(nodeID, "dealerTurn")
             else:
                 return "You can't Double Down, dont have enough chips"
+        elif choice == "resend" or choice == "r":
+            msg += show_some(p_hand.cards, d_cards, p_hand)
         else:
-            return "Invalid Choice"
+            return "(H)it,(S)tand,(F)orfit,(D)ouble,(R)esend,(L)eave table"
 
         # Check if player bust
         if player_bust(p_hand, p_chips):
             d_win += 1
-            msg += "Player:BUST💥"
+            msg += "💥PlayerBUST💥"
             setLastCmdJack(nodeID, "dealerTurn")
         
         if getLastCmdJack(nodeID) == "playing":
             msg += stats
-            msg += "[H,S,F,D,L]"
+            msg += "[H,S,F,D]"
 
         # Save the game state
         for i in range(len(jackTracker)):
             if jackTracker[i]['nodeID'] == nodeID:
-                jackTracker[i]['cash'] = p_chips.total
-                jackTracker[i]['bet'] = p_chips.bet
-                jackTracker[i]['gameStats']['p_win'] = p_win
-                jackTracker[i]['gameStats']['d_win'] = d_win
-                jackTracker[i]['gameStats']['draw'] = draw
+                jackTracker[i]['cash'] = int(p_chips.total)
+                jackTracker[i]['bet'] = int(p_chips.bet)
+                jackTracker[i]['gameStats']['p_win'] = int(p_win)
+                jackTracker[i]['gameStats']['d_win'] = int(d_win)
+                jackTracker[i]['gameStats']['draw'] = int(draw)
                 jackTracker[i]['p_cards'] = p_cards
                 jackTracker[i]['d_cards'] = d_cards
                 jackTracker[i]['p_hand'] = p_hand
@@ -375,20 +395,22 @@ def playBlackJack(nodeID, message):
         return msg
 
     if getLastCmdJack(nodeID) == "dealerTurn":
+        # Dealers Turn
+        if not blackJack:
         # recall the game state
-        for i in range(len(jackTracker)):
-            if jackTracker[i]['nodeID'] == nodeID:
-                p_chips.total = int(jackTracker[i]['cash'])
-                p_chips.bet = int(jackTracker[i]['bet'])
-                p_win = int(jackTracker[i]['gameStats']['p_win'])
-                d_win = int(jackTracker[i]['gameStats']['d_win'])
-                draw = jackTracker[i]['gameStats']['draw']
-                p_cards = jackTracker[i]['p_cards']
-                d_cards = jackTracker[i]['d_cards']
-                p_hand = jackTracker[i]['p_hand']
-                d_hand = jackTracker[i]['d_hand']
-                next_card = jackTracker[i]['next_card']
-                break
+            for i in range(len(jackTracker)):
+                if jackTracker[i]['nodeID'] == nodeID:
+                    p_chips.total = jackTracker[i]['cash']
+                    p_chips.bet = jackTracker[i]['bet']
+                    p_win = jackTracker[i]['gameStats']['p_win']
+                    d_win = jackTracker[i]['gameStats']['d_win']
+                    draw = jackTracker[i]['gameStats']['draw']
+                    p_cards = jackTracker[i]['p_cards']
+                    d_cards = jackTracker[i]['d_cards']
+                    p_hand = jackTracker[i]['p_hand']
+                    d_hand = jackTracker[i]['d_hand']
+                    next_card = jackTracker[i]['next_card']
+                    break
 
         if p_hand.value <= 21:
             # Dealer's Turn
@@ -397,7 +419,7 @@ def playBlackJack(nodeID, message):
                 d_hand.add_cards(d_card)
                 if dealer_bust(d_hand, p_hand, p_chips):
                     p_win += 1
-                    msg += "Dealer:BUST💥"
+                    msg += "💰DealerBUST💥"
                     break
             # Show all cards
             msg += show_all(p_hand.cards, d_hand.cards, p_hand, d_hand)
@@ -423,12 +445,18 @@ def playBlackJack(nodeID, message):
             if p_chips.total > 0:
                 msg += "🪙Keep the change you filthy animal!"
             else:
-                msg += "💸NO MORE MONEY! Game Over!"
+                msg += "💸NO MORE CHIPS!🏧💳"
                 p_chips.total = jack_starting_cash
         else:
-            msg += f"💰You have {p_chips.total} chips left"
+            # check high score
+            highScore = loadHSJack()
+            if highScore != 0 and p_chips.total > highScore['highScore']:
+                msg += f"💰HighScore💰{p_chips.total} "
+                saveHSJack(nodeID, p_chips.total)
+            else:
+                msg += f"💰You have {p_chips.total} chips "
 
-        msg += "(B)et or (L)eave table."
+        msg += " Bet or Leave?"
 
         # Reset the game
         setLastCmdJack(nodeID, "new")

modules/games/dopewar.py

@@ -110,38 +110,67 @@ def officer(nodeID):
             cash = dwCashDb[i].get('cash')
 
     # rolls to see if the officer takes drugs from you
-    # odds are (1 - event chance) * (officer chance) * (confiscation chance)
-    # currently (1 - 0.35) * (0.20) * (0.35) = 4.55%
-    # chance is approximate, not sure how randint handles endpoints, close enough for my purposes
-    if random.randint(0, 100) > 65: # confiscation chance
-        k = 0
-        j = 0
-        # removes all drugs from inventory tally and individual class attirbute
+    if random.randint(0, 100) > 65: # confiscation chance is 35%
+        j, k = 0, 0
         for i in range(0, len(my_drugs)):
             j = amount[i]
             amount[i] = 0
             k += j
-        inventory -= k
-        # sends 'conf' for confiscated. sending a string is better than a number here
+        # set the cash_taken to conf for confiscation not of cash
         cash_taken = 'conf'
+        # Update the inventory_db
+        inventory -= k
+        for i in range(0, len(dwInventoryDb)):
+            if dwInventoryDb[i].get('userID') == nodeID:
+                dwInventoryDb[i]['inventory'] = inventory
+                amount = dwInventoryDb[i].get('amount')
         return cash_taken
-    # rolls to see if the officer takes cash from you
-    # odds are (1 - event chance) * (officer chance) * (1 - confiscation chance)
-    # currently (1 - 0.35) * (0.20) * (0.65) = 8.45%
-    # chance is approximate, not sure how randint handles endpoints, close enough for my purposes
+    # rolls to see how much cash the officer takes
     cash_taken = random.randint(1, cash-1)
     cash -= cash_taken
-    
     # Update the cash_db and inventory_db
     for i in range(0, len(dwCashDb)):
         if dwCashDb[i].get('userID') == nodeID:
             dwCashDb[i]['cash'] = cash
+    return cash_taken
+
+def get_found_items(nodeID):
+    global dwInventoryDb, dwCashDb
+    msg = ''
+    # get the inventory for the user
     for i in range(0, len(dwInventoryDb)):
         if dwInventoryDb[i].get('userID') == nodeID:
-            dwInventoryDb[i]['inventory'] = inventory
-            amount = dwInventoryDb[i].get('amount')
+            inventory = dwInventoryDb[i].get('inventory')
+    amount = check_inv(nodeID)
 
-    return cash_taken
+    # get the cash for the user
+    for i in range(0, len(dwCashDb)):
+        if dwCashDb[i].get('userID') == nodeID:
+            cash = dwCashDb[i].get('cash')
+
+    if random.randint(0, 100) > 50: # 50% chance to find cash or drugs
+        if random.randint(0, 100) > 30: # 30% chance to find drugs
+            found = random.choice(range(len(my_drugs)))
+            # rolls to see how much of the drug the user finds
+            qty =random.randint(1, 80 - inventory)
+            amount[found] += qty
+            inventory += qty
+            for i in range(0, len(dwInventoryDb)):
+                if dwInventoryDb[i].get('userID') == nodeID:
+                    dwInventoryDb[i]['inventory'] = inventory
+                    dwInventoryDb[i]['amount'] = amount
+            msg = "💊You found " + str(qty) + " of " + str(my_drugs[found])
+    else:
+        # rolls to see how much cash the user finds
+        cash_found = random.randint(1, 977)
+        cash += cash_found
+        # Update the cash_db
+        for i in range(0, len(dwCashDb)):
+            if dwCashDb[i].get('userID') == nodeID:
+                dwCashDb[i]['cash'] = cash
+        msg = "You found $" + str(cash_found) + "💸"
+        
+    return msg
 
 
 def price_change(event_number):
@@ -203,8 +232,9 @@ def buy_func(nodeID, price_list, choice=0, value='0'):
     else:
         if drug_choice in range(1, len(my_drugs) + 1):
             drug_choice = drug_choice - 1
+            cost = price_list[drug_choice]
             msg = my_drugs[drug_choice].name + ": you have🎒 " + str(amount[drug_choice]) + " "
-            msg += " The going price is: $" + str(price_list[drug_choice]) + " "
+            msg += " The going price is: $" + "{:,}".format(cost) + " "
 
     buy_amount = value
     if buy_amount == 'm':
@@ -228,7 +258,7 @@ def buy_func(nodeID, price_list, choice=0, value='0'):
         cash -= buy_amount * price_list[drug_choice]
         inventory += buy_amount
         msg += "You bought " + str(buy_amount) + " " + my_drugs[drug_choice].name + '. Remaining cash: $' + str(cash)
-        msg += f"\nBuy Sell Fly?"
+        msg += f"\nBuy💸, Sell💰, Fly🛫?"
     else:
         msg = "You don't have enough cash!😭"
         return msg
@@ -286,15 +316,17 @@ def sell_func(nodeID, price_list, choice=0, value='0'):
     else:
         if drug_choice in range(1, len(my_drugs) + 1) and amount[drug_choice - 1] > 0:
             drug_choice = drug_choice - 1
+            cost = price_list[drug_choice]
             msg = my_drugs[drug_choice].name + ": you have " + str(amount[drug_choice]) +\
-                " The going price is: $" + str(price_list[drug_choice])
+                " The going price is: $" + str("{:,}".format(cost))
             # check if the user has enough of the drug to sell
             if sell_amount <= amount[drug_choice]:
                 amount[drug_choice] -= sell_amount
                 cash += sell_amount * price_list[drug_choice]
                 inventory -= sell_amount
-                msg += " You sold " + str(sell_amount) + " " + my_drugs[drug_choice].name + ' for $' +\
-                    str(sell_amount * price_list[drug_choice]) + '. Total cash: $' + str(cash)
+                profit = sell_amount * price_list[drug_choice]
+                msg += " You sold " + str(sell_amount) + " " + my_drugs[drug_choice].name +\
+                     ' for $' + "{:,}".format(profit) + '. Total cash: $' + "{:,}".format(cash)
             else:
                 msg = "You don't have that much"
                 return msg
@@ -317,7 +349,6 @@ def sell_func(nodeID, price_list, choice=0, value='0'):
     
     return msg
 
-
 def get_location_table(nodeID, choice=0):
     global dwLocationDb
     # get the location for the user
@@ -332,7 +363,6 @@ def get_location_table(nodeID, choice=0):
     loc_table_string += ' Where do you want to 🛫?#'
     return loc_table_string
 
-
 def endGameDw(nodeID):
     global dwCashDb, dwInventoryDb, dwLocationDb, dwGameDayDb, dwHighScore
     msg = ''
@@ -363,9 +393,9 @@ def endGameDw(nodeID):
     # checks if the player's score is higher than the high score and writes a new high score if it is
     if cash > dwHighScore.get('cash'):
         dwHighScore = ({'userID': nodeID, 'cash': round(cash, 2)})
-        with open('dopewar_hs.pkl', 'wb') as file:
+        with open('data/dopewar_hs.pkl', 'wb') as file:
             pickle.dump(dwHighScore, file)
-        msg = "You finished with $" + str(cash) + " and beat the high score!🎉💰"
+            msg = "You finished with $" + "{:,}".format(cash) + " and beat the high score!🎉💰"
         return msg
     if cash > starting_cash:
         msg = 'You made money! 💵 Up ' + str((cash/starting_cash).__round__()) + 'x! Well done.'
@@ -375,8 +405,6 @@ def endGameDw(nodeID):
         return msg
     if cash < starting_cash:
         msg = "You lost money, better go get a real job.💸"
-
-    logger.debug("System: DopeWars: Game Over for user: " + str(nodeID) + " with cash: " + str(cash))
     
     return msg
 
@@ -384,31 +412,35 @@ def getHighScoreDw():
     global dwHighScore
     # Load high score table
     try:
-        with open('dopewar_hs.pkl', 'rb') as file:
+        with open('data/dopewar_hs.pkl', 'rb') as file:
             dwHighScore = pickle.load(file)
     except FileNotFoundError:
         logger.debug("System: DopeWars: No high score table found")
         # high score pickle file is a touple of the nodeID and the high score
         dwHighScore = ({"userID": 4258675309, "cash": 100})
         # write a new high score file if one is not found
-        with open('dopewar_hs.pkl', 'wb') as file:
+        with open('data/dopewar_hs.pkl', 'wb') as file:
             pickle.dump(dwHighScore, file)
     return dwHighScore
 
-def render_game_screen(userID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen):
+def render_game_screen(userID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen, found_items):
     global dwCashDb, dwInventoryDb, dwLocationDb
     msg = ''
     # get the location for the user
     for i in range(0, len(dwLocationDb)):
         if dwLocationDb[i].get('userID') == userID:
             loc = dwLocationDb[i].get('location')
-    
+
     if event_number != -1:
         msg += event_list[event_number].text + f"\n"
-    if event_number == -1 and cash_stolen != 0 and cash_stolen != 'conf':
-        msg += "🚔Officer Leroy stopped you and took $" + str(cash_stolen) + "💸" + f"\n"
-    if event_number == -1 and cash_stolen == 'conf':
-        msg += "🚔Officer Leroy stopped you and took all of your drugs.🚭" + f"\n"
+    elif event_number == -1 and cash_stolen != 0 and cash_stolen != 'conf':
+        msg += random.choice([f"You got high and spent ${str(cash_stolen)}💊💸\n", 
+                              f"You got mugged and lost ${str(cash_stolen)}💸🔫\n",
+                              f"You got a new tattoo and spent ${str(cash_stolen)}💉💸\n",])
+    elif event_number == -1 and cash_stolen == 'conf':
+        msg += f"🚔Officer Bob stopped you and took all of your drugs.🚭\n"
+    elif event_number == -1 and found_items != 'nothing':
+        msg += found_items + f"\n"
 
     # get the inventory for the user
     for i in range(0, len(dwInventoryDb)):
@@ -421,18 +453,18 @@ def render_game_screen(userID, day_play, total_day, loc_choice, event_number, pr
         if dwCashDb[i].get('userID') == userID:
             cash = dwCashDb[i].get('cash')
 
-    msg += "Location: " + loc[int(loc_choice) - 1] + ", Day:" + str(day_play) + '/' + str(total_day) +  " 🎒: " + str(inventory) + "/100" + ", $" + str(cash) + f"\n"
+    msg += "🗺️" + loc[int(loc_choice) - 1] + " 📆" + str(day_play) + '/' + str(total_day) +  " 🎒" + str(inventory) + "/100" + " 💵" + "{:,}".format(cash) + f"\n"
     
     for i, drug in enumerate(my_drugs, 1):
         qty = amount[i-1]
-        msg += f'#{str(i)}.{drug.name}/${price_list[i-1]}({qty})    '
+        msg += f'#{str(i)}.{drug.name}${"{:,}".format(price_list[i-1])}({qty})    '
 
     return msg
 
-
 def dopeWarGameDay(nodeID, day_play, total_day):
     global dwCashDb, dwLocationDb, dwInventoryDb
     cash_stolen = 0
+    found_items = 'nothing'
 
     # roll for the event of the day
     event_number = generate_event()
@@ -443,12 +475,14 @@ def dopeWarGameDay(nodeID, day_play, total_day):
             loc = dwLocationDb[i].get('location')
             loc_choice = dwLocationDb[i].get('loc_choice')
 
-    # rolls to see if the officer event happens
-    # odds are (1 - event chance) * (officer chance)
-    # currently (1 - 0.35) * (0.20) = 13%
-    # chance is approximate, not sure how randint handles endpoints, close enough for my purposes
-    if event_number == -1 and random.randint(0, 100) > 80:
-        cash_stolen = officer(nodeID)
+    # rolls to see if event happens
+    if event_number == -1 and random.randint(0, 100) > 80: # 20% chance to have an event
+        if random.randint(0, 100) > 50: # 50% chance to have an officer encounter
+            cash_stolen = officer(nodeID)
+        else:
+            # find items
+            found_items = get_found_items(nodeID)
+
 
     price_list = price_change(event_number)
 
@@ -460,7 +494,7 @@ def dopeWarGameDay(nodeID, day_play, total_day):
     check_inv(nodeID)
 
     # main game display print
-    msg = render_game_screen(nodeID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen)
+    msg = render_game_screen(nodeID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen, found_items)
     
     return msg
 
@@ -516,7 +550,7 @@ def playDopeWars(nodeID, cmd):
                 dwPlayerTracker[i]['cmd'] = 'location'
 
     if last_cmd == 'ask_bsf':
-        msg = 'example Buy: b,Drug,Qty or Sell s,1,10. Fly: f. Price list: p or end'
+        msg = f'example buy:\nb,drug#,qty# or Sell: s,1,10 qty can be (m)ax\n f,p or end'
         menu_choice = cmd.lower()
         if ',' in menu_choice or '.' in menu_choice:
             #split the choice into a letter and a number for the buy/sell functions
@@ -539,7 +573,7 @@ def playDopeWars(nodeID, cmd):
                         menu_choice[2] = int(menu_choice[2])
                 
             except ValueError:
-                msg = 'a value was bad, example dopeware Buy or Sell b,1,10 or s,1,m'
+                msg = f'a value was bad, example dopeware Buy or Sell\n b,1,10 or s,1,m'
                 return msg
 
             if menu_choice[0] == 'b':
@@ -570,9 +604,9 @@ def playDopeWars(nodeID, cmd):
                     sell =  sell_func(nodeID, price_list, i, 'm')
                     # ignore starts with "You don't have any"
                     if not sell.startswith("You don't have any"):
-                        msg += sell
-                        if i != len(my_drugs):
-                            msg += '\n'
+                        msg += sell + '\n'
+            # trim the last newline
+            msg = msg[:-1]
             return msg
         elif 'f' in menu_choice:
                 # set last command to location
@@ -583,13 +617,13 @@ def playDopeWars(nodeID, cmd):
 
         elif 'p' in menu_choice:
                 # render_game_screen
-                msg = render_game_screen(nodeID, game_day, total_days, loc_choice, -1, price_list, 0)
+                msg = render_game_screen(nodeID, game_day, total_days, loc_choice, -1, price_list, 0, 'nothing')
                 return msg
-        elif 'end' in menu_choice:
+        elif 'e' in menu_choice:
                 msg = endGameDw(nodeID)
                 return msg
         else:
-            msg = 'example Buy: b,Drug,Qty or Sell s,1,10. Fly: f. Price list: p or end'
+            msg = f'example buy:\nb,drug#,qty# or Sell: s,1,10 qty can be (m)ax\n f,p or end'
             return msg
         
     # Buy
@@ -639,7 +673,7 @@ def playDopeWars(nodeID, cmd):
     # Display Main Game Screen and ask for buy, sell, or fly
     if last_cmd == 'display_main':
         msg = dopeWarGameDay(nodeID, game_day, total_days)
-        msg += f"\nBuy, Sell, Fly? Price list?"
+        msg += f"\nBuy💸, Sell💰, (F)ly🛫? (P)riceList?"
         # set the player's last command
         for i in range(0, len(dwPlayerTracker)):
             if dwPlayerTracker[i].get('userID') == nodeID:

modules/games/golfsim.py

@@ -0,0 +1,409 @@
+# https://github.com/danfriedman30/pythongame
+# Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+import random
+import time
+import pickle
+from modules.log import *
+
+# Clubs setup
+driver_distances = list(range(230, 280, 5))
+low_distances = list(range(185, 215, 5))
+mid_distances = list(range(130, 185, 5))
+high_distances = list(range(90, 135, 5))
+gap_wedge_distances = list(range(50, 85, 5))
+lob_wedge_distances = list(range(10, 50, 5))
+putt_outcomes = [1, 2, 3]
+
+# Hole/Course Setup
+full_hole_range = list(range(130, 520, 5))
+par3_range = list(range(130, 255, 5))
+par4_range = list(range(255, 445, 5))
+par5_range = list(range(445, 520, 5))
+par3_4_range = par3_range + par4_range
+par3_5_range = par3_range + par5_range
+par4_5_range = par4_range + par5_range
+
+# Player setup
+playingHole = False
+golfTracker = [{'nodeID': 0, 'last_played': time.time(), 'cmd': '', 'hole': 0, 'distance_remaining': 0, 'hole_shots': 0, 'hole_strokes': 0, 'hole_to_par': 0, 'total_strokes': 0, 'total_to_par': 0, 'par': 0, 'hazard': ''}]
+
+# Club functions
+def hit_driver():
+    club_distance = random.choice(driver_distances)
+    return club_distance
+
+def hit_low_iron():
+    club_distance = random.choice(low_distances)
+    return club_distance
+
+def hit_mid_iron():
+    club_distance = random.choice(mid_distances)
+    return club_distance
+
+def hit_high_iron():
+    club_distance = random.choice(high_distances)
+    return club_distance
+
+def hit_gap_wedge():
+    club_distance = random.choice(gap_wedge_distances)
+    return club_distance
+
+def hit_lob_wedge():
+    club_distance = random.choice(lob_wedge_distances)
+    return club_distance
+
+def finish_hole():
+    finish = random.choice(putt_outcomes)
+    return finish
+
+def endGameGolf(nodeID):
+    # pop player from tracker
+    for i in range(len(golfTracker)):
+        if golfTracker[i]['nodeID'] == nodeID:
+            golfTracker.pop(i)
+    logger.debug("System: GolfSim: Player " + str(nodeID) + " has ended their round.")
+
+def getScorecardGolf(scorecard):
+    # Scorecard messages, convert score to message comment
+    msg = ""
+    if scorecard == 8:
+        # Quadruple bogey
+        msg += " +Quad Bogey☃️ "
+    elif scorecard == 7:
+        # Triple bogey
+        msg += " +Triple Bogey "
+    elif scorecard == 6:
+        # Double bogey
+        msg += " +Double Bogey "
+    elif scorecard == 5:
+        # Bogey
+        msg += " +Bogey "
+    elif scorecard > 0:
+        # Over par
+        msg += f" +Par {str(scorecard)} "
+    elif scorecard == 0:
+        # Even par
+        msg += " Even Par💪 "
+    elif scorecard == -1:
+        # Birdie
+        msg += " -Birdie🐦 "
+    elif scorecard == -2:
+        # Eagle
+        msg += " -Eagle🦅 "
+    elif scorecard == -3:
+        # Albatross
+        msg += " -Albatross🦅🦅 "
+    else:
+        # Under par
+        msg += f" -Par {str(abs(scorecard))} "
+    return msg
+
+def getHighScoreGolf(nodeID, strokes, par):
+    # check if player is in high score list
+    try:
+        with open('data/golfsim_hs.pkl', 'rb') as f:
+            golfHighScore = pickle.load(f)
+    except:
+        logger.debug("System: GolfSim: High Score file not found.")
+        golfHighScore = [{'nodeID': nodeID, 'strokes': strokes, 'par': par}]
+        with open('data/golfsim_hs.pkl', 'wb') as f:
+            pickle.dump(golfHighScore, f)
+
+    if strokes < golfHighScore[0]['strokes']:
+        # player got new low score which is high score
+        golfHighScore[0]['nodeID'] = nodeID
+        golfHighScore[0]['strokes'] = strokes
+        golfHighScore[0]['par'] = par
+        with open('data/golfsim_hs.pkl', 'wb') as f:
+            pickle.dump(golfHighScore, f)
+        return golfHighScore
+    
+    return 0
+
+# Main game loop
+def playGolf(nodeID, message, finishedHole=False):
+    msg = ''
+    global golfTracker
+    # Course setup
+    par3_count = 0
+    par4_count = 0
+    par5_count = 0
+    # Scorecard setup
+    total_strokes = 0
+    total_to_par = 0
+    par = 0
+
+    # get player's last command from tracker if not new player
+    last_cmd = ""
+    for i in range(len(golfTracker)):
+        if golfTracker[i]['nodeID'] == nodeID:
+            last_cmd = golfTracker[i]['cmd']
+            hole = golfTracker[i]['hole']
+            distance_remaining = golfTracker[i]['distance_remaining']
+            hole_shots = golfTracker[i]['hole_shots']
+            par = golfTracker[i]['par']
+            total_strokes = golfTracker[i]['total_strokes']
+            total_to_par = golfTracker[i]['total_to_par']
+
+    if last_cmd == "" or last_cmd == "new":
+        # Start a new hole
+        if hole <= 9:
+            # Set up hole count restrictions on par
+            if par3_count < 2 and par4_count < 5 and par5_count < 2:
+                hole_length = random.choice(full_hole_range)
+            if par3_count >= 2 and par4_count < 5 and par5_count < 2:
+                hole_length = random.choice(par4_5_range)
+            if par3_count >= 2 and par4_count < 5 and par5_count >= 2:
+                hole_length = random.choice(par4_range)
+            if par3_count < 2 and par4_count < 5 and par5_count >= 2:
+                hole_length = random.choice(par3_4_range)
+            if par3_count < 2 and par4_count >= 5 and par5_count >= 2:
+                hole_length = random.choice(par3_range)
+            if par3_count >= 2 and par4_count >= 5 and par5_count < 2:
+                hole_length = random.choice(par5_range)
+            if par3_count < 2 and par4_count >= 5 and par5_count < 2:
+                hole_length = random.choice(par3_5_range)
+
+            # Set up par for the hole
+            if hole_length <= 250:
+                par = 3
+                par3_count += 1
+            elif hole_length > 250 and hole_length <= 440:
+                par = 4
+                par4_count += 1
+            elif hole_length > 440:
+                par = 5
+                par5_count += 1
+
+            # roll for chance of hazard
+            hazard_chance = random.randint(1, 100)
+            weather_chance = random.randint(1, 100)
+            # have low chances of hazards and weather
+            hasHazard = False
+            hazard = ""
+            if hazard_chance < 25:
+                # Further reduce chance of hazards with weather
+                if weather_chance < 15:
+                    # randomly calculate a hazard for the hole sand, 🌊, 🌲, 🏘️, etc
+                    hazard = random.choice(["🏖️", "🌊", "🌲", "🏘️"])
+                    hasHazard = True
+                    
+
+            # Set initial parameters before starting a hole
+            distance_remaining = hole_length
+            hole_shots = 0
+
+            # save player's current game state
+            for i in range(len(golfTracker)):
+                if golfTracker[i]['nodeID'] == nodeID:
+                    golfTracker[i]['distance_remaining'] = distance_remaining
+                    golfTracker[i]['cmd'] = 'stroking'
+                    golfTracker[i]['par'] = par
+                    golfTracker[i]['total_strokes'] = total_strokes
+                    golfTracker[i]['total_to_par'] = total_to_par
+                    golfTracker[i]['hazard'] = hazard
+                    golfTracker[i]['hole'] = hole
+                    golfTracker[i]['last_played'] = time.time()
+                    golfTracker[i]['hole_shots'] = hole_shots
+
+            # Show player the hole information
+            msg += "⛳️#" + str(hole) + " is a " + str(hole_length) + "-yard Par " + str(par) + "."
+            if hasHazard: 
+                msg += "⚠️" + hazard + "."
+            else:
+                # add weather conditions with random choice from list, this is fluff
+                msg += random.choice(["☀️", "💨", "☀️", "☀️", "⛅️", "☁️", "☀️"])
+
+            if not finishedHole:
+                msg += f"\nChoose your club."
+
+            return msg
+
+    if last_cmd == 'stroking':
+
+        # Get player's current game state
+        for i in range(len(golfTracker)):
+            if golfTracker[i]['nodeID'] == nodeID:
+                distance_remaining = golfTracker[i]['distance_remaining']
+                hole = golfTracker[i]['hole']
+                hole_shots = golfTracker[i]['hole_shots']
+                par = golfTracker[i]['par']
+                total_strokes = golfTracker[i]['total_strokes']
+                total_to_par = golfTracker[i]['total_to_par']
+                hazard = golfTracker[i]['hazard']
+
+        # Start loop to be able to choose clubs while at least 20 yards away
+        if distance_remaining >= 20:
+            msg = ""
+            club = message.lower()
+            shot_distance = 0
+
+            pin_distance = distance_remaining
+
+            if club == "driver" or club.startswith("d"):
+                shot_distance = hit_driver()
+                msg += "🏌️Hit D " + str(shot_distance) + "yd. "
+                distance_remaining = abs(distance_remaining - shot_distance)
+                hole_shots += 1
+            elif "low" in club or club.startswith("l"):
+                shot_distance = hit_low_iron()
+                msg += "🏌️Hit L Iron " + str(shot_distance) + "yd. "
+                distance_remaining = abs(distance_remaining - shot_distance)
+                hole_shots += 1
+            elif "mid" in club or club.startswith("m"):
+                shot_distance = hit_mid_iron()
+                msg += "🏌️Hit M Iron " + str(shot_distance) + "yd. "
+                distance_remaining = abs(distance_remaining - shot_distance)
+                hole_shots += 1
+            elif "high" in club or club.startswith("h"):
+                shot_distance = hit_high_iron()
+                msg += "🏌️Hit H Iron " + str(shot_distance) + "yd. "
+                distance_remaining = abs(distance_remaining - shot_distance)
+                hole_shots += 1
+            elif "gap" in club or club.startswith("g"):
+                shot_distance = hit_gap_wedge()
+                msg += "🏌️Hit G Wedge " + str(shot_distance) + "yd ."
+                distance_remaining = abs(distance_remaining - shot_distance)
+                hole_shots += 1
+            elif "wedge" in club or club.startswith("w"):
+                shot_distance = hit_lob_wedge()
+                msg += "🏌️Hit L Wedge " + str(shot_distance) + "yd. "
+                distance_remaining = abs(distance_remaining - shot_distance)
+                hole_shots += 1
+            elif club == "caddy" or club.startswith("c"):
+                # Show player the club distances
+                msg += f"Caddy Guess:\nD:{hit_driver()} L:{hit_low_iron()} M:{hit_mid_iron()} H:{hit_high_iron()} G:{hit_gap_wedge()} W:{hit_lob_wedge()}"
+            else:
+                msg += f"Didnt get your club 🥪♣️🪩 choice, you have {distance_remaining}yds. to ⛳️"
+                return msg
+
+            if distance_remaining - pin_distance > pin_distance or shot_distance > pin_distance:
+                # Check for over-shooting the hole
+                if distance_remaining > 20:
+                    # did it go off the "green"?
+                    msg += "Overshot the green!🚀"
+            if distance_remaining == 0:
+                msg += "🎯Perfect shot! "
+                last_cmd = 'putt'
+            elif distance_remaining < 20:
+                # Roll Dice
+                hole_in_one_chance = random.randint(1, 100)
+                wind_factor = random.randint(1, 10)
+                skill_factor = random.randint(1, 10)
+                critter_factor = random.randint(1, 50)
+
+                # Check for hole in one
+                if hole_in_one_chance <= 5 and wind_factor > 7 and skill_factor > 8:
+                    distance_remaining = 0
+                # Check for critters
+                if skill_factor > 8 and critter_factor < 40 and wind_factor > 2 and hole_in_one_chance > 5:
+                    msg += random.choice(["A 🐿️ steals your ball!😡 ","You Hit a 🦅 soring past ", "🐊 need we say more? ", "hit a 🪟 of a 🏡 "])
+                    distance_remaining = -1
+                # Handle hazard
+                if hazard == "🌊" and skill_factor < 7:
+                    msg += "In the water!🌊"
+                    distance_remaining = -1
+                if hazard == "🏖️" and skill_factor < 5:
+                    msg += "In the sand!🏖️"
+                    distance_remaining = random.randint(5, 10)
+                if hazard == "🌲" and skill_factor < 3:
+                    msg += "In the trees!🌲"
+                    distance_remaining += random.randint(5, 20)
+                if hazard == "🏘️" and skill_factor < 2:
+                    msg += "In the parking lot!🚗"
+                    distance_remaining += random.randint(10, 30)
+                
+                # Check we didnt go off the green or into a hazard
+                if distance_remaining < 20:
+                    last_cmd = 'putt'
+                else:
+                    last_cmd = 'stroking'
+            else:
+                msg += "\nYou have " + str(distance_remaining) + "yd. ⛳️"
+                msg += "\nClub?[D, L, M, H, G, W]🏌️"
+
+
+                # save player's current game state, keep stroking
+                for i in range(len(golfTracker)):
+                    if golfTracker[i]['nodeID'] == nodeID:
+                        golfTracker[i]['distance_remaining'] = distance_remaining
+                        golfTracker[i]['hole_shots'] = hole_shots
+                        golfTracker[i]['total_strokes'] = total_strokes
+                        golfTracker[i]['cmd'] = 'stroking'
+
+                return msg
+
+    if last_cmd == 'putt':
+        # Finish the hole by putting
+        critter = False
+        if distance_remaining < 20:
+            if distance_remaining == 0:
+                putts = 0
+            elif distance_remaining == -1:
+                putts = 0
+                critter = True
+            else:
+                putts = finish_hole()
+
+            # Calculate hole and round scores
+            hole_strokes = hole_shots + putts
+            hole_to_par = hole_strokes - par
+            total_strokes += hole_strokes
+            total_to_par += hole_to_par
+
+
+            if not critter:
+                # Show player hole/round scoring info
+                if putts == 0 and hole_strokes == 1:
+                    msg += "🎯Hole in one!⛳️"
+                elif putts == 0:
+                    msg += "You're in the hole at " + str(hole_strokes) + " strokes!"
+                else:
+                    msg += "You're on the green! After " + str(putts) + " putt(s), you're in for " + str(hole_strokes) + " strokes."
+                msg += getScorecardGolf(hole_to_par)
+
+                if hole not in [1, 10]:
+                    # Show player total scoring info for the round, except hole 1 and 10
+                    msg += "\nYou've hit a total of " + str(total_strokes) + " strokes today, for"
+                    msg += getScorecardGolf(total_to_par)
+
+                # Move to next hole
+                hole += 1
+            else:
+                msg += f"Got a new ball at Pro-Shop, marshal put you @" # flow into same hole haha
+
+            # Scorecard reset
+            hole_to_par = 0
+            hole_strokes = 0
+            hole_shots = 0
+        
+        # Save player's current game state
+        for i in range(len(golfTracker)):
+            if golfTracker[i]['nodeID'] == nodeID:
+                golfTracker[i]['hole_strokes'] = hole_strokes
+                golfTracker[i]['hole_to_par'] = hole_to_par
+                golfTracker[i]['total_strokes'] = total_strokes
+                golfTracker[i]['total_to_par'] = total_to_par
+                golfTracker[i]['hole'] = hole
+                golfTracker[i]['cmd'] = 'new'
+                golfTracker[i]['last_played'] = time.time()
+
+        if hole >= 9:
+            # Final score messages & exit prompt
+            msg += f"🎉Finished 9-hole round⛳️"
+            #HighScore Display
+            highscore = getHighScoreGolf(nodeID, total_strokes, total_to_par)
+            if highscore != 0:
+                msg += " 🏆New Club Record🏆"
+            # pop player from tracker
+            for i in range(len(golfTracker)):
+                if golfTracker[i]['nodeID'] == nodeID:
+                    golfTracker.pop(i)
+            logger.debug("System: GolfSim: Player " + str(nodeID) + " has finished their round.")
+        else:
+            # Show player the next hole
+            msg += playGolf(nodeID, 'new', True)
+            msg += "\n🏌️[D, L, M, H, G, W, End]🏌️"
+            
+    return msg

modules/games/joke.py

@@ -0,0 +1,122 @@
+# This module is used to tell jokes to the user
+# The emoji table of contents is used to replace words in the joke with emojis
+# As a Ham, is this obsecuring the meaning of the joke? Or is it enhancing it?
+from dadjokes import Dadjoke # pip install dadjokes
+from modules.log import *
+
+def tableOfContents():
+    wordToEmojiMap = {
+        'love': '❤️', 'heart': '❤️', 'happy': '😊', 'smile': '😊', 'sad': '😢', 'angry': '😠', 'mad': '😠', 'cry': '😢', 'laugh': '😂', 'funny': '😂', 'cool': '😎',
+        'joy': '😂', 'kiss': '😘', 'hug': '🤗', 'wink': '😉', 'grin': '😁', 'bored': '😐', 'tired': '😴', 'sleepy': '😴', 'shocked': '😲', 'surprised': '😲',
+        'confused': '😕', 'thinking': '🤔', 'sick': '🤢', 'party': '🎉', 'celebrate': '🎉', 'clap': '👏', 'thumbs up': '👍', 'thumbs down': '👎',
+        'ok': '👌', 'wave': '👋', 'pray': '🙏', 'muscle': '💪', 'fire': '🔥', 'star': '⭐', 'sun': '☀️', 'moon': '🌙', 'rain': '🌧️', 'snow': '❄️', 'cloud': '☁️',
+        'dog': '🐶', 'cat': '🐱', 'mouse': '🐭', 'rabbit': '🐰', 'fox': '🦊', 'bear': '🐻', 'panda': '🐼', 'koala': '🐨', 'tiger': '🐯', 'lion': '🦁', 'cow': '🐮',
+        'pig': '🐷', 'frog': '🐸', 'monkey': '🐵', 'chicken': '🐔', 'penguin': '🐧', 'bird': '🐦', 'fish': '🐟', 'whale': '🐋', 'dolphin': '🐬', 'octopus': '🐙',
+        'apple': '🍎', 'orange': '🍊', 'banana': '🍌', 'watermelon': '🍉', 'grape': '🍇', 'strawberry': '🍓', 'cherry': '🍒', 'peach': '🍑', 'pineapple': '🍍', 'mango': '🥭', 'coconut': '🥥',
+        'tomato': '🍅', 'eggplant': '🍆', 'avocado': '🥑', 'broccoli': '🥦', 'cucumber': '🥒', 'corn': '🌽', 'carrot': '🥕', 'potato': '🥔', 'sweet potato': '🍠', 'chili': '🌶️', 'garlic': '🧄',
+        'pizza': '🍕', 'burger': '🍔', 'fries': '🍟', 'hotdog': '🌭', 'popcorn': '🍿', 'donut': '🍩', 'cookie': '🍪', 'cake': '🎂', 'pie': '🍰', 'cupcake': '🧁', 'chocolate': '🍫',
+        'candy': '🍬', 'lollipop': '🍭', 'pudding': '🍮', 'honey': '🍯', 'milk': '🍼', 'coffee': '☕', 'tea': '🍵', 'sake': '🍶', 'beer': '🍺', 'cheers': '🍻', 'champagne': '🥂',
+        'wine': '🍷', 'whiskey': '🥃', 'cocktail': '🍸', 'tropical drink': '🍹', 'bottle': '🍾', 'soda': '🥤', 'chopsticks': '🥢', 'fork': '🍴', 'knife': '🔪', 'spoon': '🥄', 'kitchen knife': '🔪',
+        'house': '🏠', 'home': '🏡', 'office': '🏢', 'post office': '🏣', 'hospital': '🏥', 'bank': '🏦', 'hotel': '🏨', 'love hotel': '🏩', 'convenience store': '🏪', 'school': '🏫', 'department store': '🏬',
+        'factory': '🏭', 'castle': '🏯', 'palace': '🏰', 'church': '💒', 'tower': '🗼', 'statue of liberty': '🗽', 'mosque': '🕌', 'synagogue': '🕍', 'hindu temple': '🛕', 'kaaba': '🕋', 'shinto shrine': '⛩️',
+        'railway': '🛤️', 'highway': '🛣️', 'map': '🗾', 'carousel': '🎠', 'ferris wheel': '🎡', 'roller coaster': '🎢', 'circus': '🎪', 'theater': '🎭', 'art': '🎨', 'slot machine': '🎰', 'dice': '🎲',
+        'bowling': '🎳', 'video game': '🎮', 'dart': '🎯', 'billiard': '🎱', 'medal': '🎖️', 'trophy': '🏆', 'gold medal': '🥇', 'silver medal': '🥈', 'bronze medal': '🥉', 'soccer': '⚽', 'baseball': '⚾',
+        'basketball': '🏀', 'volleyball': '🏐', 'football': '🏈', 'rugby': '🏉', 'tennis': '🎾', 'frisbee': '🥏', 'ping pong': '🏓', 'badminton': '🏸', 'boxing': '🥊', 'martial arts': '🥋',
+        'goal': '🥅', 'golf': '⛳', 'skating': '⛸️', 'fishing': '🎣', 'diving': '🤿', 'running': '🎽', 'skiing': '🎿', 'sledding': '🛷', 'curling': '🥌', 'climbing': '🧗', 'yoga': '🧘',
+        'surfing': '🏄', 'swimming': '🏊', 'water polo': '🤽', 'cycling': '🚴', 'mountain biking': '🚵', 'horse riding': '🏇', 'kneeling': '🧎', 'weightlifting': '🏋️', 'gymnastics': '🤸', 'wrestling': '🤼', 'handball': '🤾',
+        'juggling': '🤹', 'meditation': '🧘', 'sauna': '🧖', 'rock climbing': '🧗', 'stop': '🛑', 'computer': '💻', 'phone': '📱', 'email': '📧', 'camera': '📷', 'video': '📹', 'music': '🎵',
+        'guitar': '🎸', 'piano': '🎹', 'drum': '🥁', 'microphone': '🎤', 'headphone': '🎧', 'book': '📚', 'newspaper': '📰', 'magazine': '📖', 'pen': '🖊️', 'pencil': '✏️', 'paintbrush': '🖌️',
+        'scissors': '✂️', 'ruler': '📏', 'globe': '🌍', 'earth': '🌎', 'star': '🌟', 'comet': '☄️', 'rocket': '🚀', 'airplane': '✈️', 'car': '🚗', 'bus': '🚌', 'train': '🚆',
+        'bicycle': '🚲', 'motorcycle': '🏍️', 'boat': '🚤', 'ship': '🚢', 'helicopter': '🚁', 'tractor': '🚜', 'ambulance': '🚑', 'fire truck': '🚒', 'police car': '🚓', 'taxi': '🚕', 'truck': '🚚',
+        'construction': '🚧', 'traffic light': '🚦', 'stop sign': '🛑', 'fuel': '⛽', 'battery': '🔋', 'light bulb': '💡', 'flashlight': '🔦', 'candle': '🕯️', 'lamp': '🛋️',
+        'bed': '🛏️', 'sofa': '🛋️', 'chair': '🪑', 'table': '🛋️', 'toilet': '🚽', 'shower': '🚿', 'bathtub': '🛁', 'sink': '🚰', 'mirror': '🪞', 'door': '🚪', 'window': '🪟',
+        'key': '🔑', 'lock': '🔒', 'hammer': '🔨', 'wrench': '🔧', 'screwdriver': '🪛', 'saw': '🪚', 'drill': '🛠️', 'toolbox': '🧰', 'paint roller': '🖌️', 'brush': '🖌️', 'broom': '🧹',
+        'mop': '🧽', 'bucket': '🪣', 'vacuum': '🧹', 'washing machine': '🧺', 'dryer': '🧺', 'iron': '🧺', 'hanger': '🧺', 'laundry': '🧺', 'basket': '🧺', 'trash': '🗑️', 'recycle': '♻️',
+        'plant': '🌱', 'tree': '🌳', 'flower': '🌸', 'leaf': '🍃', 'cactus': '🌵', 'mushroom': '🍄', 'herb': '🌿', 'bamboo': '🎍', 'rose': '🌹', 'tulip': '🌷', 'sunflower': '🌻',
+        'hibiscus': '🌺', 'cherry blossom': '🌸', 'bouquet': '💐', 'seedling': '🌱', 'palm tree': '🌴', 'evergreen tree': '🌲', 'deciduous tree': '🌳', 'fallen leaf': '🍂', 'maple leaf': '🍁',
+        'ear of rice': '🌾', 'shamrock': '☘️', 'four leaf clover': '🍀', 'grapes': '🍇', 'melon': '🍈', 'watermelon': '🍉', 'tangerine': '🍊', 'lemon': '🍋', 'banana': '🍌', 'pineapple': '🍍',
+        'mango': '🥭', 'apple': '🍎', 'green apple': '🍏', 'pear': '🍐', 'peach': '🍑', 'cherries': '🍒', 'strawberry': '🍓', 'kiwi': '🥝', 'tomato': '🍅', 'coconut': '🥥', 'avocado': '🥑',
+        'eggplant': '🍆', 'potato': '🥔', 'carrot': '🥕', 'corn': '🌽', 'hot pepper': '🌶️', 'cucumber': '🥒', 'leafy green': '🥬', 'broccoli': '🥦', 'garlic': '🧄', 'onion': '🧅',
+        'peanuts': '🥜', 'chestnut': '🌰', 'bread': '🍞', 'croissant': '🥐', 'baguette': '🥖', 'flatbread': '🥙', 'pretzel': '🥨', 'bagel': '🥯', 'pancakes': '🥞', 'waffle': '🧇', 'cheese': '🧀',
+        'meat': '🍖', 'poultry': '🍗', 'bacon': '🥓', 'hamburger': '🍔', 'fries': '🍟', 'pizza': '🍕', 'hot dog': '🌭', 'sandwich': '🥪', 'taco': '🌮', 'burrito': '🌯', 'tamale': '🫔',
+        'stuffed flatbread': '🥙', 'falafel': '🧆', 'egg': '🥚', 'fried egg': '🍳', 'shallow pan of food': '🥘', 'pot of food': '🍲', 'fondue': '🫕', 'bowl with spoon': '🥣', 'green salad': '🥗',
+        'popcorn': '🍿', 'butter': '🧈', 'salt': '🧂', 'canned food': '🥫', 'bento box': '🍱', 'rice cracker': '🍘', 'rice ball': '🍙', 'cooked rice': '🍚', 'curry rice': '🍛', 'steaming bowl': '🍜',
+        'spaghetti': '🍝', 'roasted sweet potato': '🍠', 'oden': '🍢', 'sushi': '🍣', 'fried shrimp': '🍤', 'fish cake': '🍥', 'moon cake': '🥮', 'dango': '🍡', 'dumpling': '🥟', 'fortune cookie': '🥠',
+        'takeout box': '🥡', 'crab': '🦀', 'lobster': '🦞', 'shrimp': '🦐', 'squid': '🦑', 'oyster': '🦪', 'ice cream': '🍨', 'shaved ice': '🍧', 'ice cream cone': '🍦', 'doughnut': '🍩', 'cookie': '🍪',
+        'birthday cake': '🎂', 'shortcake': '🍰', 'cupcake': '🧁', 'pie': '🥧', 'chocolate bar': '🍫', 'candy': '🍬', 'lollipop': '🍭', 'custard': '🍮', 'honey pot': '🍯', 'baby bottle': '🍼',
+        'glass of milk': '🥛', 'hot beverage': '☕', 'teapot': '🫖', 'teacup without handle': '🍵', 'sake': '🍶', 'bottle with popping cork': '🍾', 'wine glass': '🍷', 'cocktail glass': '🍸', 'tropical drink': '🍹',
+        'beer mug': '🍺', 'clinking beer mugs': '🍻', 'clinking glasses': '🥂', 'tumbler glass': '🥃', 'cup with straw': '🥤', 'bubble tea': '🧋', 'beverage box': '🧃', 'mate': '🧉', 'ice': '🧊',
+        'chopsticks': '🥢', 'fork and knife': '🍴', 'spoon': '🥄', 'kitchen knife': '🔪', 'amphora': '🏺', 'globe showing Europe-Africa': '🌍', 'globe showing Americas': '🌎', 'globe showing Asia-Australia': '🌏',
+        'globe with meridians': '🌐', 'world map': '🗺️', 'mountain': '⛰️', 'volcano': '🌋', 'mount fuji': '🗻', 'camping': '🏕️', 'beach with umbrella': '🏖️', 'desert': '🏜️', 'desert island': '🏝️',
+        'national park': '🏞️', 'stadium': '🏟️', 'classical building': '🏛️', 'building construction': '🏗️', 'brick': '🧱', 'rock': '🪨', 'wood': '🪵', 'hut': '🛖', 'houses': '🏘️', 'derelict house': '🏚️',
+        'house with garden': '🏡', 'office building': '🏢', 'japanese post office': '🏣', 'post office': '🏤', 'hospital': '🏥', 'bank': '🏦', 'hotel': '🏨', 'love hotel': '🏩', 'convenience store': '🏪',
+        'school': '🏫', 'department store': '🏬', 'factory': '🏭', 'japanese castle': '🏯', 'castle': '🏰', 'wedding': '💒', 'tokyo tower': '🗼', 'statue of liberty': '🗽', 'church': '⛪', 'mosque': '🕌',
+        'hindu temple': '🛕', 'synagogue': '🕍', 'shinto shrine': '⛩️', 'kaaba': '🕋', 'fountain': '⛲', 'tent': '⛺', 'foggy': '🌁', 'night with stars': '🌃', 'sunrise over mountains': '🌄', 'sunrise': '🌅',
+        'cityscape at dusk': '🌆', 'sunset': '🌇', 'cityscape': '🏙️', 'bridge at night': '🌉', 'hot springs': '♨️', 'carousel horse': '🎠', 'ferris wheel': '🎡', 'roller coaster': '🎢', 'barber pole': '💈',
+        'robot': '🤖', 'alien': '👽', 'ghost': '👻', 'skull': '💀', 'pumpkin': '🎃', 'clown': '🤡', 'wizard': '🧙', 'elf': '🧝', 'fairy': '🧚', 'mermaid': '🧜', 'vampire': '🧛',
+        'zombie': '🧟', 'genie': '🧞', 'superhero': '🦸', 'supervillain': '🦹', 'mage': '🧙', 'knight': '🛡️', 'ninja': '🥷', 'pirate': '🏴‍☠️', 'angel': '👼', 'devil': '😈', 'dragon': '🐉',
+        'unicorn': '🦄', 'phoenix': '🦅', 'griffin': '🦅', 'centaur': '🐎', 'minotaur': '🐂', 'cyclops': '👁️', 'medusa': '🐍', 'sphinx': '🦁', 'kraken': '🦑', 'yeti': '❄️', 'sasquatch': '🦧',
+        'loch ness monster': '🦕', 'chupacabra': '🐐', 'banshee': '👻', 'golem': '🗿', 'djinn': '🧞', 'basilisk': '🐍', 'hydra': '🐉', 'cerberus': '🐶', 'chimera': '🐐', 'manticore': '🦁', 'wyvern': '🐉',
+        'pegasus': '🦄', 'hippogriff': '🦅', 'kelpie': '🐎', 'selkie': '🦭', 'kitsune': '🦊', 'tanuki': '🦝', 'tengu': '🦅', 'oni': '👹', 'yokai': '👻', 'kappa': '🐢', 'yurei': '👻',
+        'kami': '👼', 'shinigami': '💀', 'bakemono': '👹', 'tsukumogami': '🧸', 'noppera-bo': '👤', 'rokurokubi': '🧛', 'yuki-onna': '❄️', 'jorogumo': '🕷️', 'nue': '🐍', 'ubume': '👼',
+        'atom': '⚛️', 'dna': '🧬', 'microscope': '🔬', 'telescope': '🔭', 'rocket': '🚀', 'satellite': '🛰️', 'spaceship': '🛸', 'planet': '🪐', 'black hole': '🕳️', 'galaxy': '🌌',
+        'comet': '☄️', 'constellation': '🌠', 'lightning': '⚡', 'magnet': '🧲', 'battery': '🔋', 'computer': '💻', 'keyboard': '⌨️', 'mouse': '🖱️', 'printer': '🖨️', 'floppy disk': '💾',
+        'cd': '💿', 'dvd': '📀', 'smartphone': '📱', 'tablet': '📲', 'watch': '⌚', 'camera': '📷', 'video camera': '📹', 'projector': '📽️', 'radio': '📻', 'television': '📺',
+        'satellite dish': '📡', 'game controller': '🎮', 'joystick': '🕹️', 'vr headset': '🕶️', 'headphones': '🎧', 'speaker': '🔊', 'flashlight': '🔦', 'circuit': '🔌', 'chip': '💻',
+        'server': '🖥️', 'database': '💾', 'cloud': '☁️', 'network': '🌐', 'code': '💻', 'bug': '🐛', 'virus': '🦠', 'bacteria': '🦠', 'lab coat': '🥼', 'safety goggles': '🥽',
+        'test tube': '🧪', 'petri dish': '🧫', 'beaker': '🧪', 'bunsen burner': '🔥', 'graduated cylinder': '🧪', 'pipette': '🧪', 'scalpel': '🔪', 'syringe': '💉', 'pill': '💊',
+        'stethoscope': '🩺', 'thermometer': '🌡️', 'x-ray': '🩻', 'brain': '🧠', 'heart': '❤️', 'lung': '🫁', 'bone': '🦴', 'muscle': '💪', 'robot arm': '🦾', 'robot leg': '🦿',
+        'prosthetic arm': '🦾', 'prosthetic leg': '🦿', 'wheelchair': '🦽', 'crutch': '🦯', 'hearing aid': '🦻', 'glasses': '👓', 'magnifying glass': '🔍', 'circus tent': '🎪',
+        'duck': '🦆', 'eagle': '🦅', 'owl': '🦉', 'bat': '🦇', 'shark': '🦈', 'butterfly': '🦋', 'snail': '🐌', 'bee': '🐝', 'beetle': '🐞', 'ant': '🐜', 'cricket': '🦗', 
+        'spider': '🕷️', 'scorpion': '🦂', 'turkey': '🦃', 'peacock': '🦚', 'parrot': '🦜', 'swan': '🦢', 'flamingo': '🦩', 'dodo': '🦤', 'sloth': '🦥', 'otter': '🦦', 
+        'skunk': '🦨', 'kangaroo': '🦘', 'badger': '🦡', 'beaver': '🦫', 'bison': '🦬', 'mammoth': '🦣', 'raccoon': '🦝', 'hedgehog': '🦔', 'squirrel': '🐿️', 'chipmunk': '🐿️', 
+        'porcupine': '🦔', 'llama': '🦙', 'giraffe': '🦒', 'zebra': '🦓', 'hippopotamus': '🦛', 'rhinoceros': '🦏', 'gorilla': '🦍', 'orangutan': '🦧', 'elephant': '🐘', 'camel': '🐫', 
+        'llama': '🦙', 'alpaca': '🦙', 'buffalo': '🐃', 'ox': '🐂', 'deer': '🦌', 'moose': '🦌', 'reindeer': '🦌', 'goat': '🐐', 'sheep': '🐑', 'ram': '🐏', 'lamb': '🐑', 'horse': '🐴', 
+        'unicorn': '🦄', 'zebra': '🦓', 'cow': '🐄', 'pig': '🐖', 'boar': '🐗', 'mouse': '🐁', 'rat': '🐀', 'hamster': '🐹', 'rabbit': '🐇', 'chipmunk': '🐿️', 'beaver': '🦫', 'hedgehog': '🦔', 
+        'bat': '🦇', 'bear': '🐻', 'koala': '🐨', 'panda': '🐼', 'sloth': '🦥', 'otter': '🦦', 'skunk': '🦨', 'kangaroo': '🦘', 'badger': '🦡', 'turkey': '🦃', 'chicken': '🐔', 'rooster': '🐓', 
+        'peacock': '🦚', 'parrot': '🦜', 'swan': '🦢', 'flamingo': '🦩', 'dodo': '🦤', 'crocodile': '🐊', 'turtle': '🐢', 'lizard': '🦎', 'snake': '🐍', 'dragon': '🐉', 'sauropod': '🦕', 't-rex': '🦖', 
+        'whale': '🐋', 'dolphin': '🐬', 'fish': '🐟', 'blowfish': '🐡', 'shark': '🦈', 'octopus': '🐙', 'shell': '🐚', 'crab': '🦀', 'lobster': '🦞', 'shrimp': '🦐', 'squid': '🦑', 'snail': '🐌', 'butterfly': '🦋', 
+        'bee': '🐝', 'beetle': '🐞', 'ant': '🐜', 'cricket': '🦗', 'spider': '🕷️', 'scorpion': '🦂', 'mosquito': '🦟', 'microbe': '🦠', 'locomotive': '🚂', 'arm': '💪', 'leg': '🦵', 'sponge': '🧽',
+        'toothbrush': '🪥', 'broom': '🧹', 'basket': '🧺', 'roll of paper': '🧻', 'bucket': '🪣', 'soap': '🧼', 'toilet paper': '🧻', 'shower': '🚿', 'bathtub': '🛁', 'razor': '🪒', 'lotion': '🧴',
+        'letter': '✉️', 'envelope': '✉️', 'mail': '📬', 'post': '📮', 'golf': '⛳️', 'golfing': '⛳️', 'office': '🏢', 'meeting': '📅', 'presentation': '📊', 'report': '📄', 'document': '📄',
+        'file': '📁', 'folder': '📂', 'sports': '🏅', 'athlete': '🏃', 'competition': '🏆', 'race': '🏁', 'tournament': '🏆', 'champion': '🏆', 'medal': '🏅', 'victory': '🏆', 'win': '🏆', 'lose': '😞',
+        'draw': '🤝', 'team': '👥', 'player': '👤', 'coach': '👨‍🏫', 'referee': '🧑‍⚖️', 'stadium': '🏟️', 'arena': '🏟️', 'field': '🏟️', 'court': '🏟️', 'track': '🏟️', 'gym': '🏋️', 'fitness': '🏋️', 'exercise': '🏋️', 
+        'workout': '🏋️', 'training': '🏋️', 'practice': '🏋️', 'game': '🎮', 'match': '🎮', 'score': '🏅', 'goal': '🥅', 'point': '🏅', 'basket': '🏀', 'home run': '⚾️', 'strike': '🎳', 'spare': '🎳', 'frame': '🎳', 
+        'inning': '⚾️', 'quarter': '🏈', 'half': '🏈', 'overtime': '🏈', 'penalty': '⚽️', 'foul': '⚽️', 'timeout': '⏱️', 'substitute': '🔄', 'bench': '🪑', 'sideline': '🏟️', 'dugout': '⚾️', 'locker room': '🚪', 'shower': '🚿', 
+        'uniform': '👕', 'jersey': '👕', 'cleats': '👟', 'helmet': '⛑️', 'pads': '🛡️', 'gloves': '🧤', 'bat': '⚾️', 'ball': '⚽️', 'puck': '🏒', 'stick': '🏒', 'net': '🥅', 'hoop': '🏀', 'goalpost': '🥅', 'whistle': '🔔', 
+        'scoreboard': '📊', 'fans': '👥', 'crowd': '👥', 'cheer': '📣', 'boo': '😠', 'applause': '👏', 'celebration': '🎉', 'parade': '🎉', 'trophy': '🏆', 'medal': '🏅', 'ribbon': '🎀', 'cup': '🏆', 'championship': '🏆', 
+        'league': '🏆', 'season': '🏆', 'playoffs': '🏆', 'finals': '🏆', 'champion': '🏆', 'runner-up': '🥈', 'third place': '🥉', 'snowman': '☃️', 'snowmen': '⛄️'
+    }
+
+    return wordToEmojiMap
+
+def sendWithEmoji(message):
+    # this will take a string of text and replace any word or phrase that is in the word list with the corresponding emoji
+    wordToEmojiMap = tableOfContents()
+    # type format to clean it up
+    words = message.split()
+    i = 0
+    while i < len(words):
+        for phrase in sorted(wordToEmojiMap.keys(), key=len, reverse=True):
+            phrase_words = phrase.split()
+            # Strip punctuation from the words
+            stripped_words = [word.lower().strip('.,!?') for word in words[i:i+len(phrase_words)]]
+            if stripped_words == phrase_words:
+                logger.debug(f"System: Replaced the phrase '{phrase}' with '{wordToEmojiMap[phrase]}'")
+                words[i:i+len(phrase_words)] = [wordToEmojiMap[phrase]]
+                i += len(phrase_words) - 1
+                break
+            # Check for plural forms
+            elif stripped_words == [word + 's' for word in phrase_words]:
+                logger.debug(f"System: Replaced the plural phrase '{' '.join([word + 's' for word in phrase_words])}' with '{wordToEmojiMap[phrase]}'")
+                words[i:i+len(phrase_words)] = [wordToEmojiMap[phrase]]
+                i += len(phrase_words) - 1
+                break
+        i += 1
+    return ' '.join(words)
+
+def tell_joke(nodeID=0):
+    dadjoke = Dadjoke()
+    renderedLaugh = sendWithEmoji(dadjoke.joke)
+    return renderedLaugh
+

modules/games/lemonade.py

@@ -22,7 +22,7 @@ lemonadeTracker = [{'nodeID': 0, 'cups': 0, 'lemons': 0, 'sugar': 0, 'cash': lem
 lemonadeCups = [{'nodeID': 0, 'cost': 2.50, 'count': 25, 'min': 0.99, 'unit': 0.00}]
 lemonadeLemons = [{'nodeID': 0, 'cost': 4.00, 'count': 8, 'min': 2.00, 'unit': 0.00}]
 lemonadeSugar = [{'nodeID': 0, 'cost': 3.00, 'count': 15, 'min': 1.50, 'unit': 0.00}]
-lemonadeWeeks = [{'nodeID': 0, 'current': 1, 'total': lemon_total_weeks, 'sales': 99, 'potential': 0, 'unit': 0.00, 'price': 0.00}]
+lemonadeWeeks = [{'nodeID': 0, 'current': 1, 'total': lemon_total_weeks, 'sales': 99, 'potential': 0, 'unit': 0.00, 'price': 0.00, 'total_sales': 0}]
 lemonadeScore = [{'nodeID': 0, 'value': 0.00, 'total': 0.00}]
 
 def get_sales_amount(potential, unit, price):
@@ -38,17 +38,15 @@ def get_sales_amount(potential, unit, price):
     return math.floor(potential * (unit / (price ** 1.5)))
 
 def getHighScoreLemon():
-    global high_score
+    high_score = {"userID": 0, "cash": 0, "success": 0}
     # Load high score table
     try:
-        with open('lemonade_hs.pkl', 'rb') as file:
+        with open('data/lemonstand.pkl', 'rb') as file:
             high_score = pickle.load(file)
     except FileNotFoundError:
         logger.debug("System: Lemonade: No high score table found")
-        # high score pickle file is a touple of the nodeID and the high score
-        high_score = ({"userID": 4258675309, "cash": 2, "success": 0})
         # write a new high score file if one is not found
-        with open('lemonade_hs.pkl', 'wb') as file:
+        with open('data/lemonstand.pkl', 'wb') as file:
             pickle.dump(high_score, file)
     return high_score
 
@@ -57,10 +55,11 @@ def start_lemonade(nodeID, message, celsius=False):
     potential = 0
     unit = 0.0
     price = 0.0
+    total_sales = 0
 
     high_score = getHighScoreLemon()
 
-    def saveValues():
+    def saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score):
         # save playerDB values
         for i in range(len(lemonadeTracker)):
             if lemonadeTracker[i]['nodeID'] == nodeID:
@@ -89,6 +88,7 @@ def start_lemonade(nodeID, message, celsius=False):
                 lemonadeWeeks[i]['potential'] = potential
                 lemonadeWeeks[i]['unit'] = unit
                 lemonadeWeeks[i]['price'] = price
+                lemonadeWeeks[i]['total_sales'] = weeks.total_sales
         for i in range(len(lemonadeScore)):
             if lemonadeScore[i]['nodeID'] == nodeID:
                 lemonadeScore[i]['value'] = score.value
@@ -117,7 +117,7 @@ def start_lemonade(nodeID, message, celsius=False):
         logger.debug("System: Lemonade: Game Over for " + str(nodeID))
 
     # Check for end of game
-    if "end" in message.lower():
+    if message.lower().startswith("e"):
         endGame(nodeID)
         return "Goodbye!👋"
 
@@ -171,6 +171,7 @@ def start_lemonade(nodeID, message, celsius=False):
         'current' : 1,   # start with the 1st week
         'total'   : 12,  # span the 12 weeks of Summer
         'sales'   : 99,  # 99 maximum sales per week
+        'total_sales' : 0, # total sales
         'summary' : []   # empty array
     }
     weeks = SimpleNamespace(**weeksd)
@@ -233,13 +234,12 @@ def start_lemonade(nodeID, message, celsius=False):
             potential = lemonadeWeeks[i]['potential']
             unit = lemonadeWeeks[i]['unit']
             price = lemonadeWeeks[i]['price']
+            weeks.total_sales = lemonadeWeeks[i]['total_sales']
     for i in range(len(lemonadeScore)):
         if lemonadeScore[i]['nodeID'] == nodeID:
             score.value = lemonadeScore[i]['value']
             score.total = lemonadeScore[i]['total']
 
-    logger.debug("System: Lemonade: Last Command: " + last_cmd)
-
     # Start the main loop
     if (weeks.current <= weeks.total):
 
@@ -326,7 +326,7 @@ def start_lemonade(nodeID, message, celsius=False):
                     buffer += "📊P&L📈" + pnl
 
             buffer += f"\n🥤 to buy? Have {inventory.cups} Cost {locale.currency(cups.cost, grouping=True)} a 📦 of {str(cups.count)}"
-            saveValues()
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return buffer
         
         if "cups" in last_cmd:
@@ -353,7 +353,7 @@ def start_lemonade(nodeID, message, celsius=False):
             for i in range(len(lemonadeTracker)):
                 if lemonadeTracker[i]['nodeID'] == nodeID:
                     lemonadeTracker[i]['cmd'] = "lemons"
-            saveValues()
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             msg += f"\n 🍋 to buy? Have {inventory.lemons}🥤 of 🍋 Cost {locale.currency(lemons.cost, grouping=True)} a 🧺 for {str(lemons.count)}🥤"
             return msg
                 
@@ -383,7 +383,7 @@ def start_lemonade(nodeID, message, celsius=False):
             for i in range(len(lemonadeTracker)):
                 if lemonadeTracker[i]['nodeID'] == nodeID:
                     lemonadeTracker[i]['cmd'] = "sugar"
-            saveValues()
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             msg += f"\n 🍚 to buy? You have {inventory.sugar}🥤 of 🍚, Cost {locale.currency(sugar.cost, grouping=True)} a bag for {str(sugar.count)}🥤"
             return msg
 
@@ -415,7 +415,7 @@ def start_lemonade(nodeID, message, celsius=False):
             for i in range(len(lemonadeTracker)):
                 if lemonadeTracker[i]['nodeID'] == nodeID:
                     lemonadeTracker[i]['cmd'] = "price"
-            saveValues()
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return msg
     
         if "price" in last_cmd:
@@ -440,11 +440,12 @@ def start_lemonade(nodeID, message, celsius=False):
                         return "The price must be greater than zero."
                 except Exception as e:
                     price = 0.00
+                    last_cmd = "price"
                     return "⛔️Invalid input, enter the price of the lemonade per 🥤"
             
             # this isnt sent to the user, not needed
             #msg = "  Setting the price at " + locale.currency(price, grouping=True)
-            saveValues()
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
         
 
         if "sales" in last_cmd:
@@ -493,13 +494,16 @@ def start_lemonade(nodeID, message, celsius=False):
             # Display the weekly sales summary
             pad_week = len(str(weeks.total))
             pad_sale = len(str(weeks.sales))
-            total    = 0
+            total = 0
             msg += "\nWeekly📊"
             for i in range(len(weeks.summary)):
                 msg += "#" + str(weeks.current).rjust(pad_week) + ".  " + str(weeks.summary[i]['sales']).rjust(pad_sale) + \
                     " sold x " + locale.currency(weeks.summary[i]['price'], grouping=True) + "ea. "
                 total = total + weeks.summary[i]['sales']
 
+            # Update the total sales for the game
+            weeks.total_sales += total
+            
             # Loop through a range of prices to find the highest net profit
             maxsales = 0
             maxprice = 0.00
@@ -537,13 +541,14 @@ def start_lemonade(nodeID, message, celsius=False):
             score.value = score.value + minnet
             score.total = score.total + maxnet
 
+
             # Increment the week number
             if (weeks.current == weeks.total):
                 # end of the game
                 success = round((score.value / score.total) * 100)
                 msg += "\nYou've made " + locale.currency(score.value, grouping=True) + " out of a possible " + \
                     locale.currency(score.total, grouping=True) + " for a score of " + str(success) + "% "
-                msg += "You've sold " + str(total) + " total 🥤🍋"
+                msg += "You've sold " + str(weeks.total_sales) + " total 🥤🍋"
 
                 # check for high score
                 high_score = getHighScoreLemon()
@@ -552,7 +557,7 @@ def start_lemonade(nodeID, message, celsius=False):
                     high_score['cash'] = inventory.cash
                     high_score['success'] = success
                     high_score['userID'] = nodeID
-                    with open('lemonade_hs.pkl', 'wb') as file:
+                    with open('data/lemonstand.pkl', 'wb') as file:
                         pickle.dump(high_score, file)
                 endGame(nodeID)
 
@@ -562,10 +567,11 @@ def start_lemonade(nodeID, message, celsius=False):
                 for i in range(len(lemonadeTracker)):
                     if lemonadeTracker[i]['nodeID'] == nodeID:
                         lemonadeTracker[i]['cmd'] = "new"
-            
+                        lemonadeTracker[i]['time'] = time.time()
+                
                 weeks.current = weeks.current + 1
 
-                msg += f"Play another week🥤? 'end' to end game"
+                msg += f"Play another week🥤? or (E)nd Game"
                 
-                saveValues()
+                saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return msg

modules/games/meshtrekker.py

@@ -0,0 +1,255 @@
+"""
+Mesh Trekker Game
+Game Rules:
+1. Players compete to cover the most distance over time using their Meshtastic devices.
+2. The game tracks players' movements via GPS coordinates sent by their devices.
+3. Total distance traveled is calculated and summed over time for each player.
+4. Leaderboards show top distances for daily, weekly, and all-time periods.
+5. Players can form teams, with team distances being the sum of all team members' distances.
+6. Special achievements are awarded for milestones (e.g., 10km, 50km, 100km total distance).
+7. The game runs continuously, allowing players to participate at their own pace.
+8. Players can use the 'whereami' command to check their current location and update their position in the game.
+"""
+
+import pickle
+from modules.log import *
+from datetime import datetime, timedelta
+from geopy.distance import geodesic
+
+class MeshTrekkerError(Exception):
+    """Base class for exceptions in this module."""
+    pass
+
+class DataLoadError(MeshTrekkerError):
+    """Raised when there's an error loading data."""
+    pass
+
+class DataSaveError(MeshTrekkerError):
+    """Raised when there's an error saving data."""
+    pass
+
+class InvalidGPSDataError(MeshTrekkerError):
+    """Raised when invalid GPS data is provided."""
+    pass
+
+class MeshTrekker:
+    def __init__(self, data_file='mesh_trekker_data.pkl'):
+        self.data_file = data_file
+        try:
+            self.data = self.load_data()
+        except DataLoadError as e:
+            logger.error(f"Failed to load data: {e}")
+            self.data = self.initialize_data()
+
+    def initialize_data(self):
+        return {
+            'gps_data': {},
+            'user_distances': {},
+            'teams': {},
+            'achievements': {},
+        }
+
+    def load_data(self):
+        try:
+            with open(self.data_file, 'rb') as f:
+                return pickle.load(f)
+        except (pickle.PickleError, EOFError, FileNotFoundError) as e:
+            logger.info(f"Data file {self.data_file} not found. Initializing new data.")
+            return self.initialize_data()
+
+    def save_data(self):
+        try:
+            with open(self.data_file, 'wb') as f:
+                pickle.dump(self.data, f)
+        except (pickle.PickleError, IOError) as e:
+            raise DataSaveError(f"Error saving data: {e}")
+
+    def validate_gps_data(self, latitude, longitude, timestamp):
+        try:
+            lat = float(latitude)
+            lon = float(longitude)
+            if not -90 <= lat <= 90:
+                raise InvalidGPSDataError(f"Invalid latitude: {latitude}")
+            if not -180 <= lon <= 180:
+                raise InvalidGPSDataError(f"Invalid longitude: {longitude}")
+            if not isinstance(timestamp, datetime):
+                raise InvalidGPSDataError(f"Invalid timestamp: {timestamp}")
+        except ValueError:
+            raise InvalidGPSDataError(f"Invalid GPS data: latitude={latitude}, longitude={longitude}")
+
+    def process_gps_data(self, user_id, latitude, longitude, timestamp):
+        try:
+            self.validate_gps_data(latitude, longitude, timestamp)
+
+            if user_id not in self.data['gps_data']:
+                self.data['gps_data'][user_id] = []
+
+            self.data['gps_data'][user_id].append((float(latitude), float(longitude), timestamp))
+
+            if len(self.data['gps_data'][user_id]) > 1:
+                last_lat, last_lon, last_time = self.data['gps_data'][user_id][-2]
+                last_point = (last_lat, last_lon)
+                new_point = (float(latitude), float(longitude))
+
+                distance = geodesic(last_point, new_point).kilometers
+
+                if user_id not in self.data['user_distances']:
+                    self.data['user_distances'][user_id] = (0, timestamp)
+
+                total_distance, _ = self.data['user_distances'][user_id]
+                new_total_distance = total_distance + distance
+                self.data['user_distances'][user_id] = (new_total_distance, timestamp)
+
+                self.check_achievements(user_id, new_total_distance)
+
+            self.save_data()
+            return new_total_distance
+        except InvalidGPSDataError as e:
+            logger.error(f"Invalid GPS data for user {user_id}: {e}")
+        except DataSaveError as e:
+            logger.error(f"Failed to save data after processing GPS for user {user_id}: {e}")
+        except Exception as e:
+            logger.error(f"Unexpected error processing GPS data for user {user_id}: {e}")
+        return None
+
+    def get_leaderboard(self, timeframe='all'):
+        try:
+            now = datetime.now()
+            if timeframe == 'daily':
+                start_time = now - timedelta(days=1)
+            elif timeframe == 'weekly':
+                start_time = now - timedelta(weeks=1)
+            else:
+                start_time = datetime.min
+
+            leaderboard = []
+            for user_id, (distance, last_updated) in self.data['user_distances'].items():
+                if last_updated > start_time:
+                    leaderboard.append((user_id, distance))
+
+            return sorted(leaderboard, key=lambda x: x[1], reverse=True)[:10]
+        except Exception as e:
+            logger.error(f"Error generating leaderboard: {e}")
+            return []
+
+    def get_team_leaderboard(self):
+        try:
+            team_distances = {}
+            for team_name, members in self.data['teams'].items():
+                team_distance = sum(self.data['user_distances'].get(member, (0, None))[0] for member in members)
+                team_distances[team_name] = team_distance
+
+            return sorted(team_distances.items(), key=lambda x: x[1], reverse=True)[:10]
+        except Exception as e:
+            logger.error(f"Error generating team leaderboard: {e}")
+            return []
+
+    def get_user_stats(self, user_id):
+        try:
+            distance, last_updated = self.data['user_distances'].get(user_id, (0, None))
+            achievements = self.data['achievements'].get(user_id, [])
+            return {
+                'distance': distance,
+                'last_updated': last_updated,
+                'achievements': achievements
+            }
+        except Exception as e:
+            logger.error(f"Error retrieving stats for user {user_id}: {e}")
+            return None
+
+    def create_team(self, team_name, user_id):
+        try:
+            if team_name not in self.data['teams']:
+                self.data['teams'][team_name] = [user_id]
+                self.save_data()
+                return True
+            return False
+        except DataSaveError as e:
+            logger.error(f"Failed to save data after creating team {team_name}: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Error creating team {team_name}: {e}")
+            return False
+
+    def join_team(self, team_name, user_id):
+        try:
+            if team_name in self.data['teams'] and user_id not in self.data['teams'][team_name]:
+                self.data['teams'][team_name].append(user_id)
+                self.save_data()
+                return True
+            return False
+        except DataSaveError as e:
+            logger.error(f"Failed to save data after user {user_id} joined team {team_name}: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Error joining team {team_name} for user {user_id}: {e}")
+            return False
+
+    def check_achievements(self, user_id, total_distance):
+        try:
+            if user_id not in self.data['achievements']:
+                self.data['achievements'][user_id] = []
+
+            milestones = [10, 50, 100, 500, 1000]  # in km
+            new_achievements = []
+            for milestone in milestones:
+                if total_distance >= milestone and milestone not in self.data['achievements'][user_id]:
+                    self.data['achievements'][user_id].append(milestone)
+                    new_achievements.append(milestone)
+                    logger.info(f"User {user_id} achieved {milestone}km milestone!")
+            return new_achievements
+        except Exception as e:
+            logger.error(f"Error checking achievements for user {user_id}: {e}")
+            return []
+
+    def get_achievements(self, user_id):
+        try:
+            return self.data['achievements'].get(user_id, [])
+        except Exception as e:
+            logger.error(f"Error retrieving achievements for user {user_id}: {e}")
+            return []
+        
+# Initialize the game
+game = MeshTrekker()
+
+def handle_meshtrekker(user_id, deviceID, channel_number, location_info=(0,0)):
+    # Process GPS data from Meshtastic devices
+    latitude, longitude = location_info.split(": ")[1].split(", ")
+    
+    current_time = datetime.now()
+    new_distance = game.process_gps_data(user_id, latitude, longitude, current_time)
+
+
+    # # Create and join teams
+    # game.create_team("Team A", "user1")
+    # game.join_team("Team A", "user2")
+
+    # # Get individual leaderboard
+    # print("\nAll-time individual leaderboard:")
+    # for user, distance in game.get_leaderboard():
+    #     print(f"{user}: {distance:.2f} km")
+
+    # # Get team leaderboard
+    # print("\nTeam leaderboard:")
+    # for team, distance in game.get_team_leaderboard():
+    #     print(f"{team}: {distance:.2f} km")
+
+    # # Get user stats
+    # user_stats = game.get_user_stats("user1")
+    # print(f"\nUser1 stats: {user_stats}")
+
+    # # Get achievements
+    # achievements = game.get_achievements("user1")
+    # print(f"User1 achievements: {achievements}")
+
+    
+    if new_distance is not None:
+        new_achievements = game.check_achievements(user_id, new_distance)
+        response = f"{location_info}\nTotal distance: {new_distance:.2f} km"
+        if new_achievements:
+            response += f"\nNew achievements: {', '.join([f'{a}km' for a in new_achievements])}"
+    else:
+        response = f"{location_info}\nFailed to update distance. Please try again."
+    
+    return response
+

modules/games/mmind.py

@@ -0,0 +1,340 @@
+# https://github.com/pwdkramer/pythonMastermind/blob/main/main.py
+# Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+import random
+import time
+import pickle
+from modules.log import *
+
+mindTracker = [{'nodeID': 0, 'last_played': time.time(), 'cmd': '', 'secret_code': '', 'diff': 'n', 'turns': 1}]
+
+def chooseDifficultyMMind(message):
+    usrInput = message.lower()
+    msg = ''
+    valid_colorsMMind = "RYGB"
+    
+    if not usrInput.startswith("n") and not usrInput.startswith("h") and not usrInput.startswith("x"):
+        # default to normal difficulty
+        usrInput = "n"
+    
+    if usrInput == "n":
+        msg += f"The colors to choose from are:\nR🔴, Y🟡, G🟢, B🔵"
+    elif usrInput == "h":
+        valid_colorsMMind += "OP"
+        msg += f"The colors to choose from are\nR🔴, Y🟡, G🟢, B🔵, O🟠, P🟣"
+    elif usrInput == "x":
+        valid_colorsMMind += "OPWK"
+        msg += f"The colors to choose from are\nR🔴, Y🟡, G🟢, B🔵, O🟠, P🟣, W⚪, K⚫"
+    return msg
+
+
+#possible colors on nomral: Red, Yellow, Green, Blue
+#added colors on hard: Orange, Purple
+def makeCodeMMind(diff):
+    secret_code = ""
+    for i in range(4):
+        if diff == "n":
+            roll = random.randrange(1, 5)
+        elif diff == "h":
+            roll = random.randrange(1,7)
+        elif diff == "x":
+            roll = random.randrange(1,9)
+        else:
+            print("Difficulty error in makeCode()")
+        if roll == 1:
+            secret_code += "R"
+        elif roll == 2:
+            secret_code += "Y"
+        elif roll == 3:
+            secret_code += "G"
+        elif roll == 4:
+            secret_code += "B"
+        elif roll == 5:
+            secret_code += "O"
+        elif roll == 6:
+            secret_code += "P"
+        elif roll == 7:
+            secret_code += "W"
+        elif roll == 8:
+            secret_code += "K"
+        else:
+            print("Error with range of roll in makeCode()")
+    return secret_code
+
+#get guess from user
+def getGuessMMind(diff, guess):
+    msg = ''
+    if diff == "n":
+        valid_colorsMMind = "RYGB"
+    elif diff == "h":
+        valid_colorsMMind = "RYGBOP"
+    elif diff == "x":
+        valid_colorsMMind = "RYGBOPWK"
+        
+    user_guess = guess.upper()
+    valid_guess = True
+    if len(user_guess) != 4:
+        valid_guess = False
+    for i in range(len(user_guess)):
+        if user_guess[i] not in valid_colorsMMind:
+            valid_guess = False
+    if valid_guess == False:
+        user_guess = "XXXX"
+    return user_guess
+
+def getHighScoreMMind(nodeID, turns, diff):
+    # check if player is in high score list and pick the lowest score
+    try:
+        with open('mmind_hs.pkl', 'rb') as f:
+            mindHighScore = pickle.load(f)
+    except:
+        logger.debug("System: MasterMind: High Score file not found.")
+        mindHighScore = [{'nodeID': nodeID, 'turns': turns, 'diff': diff}]
+        with open('mmind_hs.pkl', 'wb') as f:
+            pickle.dump(mindHighScore, f)
+
+    if nodeID == 0:
+        # just return the high score
+        return mindHighScore
+
+    # calculate lowest score
+    lowest_score = mindHighScore[0]['turns']
+
+    if mindHighScore[0]['diff'] == "n" and diff == "n":
+        if lowest_score > turns:
+            # update the high score for normal if new score is lower
+            mindHighScore[0]['nodeID'] = nodeID
+            mindHighScore[0]['turns'] = turns
+            mindHighScore[0]['diff'] = diff
+            
+            # write new high score to file
+            with open('mmind_hs.pkl', 'wb') as f:
+                pickle.dump(mindHighScore, f)
+            return mindHighScore
+    elif mindHighScore[0]['diff'] == "n" and diff == "h":
+        # update the high score for hard if normal is the only high score
+        mindHighScore[0]['nodeID'] = nodeID
+        mindHighScore[0]['turns'] = turns
+        mindHighScore[0]['diff'] = diff
+        
+        # write new high score to file
+        with open('mmind_hs.pkl', 'wb') as f:
+            pickle.dump(mindHighScore, f)
+        return mindHighScore
+    elif mindHighScore[0]['diff'] == "h" and diff == "h":
+        if lowest_score > turns:
+            # update the high score for hard if new score is lower
+            mindHighScore[0]['nodeID'] = nodeID
+            mindHighScore[0]['turns'] = turns
+            mindHighScore[0]['diff'] = diff
+            
+            # write new high score to file
+            with open('mmind_hs.pkl', 'wb') as f:
+                pickle.dump(mindHighScore, f)
+            return mindHighScore
+    elif mindHighScore[0]['diff'] == "n" or mindHighScore[0]['diff'] == "h" and diff == "x":
+        # update the high score for expert if normal or high is the only high score
+        mindHighScore[0]['nodeID'] = nodeID
+        mindHighScore[0]['turns'] = turns
+        mindHighScore[0]['diff'] = diff
+        
+        # write new high score to file
+        with open('mmind_hs.pkl', 'wb') as f:
+            pickle.dump(mindHighScore, f)
+        return mindHighScore
+    elif mindHighScore[0]['diff'] == "x" and diff == "x":
+        if lowest_score > turns:
+            # update the high score for expert if new score is lower
+            mindHighScore[0]['nodeID'] = nodeID
+            mindHighScore[0]['turns'] = turns
+            mindHighScore[0]['diff'] = diff
+            
+            # write new high score to file
+            with open('mmind_hs.pkl', 'wb') as f:
+                pickle.dump(mindHighScore, f)
+            return mindHighScore
+    return 0
+
+
+def getEmojiMMind(secret_code):
+    # for each letter in the secret code, convert to emoji for display
+    secret_code = secret_code.upper()
+    secret_code_emoji = ""
+    for i in range(len(secret_code)):
+        if secret_code[i] == "R":
+            secret_code_emoji += "🔴"
+        elif secret_code[i] == "Y":
+            secret_code_emoji += "🟡"
+        elif secret_code[i] == "G":
+            secret_code_emoji += "🟢"
+        elif secret_code[i] == "B":
+            secret_code_emoji += "🔵"
+        elif secret_code[i] == "O":
+            secret_code_emoji += "🟠"
+        elif secret_code[i] == "P":
+            secret_code_emoji += "🟣"
+        elif secret_code[i] == "W":
+            secret_code_emoji += "⚪"
+        elif secret_code[i] == "K":
+            secret_code_emoji += "⚫"
+        elif secret_code[i] == "X":
+            secret_code_emoji += "❌"
+    return secret_code_emoji
+
+#compare userGuess with secret code and provide feedback
+def compareCodeMMind(secret_code, user_guess):
+    game_won = False
+    perfect_pins = 0
+    wrong_position = 0
+    msg = ''
+    #logger.debug("System: MasterMind: secret_code: " + str(secret_code) + " user_guess: " + str(user_guess))
+    if secret_code == user_guess: #correct guess, user wins
+        perfect_pins = 4
+        game_won = True
+    else:
+        # check for perfect pins and right color wrong position
+        temp_code = []
+        temp_guess = []
+        # Check for perfect pins
+        for i in range(len(user_guess)):
+            if user_guess[i] == secret_code[i]:
+                perfect_pins += 1
+            else:
+                temp_code.append(secret_code[i])
+                temp_guess.append(user_guess[i])
+
+        # Check for right color wrong position
+        for guess in temp_guess:
+            if guess in temp_code:
+                wrong_position += 1
+                temp_code.remove(guess)  # Remove the first occurrence of the matched color
+    # display feedback
+    if game_won:
+        msg += f"Correct{getEmojiMMind(user_guess)}\n"
+    else:
+        msg += f"Guess{getEmojiMMind(user_guess)}\n"
+
+    if perfect_pins > 0 and game_won == False:
+        msg += "✅ color ✅ position: {}".format(perfect_pins)
+
+    if wrong_position > 0:
+        if "✅" in msg: msg += f"\n"
+        msg += "✅ color 🚫 position: {}".format(wrong_position)
+    
+    if "✅" not in msg and game_won == False:
+        msg += "🚫No pins in your guess😿 are in the code!"
+
+    return msg
+
+#game loop with turn counter
+def playGameMMind(diff, secret_code, turn_count, nodeID, message):
+    msg = ''
+    won = False
+    if turn_count <= 10:
+        user_guess = getGuessMMind(diff, message)
+        if user_guess == "XXXX":
+            msg += f"⛔️Invalid guess. Please enter 4 valid colors letters.\n🔴🟢🔵🔴 is RGBR"
+            return msg
+        check_guess = compareCodeMMind(secret_code, user_guess)
+
+        # display turn count and feedback
+        msg += "Turn {}:".format(turn_count)
+        if check_guess.startswith("Correct"):
+            won = True
+        msg += check_guess
+    
+        if won == True:
+            msg += f"\n🎉🧠 you win 🥷🤯"
+            # get high score
+            high_score = getHighScoreMMind(nodeID, turn_count, diff)
+            if high_score != 0:
+                msg += f"\n🏆 High Score:{high_score[0]['turns']} turns, Difficulty:{high_score[0]['diff'].upper()}"
+            
+            msg += "\nWould you like to play again?\n(N)ormal, (H)ard, e(X)pert (E)nd?"
+            # reset turn count in tracker
+            for i in range(len(mindTracker)):
+                if mindTracker[i]['nodeID'] == nodeID:
+                    mindTracker[i]['turns'] = 1
+                    mindTracker[i]['secret_code'] = ''
+                    mindTracker[i]['cmd'] = 'new'
+        else:
+            # increment turn count and keep playing
+            turn_count += 1
+            # store turn count in tracker
+            for i in range(len(mindTracker)):
+                if mindTracker[i]['nodeID'] == nodeID:
+                    mindTracker[i]['turns'] = turn_count
+    elif won == False:
+        msg += f"🙉Game Over🙈\nThe code was: {getEmojiMMind(secret_code)}"
+        msg += "\nYou have run out of turns.😿"
+        msg += "\nWould you like to play again? (N)ormal, (H)ard, or e(X)pert?"
+        # reset turn count in tracker
+        for i in range(len(mindTracker)):
+            if mindTracker[i]['nodeID'] == nodeID:
+                mindTracker[i]['turns'] = 1
+                mindTracker[i]['secret_code'] = ''
+                mindTracker[i]['cmd'] = 'new'
+
+    return msg
+
+def endGameMMind(nodeID):
+    global mindTracker
+    # remove player from tracker
+    for i in range(len(mindTracker)):
+        if mindTracker[i]['nodeID'] == nodeID:
+            del mindTracker[i]
+            logger.debug("System: MasterMind: Player removed: " + str(nodeID))
+            break
+
+#main game
+def start_mMind(nodeID, message):
+    global mindTracker
+    last_cmd = ""
+    msg = ''
+
+    # get player's last command from tracker if not new player
+    for i in range(len(mindTracker)):
+        if mindTracker[i]['nodeID'] == nodeID:
+            last_cmd = mindTracker[i]['cmd']
+
+    if last_cmd == "new":
+        if message.lower().startswith("n") or message.lower().startswith("h") or message.lower().startswith("x"):
+            diff = message.lower()[0]
+        else:
+            diff = "n"
+
+        # set player's last command to makeCode
+        for i in range(len(mindTracker)):
+            if mindTracker[i]['nodeID'] == nodeID:
+                mindTracker[i]['cmd'] = 'makeCode'
+                mindTracker[i]['diff'] = diff
+        # Return color message to player
+        msg += chooseDifficultyMMind(message.lower()[0])
+        return msg
+    
+    if last_cmd == "makeCode":
+        # get difficulty from tracker
+        for i in range(len(mindTracker)):
+            if mindTracker[i]['nodeID'] == nodeID:
+                diff = mindTracker[i]['diff']
+
+        secret_code = makeCodeMMind(diff)
+        last_cmd = "playGame"
+        # set player's last command to playGame
+        for i in range(len(mindTracker)):
+            if mindTracker[i]['nodeID'] == nodeID:
+                mindTracker[i]['cmd'] = 'playGame'
+                mindTracker[i]['secret_code'] = secret_code
+                mindTracker[i]['last_played'] = time.time()
+    
+    if last_cmd == "playGame":
+        # get difficulty, secret code, and turn count from tracker
+        for i in range(len(mindTracker)):
+            if mindTracker[i]['nodeID'] == nodeID:
+                diff = mindTracker[i]['diff']
+                secret_code = mindTracker[i]['secret_code']
+                turn_count = mindTracker[i]['turns']
+
+        msg += playGameMMind(diff, secret_code, turn_count, nodeID=nodeID, message=message)
+
+    return msg

modules/games/videopoker.py

@@ -2,6 +2,7 @@
 # Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
 import random
 import time
+import pickle
 from modules.log import *
 
 vpStartingCash = 20
@@ -164,7 +165,7 @@ class PlayerVP:
             except Exception as e:
                 pass
     
-        return "Re-Draw/Deal ex:1,3,4 to hold cards 1,3 and 4, or (N)o to keep current (H)and"
+        return "ex:1,3,4 deals them new, and keeps 2,5 or (N)o to keep current (H)and"
 
     # Method for scoring hand, calculating winnings, and outputting message
     def score_hand(self, resetHand = True):
@@ -230,7 +231,6 @@ class PlayerVP:
             if resetHand:
                 self.bankroll += self.bet_size * payoff[hand_name]
         elif 2 in points_repeat: # find pair
-            logger.debug(f"System: VideoPoker: 235 self.bankroll: {self.bankroll} bet_size: {self.bet_size}")
             hand_name = "Pair👯"
             if resetHand:
                 self.bankroll += self.bet_size * payoff[hand_name]
@@ -272,6 +272,30 @@ def setLastCmdVp(nodeID, cmd):
         if vpTracker[i]['nodeID'] == nodeID:
             vpTracker[i]['cmd'] = cmd
 
+def saveHSVp(nodeID, highScore):
+    # Save the game high_score to pickle
+    highScore = {'nodeID': nodeID, 'highScore': highScore}
+    try:
+        with open('data/videopoker_hs.pkl', 'wb') as file:
+            pickle.dump(highScore, file)
+    except FileNotFoundError:
+        logger.debug("System: BlackJack: Creating new data/videopoker_hs.pkl file")
+        with open('data/videopoker_hs.pkl', 'wb') as file:
+            pickle.dump(highScore, file)
+
+def loadHSVp():
+    # Load the game high_score from pickle
+    try:
+        with open('data/videopoker_hs.pkl', 'rb') as file:
+            highScore = pickle.load(file)
+            return highScore
+    except FileNotFoundError:
+        logger.debug("System: VideoPoker: Creating new data/videopoker_hs.pkl file")
+        highScore = {'nodeID': 0, 'highScore': 0}
+        with open('data/videopoker_hs.pkl', 'wb') as file:
+            pickle.dump(highScore, file)
+        return 0
+
 def playVideoPoker(nodeID, message):
     msg = ""
 
@@ -280,7 +304,7 @@ def playVideoPoker(nodeID, message):
         # create new player if not in tracker
         logger.debug(f"System: VideoPoker: New Player {nodeID}")
         vpTracker.append({'nodeID': nodeID, 'cmd': 'new', 'time': time.time(), 'cash': vpStartingCash, 'player': None, 'deck': None, 'highScore': 0, 'drawCount': 0})
-        return f"Welcome to 🎰 VideoPoker! you have {vpStartingCash} coins, Game Played via Direct Message. Whats your bet?"
+        return f"Welcome to 🎰VideoPoker♥️ you have {vpStartingCash} coins, Whats your bet?"
     
     # Gather the player's bet
     if getLastCmdVp(nodeID) == "new" or getLastCmdVp(nodeID) == "gameOver":
@@ -302,15 +326,15 @@ def playVideoPoker(nodeID, message):
         try:
             bet = int(message)
         except ValueError:
-            msg += "Please enter a valid bet amount. 1 to 5 coins."
+            msg += f"Please enter a valid bet, 1 to 5 coins. you have {player.bankroll} coins."
 
         # Check if bet is valid
         if bet > player.bankroll:
-            msg += "You can only bet the money you have. No strip poker here..."
+            msg += f"You can only bet the money you have. {player.bankroll} coins, No strip poker here..."
         elif bet < 1:
-            msg += "You must bet at least 1 coin."
+            msg += "You must bet at least 1 coin.🪙"
         elif bet > 5:
-            msg += "You can only bet up to 5 coins."
+            msg += "The 🎰 coin slot only fits 5 coins max."
 
         # if msg contains an error, return it
         if msg is not None and msg != '':
@@ -344,7 +368,7 @@ def playVideoPoker(nodeID, message):
                 vpTracker[i]['deck'] = deck
                 vpTracker[i]['drawCount'] = drawCount
 
-        msg += f"\nDeal new card? \nex: 1,3,4 or (N)o,(A)ll"
+        msg += f"\nDeal new card? \nex: 1,3,4 or (N)o,(A)ll (H)and"
         setLastCmdVp(nodeID, "redraw")
         return msg
     
@@ -406,8 +430,10 @@ def playVideoPoker(nodeID, message):
         elif player.bankroll > vpTracker[i]['highScore']:
             vpTracker[i]['highScore'] = player.bankroll
             msg += " 🎉HighScore!"
+            # save high score
+            saveHSVp(nodeID, vpTracker[i]['highScore'])
 
-        msg += f"\nPlace your Bet, 'L' to leave the game."
+        msg += f"\nPlace your Bet, or (L)eave Table."
 
         setLastCmdVp(nodeID, "gameOver")
         # reset player and deck in tracker

modules/llm.py

@@ -4,18 +4,29 @@
 # K7MHI Kelly Keeton 2024
 from modules.log import *
 
-from langchain_ollama import OllamaLLM # pip install ollama langchain-ollama
-from langchain_core.prompts import ChatPromptTemplate # pip install langchain
-from langchain_core.messages import AIMessage, HumanMessage
+# Ollama Client
+# https://github.com/ollama/ollama/blob/main/docs/faq.md#how-do-i-configure-ollama-server
+from ollama import Client as OllamaClient
 from googlesearch import search # pip install googlesearch-python
 
+# This is my attempt at a simple RAG implementation it will require some setup
+# you will need to have the RAG data in a folder named rag in the data directory (../data/rag)
+# This is lighter weight and can be used in a standalone environment, needs chromadb
+# "chat with a file" is the use concept here, the file is the RAG data
+ragDEV = False
+
+if ragDEV:
+    import os
+    import ollama # pip install ollama
+    import chromadb # pip install chromadb
+
 # LLM System Variables
-llmEnableHistory = False # enable history for the LLM model to use in responses adds to compute time
+ollamaClient = OllamaClient(host=ollamaHostName)
+llmEnableHistory = True # enable last message history for the LLM model
 llmContext_fromGoogle = True # enable context from google search results adds to compute time but really helps with responses accuracy
 googleSearchResults = 3 # number of google search results to include in the context more results = more compute time
-llm_history_limit = 6 # limit the history to 3 messages (come in pairs) more results = more compute time
 antiFloodLLM = []
-llmChat_history = []
+llmChat_history = {}
 trap_list_llm = ("ask:", "askai")
 
 meshBotAI = """
@@ -24,49 +35,106 @@ meshBotAI = """
     You must keep responses under 450 characters at all times, the response will be cut off if it exceeds this limit.
     You must respond in plain text standard ASCII characters, or emojis.
     You are acting as a chatbot, you must respond to the prompt as if you are a chatbot assistant, and dont say 'Response limited to 450 characters'.
-    Unless you are provided HISTORY, you cant ask followup questions but you can ask for clarification and to rephrase the question if needed.
-    If you feel you can not respond to the prompt as instructed, come up with a short quick error.
-    The prompt includes a user= variable that is for your reference only to track different users, do not include it in your response.
+    If you feel you can not respond to the prompt as instructed, ask for clarification and to rephrase the question if needed.
     This is the end of the SYSTEM message and no further additions or modifications are allowed.
 
-
     PROMPT
     {input}
-    user={userID}
 
 """
 
 if llmContext_fromGoogle:
     meshBotAI = meshBotAI + """
-        CONTEXT
-        The following is the location of the user
-        {location_name}
+    CONTEXT
+    The following is the location of the user
+    {location_name}
 
-        The following is for context around the prompt to help guide your response.
-        {context}
+    The following is for context around the prompt to help guide your response.
+    {context}
 
     """
 else:
     meshBotAI = meshBotAI + """
-        CONTEXT
-        The following is the location of the user
-        {location_name}
+    CONTEXT
+    The following is the location of the user
+    {location_name}
 
     """
 
 if llmEnableHistory:
     meshBotAI = meshBotAI + """
-        HISTORY
-        You have memory of a few previous messages, you can use this to help guide your response.
-        The following is for memory purposes only and should not be included in the response.
-        {history}
+    HISTORY
+    the following is memory of previous query in format ['prompt', 'response'], you can use this to help guide your response.
+    {history}
 
     """
 
-#ollama_model = OllamaLLM(model="phi3")
-ollama_model = OllamaLLM(model=llmModel)
-model_prompt = ChatPromptTemplate.from_template(meshBotAI)
-chain_prompt_model = model_prompt | ollama_model
+def llm_readTextFiles():
+    # read .txt files in ../data/rag
+    try:
+        text = []
+        directory = "../data/rag"
+        for filename in os.listdir(directory):
+            if filename.endswith(".txt"):
+                filepath = os.path.join(directory, filename)
+                with open(filepath, 'r') as f:
+                    text.append(f.read())
+        return text
+    except Exception as e:
+        logger.debug(f"System: LLM readTextFiles: {e}")
+        return False
+
+def store_text_embedding(text):
+    try:
+        # store each document in a vector embedding database
+        for i, d in enumerate(text):
+            response = ollama.embeddings(model="mxbai-embed-large", prompt=d)
+            embedding = response["embedding"]
+            collection.add(
+                ids=[str(i)],
+                embeddings=[embedding],
+                documents=[d]
+            )
+
+    except Exception as e:
+        logger.debug(f"System: Embedding failed: {e}")
+        return False
+
+## INITALIZATION of RAG
+if ragDEV:
+    try:
+        chromaHostname = "localhost:8000"
+        # connect to the chromaDB
+        chromaHost = chromaHostname.split(":")[0]
+        chromaPort = chromaHostname.split(":")[1]
+        if chromaHost == "localhost" and chromaPort == "8000":
+            # create a client using local python Client
+            chromaClient = chromadb.Client()
+        else:
+            # create a client using the remote python Client
+            # this isnt tested yet please test and report back
+            chromaClient = chromadb.Client(host=chromaHost, port=chromaPort)
+
+        clearCollection = False
+        if "meshBotAI" in chromaClient.list_collections() and clearCollection:
+            logger.debug(f"System: LLM: Clearing RAG files from chromaDB")
+            chromaClient.delete_collection("meshBotAI")
+        
+        # create a new collection
+        collection = chromaClient.create_collection("meshBotAI")
+
+        logger.debug(f"System: LLM: Cataloging RAG data")
+        store_text_embedding(llm_readTextFiles())
+
+    except Exception as e:
+        logger.debug(f"System: LLM: RAG Initalization failed: {e}")
+
+def query_collection(prompt):
+    # generate an embedding for the prompt and retrieve the most relevant doc
+    response = ollama.embeddings(prompt=prompt, model="mxbai-embed-large")
+    results = collection.query(query_embeddings=[response["embedding"]], n_results=1)
+    data = results['documents'][0][0]
+    return data
 
 def llm_query(input, nodeID=0, location_name=None):
     global antiFloodLLM, llmChat_history
@@ -90,7 +158,6 @@ def llm_query(input, nodeID=0, location_name=None):
         # remove common words from the search query
         # commonWordsList = ["is", "for", "the", "of", "and", "in", "on", "at", "to", "with", "by", "from", "as", "a", "an", "that", "this", "these", "those", "there", "here", "where", "when", "why", "how", "what", "which", "who", "whom", "whose", "whom"]
         # sanitizedSearch = ' '.join([word for word in input.split() if word.lower() not in commonWordsList])
-
         try:
             googleSearch = search(input, advanced=True, num_results=googleSearchResults)
             if googleSearch:
@@ -103,9 +170,10 @@ def llm_query(input, nodeID=0, location_name=None):
             logger.debug(f"System: LLM Query: context gathering failed, likely due to network issues")
             googleResults = ['no other context provided']
 
+    history = llmChat_history.get(nodeID, ["", ""])
 
     if googleResults:
-        logger.debug(f"System: LLM Query: {input} From:{nodeID} with context from google")
+        logger.debug(f"System: Google-Enhanced LLM Query: {input} From:{nodeID}")
     else:
         logger.debug(f"System: LLM Query: {input} From:{nodeID}")
     
@@ -114,28 +182,40 @@ def llm_query(input, nodeID=0, location_name=None):
     location_name += f" at the current time of {datetime.now().strftime('%Y-%m-%d %H:%M:%S %Z')}"
 
     try:
-        result = chain_prompt_model.invoke({"input": input, "llmModel": llmModel, "userID": nodeID, \
-                                            "history": llmChat_history, "context": googleResults, "location_name": location_name})
+        # RAG context inclusion testing
+        ragContext = False
+        if ragDEV:
+            ragContext = query_collection(input)
+
+        if ragContext:
+            ragContextGooogle = ragContext + '\n'.join(googleResults)
+            # Build the query from the template
+            modelPrompt = meshBotAI.format(input=input, context=ragContext, location_name=location_name, llmModel=llmModel, history=history)
+            # Query the model with RAG context
+            result = ollamaClient.generate(model=llmModel, prompt=modelPrompt)
+        else:
+            # Build the query from the template
+            modelPrompt = meshBotAI.format(input=input, context='\n'.join(googleResults), location_name=location_name, llmModel=llmModel, history=history)
+            # Query the model without RAG context
+            result = ollamaClient.generate(model=llmModel, prompt=modelPrompt)
+    
+        # Condense the result to just needed
+        if isinstance(result, dict):
+            result = result.get("response")
+
         #logger.debug(f"System: LLM Response: " + result.strip().replace('\n', ' '))
     except Exception as e:
         logger.warning(f"System: LLM failure: {e}")
         return "I am having trouble processing your request, please try again later."
     
-
+    # cleanup for message output
     response = result.strip().replace('\n', ' ')
-
-    # Store history of the conversation, with limit to prevent template growing too large causing speed issues
-    if len(llmChat_history) > llm_history_limit:
-        # remove the oldest two messages
-        llmChat_history.pop(0)
-        llmChat_history.pop(1)
-    inputWithUserID = input + f"   user={nodeID}"
-    llmChat_history.append(HumanMessage(content=inputWithUserID))
-    llmChat_history.append(AIMessage(content=response))
-
     # done with the query, remove the user from the anti flood list
     antiFloodLLM.remove(nodeID)
 
+    if llmEnableHistory:
+        llmChat_history[nodeID] = [input, response]
+
     return response
 
 # import subprocess

modules/locationdata.py

@@ -9,9 +9,9 @@ import bs4 as bs # pip install beautifulsoup4
 import xml.dom.minidom 
 from modules.log import *
 
-trap_list_location = ("whereami", "tide", "moon", "wx", "wxc", "wxa", "wxalert")
+trap_list_location = ("whereami", "tide", "moon", "wx", "wxc", "wxa", "wxalert", "rlist")
 
-def where_am_i(lat=0, lon=0, short=False):
+def where_am_i(lat=0, lon=0, short=False, zip=False):
     whereIam = ""
     grid = mh.to_maiden(float(lat), float(lon))
     
@@ -31,24 +31,130 @@ def where_am_i(lat=0, lon=0, short=False):
             whereIam = f"City: {address.get('city', '')}. State: {address.get('state', '')}. County: {address.get('county', '')}. Country: {address.get('country', '')}."
             return whereIam
         
+        if zip:
+            # return a string with zip code only
+            location = geolocator.reverse(str(lat) + ", " + str(lon))
+            whereIam = location.raw['address'].get('postcode', '')
+            return whereIam
+        
         if float(lat) == latitudeValue and float(lon) == longitudeValue:
             # redacted address when no GPS and using default location
-            location = geolocator.reverse(lat + ", " + lon)
+            location = geolocator.reverse(str(lat) + ", " + str(lon))
             address = location.raw['address']
-            address_components = ['city', 'state', 'postcode', 'county', 'country']
-            whereIam += ' '.join([address.get(component, '') for component in address_components if component in address])
-            whereIam += " Grid: " + grid
+            address_components = {
+                'city': 'City',
+                'state': 'State',
+                'postcode': 'Zip',
+                'county': 'County',
+                'country': 'Country'
+            }
+            whereIam += ', '.join([f"{label}: {address.get(component, '')}" for component, label in address_components.items() if component in address])
         else:
             location = geolocator.reverse(lat + ", " + lon)
             address = location.raw['address']
-            address_components = ['house_number', 'road', 'city', 'state', 'postcode', 'county', 'country']
-            whereIam += ' '.join([address.get(component, '') for component in address_components if component in address])
-            whereIam += " Grid: " + grid
+            address_components = {
+                'house_number': 'Number',
+                'road': 'Road',
+                'city': 'City',
+                'state': 'State',
+                'postcode': 'Zip',
+                'county': 'County',
+                'country': 'Country'
+            }
+            whereIam += ', '.join([f"{label}: {address.get(component, '')}" for component, label in address_components.items() if component in address])
+            whereIam += f", Grid: " + grid
         return whereIam
     except Exception as e:
         logger.debug("Location:Error fetching location data with whereami, likely network error")
         return ERROR_FETCHING_DATA
     
+def getRepeaterBook(lat=0, lon=0):
+    grid = mh.to_maiden(float(lat), float(lon))
+    data = []
+    repeater_url = f"https://www.repeaterbook.com/repeaters/prox_result.php?city={grid}&lat=&long=&distance=50&Dunit=m&band%5B%5D=4&band%5B%5D=16&freq=&call=&mode%5B%5D=1&mode%5B%5D=2&mode%5B%5D=4&mode%5B%5D=64&status_id=1&use=%25&use=OPEN&order=distance_calc%2C+state_id+ASC"
+    try:
+        msg = ''
+        response = requests.get(repeater_url)
+        soup = bs.BeautifulSoup(response.text, 'html.parser')
+        table = soup.find('table', attrs={'class': 'w3-table w3-striped w3-responsive w3-mobile w3-auto sortable'})
+        if table is not None:
+            cells = table.find_all('td')
+            data = []
+            for i in range(0, len(cells), 11):
+                if i + 10 < len(cells):  #avoid IndexError
+                    repeater = {
+                        'frequency': cells[i].text.strip() if i < len(cells) else 'N/A',
+                        'offset': cells[i + 1].text.strip() if i + 1 < len(cells) else 'N/A',
+                        'tone': cells[i + 2].text.strip() if i + 2 < len(cells) else 'N/A',
+                        'call_sign': cells[i + 3].text.strip() if i + 3 < len(cells) else 'N/A',
+                        'location': cells[i + 4].text.strip() if i + 4 < len(cells) else 'N/A',
+                        'state': cells[i + 5].text.strip() if i + 5 < len(cells) else 'N/A',
+                        'use': cells[i + 6].text.strip() if i + 6 < len(cells) else 'N/A',
+                        'mode': cells[i + 7].text.strip() if i + 7 < len(cells) else 'N/A',
+                        'distance': cells[i + 8].text.strip() if i + 8 < len(cells) else 'N/A',
+                        'direction': cells[i + 9].text.strip() if i + 9 < len(cells) else 'N/A'
+                    }
+                    data.append(repeater)
+                else:
+                    msg = "bug?Not enough columns"
+        else:
+            msg = "bug?Table not found"
+    except Exception as e:
+        msg = "No repeaters found 😔"
+    # Limit the output to the first 4 repeaters
+    for repeater in data[:4]:
+        tmpTone = repeater['tone'].replace(" /", "")
+        msg += f"{repeater['call_sign']}📶{repeater['frequency']}{repeater['offset']},{tmpTone}.{repeater['mode']}"
+        if repeater != data[:4][-1]: msg += '\n'
+    return msg
+
+def getArtSciRepeaters(lat=0, lon=0):
+    # UK api_url = "https://api-beta.rsgb.online/all/systems"
+    #grid = mh.to_maiden(float(lat), float(lon))
+    repeaters = []
+    zipCode = where_am_i(lat, lon, zip=True)
+    if zipCode == NO_DATA_NOGPS or zipCode == ERROR_FETCHING_DATA:
+        return zipCode
+
+    if zipCode.isnumeric():
+        try:
+            artsci_url = f"http://www.artscipub.com/mobile/showstate.asp?zip={zipCode}"
+            response = requests.get(artsci_url)
+            soup = bs.BeautifulSoup(response.text, 'html.parser')
+            # results needed xpath is /html/body/table[2]/tbody/tr/td/table/tbody/tr[2]/td/table
+            table = soup.find_all('table')[1]
+            rows = table.find_all('tr')
+            for row in rows:
+                cols = row.find_all('td')
+                cols = [ele.text.strip() for ele in cols]
+                # if no elements have the word 'located' then append
+                if not any('located' in ele for ele in cols):
+                    if not any('Location' in ele for ele in cols):
+                        repeaters.append([ele for ele in cols if ele])
+        except Exception as e:
+            logger.error(f"Error fetching data from {artsci_url}: {e}")
+
+    if repeaters != []:
+        msg = f"Found:{len(repeaters)} in {zipCode}\n"
+        for repeater in repeaters:
+            # format is ['City', 'Frequency', 'Offset', 'PL', 'Call', 'Notes']
+            # there might be missing elements or only one element
+            if len(repeater) == 2:
+                msg += f"Freq:{repeater[1]}"
+            elif len(repeater) == 3:
+                msg += f"Freq:{repeater[1]}, PL:{repeater[2]}"
+            elif len(repeater) == 4:
+                msg += f"Freq:{repeater[1]}, PL:{repeater[2]}, ID: {repeater[3]}"
+            elif len(repeater) == 5:
+                msg += f"Freq:{repeater[1]}, PL:{repeater[2]}, ID:{repeater[3]}"
+            elif len(repeater) == 6:
+                msg += f"Freq:{repeater[1]}, PL:{repeater[2]}, ID:{repeater[3]}. {repeater[5]}"
+            if repeater != repeaters[-1]:
+                msg += "\n"
+    else:
+        msg = f"no results.. sorry"
+    return msg
+    
 
 def get_tide(lat=0, lon=0):
     station_id = ""
@@ -74,40 +180,44 @@ def get_tide(lat=0, lon=0):
         logger.error("Location:Error fetching tide station table from NOAA")
         return ERROR_FETCHING_DATA
     
-    station_url = "https://tidesandcurrents.noaa.gov/noaatidepredictions.html?id=" + station_id
-    if zuluTime:
-        station_url += "&clock=24hour"
+    station_url = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter?date=today&time_zone=lst_ldt&datum=MLLW&product=predictions&interval=hilo&format=json&station=" + station_id
+
+    if use_metric:
+        station_url += "&units=metric"
+    else:
+        station_url += "&units=english"
 
     try:
-        station_data = requests.get(station_url, timeout=urlTimeoutSeconds)
-        if not station_data.ok:
-            logger.error("Location:Error fetching station data from NOAA")
+        tide_data = requests.get(station_url, timeout=urlTimeoutSeconds)
+        if tide_data.ok:
+            tide_json = tide_data.json()
+        else:
+            logger.error("Location:Error fetching tide data from NOAA")
             return ERROR_FETCHING_DATA
-    except (requests.exceptions.RequestException):
-        logger.error("Location:Error fetching station data from NOAA")
-        return ERROR_FETCHING_DATA
-    
-    # extract table class="table table-condensed"
-    soup = bs.BeautifulSoup(station_data.text, 'html.parser')
-    table = soup.find('table', class_='table table-condensed')
 
-    # extract rows
-    rows = table.find_all('tr')
-    # extract data from rows
-    tide_data = []
-    for row in rows:
-        row_text = ""
-        cols = row.find_all('td')
-        for col in cols:
-            row_text += col.text + " "
-        tide_data.append(row_text)
-    # format tide data into a string
-    tide_string = ""
-    for data in tide_data:
-        tide_string += data + "\n"
-    # trim off last newline
-    tide_string = tide_string[:-1]
-    return tide_string
+    except (requests.exceptions.RequestException, json.JSONDecodeError):
+        logger.error("Location:Error fetching tide data from NOAA")
+        return ERROR_FETCHING_DATA
+
+    tide_data = tide_json['predictions']
+
+    # format tide data into a table string for mesh
+    # get the date out of the first t value 
+    tide_date = tide_data[0]['t'].split(" ")[0]
+    tide_table = "Tide Data for " + tide_date + "\n"
+    for tide in tide_data:
+        tide_time = tide['t'].split(" ")[1]
+        if not zuluTime:
+            # convert to 12 hour clock
+            if int(tide_time.split(":")[0]) > 12:
+                tide_time = str(int(tide_time.split(":")[0]) - 12) + ":" + tide_time.split(":")[1] + " PM"
+            else:
+                tide_time = tide_time + " AM"
+                
+        tide_table +=  tide['type'] + " " + tide_time + ", " + tide['v'] + "\n"
+    # remove last newline
+    tide_table = tide_table[:-1]
+    return tide_table
     
 def get_weather(lat=0, lon=0, unit=0):
     # get weather report from NOAA for forecast detailed

modules/log.py

@@ -1,8 +1,5 @@
-# Custom logger for MeshBot and PongBot
-# you can change the sdtout_handler level to logging.INFO to only show INFO level logs
-# stdout_handler.setLevel(logging.INFO)vs stdout_handler.setLevel(logging.DEBUG)
-# 2024 Kelly Keeton K7MHI
 import logging
+import re
 from datetime import datetime
 from modules.settings import *
 
@@ -33,6 +30,13 @@ class CustomFormatter(logging.Formatter):
         log_fmt = self.FORMATS.get(record.levelno)
         formatter = logging.Formatter(log_fmt)
         return formatter.format(record)
+    
+class plainFormatter(logging.Formatter):
+    ansi_escape = re.compile(r'\x1b\[([0-9]+)(;[0-9]+)*m')
+
+    def format(self, record):
+        message = super().format(record)
+        return self.ansi_escape.sub('', message)
 
 # Create logger
 logger = logging.getLogger("MeshBot System Logger")
@@ -54,19 +58,19 @@ stdout_handler = logging.StreamHandler()
 stdout_handler.setLevel(logging.DEBUG)
 # Set format for stdout handler
 stdout_handler.setFormatter(CustomFormatter(logFormat))
-
 # Add handlers to the logger
 logger.addHandler(stdout_handler)
+
 if syslog_to_file:
     # Create file handler for logging to a file
-    file_handler = logging.FileHandler('system{}.log'.format(today.strftime('%Y_%m_%d')))
-    file_handler.setLevel(logging.DEBUG) # DEBUG used by default for system logs to disk
-    file_handler.setFormatter(logging.Formatter(logFormat))
-    logger.addHandler(file_handler)
+    file_handler_sys = logging.FileHandler('logs/meshbot{}.log'.format(today.strftime('%Y_%m_%d')))
+    file_handler_sys.setLevel(logging.DEBUG) # DEBUG used by default for system logs to disk
+    file_handler_sys.setFormatter(plainFormatter(logFormat))
+    logger.addHandler(file_handler_sys)
 
 if log_messages_to_file:
     # Create file handler for logging to a file
-    file_handler = logging.FileHandler('messages{}.log'.format(today.strftime('%Y_%m_%d')))
+    file_handler = logging.FileHandler('logs/messages{}.log'.format(today.strftime('%Y_%m_%d')))
     file_handler.setLevel(logging.INFO) # INFO used for messages to disk
     file_handler.setFormatter(logging.Formatter(msgLogFormat))
-    msgLogger.addHandler(file_handler)
+    msgLogger.addHandler(file_handler)

modules/settings.py

@@ -46,7 +46,7 @@ if config.sections() == []:
     print (f"System: Config file created, check {config_file} or review the config.template")
 
 if 'sentry' not in config:
-        config['Sentry'] = {'SentryEnabled': 'False', 'SentryChannel': '2', 'SentryHoldoff': '9', 'sentryIgnoreList': '', 'SentryRadius': '100'}
+        config['sentry'] = {'SentryEnabled': 'False', 'SentryChannel': '2', 'SentryHoldoff': '9', 'sentryIgnoreList': '', 'SentryRadius': '100'}
         config.write(open(config_file, 'w'))
 
 if 'location' not in config:
@@ -54,7 +54,7 @@ if 'location' not in config:
         config.write(open(config_file, 'w'))
 
 if 'bbs' not in config:
-        config['bbs'] = {'enabled': 'False', 'bbsdb': 'bbsdb.pkl', 'bbs_ban_list': '', 'bbs_admin_list': ''}
+        config['bbs'] = {'enabled': 'False', 'bbsdb': 'data/bbsdb.pkl', 'bbs_ban_list': '', 'bbs_admin_list': ''}
         config.write(open(config_file, 'w'))
 
 if 'repeater' not in config:
@@ -94,9 +94,10 @@ try:
     # general
     useDMForResponse = config['general'].getboolean('respond_by_dm_only', True)
     publicChannel = config['general'].getint('defaultChannel', 0) # the meshtastic public channel
+    ignoreDefaultChannel = config['general'].getboolean('ignoreDefaultChannel', False)
     zuluTime = config['general'].getboolean('zuluTime', False) # aka 24 hour time
-    log_messages_to_file = config['general'].getboolean('LogMessagesToFile', True) # default True
-    syslog_to_file = config['general'].getboolean('SyslogToFile', False)
+    log_messages_to_file = config['general'].getboolean('LogMessagesToFile', False) # default off
+    syslog_to_file = config['general'].getboolean('SyslogToFile', True) # default on
     urlTimeoutSeconds = config['general'].getint('urlTimeout', 10) # default 10 seconds
     store_forward_enabled = config['general'].getboolean('StoreForward', True)
     storeFlimit = config['general'].getint('StoreLimit', 3) # default 3 messages for S&F
@@ -112,6 +113,7 @@ try:
     wikipedia_enabled = config['general'].getboolean('wikipedia', False)
     llm_enabled = config['general'].getboolean('ollama', False) # https://ollama.com
     llmModel = config['general'].get('ollamaModel', 'gemma2:2b') # default gemma2:2b
+    ollamaHostName = config['general'].get('ollamaHostName', 'http://localhost:11434') # default localhost
 
     # sentry
     sentry_enabled = config['sentry'].getboolean('SentryEnabled', False) # default False
@@ -129,10 +131,11 @@ try:
     forecastDuration = config['location'].getint('NOAAforecastDuration', 4) # NOAA forcast days
     numWxAlerts = config['location'].getint('NOAAalertCount', 2) # default 2 alerts
     wxAlertsEnabled = config['location'].getboolean('NOAAalertsEnabled', True) # default True not enabled yet
+    repeater_lookup = config['location'].get('repeaterLookup', 'rbook') # default repeater lookup source
    
     # bbs
     bbs_enabled = config['bbs'].getboolean('enabled', False)
-    bbsdb = config['bbs'].get('bbsdb', 'bbsdb.pkl')
+    bbsdb = config['bbs'].get('bbsdb', 'data/bbsdb.pkl')
     bbs_ban_list = config['bbs'].get('bbs_ban_list', '').split(',')
     bbs_admin_list = config['bbs'].get('bbs_admin_list', '').split(',')
 
@@ -150,10 +153,13 @@ try:
     signalCycleLimit = config['radioMon'].getint('signalCycleLimit', 5) # default 5 cycles, used with SIGNAL_COOLDOWN
     
     # games
+    game_hop_limit = config['messagingSettings'].getint('game_hop_limit', 5) # default 3 hops
     dopewars_enabled = config['games'].getboolean('dopeWars', True)
     lemonade_enabled = config['games'].getboolean('lemonade', True)
     blackjack_enabled = config['games'].getboolean('blackjack', True)
     videoPoker_enabled = config['games'].getboolean('videoPoker', True)
+    mastermind_enabled = config['games'].getboolean('mastermind', True)
+    golfSim_enabled = config['games'].getboolean('golfSim', True)
 
     # messaging settings
     responseDelay = config['messagingSettings'].getfloat('responseDelay', 0.7) # default 0.7

modules/wx_meteo.py

@@ -94,10 +94,20 @@ def get_wx_meteo(lat=0, lon=0, unit=0):
 		code_string = ""
 		if daily_weather_code[i] == 0:
 			code_string = "Clear sky"
-		elif daily_weather_code[i] == 1 or 2 or 3:
-			code_string = "Partly cloudy"
-		elif daily_weather_code[i] == 45 or 48:
+		elif daily_weather_code[i] == 1:
+			code_string = "Mostly Cloudy"
+		elif daily_weather_code[i] == 2:
+			code_string = "Partly Cloudy"
+		elif daily_weather_code[i] == 3:
+			code_string = "Overcast"
+		elif daily_weather_code[i] == 5:
+			code_string = "Haze"
+		elif daily_weather_code[i] == 10:
+			code_string = "Mist"
+		elif daily_weather_code[i] == 45:
 			code_string = "Fog"
+		elif daily_weather_code[i] == 48:
+			code_string = "Freezing Fog"
 		elif daily_weather_code[i] == 51:
 			code_string = "Drizzle: Light"
 		elif daily_weather_code[i] == 53:
@@ -126,6 +136,10 @@ def get_wx_meteo(lat=0, lon=0, unit=0):
 			code_string = "Snow: Heavy"
 		elif daily_weather_code[i] == 77:
 			code_string = "Snow Grains"
+		elif daily_weather_code[i] == 78:
+			code_string = "Ice Crystals"
+		elif daily_weather_code[i] == 79:
+			code_string = "Ice Pellets"
 		elif daily_weather_code[i] == 80:
 			code_string = "Rain showers: Slight"
 		elif daily_weather_code[i] == 81:
@@ -133,15 +147,17 @@ def get_wx_meteo(lat=0, lon=0, unit=0):
 		elif daily_weather_code[i] == 82:
 			code_string = "Rain showers: Heavy"
 		elif daily_weather_code[i] == 85:
-			code_string = "Snow showers: Light"
+			code_string = "Snow showers"
 		elif daily_weather_code[i] == 86:
-			code_string = "Snow showers: Moderate"
+			code_string = "Snow showers: Heavy"
 		elif daily_weather_code[i] == 95:
-			code_string = "Thunderstorm: Slight"
+			code_string = "Thunderstorm"
 		elif daily_weather_code[i] == 96:
-			code_string = "Thunderstorm: Moderate"
+			code_string = "Hailstorm"
+		elif daily_weather_code[i] == 97:
+			code_string = "Thunderstorm Heavy"
 		elif daily_weather_code[i] == 99:
-			code_string = "Thunderstorm: Heavy"
+			code_string = "Hailstorm Heavy"
 
 		weather_report += "Cond: " + code_string + ". "
 

requirements.txt

@@ -13,7 +13,7 @@ numpy
 geopy
 schedule
 wikipedia
+ollama
 langchain
 langchain-ollama
-ollama
 googlesearch-python