### MOOSE Class Examples

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/introduction.md

This section lists several popular MOOSE classes and their functionalities, providing examples of how MOOSE can be integrated into DCS missions for various purposes such as managing aircraft recoveries, creating random air traffic, and simulating missile evasion.

```Lua
Ops.Airboss: Manages recoveries of human pilots and AI aircraft on aircraft carriers.
Functional.RAT: Creates random airtraffic in your missions.
Functional.Range: Counts hits on targets for practice.
Functional.Fox: Simulates missile evasion without destruction.
```

--------------------------------

### Eclipse LDT Plugin Installation

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/eclipse-installation.md

Instructions for installing the Lua Development Tools (LDT) plugin within Eclipse IDE. This involves adding the dltk-core to software sites and then searching for and installing the LDT plugin from the Eclipse Marketplace.

```eclipse
1. Go to Help > Install New Software...
2. Click 'Add...' to add a new software site.
3. Enter 'dltk-core' as the Name and paste the URL for dltk-core zip file.
4. Select the installed dltk-core from the list.
5. Go to Help > Eclipse Marketplace...
6. Search for 'Lua Development Tools' and install version 1.4.x.
```

--------------------------------

### Build Documentation Workflow

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/build-docs.md

The main build steps to create class documentation are defined in the .github/workflows/build-docs.yml file. This includes checking out repositories, installing dependencies, running the documentation generator, and deploying the results.

```APIDOC
Workflow: Build Documentation

Steps:
1. Checkout MOOSE git repository.
2. Create output folders.
3. Checkout Applevangelist/luadocumentor (patch-1 branch) into a subdirectory.
4. Update Linux system software.
5. Install dependencies:
   - tree
   - lua (5.1)
   - LuaRocks
   - markdown
   - penlight
   - metalua-compiler
   - metalua-parser
   - checks
6. Run build steps:
   - Execute luadocumentor.lua to generate HTML files.
7. Deploy build results:
   - Checkout MOOSE_DOCS or MOOSE_DOCS_DEVELOP repository based on MOOSE branch (master -> MOOSE_DOCS, develop -> MOOSE_DOCS_DEVELOP).
   - Use a TOKEN for checkout to enable push.
   - Copy build results to the target MOOSE_DOCS folder.
   - Push results to the target repository.
```

--------------------------------

### Lua Build Script Example

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/index.md

An example of a build script in Lua that might be used to collect and merge individual Lua files into a single include file for the MOOSE framework. This script would typically handle file concatenation and potentially preprocessing.

```Lua
-- build.lua
local io = require('io')

local files_to_include = {
  'core.lua',
  'modules/math.lua',
  'modules/string.lua'
}

local output_file = 'Moose.lua'
local file_handle = io.open(output_file, 'w')

for _, filename in ipairs(files_to_include) do
  local input_handle = io.open(filename, 'r')
  if input_handle then
    local content = input_handle:read('*a')
    file_handle:write(content)
    file_handle:write('\n') -- Add newline between files
    input_handle:close()
  else
    print('Error opening file: ' .. filename)
  end
end

file_handle:close()
print('Successfully built ' .. output_file)

```

--------------------------------

### Install act CLI

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/local-test.md

Installs the 'act' command-line interface tool using Chocolatey, a package manager for Windows.

```bash
choco install act-cli
```

--------------------------------

### MOOSE Guides (Deprecated)

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/repositories.md

This repository previously contained external documentation and help for the MOOSE framework and will be removed in the future.

```markdown
## [MOOSE_GUIDES](https://github.com/FlightControl-Master/MOOSE_GUIDES) - For external documentation and help

This repository will be removed in future.
```

--------------------------------

### Local Preview with Docker

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/build-includes.md

This section describes how to generate a local preview of the include files using Docker. It details the necessary setup and the commands to run within the Docker container.

```bash
cd docker/build-includes
docker compose up
```

--------------------------------

### MOOSE Demo Missions

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/repositories.md

This repository provides demonstration missions in `.miz` format, ready to be used in DCS WORLD without additional setup.

```markdown
## [MOOSE_MISSIONS](https://github.com/FlightControl-Master/MOOSE_MISSIONS) - For users (provides demo missions)

This repository contains all the demonstration missions in packed format (*.miz),
and can be used without any further setup in DCS WORLD.
```

--------------------------------

### MOOSE Framework Execution Trigger

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world.md

This trigger is configured to execute the MOOSE framework script ('Moose_.lua') using a 'DO SCRIPT FILE' action. It uses the 'MISSION START' type, ensuring it runs before the mission begins. Crucially, it has no conditions, as the 'MISSION START' type does not support them.

```dcs
Trigger Type: 4 MISSION START
Name: Load MOOSE
Conditions: None
Actions:
  DO SCRIPT FILE: Moose_.lua
```

--------------------------------

### Setting up MOOSE Lua Project in Eclipse

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/eclipse-installation.md

Steps to create a new Lua project in Eclipse and configure it to include the MOOSE repository. This involves specifying the repository path and adding the MOOSE development directories to the build path.

```eclipse
1. Go to File > Other...
2. Select 'Lua Project' from the wizard and click Next.
3. Specify the path to your MOOSE repository.
4. Right-click on the newly created Lua project in the Project Explorer.
5. Select Properties > Lua Build Path.
6. Add 'Moose/Moose Development/Moose' to the build path.
```

--------------------------------

### Google TTS Command-Line Usage

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/text-to-speech.md

Example command to test Google TTS setup using the DCS-SR-ExternalAudio.exe utility. This command synthesizes speech with specified parameters and uses a Google service account key file.

```command-line
.\DCS-SR-ExternalAudio.exe -t "Hello Moosers" -f 251 -m AM -c 2 -z -G .\yourgoogleaccount.json
```

--------------------------------

### Mission Script Execution Trigger

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world.md

This trigger executes the mission-specific script ('001-hello-world.lua') using a 'DO SCRIPT FILE' action. It is configured with a 'ONCE' type and a 'TIME MORE(1)' condition, ensuring it runs one second after the mission starts. This timing is critical for allowing the MOOSE framework to be fully loaded before the mission script attempts to use its classes.

```dcs
Trigger Type: 1 ONCE
Name: Load Mission Script
Conditions:
  TIME MORE(1)
Actions:
  DO SCRIPT FILE: 001-hello-world.lua
```

--------------------------------

### Build Includes Workflow

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/build-includes.md

This YAML file defines the GitHub Actions workflow for building include files. It outlines the steps from checking out the repository to deploying the build results, including dependency installation and script execution.

```yaml
name: Build Includes

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
        repository: FlightControl-Master/MOOSE
    - name: Create output folders
      run: |
        mkdir -p build/result/Moose_Include_Dynamic
        mkdir -p build/result/Moose_Include_Static
    - name: Update system software
      run: sudo apt-get update && sudo apt-get install -y tree lua5.3 luarocks liblua5.3-dev
    - name: Install LuaSrcDiet and LuaCheck
      run: |
        luarocks install luasrcdiet
        luarocks install luacheck
    - name: Run build scripts
      run: |
        ./Moose Setup/Moose_Create.lua
        ./Moose Setup/Moose_Create.lua
        luasrcdiet -source Moose.lua -output build/result/Moose_Include_Dynamic/Moose_.lua
        luacheck --config .luacheckrc --exclude-files Setup/Moose_Create.lua --exclude-files Moose_.lua
    - name: Checkout MOOSE_INCLUDE repository
      uses: actions/checkout@v2
      with:
        repository: FlightControl-Master/MOOSE_INCLUDE
        path: MOOSE_INCLUDE
        token: ${{ secrets.TOKEN }}
    - name: Copy build results
      run: |
        cp build/result/Moose_Include_Dynamic/* MOOSE_INCLUDE/
    - name: Push results to MOOSE_INCLUDE
      run: |
        cd MOOSE_INCLUDE
        git config --global user.name 'GitHub Actions'
        git config --global user.email 'actions@github.com'
        git add .
        git commit -m 'Update include files'
        git push
```

--------------------------------

### Google Analytics Initialization (gtag.js)

Source: https://github.com/flightcontrol-master/moose/blob/master/Moose Development/docs-header.html

This snippet initializes Google Analytics using gtag.js. It ensures the dataLayer is available, defines the gtag function, and then sends the current date and the tracking configuration to Google Analytics. This is a standard setup for many websites using Google Analytics.

```javascript
window.dataLayer = window.dataLayer || [];
function gtag(){
  dataLayer.push(arguments);
}
gtag('js', new Date());
gtag('config', 'UA-97385487-1');
```

--------------------------------

### Local Preview Build with Docker

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/build-docs.md

Instructions for building a local preview of the class documentation using Docker. This involves running a Docker container that includes all necessary software to build the documentation.

```APIDOC
Local Preview Build:

1. Navigate to the `docker/build-docks` folder.
2. Run `docker compose up`.

Process:
- Creates a Docker image and starts a container.
- Installs all required software packages within the container.
- Checks out the Applevangelist/luadocumentor repository to `build/tools/luadocumentor`.
- Executes `luadocumentor.lua` to generate documentation in `build/docs`.

Prerequisites:
- A working installation of Docker.

Optional Manual Checkout:
- If MOOSE_DOCS is manually checked out to `/moose/build/MOOSE_DOCS`,
  generated files are also copied to `/moose/build/MOOSE_DOCS/Documentation/`.
  This allows running `docker compose up` in `/moose/build/MOOSE_DOCS/docker/`
  for a complete end-to-end check.
```

--------------------------------

### Previewing Documentation with Docker

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/gh-pages.md

Instructions for previewing the GitHub Pages documentation locally using Docker. This involves navigating to the 'docs' subfolder and running 'docker compose up'. The documentation can then be accessed via http://127.0.0.1:4000/. Changes to Markdown files require a short wait and a browser refresh, though sometimes a container restart is necessary for full regeneration.

```bash
# Navigate to the docs subfolder
cd docs

# Start the Docker container for preview
docker compose up

# Open http://127.0.0.1:4000/ in your browser
# Refresh after changes to Markdown files
```

--------------------------------

### GitHub Actions Workflow for Building Pages

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/gh-pages.md

This snippet outlines the GitHub Actions workflow defined in .github/workflows/gh-pages.yml. It includes two main jobs: 'build' for compiling the documentation using Jekyll and 'deploy' for deploying the built pages. The 'build' job checks out the repository, sets up the Ruby environment, configures pages, builds with Jekyll, and uploads artifacts. The 'deploy' job handles the actual deployment.

```yaml
name: Deploy GitHub Pages

on:
  push:
    branches:
      - master

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3

      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.1'

      - name: Configure Pages
        uses: actions/configure-pages@v1

      - name: Build with Jekyll
        run: bundle exec jekyll build --baseurl "/MOOSE"

      - name: Upload Pages artifact
        uses: actions/upload-pages-artifact@v1
        with:
          path: '_site'

  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v1

```

--------------------------------

### Updating Moose

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world-build.md

Guidance on how to update the Moose framework. It explains that updating involves re-downloading the latest version and re-adding it in the same manner as the mission script.

```text
- To update Moose download it again and add it again in the same way you did
  with the mission script in the last step.
```

--------------------------------

### Find Saved Games Folder

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/tipps-and-tricks.md

This snippet shows how to locate the 'Saved Games' folder, which is crucial for DCS and MOOSE users. It uses a Windows environment variable that works across different language installations.

```text
%userprofile%\Saved Games
```

--------------------------------

### Hello World Message Display

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world.md

This Lua code snippet demonstrates how to display a 'Hello World!' message in the upper right corner of the DCS screen using the MOOSE framework. It utilizes the `mist.HINT()` function for displaying messages.

```lua
function()
  mist.HINT("Hello World!", 15, 15)
end
```

--------------------------------

### Including MOOSE in DCS World Missions

Source: https://github.com/flightcontrol-master/moose/wiki/Home

This guide explains how to integrate the MOOSE framework into a DCS World mission using triggers and the Moose.lua file. It ensures MOOSE classes are loaded and initialized before mission execution.

```lua
-- Step 1: Create a new mission in the DCS World Mission Editor.
-- Step 2: Create a new ONCE trigger.
-- Step 3: Name the trigger 'Moose Load'.
-- Step 4: Add an action 'DO SCRIPT FILE' after (TIME MORE) 3-5 seconds.
-- Step 5: In the action, browse to the Moose.lua file.
-- Step 6: Ensure the 'Moose Load' trigger is at the top of your mission.
-- Step 7: Repeat for other LUA mission files, spacing them 1-2 seconds apart.
```

--------------------------------

### Command Line Text-to-Speech Test

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/text-to-speech.md

This command sends a text-to-speech message to a specific radio frequency and modulation within DCS-SRS. Ensure the frequency and coalition parameters match your mission setup. Running the executable without parameters provides help.

```PowerShell
.\DCS-SR-ExternalAudio.exe -t "Hello Moosers" -f 251 -m AM -c 2
```

--------------------------------

### GitHub Actions Workflow Files

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/index.md

Configuration files for GitHub Actions that define jobs for building documentation, static includes, and the project's documentation website. These files are separated for maintainability.

```YAML
--- 
# .github/workflows/build-docs.yml
name: Build Docs

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Setup Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.x'
    - name: Install dependencies
      run: pip install -r requirements.txt
    - name: Build Docs
      run: mkdocs build

```

```YAML
--- 
# .github/workflows/build-includes.yml
name: Build Includes

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Setup Lua
      uses: leafo/gh-actions-lua@v9
    - name: Install LuaSrcDiet
      run: luarocks install luasrcdiet
    - name: Build Includes
      run: |
        lua build.lua
        luasrcdiet --source=Moose.lua --output=Moose_.lua

```

```YAML
--- 
# .github/workflows/gh-pages.yml
name: Deploy Docs

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Setup Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.x'
    - name: Install dependencies
      run: pip install -r requirements.txt
    - name: Build Docs
      run: mkdocs gh-deploy

```

--------------------------------

### MOOSE Hello World Message

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world.md

This Lua script demonstrates the basic usage of the MOOSE framework to display a message to all players. It utilizes the Core.Message class to create and send a message with specified text, duration, and type.

```lua
--
-- Simple example mission to show the very basics of MOOSE
--
MESSAGE:New( "Hello World! This messages is printed by MOOSE", 35, "INFO" ):ToAll()
```

--------------------------------

### DCS Mission Editor Trigger Configuration

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world-build.md

This section details the configuration of triggers within the DCS Mission Editor to load the MOOSE framework and execute a custom mission script. It specifies trigger types, names, conditions, and actions, including using 'Do SCRIPT FILE' to load external Lua files.

```APIDOC
Trigger: Load MOOSE
  Type: 4 MISSION START
  Name: Load MOOSE
  Event: NO EVENT
  Conditions: None
  Actions:
    - NEW
      Action: Do SCRIPT FILE
      File: Moose_.lua

Trigger: Load Mission Script
  Type: 1 ONCE
  Name: Load Mission Script
  Event: NO EVENT
  Conditions:
    - TIME MORE(1)
  Actions:
    - NEW
      Action: Do SCRIPT FILE
      File: hello-world.lua
```

--------------------------------

### Loading MOOSE and Mission Scripts

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/problems.md

Instructions for loading the MOOSE framework and custom mission scripts using DCS triggers. This involves setting up specific trigger conditions and actions.

```lua
4 MISSION START
CONDITIONS: none
DO SCRIPT FILE: Moose_.lua
```

```lua
1 ONCE
CONDITIONS: TIME MORE = 1
DO SCRIPT FILE: yourscript.lua
```

--------------------------------

### MOOSE Hello World Message

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world-build.md

This Lua code snippet demonstrates how to send a 'Hello World' message to all players using the MOOSE framework in DCS. It utilizes the MESSAGE:New() function to construct the message and :ToAll() to broadcast it.

```lua
MESSAGE:New( "Hello World! This messages is printed by MOOSE", 35, "INFO" ):ToAll()
```

--------------------------------

### Update Mission Script

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/hello-world-build.md

Instructions on how to update a mission script in the DCS mission editor. It highlights that changes to the external script file are not automatically recognized and the script must be re-added.

```text
- On the left side of the `TRIGGERS` dialog click on `Load Mission Script`.
- On the right side under `ACTIONS` you need to add the script again:
    - Click **OPEN** and navigate to the created `hello-world.lua` file.
- Save the mission and test it again.
- Now the new text should be shown.
```

--------------------------------

### MOOSE Community Scripts

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/repositories.md

This repository hosts helper scripts, snippets, and functional demos based on the MOOSE framework, contributed by the community.

```markdown
## [Moose_Community_Scripts](https://github.com/FlightControl-Master/Moose_Community_Scripts)

This repository is for Moose based helper scripts, snippets, functional demos.
```

--------------------------------

### Force Push Option for act

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/local-test.md

Demonstrates how to use the '--var FORCE_PUSH=true' parameter with the 'act' command to enable the push step during local builds. This is useful for testing changes to the push process.

```bash
act push --var FORCE_PUSH=true -W .github/workflows/build-includes.yml
```

--------------------------------

### Formatting Single Line Code in Discord

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/ask-for-help.md

Demonstrates how to format a single line of code in Discord using single backticks.

```markdown
`like this:`
```

--------------------------------

### Formatting Multiple Lines of Code in Discord

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/ask-for-help.md

Illustrates the correct method for posting multiple lines of code in Discord, using triple backticks for code blocks.

```markdown
```lua
-- Your code here
```
```

--------------------------------

### Formatting Log Lines in Discord

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/beginner/ask-for-help.md

Shows how to format important log lines containing error or warning messages in Discord for better readability.

```markdown
```
-- Log message here
```
```

--------------------------------

### Dynamic Script Loading with loadfile

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/concepts.md

Illustrates an alternative method for dynamic script loading using `loadfile` combined with `assert`. This method is noted as being slightly safer but potentially less readable than `dofile`.

```lua
assert(loadfile('C:/MyScripts/hello-world.lua'))()
assert(loadfile('C:\\MyScripts\\hello-world.lua'))()
assert(loadfile([[C:\MyScripts\hello-world.lua]]))()
```

--------------------------------

### IDE Recommendations for Moose

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/concepts.md

This section provides recommendations for IDEs that offer good support for the Moose framework and Lua development. It details the pros and cons of Eclipse LDT, Visual Studio Code, and PyCharm (or IntelliJ IDEA) regarding features like IntelliSense, LuaDoc support, and debugger compatibility with DCS.

```text
The three most important for Moose are:

- [Eclipse LDT]
- [Visual Studio Code]
- [PyCharm] (or [IntelliJ IDEA])

Eclipse has the best support for hover documentation and [IntelliSense] with
Moose. The Inventor of Moose (FlightControl) did an amazing job by adding an
integration to Eclipse LDT (a special version for Lua).
Unfortunately Eclipse LDT is not maintained any longer (last release 2018).
And the debugger doesn't work anymore, since an update of DCS.

In Visual Studio Code the support of Lua can be added by an addon.
The debugger works with Moose and DCS, but showing the LuaDoc and [IntelliSense]
is very limited.

PyCharm supports Lua also with an addon. The debugger works with Moose and DCS,
but showing the LuaDoc and [IntelliSense] is very limited.
```

--------------------------------

### Dynamic Script Loading with dofile

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/concepts.md

Demonstrates loading Lua scripts dynamically using the `dofile` function. It shows different ways to specify file paths, including forward slashes, escaped backslashes, and double square brackets for paths.

```lua
dofile('C:/MyScripts/hello-world.lua')
dofile('C:\\MyScripts\\hello-world.lua')
dofile([[C:\MyScripts\hello-world.lua]])
```

--------------------------------

### Portable Script Loading with lfs.writedir

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/advanced/concepts.md

Shows how to load scripts from the user's saved games folder using `lfs.writedir()` to enhance mission portability. This ensures the script is located in a consistent directory across different systems.

```lua
dofile(lfs.writedir() .. '/Missions/hello-world.lua')
```

--------------------------------

### MOOSE_INCLUDE User Files

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/repositories.md

This repository provides the `Moose.lua` and `Moose_.lua` files for users to include in their missions. `Moose_.lua` is a minified version of `Moose.lua`.

```markdown
## [MOOSE_INCLUDE](https://github.com/FlightControl-Master/MOOSE_INCLUDE) - For users (provides generated files)

This repository contains the `Moose.lua` and `Moose\_.lua` file to be included within your missions.
Note that the `Moose\_.lua` is technically the same as `Moose.lua`, but without any commentary or unnecessary whitespace in it.
You only need to load **one** of those files at the beginning of your mission.
```

--------------------------------

### Checking for Broken Links with Linkinator

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/gh-pages.md

Steps to run linkinator to identify broken links within the documentation using Docker. This requires navigating to the 'docker/gh-pages-check' subfolder and executing 'docker compose up'. Linkinator will then scan the documentation for any invalid hyperlinks.

```bash
# Navigate to the docker/gh-pages-check subfolder
cd docker/gh-pages-check

# Start the Docker container to run linkinator
docker compose up
```

--------------------------------

### MOOSE Framework Overview

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/index.md

This section provides a general overview of the MOOSE framework, its purpose in DCS World mission design, and its underlying technology (Lua). It also touches upon the project's goals, community involvement, and branching strategy.

```Markdown
# MOOSE framework

MOOSE is a **M**ission **O**bject **O**riented **S**cripting **E**nvironment for mission designers in [DCS World].
It allows to quickly setup complex missions using pre-scripted scenarios using the available classes within the MOOSE Framework.
MOOSE is written in [Lua] which is a small and fast programming language, which is embedded in [DCS World].

## Goal of MOOSE

The goal of MOOSE is to allow mission designers to enhance their scripting with mission orchestration objects, 
which can be instantiated from defined classes within the framework. This will allow to write mission scripts with 
minimal code embedded. Of course, the richness of the framework will determine the richness of the misson scenarios.
The MOOSE is a service that is produced while being consumed. It will evolve further as more classes are developed
for the framework and as more users are using it.
MOOSE is not a one-man show, it is a collaborative effort and meant to evolve within a growing community around the framework.
Within the community, key users will start supporting, documenting, explaining and even creating new classes for the framework.
It is the ambition to grow this framework as a de-facto standard for mission designers to use.

## Two branches - Choose wisely

In [DCS World] there is a `Stable` version and an `OpenBeta`. New features are released to the `OpenBeta` first and applied to `Stable` later.
People who choose to use `OpenBeta` can use the newest featuest and module, but accept the risk of bugs and unstable updates.
In MOOSE there is a `master` branch, which is comparable to the `Stable` version.
And there is the `development` branch, which is more like the `OpenBeta`.
New modules (called classes in [Lua], like [OPS.Auftrag]) will only available in the `development` branch.

Releases are the most stable approach to use MOOSE.
From time to time the current state of the `master` branch is used to create release.
A release gets a spefific version number and will not be changed later on.

## Documentation

Documentation on the MOOSE class hierarchy will be automatically generated from [LuaDoc] comments inside of the source code of MOOOSE.
You can find the results on these websites:

- Stable `master` branch: <https://flightcontrol-master.github.io/MOOSE_DOCS/>
- `develop` branch: <https://flightcontrol-master.github.io/MOOSE_DOCS_DEVELOP/>

## YouTube Tutorials

There are different tutorial playlists available on YouTube:

- AnyTimeBaby (Pene) has kindly created a [tutorial series for MOOSE](https://youtube.com/playlist?list=PLLkY2GByvtC2ME0Q9wrKRDE6qnXJYV3iT)
 with various videos that you can watch.
- FlightControl (initiator of the project) has created a lot of [videos](https://www.youtube.com/@flightcontrol5350/featured) on how to use MOOSE. 
 They are a little bit outdated, but they still contain a lot of valuable information.

## MOOSE on Discord

MOOSE has a living community of users, beta testers and contributors.
The gathering point is a service provided by [Discord].
If you want to join this community, just click the link below and you'll be on board in no time:

- [Moose Discord server](https://discord.gg/gj68fm969S)

[DCS World]: https://www.digitalcombatsimulator.com/de/
[Lua]: https://www.lua.org/
[LuaDoc]: https://keplerproject.github.io/luadoc/
[Ops.Auftrag]: https://flightcontrol-master.github.io/MOOSE_DOCS_DEVELOP/Documentation/Ops.Auftrag.html
[Discord]: https://discord.com/
```

--------------------------------

### Lua Build Scripts

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/build-includes.md

These Lua scripts are used in the build process to create the `Moose.lua` file, which dynamically loads individual Lua class files. The first execution creates a static version, and the second creates a dynamic version.

```lua
-- Setup/Moose_Create.lua (Example structure, actual content may vary)
-- This script is responsible for creating Moose.lua
-- It might involve concatenating or processing other Lua files.
```

--------------------------------

### Run Local Builds with act

Source: https://github.com/flightcontrol-master/moose/blob/master/docs/developer/buildsystem/local-test.md

Executes specific GitHub Actions workflows locally using the 'act' tool. The '-W' flag specifies the workflow file to run. The 'push' event trigger is used here.

```bash
act push -W .github/workflows/build-includes.yml
```

```bash
act push -W .github/workflows/build-docs.yml
```