sindoring/moonwell-core
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

вывод из самбомудлей модов для азероткор

Browse Source
This commit is contained in:
sindoring
2026-03-07 22:28:31 +04:00
parent 5877ea78cd
commit adcfe8e31d
1720 changed files with 1941740 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/mod-eluna
-1
Submodule modules/mod-eluna deleted from 1153fcaef7
modules/mod-eluna/.editorconfig
+8
View File
@@ -0,0 +1,8 @@
[*]
charset = utf-8
indent_style = space
indent_size = 4
tab_width = 4
insert_final_newline = true
trim_trailing_whitespace = true
max_line_length = 80
modules/mod-eluna/.git_commit_template.txt
+49
View File
@@ -0,0 +1,49 @@
### TITLE
## Type(Scope/Subscope): Commit ultra short explanation
## |---- Write below the examples with a maximum of 50 characters ----|
## Example 1: fix(DB/SAI): Missing spell to NPC Hogger
## Example 2: fix(CORE/Raid): Phase 2 of Ragnaros
## Example 3: feat(CORE/Commands): New GM command to do something
### DESCRIPTION
## Explain why this change is being made, what does it fix etc...
## |---- Write below the examples with a maximum of 72 characters per lines ----|
## Example: Hogger (id: 492) was not charging player when being engaged.
## Provide links to any issue, commit, pull request or other resource
## Example 1: Closes issue #23
## Example 2: Ported from other project's commit (link)
## Example 3: References taken from wowpedia / wowhead / wowwiki / https://wowgaming.altervista.org/aowow/
## =======================================================
## EXTRA INFOS
## =======================================================
## "Type" can be:
## feat (new feature)
## fix (bug fix)
## refactor (refactoring production code)
## style (formatting, missing semi colons, etc; no code change)
## docs (changes to documentation)
## test (adding or refactoring tests; no production code change)
## chore (updating bash scripts, git files etc; no production code change)
## --------------------
## Remember to
## Capitalize the subject line
## Use the imperative mood in the subject line
## Do not end the subject line with a period
## Separate subject from body with a blank line
## Use the body to explain what and why rather than how
## Can use multiple lines with "-" for bullet points in body
## --------------------
## More info here https://www.conventionalcommits.org/en/v1.0.0-beta.2/
## =======================================================
## "Scope" can be:
## CORE (core related, c++)
## DB (database related, sql)
## =======================================================
## "Subscope" is optional and depends on the nature of the commit.
## =======================================================
modules/mod-eluna/.gitattributes
+105
View File
@@ -0,0 +1,105 @@
## AUTO-DETECT
## Handle line endings automatically for files detected as
## text and leave all files detected as binary untouched.
## This will handle all files NOT defined below.
* text=auto eol=lf
# Text
*.conf text
*.conf.dist text
*.cmake text
## Scripts
*.sh text
*.fish text
*.lua text
## SQL
*.sql text
## C++
*.c text
*.cc text
*.cxx text
*.cpp text
*.c++ text
*.hpp text
*.h text
*.h++ text
*.hh text
## For documentation
# Documents
*.doc diff=astextplain
*.DOC diff=astextplain
*.docx diff=astextplain
*.DOCX diff=astextplain
*.dot diff=astextplain
*.DOT diff=astextplain
*.pdf diff=astextplain
*.PDF diff=astextplain
*.rtf diff=astextplain
*.RTF diff=astextplain
## DOCUMENTATION
*.markdown text
*.md text
*.mdwn text
*.mdown text
*.mkd text
*.mkdn text
*.mdtxt text
*.mdtext text
*.txt text
AUTHORS text
CHANGELOG text
CHANGES text
CONTRIBUTING text
COPYING text
copyright text
*COPYRIGHT* text
INSTALL text
license text
LICENSE text
NEWS text
readme text
*README* text
TODO text
## GRAPHICS
*.ai binary
*.bmp binary
*.eps binary
*.gif binary
*.ico binary
*.jng binary
*.jp2 binary
*.jpg binary
*.jpeg binary
*.jpx binary
*.jxr binary
*.pdf binary
*.png binary
*.psb binary
*.psd binary
*.svg text
*.svgz binary
*.tif binary
*.tiff binary
*.wbmp binary
*.webp binary
## ARCHIVES
*.7z binary
*.gz binary
*.jar binary
*.rar binary
*.tar binary
*.zip binary
## EXECUTABLES
*.exe binary
*.pyc binary
modules/mod-eluna/.github/images/workflow.svg
Vendored
+4
View File
File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 64 KiB

modules/mod-eluna/.github/workflows/build-lua51.yml
Vendored
+14
View File
@@ -0,0 +1,14 @@
name: Build mod-eluna with Lua51 🌙
on:
push:
branches:
- 'master'
- 'main'
pull_request:
jobs:
build_lua51:
uses: ./.github/workflows/core-build-base.yml
with:
lua_version: 'lua51'
modules/mod-eluna/.github/workflows/build-lua52.yml
Vendored
+14
View File
@@ -0,0 +1,14 @@
name: Build mod-eluna with Lua52 🌙
on:
push:
branches:
- 'master'
- 'main'
pull_request:
jobs:
build_lua52:
uses: ./.github/workflows/core-build-base.yml
with:
lua_version: 'lua52'
modules/mod-eluna/.github/workflows/build-lua53.yml
Vendored
+14
View File
@@ -0,0 +1,14 @@
name: Build mod-eluna with Lua53 🌙
on:
push:
branches:
- 'master'
- 'main'
pull_request:
jobs:
build_lua53:
uses: ./.github/workflows/core-build-base.yml
with:
lua_version: 'lua53'
modules/mod-eluna/.github/workflows/build-lua54.yml
Vendored
+14
View File
@@ -0,0 +1,14 @@
name: Build mod-eluna with Lua54 🌙
on:
push:
branches:
- 'master'
- 'main'
pull_request:
jobs:
build_lua54:
uses: ./.github/workflows/core-build-base.yml
with:
lua_version: 'lua54'
modules/mod-eluna/.github/workflows/build-luajit.yml
Vendored
+14
View File
@@ -0,0 +1,14 @@
name: Build mod-eluna with LuaJIT 🌙
on:
push:
branches:
- 'master'
- 'main'
pull_request:
jobs:
build_luajit:
uses: ./.github/workflows/core-build-base.yml
with:
lua_version: 'luajit'
modules/mod-eluna/.github/workflows/core-build-base.yml
Vendored
+85
View File
@@ -0,0 +1,85 @@
name: Build mod-eluna base 🛠️
on:
workflow_call:
inputs:
lua_version:
required: true
type: string
jobs:
install_and_build:
runs-on: ubuntu-24.04
steps:
- name: Check out AzerothCore 🧑‍💻
uses: actions/checkout@v4
with:
repository: 'azerothcore/azerothcore-wotlk'
ref: 'master'
submodules: 'recursive'
fetch-depth: 0
- name: Check out module repository 📂
uses: actions/checkout@v4
with:
submodules: 'recursive'
path: 'modules/${{ github.event.repository.name }}'
fetch-depth: 0
ref: ${{ github.event.pull_request.head.sha }}
- name: Cache compilation artifacts 💾
uses: actions/cache@v4
with:
path: var/ccache
key: ccache:${{ matrix.compiler.CC }}:${{ github.ref }}:${{ github.sha }}
restore-keys: |
ccache:clang-18:${{ github.ref }}
ccache:clang-18
- name: Install build dependencies 🧰
shell: bash
run: |
sudo apt update
sudo apt-get -y install ccache clang cmake curl google-perftools \
libmysqlclient-dev make unzip build-essential cmake-data \
libboost-all-dev libbz2-dev libncurses5-dev libmysql++-dev \
libreadline6-dev libssl-dev libtool openssl zlib1g-dev
- name: Build mod-eluna with ${{ inputs.lua_version }} 🏗️
run: |
rm -rf build
mkdir build && cd build
cmake .. \
-DCMAKE_C_COMPILER=clang-18 \
-DCMAKE_CXX_COMPILER=clang++-18 \
-DSCRIPTS="static" \
-DMODULES="static" \
-DWITH_WARNINGS="ON" \
-DCMAKE_BUILD_TYPE="Release" \
-DCMAKE_CXX_COMPILER_LAUNCHER="ccache" \
-DCMAKE_C_COMPILER_LAUNCHER="ccache" \
-DCMAKE_C_FLAGS="-Werror" \
-DCMAKE_CXX_FLAGS="-Werror" \
-DLUA_VERSION=${{ inputs.lua_version }}
make -j$(nproc)
cd ..
- name: Run Cppcheck for static code analysis 🔍
run: |
sudo apt update -y
sudo apt install -y cppcheck
cd modules/${{ github.event.repository.name }}
cppcheck -j$(nproc) --force --inline-suppr \
-I src/LuaEngine/ \
-I src/ \
--suppress=*:src/lualib/* \
--suppress=*:src/LuaEngine/libs/* \
--output-file=report.txt \
.
if [ -s report.txt ]; then
echo "Cppcheck detected issues 🚨:"
cat report.txt
exit 1
else
echo "No issues detected by cppcheck ✅."
fi
modules/mod-eluna/.gitignore
+48
View File
@@ -0,0 +1,48 @@
!.gitignore
#
#Generic
#
.directory
.mailmap
*.orig
*.rej
*.*~
.hg/
*.kdev*
.DS_Store
CMakeLists.txt.user
*.bak
*.patch
*.diff
*.REMOTE.*
*.BACKUP.*
*.BASE.*
*.LOCAL.*
#
# IDE & other softwares
#
/.settings/
/.externalToolBuilders/*
# exclude in all levels
nbproject/
.sync.ffs_db
*.kate-swp
#
# Eclipse
#
*.pydevproject
.metadata
.gradle
tmp/
*.tmp
*.swp
*~.nib
local.properties
.settings/
.loadpath
.project
.cproject
modules/mod-eluna/CMakeLists.txt
+21
View File
@@ -0,0 +1,21 @@
set(LUA_VERSION "lua52" CACHE STRING "Lua version to use")
set_property(CACHE LUA_VERSION PROPERTY STRINGS luajit lua51 lua52 lua53 lua54)
MESSAGE(STATUS "Lua version: ${LUA_VERSION}")
# Avoid warning about DOWNLOAD_EXTRACT_TIMESTAMP in CMake 3.24:
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
cmake_policy(SET CMP0135 NEW)
endif()
option(LUA_STATIC "link lua statically" ON)
if (LUA_STATIC)
MESSAGE(STATUS "Lua linking: static")
else()
MESSAGE(STATUS "Lua linking: dynamic")
endif()
if (LUA_VERSION MATCHES "luajit")
add_subdirectory(src/lualib/luajit)
else()
add_subdirectory(src/lualib/lua)
endif()
modules/mod-eluna/COMMUNITY_UPDATES.md
+93
View File
@@ -0,0 +1,93 @@
<div align="center">
# [![Eluna](src/LuaEngine/docs/Eluna.png)](https://github.com/ElunaLuaEngine/Eluna)
*Unleash the power of Lua scripting in your AzerothCore server*
[![Discord](https://img.shields.io/badge/Discord-Join%20Us-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.com/invite/ZKSVREE7)
[![Lua](https://img.shields.io/badge/Lua-5.2-2C2D72?style=for-the-badge&logo=lua&logoColor=white)](http://www.lua.org/manual/5.2/)
[![AzerothCore](https://img.shields.io/badge/AzerothCore-Integrated-darkgreen?style=for-the-badge)](http://www.azerothcore.org/)
---
</div>
> [!NOTE]
> mod-eluna © is a powerful Lua scripting engine embedded into the AzerothCore emulator. We are committed to continuously improving mod-eluna for both developers and server administrators.
## 📚 Additions from Eluna/master
| Category | Method | Github |
|:---------|:-----------|:-------|
| [**RegisterPlayerEvent**](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | | |
| | [`PLAYER_EVENT_ON_PET_ADDED_TO_WORLD`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/3 |
| | [`PLAYER_EVENT_ON_LEARN_SPELL`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/46 |
| | [`PLAYER_ON_ACHIEVEMENT_COMPLETE`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/47 |
| | [`PLAYER_EVENT_ON_FFAPVP_CHANGE`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/63 |
| | [`PLAYER_EVENT_ON_UPDATE_AREA`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/65 |
| | [`PLAYER_EVENT_ON_CAN_INIT_TRADE`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/83 |
| | [`PLAYER_EVENT_ON_CAN_SEND_MAIL`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/85 |
| | [`PLAYER_EVENT_ON_CAN_JOIN_LFG`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/86 |
| | [`PLAYER_EVENT_ON_QUEST_REWARD_ITEM`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/88 |
| | [`PLAYER_EVENT_ON_CREATE_ITEM`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/88 |
| | [`PLAYER_EVENT_ON_STORE_NEW_ITEM`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/88 |
| | [`PLAYER_EVENT_ON_COMPLETE_QUEST`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/90 |
| | [`PLAYER_EVENT_ON_CAN_GROUP_INVITE`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/100 |
| | [`PLAYER_EVENT_ON_GROUP_ROLL_REWARD_ITEM`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/119 |
| | [`PLAYER_EVENT_ON_BG_DESERTION`](https://www.azerothcore.org/eluna/Global/RegisterPlayerEvent.html) | https://github.com/azerothcore/mod-eluna/pull/146 |
| **[Player](https://www.azerothcore.org/eluna/Player/index.html)** | | |
| | [`Player:GetMailCount()`](https://www.azerothcore.org/eluna/Player/GetMailCount.html) | https://github.com/azerothcore/mod-eluna/pull/76 |
| | [`Player:GetXP()`](https://www.azerothcore.org/eluna/Player/GetXP.html) | https://github.com/azerothcore/mod-eluna/pull/77 |
| | [`Player:GetAchievementCriteriaProgress()`](https://www.azerothcore.org/eluna/Player/GetAchievementCriteriaProgress.html) | https://github.com/azerothcore/mod-eluna/pull/78 |
| | [`Player:SendListInventory(object, vendorentry)`](https://www.azerothcore.org/eluna/Player/SendListInventory.html) | https://github.com/azerothcore/mod-eluna/pull/48 |
| | [`Player:GetPlayerSettingValue()`](https://www.azerothcore.org/eluna/Player/GetPlayerSettingValue.html) and [`Player:UpdatePlayerSetting()`](https://www.azerothcore.org/eluna/Player/GetPlayerSettingValue.html) | https://github.com/azerothcore/mod-eluna/pull/125 |
| | [`Player:GetTrader()`](https://www.azerothcore.org/eluna/Player/GetTrader.html) | https://github.com/azerothcore/mod-eluna/pull/126 |
| | [`Player:CanCompleteRepeatableQuest(questid)`](https://www.azerothcore.org/eluna/Player/CanCompleteRepeatableQuest.html) | https://github.com/azerothcore/mod-eluna/pull/141 |
| | [`Player:CanRewardQuest(questId)`](https://www.azerothcore.org/eluna/Player/CanRewardQuest.html) | https://github.com/azerothcore/mod-eluna/pull/141 |
| | [`Player:SetGlyph(glyphId, slotIndex)`](https://www.azerothcore.org/eluna/Player/SetGlyph.html) | https://github.com/azerothcore/mod-eluna/pull/152 |
| **[Group](https://www.azerothcore.org/eluna/Group/index.html)** | | |
| | [`Group:GetGroupType()`](https://www.azerothcore.org/eluna/Group/GetGroupType.html) | https://github.com/azerothcore/mod-eluna/pull/82 |
| | [`Group:SetMemberFlag()`](https://www.azerothcore.org/eluna/Group/SetMemberFlag.html) | https://github.com/azerothcore/mod-eluna/pull/102 |
| **[Unit](https://www.azerothcore.org/eluna/Unit/index.html)** | | |
| | [`Unit:ModifyThreatPct()`](https://www.azerothcore.org/eluna/Unit/ModifyThreatPct.html) | https://github.com/azerothcore/mod-eluna/pull/25 |
| | [`Unit:GetAttackers()`](https://www.azerothcore.org/eluna/Unit/GetAttackers.html) | https://github.com/azerothcore/mod-eluna/pull/116 |
| | [`Unit:GetThreatList()`](https://www.azerothcore.org/eluna/Unit/GetThreatList.html) | https://github.com/azerothcore/mod-eluna/pull/117 |
| | [`Unit:GetUnitFlags()`](https://www.azerothcore.org/eluna/Unit/GetUnitFlags.html) | https://github.com/azerothcore/mod-eluna/pull/137 |
| | [`Unit:GetUnitFlagsTwo()`](https://www.azerothcore.org/eluna/Unit/GetUnitFlagsTwo.html) | https://github.com/azerothcore/mod-eluna/pull/137 |
| | [`Unit:SetUnitFlags(flags)`](https://www.azerothcore.org/eluna/Unit/SetUnitFlags.html) | https://github.com/azerothcore/mod-eluna/pull/137 |
| | [`Unit:SetUnitFlagsTwo(flags)`](https://www.azerothcore.org/eluna/Unit/SetUnitFlagsTwo.html) | https://github.com/azerothcore/mod-eluna/pull/137 |
| | [`Unit:SetSpeedRate(unitMoveType, speed)`](https://www.azerothcore.org/eluna/Unit/SetSpeedRate.html) | https://github.com/azerothcore/mod-eluna/pull/155 |
| | [`Unit:GetSpeedRate()`](https://www.azerothcore.org/eluna/Unit/GetSpeedRate.html) | https://github.com/azerothcore/mod-eluna/pull/155 |
| **[GameObject](https://www.azerothcore.org/eluna/GameObject/index.html)** | | |
| | [`GameObject:AddLoot()`](https://www.azerothcore.org/eluna/GameObject/AddLoot.html) | https://github.com/azerothcore/mod-eluna/pull/52 |
| **[Object](https://www.azerothcore.org/eluna/Object/index.html)** | | |
| | [`Object:IsPlayer()`](https://www.azerothcore.org/eluna/Object/IsPlayer.html) | https://github.com/azerothcore/mod-eluna/pull/42 |
| **[Item](https://www.azerothcore.org/eluna/Item/index.html)** | | |
| | [`Item:GetItemTemplate()`](https://www.azerothcore.org/eluna/Item/GetItemTemplate.html) | https://github.com/azerothcore/mod-eluna/pull/84 |
| **[Global](https://www.azerothcore.org/eluna/Unit/index.html)** | | |
| | [`HttpRequest`](https://www.azerothcore.org/eluna/Global/HttpRequest.html) | https://github.com/azerothcore/mod-eluna/pull/2 |
| | [`GetItemTemplate(itemEntry)`](https://www.azerothcore.org/eluna/Global/GetItemTemplate.html) | https://github.com/azerothcore/mod-eluna/pull/84 |
| | [`ChatHandler`](https://www.azerothcore.org/eluna/Global/ChatHandler.html) | https://github.com/azerothcore/mod-eluna/pull/23 |
| | [`ItemTemplate`](https://www.azerothcore.org/eluna/ItemTemplate/index.html) | https://github.com/azerothcore/mod-eluna/pull/84 |
| | [`Roll`](https://www.azerothcore.org/eluna/Roll/index.html) | https://github.com/azerothcore/mod-eluna/pull/119 |
| | `ELUNA_LOG_INFO` for [`RunCommand()`](https://www.azerothcore.org/eluna/Global/RunCommand.html) | https://github.com/azerothcore/mod-eluna/pull/75 |
| | [`GetOwnerHalaa()`](https://www.azerothcore.org/eluna/Global/GetOwnerHalaa.html) and [`SetOwnerHalaa(teamId)`](https://www.azerothcore.org/eluna/Global/SetOwnerHalaa.html) | https://github.com/azerothcore/mod-eluna/pull/79 |
| | [`WorldDBQueryAsync`](https://www.azerothcore.org/eluna/Global/WorldDBQueryAsync.html), [`CharDBQueryAsync`](https://www.azerothcore.org/eluna/Global/CharDBQueryAsync.html) and [`AuthDBQueryAsync`](https://www.azerothcore.org/eluna/Global/AuthDBQueryAsync.html) | https://github.com/azerothcore/mod-eluna/pull/113 |
## 🤝 Contributing
We welcome contributions! Here's how you can help:
```mermaid
graph LR
A[Fork Repository] --> B[Create Branch]
B --> C[Make Changes]
C --> D[Submit PR]
D --> E[Review Process]
```
<div align="center">
---
<sub>Made with ❤️ by the Eluna Community</sub>
[⬆ Back to Top](#)
</div>
modules/mod-eluna/LICENSE
+674
View File
@@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
{one line to give the program's name and a brief idea of what it does.}
Copyright (C) {year} {name of author}
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
{project} Copyright (C) {year} {fullname}
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
modules/mod-eluna/README.md
+146
View File
@@ -0,0 +1,146 @@
<div align="center">
# [![mod-eluna](src/LuaEngine/docs/Eluna.png)](https://github.com/azerothcore/mod-eluna)
*Unleash the power of Lua scripting in your AzerothCore server*
[![Discord](https://img.shields.io/badge/Discord-Join%20Us-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.com/invite/ZKSVREE7)
[![Lua](https://img.shields.io/badge/Lua-5.2-2C2D72?style=for-the-badge&logo=lua&logoColor=white)](http://www.lua.org/manual/5.2/)
[![AzerothCore](https://img.shields.io/badge/AzerothCore-Integrated-darkgreen?style=for-the-badge)](http://www.azerothcore.org/)
---
</div>
> [!IMPORTANT]
> **mod-eluna** is an independent Lua scripting engine specifically designed for AzerothCore. This project has **diverged from the original Eluna project** and is no longer compatible with standard Eluna scripts. Scripts written for mod-eluna will not work with the original Eluna engine and vice versa.
## 🚀 Overview
mod-eluna is a powerful, AzerothCore-specific implementation of a Lua scripting engine that enables server administrators and developers to create custom gameplay features, events, and mechanics without modifying the core server code.
### Key Features
- **Native AzerothCore Integration**: Built specifically for AzerothCore's architecture
- **Enhanced API**: Extended functionality for AzerothCore, beyond the original Eluna specification.
- **Community-Driven Development**: Actively maintained with community contributions
## ⚠️ Compatibility Notice
### mod-eluna vs Original Eluna
**mod-eluna is NOT compatible with the original Eluna project.** This fork has evolved independently with AzerothCore-specific enhancements and API changes that make scripts non-interchangeable.
### For Original Eluna Compatibility
If you need to use standard Eluna scripts or maintain compatibility with the original Eluna project, please use the dedicated AzerothCore port available at:
**🔗 [ElunaAzerothCore](https://github.com/Eluna-Ports/ElunaAzerothCore)**
This repository maintains compatibility with the original Eluna API and supports standard Eluna scripts.
## 📋 Table of Contents
- [Installation](#-installation)
- [Documentation](#-documentation)
- [API Reference](#api-reference)
- [Support](#-support)
- [Contributing](#-contributing)
- [Acknowledgements](#-acknowledgements)
## ⚡ Installation
### Prerequisites
- AzerothCore server installation
- Git version control system
- CMake build system
### Installation Steps
```bash
# Navigate to your AzerothCore modules directory
cd <azerothcore-path>/modules
# Clone the mod-eluna repository
git clone https://github.com/azerothcore/mod-eluna.git
# Configure build with your preferred Lua version
cd <azerothcore-build-directory>
cmake ../ -DLUA_VERSION=luajit # Options: luajit, lua52, lua53, lua54
# Default: If no version is specified, Lua 5.2 will be used
# Rebuild your AzerothCore server
make -j$(nproc)
```
### Supported Lua Versions
- **LuaJIT** (Recommended for performance)
- **Lua 5.2** (Default)
- **Lua 5.3**
- **Lua 5.4**
## 📚 Documentation
### Getting Started
- [Installation Guide](https://github.com/azerothcore/mod-eluna/tree/master/docs/USAGE.md)
- [Implementation Details](https://github.com/azerothcore/mod-eluna/tree/master/docs/IMPL_DETAILS.md)
### API Reference
- **[mod-eluna API Documentation](https://www.azerothcore.org/eluna/)** - Complete API reference for mod-eluna
- **[Hooks Documentation](https://github.com/azerothcore/mod-eluna/blob/master/src/LuaEngine/Hooks.h)** - Available event hooks
- **[Lua 5.2 Reference](http://www.lua.org/manual/5.2/)** - Official Lua language documentation
> [!WARNING]
> **API Differences**: mod-eluna functions may not be available in the original Eluna project and vice versa. Always refer to the mod-eluna specific documentation when developing scripts.
## 💬 Support
### Getting Help
- **GitHub Issues**: [Report bugs or request features](https://github.com/azerothcore/mod-eluna/issues)
- **Discord Community**: [Join our Discord server](https://discord.com/invite/bx3y5Qmy)
- **AzerothCore Discord**: [Official AzerothCore support](http://www.azerothcore.org/)
### Resources
- [Lua Programming Guide](http://www.lua.org/)
- [AzerothCore Documentation](http://www.azerothcore.org/)
## 🤝 Contributing
We welcome contributions from the community! Here's how you can help:
### Development Workflow
![](.github/images/workflow.svg "workflow example")
### Contribution Guidelines
1. **Fork** the repository
2. **Create** a feature branch from `master`
3. **Implement** your changes with proper testing
4. **Follow** the existing code style and conventions
5. **Submit** a pull request with a clear description
## 🌟 Acknowledgements
### Original Project
mod-eluna is built upon the foundation of the original [Eluna](https://github.com/ElunaLuaEngine/Eluna) project. We acknowledge and thank the original Eluna team for their pioneering work in Lua scripting for World of Warcraft server emulators.
### Related Projects
- **[Original Eluna Repository](https://github.com/ElunaLuaEngine/Eluna)** - The original Eluna project
- **[Eluna Discord Community](https://discord.gg/bjkCVWqqfX)** - Original Eluna community support
- **[ElunaAzerothCore](https://github.com/Eluna-Ports/ElunaAzerothCore)** - AzerothCore with original Eluna compatibility
### Supported Emulators
- **[AzerothCore](http://www.azerothcore.org/)** - Primary target (this project)
- **[TrinityCore](https://www.trinitycore.org/)** - Original Eluna support
- **[MaNGOS](https://www.getmangos.eu/)**
- **[cMaNGOS](https://cmangos.net/)**
## 📄 License
This project is licensed under the GNU General Public License v3.0. See [LICENSE](https://github.com/azerothcore/mod-eluna/blob/master/LICENSE) for details.
---
<div align="center">
<sub>Developed with ❤️ by the AzerothCore and mod-eluna community</sub>
[⬆ Back to Top](#-overview)
</div>
modules/mod-eluna/README_CN.md
+92
View File
@@ -0,0 +1,92 @@
### [![Eluna](src/LuaEngine/docs/Eluna.png)](https://github.com/ElunaLuaEngine/Eluna)
## 关于
Eluna Lua Engine &copy; 是嵌入到魔兽世界模拟器中的lua引擎。 Eluna支持MaNGOS，CMaNGOS，TrinityCore和AzerothCore。
我们目前正在努力使Eluna从内到外变得更好。
如果您在安装或脚本方面遇到问题，请随时提出问题。
有关文档和参考，请参阅[Eluna API (AC版)](https://www.azerothcore.org/pages/eluna/index.html) and [Lua 参考手册](http://www.lua.org/manual/5.2/).
## 社区
您可以加入官方的Eluna Discord服务器，在那里您将能够找到社区提供的资源，版本和支持：
<a href="https://discord.gg/bjkCVWqqfX">
<img src="https://img.shields.io/badge/discord-join-7289DA.svg?logo=discord&longCache=true&style=flat" />
</a>
官方的Azerothcore Discord服务器也提供了一个专门用于lua开发的通道：
<a href="https://discord.gg/gkt4y2x">
<img src="https://img.shields.io/badge/discord-join-7289DA.svg?logo=discord&longCache=true&style=flat" />
</a>
# ![logo](https://raw.githubusercontent.com/azerothcore/azerothcore.github.io/master/images/logo-github.png) mod-eluna for AzerothCore
- azerothcore 的最新构建状态：[![Build Status](https://github.com/azerothcore/mod-eluna/workflows/core-build/badge.svg?branch=master&event=push)](https://github.com/azerothcore/mod-eluna)
[english](README.md) | [中文说明](README_CN.md) | [Español](README_ES.md)
一个AzerothCore的[Eluna](https://github.com/ElunaLuaEngine/Eluna)模块。
## 如何安装:
### 1) 下载源代码
您可以使用 git 获取源代码。
#### 使用 git 下载
1. 在命令行中打开 `azerothcore-wotlk` 的文件夹。
2. 进入 **modules** 文件夹: `cd modules`
3. 使用以下命令下载模块源代码。
```
git clone https://github.com/azerothcore/mod-eluna.git mod-eluna
```
### 2) 构建
您需要再次运行 cmake 并重新生成项目。
AC版的Eluna API:
[https://www.azerothcore.org/pages/eluna/index.html](https://www.azerothcore.org/pages/eluna/index.html)
## 文档
* [入门指南](https://github.com/ElunaLuaEngine/Eluna/blob/master/docs/USAGE.md)
* [Eluna特性](https://github.com/ElunaLuaEngine/Eluna/blob/master/docs/IMPL_DETAILS.md)
* [功能文档(AC版本)](https://www.azerothcore.org/pages/eluna/index.html)
* [Hook文档](https://github.com/ElunaLuaEngine/Eluna/blob/master/Hooks.h)
* [Lua参考手册](http://www.lua.org/manual/5.2/)
* [论坛 - 支持, 发布, 指南](https://www.getmangos.eu/forums/forum/119-eluna-central/)
* [示例脚本](https://github.com/ElunaLuaEngine/Scripts)
* [贡献](https://github.com/ElunaLuaEngine/Eluna/blob/master/docs/CONTRIBUTING.md)
## 链接
* [MaNGOS](http://getmangos.eu/)
* [cMaNGOS](http://cmangos.net/)
* [TrinityCore](http://www.trinitycore.org/)
* [AzerothCore](http://www.azerothcore.org/)
* [Lua.org](http://www.lua.org/)
* [License](https://github.com/ElunaLuaEngine/Eluna/blob/master/docs/LICENSE.md)
## 来自Eluna/master的拓展
- 添加了 HttpRequest 方法. https://github.com/azerothcore/Eluna/pull/2
- 添加玩家注册事件43(当宠物添加到世界中时): `PLAYER_EVENT_ON_PET_ADDED_TO_WORLD` https://github.com/azerothcore/Eluna/pull/3
- 添加聊天处理方法到玩家事件中。 https://github.com/azerothcore/Eluna/pull/23
- 暴露方法 `ModifyThreatPct()`. https://github.com/azerothcore/Eluna/pull/25
- 暴露方法 `Object:IsPlayer()`. https://github.com/azerothcore/Eluna/pull/42
- 添加玩家注册事件44(当玩家学习技能时): `PLAYER_EVENT_ON_LEARN_SPELL`. https://github.com/azerothcore/mod-eluna/pull/46
- 添加玩家注册事件45(当玩家完成成就时): `PLAYER_ON_ACHIEVEMENT_COMPLETE`。 https://github.com/azerothcore/mod-eluna/pull/47
- 添加玩家注册事件51(当玩家获得任务奖励时) `PLAYER_EVENT_ON_QUEST_REWARD_ITEM`。https://github.com/azerothcore/mod-eluna/pull/88
- 添加玩家注册事件52(当玩家创建物品时) `PLAYER_EVENT_ON_CREATE_ITEM`。https://github.com/azerothcore/mod-eluna/pull/88
- 添加玩家注册事件53(当玩家创建物品实例时) `PLAYER_EVENT_ON_STORE_NEW_ITEM`。https://github.com/azerothcore/mod-eluna/pull/88
- 添加玩家注册事件54(当玩家完成任务时) `PLAYER_EVENT_ON_COMPLETE_QUEST`。https://github.com/azerothcore/mod-eluna/pull/90
- 新增参数*商人Id*到方法player:SendListInventory(object, vendorentry)中。 https://github.com/azerothcore/mod-eluna/pull/48
- 添加方法`gameobject:AddLoot()`, 可以在线给**空**的容器中添加战利品。 https://github.com/azerothcore/mod-eluna/pull/52
modules/mod-eluna/README_ES.md
+26
View File
@@ -0,0 +1,26 @@
# Esta traducción proviene de una versión desactualizada.
##
##
##
##
# mod-LuaEngine
[English](README.md) | [中文说明](README_CN.md) | [Español](README_ES.md)
Un módulo de Eluna para AzerothCore.
Cómo instalar:
1. Descargar o clonar este módulo:
> [Descargar archivo zip](https://github.com/azerothcore/mod-eluna-lua-engine/archive/master.zip)
> o clonar `git clone https://github.com/azerothcore/mod-eluna-lua-engine.git`
2. Póngalo en la carpeta de módulos del Azerothcore.
> $HOME/azerothcore/modules/
3. Descargar o clonar el archivo central de ELUNA:
> [Descargar archivo zip](https://github.com/ElunaLuaEngine/Eluna/archive/master.zip)
> o clonar `git clone https://github.com/ElunaLuaEngine/Eluna.git .`
4. Dentro de la carpeta del módulo de Eluna de Azeroth, se encuentra una carpeta / directorio llamado: `LuaEngine` (mod-eluna-lua-engine/LuaEngine). Debe depositar los ficheros de lua, directamente dentro de esa carpeta. Los archivos directamente, no un directorio y luego los ficheros dentro. Por eso te utiliza el “.” cuando se está clonando, para que no genere un directorio nuevo.
5. Una vez copiado los ficheros y descargado el modulo, debes volver a compilar. Si seguiste la guía de instalación, debiste haber generado un directorio build, dentro de azerothcore. Dirígete a él y realiza la compilación como lo menciona en la guía.
Eluna API :
[http://elunaluaengine.github.io/](http://elunaluaengine.github.io/)
modules/mod-eluna/_config.yml
+1
View File
@@ -0,0 +1 @@
theme: jekyll-theme-architect
modules/mod-eluna/conf/mod_eluna.conf.dist
+159
View File
@@ -0,0 +1,159 @@
[worldserver]
###################################################################################################
# ELUNA SETTINGS
#
# Eluna.Enabled
# Description: Enable or disable Eluna LuaEngine
# Default: true - (enabled)
# false - (disabled)
#
# Eluna.TraceBack
# Description: Sets whether to use debug.traceback function on a lua error or not.
# Notice that you can redefine the function.
# Default: false - (use default error output)
# true - (use debug.traceback function)
#
# Eluna.ScriptPath
# Description: Sets the location of the script folder to load scripts from
# The path can be relative or absolute.
# Default: "lua_scripts"
#
# Eluna.PlayerAnnounceReload
# Description: Enable or disable whether the reload announcement is sent to players (Lowest security level).
# Default: false - (disabled)
# true - (enabled)
#
# Eluna.RequirePaths
# Description: Sets the location of additional require paths.
# These paths are absolute and follows the standard Lua require path patterns.
# Below are a set of "standard" paths used by most package managers.
# "/usr/share/%s/?.lua;/usr/local/share/lua/%s/?.lua;/usr/local/share/lua/%s/?/init.lua;/usr/share/lua/%s/?.lua;/usr/share/lua/%s/?/init.lua;"
# Default: ""
#
# Eluna.RequireCPaths
# Description: Sets the location of additional require C paths.
# These paths are absolute and follows the standard Lua require path patterns.
# Below are a set of "standard" paths used by most package managers.
# "/usr/local/lib/lua/%s/?.so;/usr/lib/x86_64-linux-gnu/lua/%s/?.so;/usr/local/lib/lua/%s/loadall.so;"
# Default: ""
#
# Eluna.AutoReload
# Description: Enable or disable automatic reloading of Lua scripts when files are modified.
# This feature watches the script directory for changes and automatically
# triggers a reload when .lua files are added, modified, or deleted.
# Useful for development but should be disabled in production environments.
# Default: false - (disabled)
# true - (enabled)
#
# Eluna.AutoReloadInterval
# Description: Sets the interval in seconds between file system checks for auto-reload.
# Lower values provide faster detection but use more CPU resources.
# Higher values reduce CPU usage but increase detection delay.
# Default: 1 - (check every 1 second)
#
# Eluna.BytecodeCache
# Description: Enable or disable bytecode caching for improved performance.
# When enabled, Lua/MoonScript files are compiled to bytecode and cached in memory.
# This significantly speeds up script reloading (.reload eluna).
# Cache is cleared only when files are modified or server restarts.
# Default: true - (enabled)
# false - (disabled)
Eluna.Enabled = true
Eluna.TraceBack = false
Eluna.ScriptPath = "lua_scripts"
Eluna.PlayerAnnounceReload = false
Eluna.RequirePaths = ""
Eluna.RequireCPaths = ""
Eluna.AutoReload = false
Eluna.AutoReloadInterval = 1
Eluna.BytecodeCache = true
###################################################################################################
# LOGGING SYSTEM SETTINGS
#
# Appender config values: Given an appender "name"
# Appender.name
# Description: Defines 'where to log'.
# Format: Type,LogLevel,Flags,optional1,optional2,optional3
#
# Type
# 0 - (None)
# 1 - (Console)
# 2 - (File)
# 3 - (DB)
#
# LogLevel
# 0 - (Disabled)
# 1 - (Fatal)
# 2 - (Error)
# 3 - (Warning)
# 4 - (Info)
# 5 - (Debug)
# 6 - (Trace)
#
# Flags:
# 0 - None
# 1 - Prefix Timestamp to the text
# 2 - Prefix Log Level to the text
# 4 - Prefix Log Filter type to the text
# 8 - Append timestamp to the log file name. Format: YYYY-MM-DD_HH-MM-SS
# (Only used with Type = 2)
# 16 - Make a backup of existing file before overwrite
# (Only used with Mode = w)
#
# Colors (read as optional1 if Type = Console)
# Format: "fatal error warn info debug trace"
# 0 - BLACK
# 1 - RED
# 2 - GREEN
# 3 - BROWN
# 4 - BLUE
# 5 - MAGENTA
# 6 - CYAN
# 7 - GREY
# 8 - YELLOW
# 9 - LRED
# 10 - LGREEN
# 11 - LBLUE
# 12 - LMAGENTA
# 13 - LCYAN
# 14 - WHITE
# Example: "1 9 3 6 5 8"
#
# File: Name of the file (read as optional1 if Type = File)
# Allows to use one "%s" to create dynamic files
#
# Mode: Mode to open the file (read as optional2 if Type = File)
# a - (Append)
# w - (Overwrite)
#
# MaxFileSize: Maximum file size of the log file before creating a new log file
# (read as optional3 if Type = File)
# Size is measured in bytes expressed in a 64-bit unsigned integer.
# Maximum value is 4294967295 (4 GB). Leave blank for no limit.
# NOTE: Does not work with dynamic filenames.
# Example: 536870912 (512 MB)
#
Appender.ElunaLog=2,5,0,eluna.log,w
Appender.ElunaConsole=1,4,0,"0 9 0 3 5 0"
# Logger config values: Given a logger "name"
# Logger.name
# Description: Defines 'What to log'
# Format: LogLevel,AppenderList
#
# LogLevel
# 0 - (Disabled)
# 1 - (Fatal)
# 2 - (Error)
# 3 - (Warning)
# 4 - (Info)
# 5 - (Debug)
# 6 - (Trace)
#
# AppenderList: List of appenders linked to logger
# (Using spaces as separator).
#
Logger.eluna=4,ElunaLog ElunaConsole
modules/mod-eluna/icon.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.0 KiB

modules/mod-eluna/include.sh
View File
modules/mod-eluna/sql/README.md
+24
View File
@@ -0,0 +1,24 @@
# BEST PRACTICES
## Create a new table
**Example:**
```
CREATE TABLE IF NOT EXISTS `table`(
`id` int(11) unsigned NOT NULL,
`active` BOOLEAN DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
**Boolean datatype in mysql:**
Use "TinyInt(1)"" or "Boolean" (this is the same thing)
"bit(1)" can also work, but it may require a syntax like b'(0) and b'(1) when inserting (not sure).
If there are multiple booleans in the same table, bit(1) is better, otherwise it's the same result.
## Resources
https://www.w3schools.com/sql/sql_datatypes.asp
modules/mod-eluna/sql/auth/.gitkeep
View File
modules/mod-eluna/sql/characters/.gitkeep
View File
modules/mod-eluna/sql/world/.gitkeep
View File
modules/mod-eluna/src/ElunaLuaEngine_SC.cpp
+1252
View File
File diff suppressed because it is too large Load Diff
modules/mod-eluna/src/LuaEngine/.editorconfig
+7
View File
@@ -0,0 +1,7 @@
[*]
charset = utf-8
indent_style = space
indent_size = 4
tab_width = 4
insert_final_newline = true
trim_trailing_whitespace = true
modules/mod-eluna/src/LuaEngine/.github/workflows/build.yml
Vendored
+63
View File
@@ -0,0 +1,63 @@
name: build
on:
push:
pull_request:
jobs:
AC-Eluna:
strategy:
fail-fast: false
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v2
with:
submodules: recursive
repository: azerothcore/azerothcore-wotlk
ref: 'master'
- uses: actions/checkout@v2
with:
submodules: false
repository: azerothcore/mod-eluna-lua-engine
path: modules/mod-eluna-lua-engine
- uses: actions/checkout@v2
with:
path: modules/mod-eluna-lua-engine/LuaEngine
- name: Configure OS
run: |
# Copy paste of https://github.com/azerothcore/azerothcore-wotlk/blob/master/apps/ci/ci-install.sh
cat >>conf/config.sh <<CONFIG_SH
MTHREADS=4
CWARNINGS=ON
CDEBUG=OFF
CTYPE=Release
CSCRIPTS=static
CUNIT_TESTS=ON
CSERVERS=ON
CTOOLS=ON
CSCRIPTPCH=ON
CCOREPCH=ON
CCUSTOMOPTIONS='-DCMAKE_C_FLAGS="-Werror" -DCMAKE_CXX_FLAGS="-Werror"'
DB_CHARACTERS_CONF="MYSQL_USER='root'; MYSQL_PASS='root'; MYSQL_HOST='localhost';"
DB_AUTH_CONF="MYSQL_USER='root'; MYSQL_PASS='root'; MYSQL_HOST='localhost';"
DB_WORLD_CONF="MYSQL_USER='root'; MYSQL_PASS='root'; MYSQL_HOST='localhost';"
CONFIG_SH
time sudo apt-get update -y
# time sudo apt-get upgrade -y
time sudo apt-get install -y git lsb-release sudo ccache
time ./acore.sh install-deps
time sudo apt-get install -y clang-11
echo "CCOMPILERC=\"clang-11\"" >> ./conf/config.sh
echo "CCOMPILERCXX=\"clang++-11\"" >> ./conf/config.sh
- name: Import db
run: source ./apps/ci/ci-import-db.sh
- name: Build
run: source ./apps/ci/ci-compile.sh
- name: Dry run
run: source ./apps/ci/ci-worldserver-dry-run.sh
- name: Check startup errors
run: source ./apps/ci/ci-error-check.sh
modules/mod-eluna/src/LuaEngine/.github/workflows/create-pr.sh
Vendored
+36
View File
@@ -0,0 +1,36 @@
# Adapted from https://github.com/paygoc6/action-pull-request-another-repo
CLONE_DIR=$(mktemp -d)
echo "Setting git variables"
export GITHUB_TOKEN=$API_TOKEN_GITHUB
git config --global user.email "$USER_EMAIL"
git config --global user.name "$USER_NAME"
echo "Cloning destination git repository"
git clone "https://$API_TOKEN_GITHUB@github.com/$DESTINATION_REPO.git" "$CLONE_DIR"
cd "$CLONE_DIR"
git checkout "$DESTINATION_BASE_BRANCH"
git pull origin "$DESTINATION_BASE_BRANCH"
git checkout -b "$DESTINATION_HEAD_BRANCH"
echo "Copying contents to git repo"
mkdir -p "$CLONE_DIR/$DESTINATION_FOLDER"
cp -r "$SOURCE_FOLDER/." "$CLONE_DIR/$DESTINATION_FOLDER/"
echo "Adding files"
git add .
if git status | grep -q "Changes to be committed"
then
echo "Adding git commit"
git commit -m "$COMMIT_MESSAGE"
echo "Pushing git commit"
git push -u origin "$DESTINATION_HEAD_BRANCH"
echo "Creating a pull request"
gh pr create -t "$PR_TITLE" \
-B "$DESTINATION_BASE_BRANCH" \
-b "" \
-H "$DESTINATION_HEAD_BRANCH"
else
echo "No changes detected"
fi
modules/mod-eluna/src/LuaEngine/.github/workflows/documentation.yml
Vendored
+38
View File
@@ -0,0 +1,38 @@
name: Documentation
on:
push:
branches:
- 'main'
- 'master'
jobs:
Push-Docs-To-AzerothCore-Website:
runs-on: ubuntu-latest
steps:
- name: Check out repository code
uses: actions/checkout@v2
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: '3.x'
architecture: 'x64'
- name: Install Python dependencies
run: pip install jinja2 typedecorator markdown
- name: Compile documentation
run: |
cd ${{ github.workspace }}/docs/
python -m ElunaDoc
- name: Create pull request
run: |
chmod +x "${GITHUB_WORKSPACE}/.github/workflows/create-pr.sh"
"${GITHUB_WORKSPACE}/.github/workflows/create-pr.sh"
env:
API_TOKEN_GITHUB: ${{ secrets.API_TOKEN_GITHUB }}
SOURCE_FOLDER: '${{ github.workspace }}/docs/build'
DESTINATION_REPO: 'azerothcore/azerothcore.github.io'
DESTINATION_FOLDER: 'pages/eluna'
DESTINATION_BASE_BRANCH: 'master'
DESTINATION_HEAD_BRANCH: 'eluna-docs'
PR_TITLE: 'chore: update eluna documentation'
COMMIT_MESSAGE: 'chore: update eluna documentation'
USER_EMAIL: 'ax.cocat@gmail.com'
USER_NAME: 'r-o-b-o-t-o'
modules/mod-eluna/src/LuaEngine/BindingMap.h
+375
View File
@@ -0,0 +1,375 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _BINDING_MAP_H
#define _BINDING_MAP_H
#include <memory>
#include "Common.h"
#include "ElunaUtility.h"
#include <type_traits>
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
};
/*
* A set of bindings from keys of type `K` to Lua references.
*/
template<typename K>
class BindingMap : public ElunaUtil::Lockable
{
private:
lua_State* L;
uint64 maxBindingID;
struct Binding
{
uint64 id;
lua_State* L;
uint32 remainingShots;
int functionReference;
Binding(lua_State* L, uint64 id, int functionReference, uint32 remainingShots) :
id(id),
L(L),
remainingShots(remainingShots),
functionReference(functionReference)
{ }
~Binding()
{
luaL_unref(L, LUA_REGISTRYINDEX, functionReference);
}
};
typedef std::vector< std::unique_ptr<Binding> > BindingList;
std::unordered_map<K, BindingList> bindings;
/*
* This table is for fast removal of bindings by ID.
*
* Instead of having to look through (potentially) every BindingList to find
* the Binding with the right ID, this allows you to go directly to the
* BindingList that might have the Binding with that ID.
*
* However, you must be careful not to store pointers to BindingLists
* that no longer exist (see `void Clear(const K& key)` implementation).
*/
std::unordered_map<uint64, BindingList*> id_lookup_table;
public:
BindingMap(lua_State* L) :
L(L),
maxBindingID(0)
{ }
/*
* Insert a new binding from `key` to `ref`, which lasts for `shots`-many pushes.
*
* If `shots` is 0, it will never automatically expire, but can still be
* removed with `Clear` or `Remove`.
*/
uint64 Insert(const K& key, int ref, uint32 shots)
{
Guard guard(GetLock());
uint64 id = (++maxBindingID);
BindingList& list = bindings[key];
list.push_back(std::unique_ptr<Binding>(new Binding(L, id, ref, shots)));
id_lookup_table[id] = &list;
return id;
}
/*
* Clear all bindings for `key`.
*/
void Clear(const K& key)
{
Guard guard(GetLock());
if (bindings.empty())
return;
auto iter = bindings.find(key);
if (iter == bindings.end())
return;
BindingList& list = iter->second;
// Remove all pointers to `list` from `id_lookup_table`.
for (auto i = list.begin(); i != list.end(); ++i)
{
std::unique_ptr<Binding>& binding = *i;
id_lookup_table.erase(binding->id);
}
bindings.erase(key);
}
/*
* Clear all bindings for all keys.
*/
void Clear()
{
Guard guard(GetLock());
if (bindings.empty())
return;
id_lookup_table.clear();
bindings.clear();
}
/*
* Remove a specific binding identified by `id`.
*
* If `id` in invalid, nothing is removed.
*/
void Remove(uint64 id)
{
Guard guard(GetLock());
auto iter = id_lookup_table.find(id);
if (iter == id_lookup_table.end())
return;
BindingList* list = iter->second;
auto i = list->begin();
for (; i != list->end(); ++i)
{
std::unique_ptr<Binding>& binding = *i;
if (binding->id == id)
break;
}
if (i != list->end())
list->erase(i);
// Unconditionally erase the ID in the lookup table because
// it was either already invalid, or it's no longer valid.
id_lookup_table.erase(id);
}
/*
* Check whether `key` has any bindings.
*/
bool HasBindingsFor(const K& key)
{
Guard guard(GetLock());
if (bindings.empty())
return false;
auto result = bindings.find(key);
if (result == bindings.end())
return false;
BindingList& list = result->second;
return !list.empty();
}
/*
* Push all Lua references for `key` onto the stack.
*/
void PushRefsFor(const K& key)
{
Guard guard(GetLock());
if (bindings.empty())
return;
auto result = bindings.find(key);
if (result == bindings.end())
return;
BindingList& list = result->second;
for (auto i = list.begin(); i != list.end();)
{
std::unique_ptr<Binding>& binding = (*i);
auto i_prev = (i++);
lua_rawgeti(L, LUA_REGISTRYINDEX, binding->functionReference);
if (binding->remainingShots > 0)
{
binding->remainingShots -= 1;
if (binding->remainingShots == 0)
{
id_lookup_table.erase(binding->id);
list.erase(i_prev);
}
}
}
}
};
/*
* A `BindingMap` key type for simple event ID bindings
* (ServerEvents, GuildEvents, etc.).
*/
template <typename T>
struct EventKey
{
T event_id;
EventKey(T event_id) :
event_id(event_id)
{ }
};
/*
* A `BindingMap` key type for event ID/Object entry ID bindings
* (CreatureEvents, GameObjectEvents, etc.).
*/
template <typename T>
struct EntryKey
{
T event_id;
uint32 entry;
EntryKey(T event_id, uint32 entry) :
event_id(event_id),
entry(entry)
{ }
};
/*
* A `BindingMap` key type for event ID/unique Object bindings
* (currently just CreatureEvents).
*/
template <typename T>
struct UniqueObjectKey
{
T event_id;
ObjectGuid guid;
uint32 instance_id;
UniqueObjectKey(T event_id, ObjectGuid guid, uint32 instance_id) :
event_id(event_id),
guid(guid),
instance_id(instance_id)
{ }
};
class hash_helper
{
public:
typedef std::size_t result_type;
template <typename T1, typename T2, typename... T>
static inline result_type hash(T1 const & t1, T2 const & t2, T const &... t)
{
result_type seed = 0;
_hash_combine(seed, t1, t2, t...);
return seed;
}
template <typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
static inline result_type hash(T const & t)
{
return std::hash<typename std::underlying_type<T>::type>()(t);
}
template <typename T, typename std::enable_if<!std::is_enum<T>::value>::type* = nullptr>
static inline result_type hash(T const & t)
{
return std::hash<T>()(t);
}
private:
template <typename T>
static inline void _hash_combine(result_type& seed, T const & v)
{
// from http://www.boost.org/doc/libs/1_40_0/boost/functional/hash/hash.hpp
seed ^= hash(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <typename H, typename T1, typename... T>
static inline void _hash_combine(result_type& seed, H const & h, T1 const & t1, T const &... t)
{
_hash_combine(seed, h);
_hash_combine(seed, t1, t...);
}
};
/*
* Implementations of various std functions on the above key types,
* so that they can be used within an unordered_map.
*/
namespace std
{
template<typename T>
struct equal_to < EventKey<T> >
{
bool operator()(EventKey<T> const& lhs, EventKey<T> const& rhs) const
{
return lhs.event_id == rhs.event_id;
}
};
template<typename T>
struct equal_to < EntryKey<T> >
{
bool operator()(EntryKey<T> const& lhs, EntryKey<T> const& rhs) const
{
return lhs.event_id == rhs.event_id
&& lhs.entry == rhs.entry;
}
};
template<typename T>
struct equal_to < UniqueObjectKey<T> >
{
bool operator()(UniqueObjectKey<T> const& lhs, UniqueObjectKey<T> const& rhs) const
{
return lhs.event_id == rhs.event_id
&& lhs.guid == rhs.guid
&& lhs.instance_id == rhs.instance_id;
}
};
template<typename T>
struct hash < EventKey<T> >
{
typedef EventKey<T> argument_type;
hash_helper::result_type operator()(argument_type const& k) const
{
return hash_helper::hash(k.event_id);
}
};
template<typename T>
struct hash < EntryKey<T> >
{
typedef EntryKey<T> argument_type;
hash_helper::result_type operator()(argument_type const& k) const
{
return hash_helper::hash(k.event_id, k.entry);
}
};
template<typename T>
struct hash < UniqueObjectKey<T> >
{
typedef UniqueObjectKey<T> argument_type;
hash_helper::result_type operator()(argument_type const& k) const
{
return hash_helper::hash(k.event_id, k.instance_id, k.guid.GetRawValue());
}
};
}
#endif // _BINDING_MAP_H
modules/mod-eluna/src/LuaEngine/ElunaCompat.cpp
+88
View File
@@ -0,0 +1,88 @@
/*
* Copyright (C) 2010 - 2024 Eluna Lua Engine <https://elunaluaengine.github.io/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "ElunaCompat.h"
#if LUA_VERSION_NUM == 501
const char* luaL_tolstring(lua_State* L, int idx, size_t* len) {
if (!luaL_callmeta(L, idx, "__tostring")) {
int t = lua_type(L, idx), tt = 0;
char const* name = NULL;
switch (t) {
case LUA_TNIL:
lua_pushliteral(L, "nil");
break;
case LUA_TSTRING:
case LUA_TNUMBER:
lua_pushvalue(L, idx);
break;
case LUA_TBOOLEAN:
if (lua_toboolean(L, idx))
lua_pushliteral(L, "true");
else
lua_pushliteral(L, "false");
break;
default:
tt = luaL_getmetafield(L, idx, "__name");
name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
if (tt != LUA_TNIL)
lua_replace(L, -2);
break;
}
}
else {
if (!lua_isstring(L, -1))
luaL_error(L, "'__tostring' must return a string");
}
return lua_tolstring(L, -1, len);
}
int luaL_getsubtable(lua_State* L, int i, const char* name) {
int abs_i = lua_absindex(L, i);
luaL_checkstack(L, 3, "not enough stack slots");
lua_pushstring(L, name);
lua_gettable(L, abs_i);
if (lua_istable(L, -1))
return 1;
lua_pop(L, 1);
lua_newtable(L);
lua_pushstring(L, name);
lua_pushvalue(L, -2);
lua_settable(L, abs_i);
return 0;
}
int lua_absindex(lua_State* L, int i) {
if (i < 0 && i > LUA_REGISTRYINDEX)
i += lua_gettop(L) + 1;
return i;
}
#if !defined LUAJIT_VERSION
void* luaL_testudata(lua_State* L, int index, const char* tname) {
void* ud = lua_touserdata(L, index);
if (ud)
{
if (lua_getmetatable(L, index))
{
luaL_getmetatable(L, tname);
if (!lua_rawequal(L, -1, -2))
ud = NULL;
lua_pop(L, 2);
return ud;
}
}
return NULL;
}
void luaL_setmetatable(lua_State* L, const char* tname) {
lua_pushstring(L, tname);
lua_rawget(L, LUA_REGISTRYINDEX);
lua_setmetatable(L, -2);
}
#endif
#endif
modules/mod-eluna/src/LuaEngine/ElunaCompat.h
+47
View File
@@ -0,0 +1,47 @@
/*
* Copyright (C) 2010 - 2024 Eluna Lua Engine <https://elunaluaengine.github.io/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef ELUNACOMPAT_H
#define ELUNACOMPAT_H
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
};
/* Compatibility layer for compiling with Lua 5.1 or LuaJIT */
#if LUA_VERSION_NUM == 501
int luaL_getsubtable(lua_State* L, int i, const char* name);
const char* luaL_tolstring(lua_State* L, int idx, size_t* len);
int lua_absindex(lua_State* L, int i);
#define lua_pushglobaltable(L) \
lua_pushvalue((L), LUA_GLOBALSINDEX)
#define lua_rawlen(L, idx) \
lua_objlen(L, idx)
#define lua_pushunsigned(L, u) \
lua_pushinteger(L, u)
#define lua_load(L, buf_read, dec_buf, str, NULL) \
lua_load(L, buf_read, dec_buf, str)
#ifndef LUA_OK
#define LUA_OK 0
#endif
#if !defined LUAJIT_VERSION
void* luaL_testudata(lua_State* L, int index, const char* tname);
void luaL_setmetatable(lua_State* L, const char* tname);
#define luaL_setfuncs(L, l, n) luaL_register(L, NULL, l)
#endif
#endif
#if LUA_VERSION_NUM > 502
#define lua_dump(L, writer, data) \
lua_dump(L, writer, data, 0)
#define lua_pushunsigned(L, u) \
lua_pushinteger(L, u)
#endif
#endif
modules/mod-eluna/src/LuaEngine/ElunaConfig.cpp
+30
View File
@@ -0,0 +1,30 @@
#include "ElunaConfig.h"
ElunaConfig& ElunaConfig::GetInstance()
{
static ElunaConfig instance;
return instance;
}
ElunaConfig::ElunaConfig() : ConfigValueCache<ElunaConfigValues>(ElunaConfigValues::CONFIG_VALUE_COUNT)
{
}
void ElunaConfig::Initialize(bool reload)
{
ConfigValueCache<ElunaConfigValues>::Initialize(reload);
}
void ElunaConfig::BuildConfigCache()
{
SetConfigValue<bool>(ElunaConfigValues::ENABLED, "Eluna.Enabled", "false");
SetConfigValue<bool>(ElunaConfigValues::TRACEBACK_ENABLED, "Eluna.TraceBack", "false");
SetConfigValue<bool>(ElunaConfigValues::AUTORELOAD_ENABLED, "Eluna.AutoReload", "false");
SetConfigValue<bool>(ElunaConfigValues::BYTECODE_CACHE_ENABLED, "Eluna.BytecodeCache", "false");
SetConfigValue<std::string>(ElunaConfigValues::SCRIPT_PATH, "Eluna.ScriptPath", "lua_scripts");
SetConfigValue<std::string>(ElunaConfigValues::REQUIRE_PATH, "Eluna.RequirePaths", "");
SetConfigValue<std::string>(ElunaConfigValues::REQUIRE_CPATH, "Eluna.RequireCPaths", "");
SetConfigValue<uint32>(ElunaConfigValues::AUTORELOAD_INTERVAL, "Eluna.AutoReloadInterval", 1);
}
modules/mod-eluna/src/LuaEngine/ElunaConfig.h
+53
View File
@@ -0,0 +1,53 @@
#ifndef ELUNA_CONFIG_HPP
#define ELUNA_CONFIG_HPP
#include "ConfigValueCache.h"
enum class ElunaConfigValues : uint32
{
// Boolean
ENABLED = 0,
TRACEBACK_ENABLED,
AUTORELOAD_ENABLED,
BYTECODE_CACHE_ENABLED,
// String
SCRIPT_PATH,
REQUIRE_PATH,
REQUIRE_CPATH,
// Number
AUTORELOAD_INTERVAL,
CONFIG_VALUE_COUNT
};
class ElunaConfig final : public ConfigValueCache<ElunaConfigValues>
{
public:
static ElunaConfig& GetInstance();
void Initialize(bool reload = false);
bool IsElunaEnabled() const { return GetConfigValue<bool>(ElunaConfigValues::ENABLED); }
bool IsTraceBackEnabled() const { return GetConfigValue<bool>(ElunaConfigValues::TRACEBACK_ENABLED); }
bool IsAutoReloadEnabled() const { return GetConfigValue<bool>(ElunaConfigValues::AUTORELOAD_ENABLED); }
bool IsByteCodeCacheEnabled() const { return GetConfigValue<bool>(ElunaConfigValues::BYTECODE_CACHE_ENABLED); }
std::string_view GetScriptPath() const { return GetConfigValue(ElunaConfigValues::SCRIPT_PATH); }
std::string_view GetRequirePath() const { return GetConfigValue(ElunaConfigValues::REQUIRE_PATH); }
std::string_view GetRequireCPath() const { return GetConfigValue(ElunaConfigValues::REQUIRE_CPATH); }
uint32 GetAutoReloadInterval() const { return GetConfigValue<uint32>(ElunaConfigValues::AUTORELOAD_INTERVAL); }
protected:
void BuildConfigCache() override;
private:
ElunaConfig();
~ElunaConfig() = default;
ElunaConfig(const ElunaConfig&) = delete;
ElunaConfig& operator=(const ElunaConfig&) = delete;
};
#endif // ELUNA_CONFIG_H
modules/mod-eluna/src/LuaEngine/ElunaCreatureAI.h
+196
View File
@@ -0,0 +1,196 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _ELUNA_CREATURE_AI_H
#define _ELUNA_CREATURE_AI_H
#include "LuaEngine.h"
struct ScriptedAI;
struct ElunaCreatureAI : ScriptedAI
{
// used to delay the spawn hook triggering on AI creation
bool justSpawned;
// used to delay movementinform hook (WP hook)
std::vector< std::pair<uint32, uint32> > movepoints;
ElunaCreatureAI(Creature* creature) : ScriptedAI(creature), justSpawned(true)
{
}
~ElunaCreatureAI() { }
//Called at World update tick
void UpdateAI(uint32 diff) override
{
if (justSpawned)
{
justSpawned = false;
JustRespawned();
}
if (!movepoints.empty())
{
for (auto& point : movepoints)
{
if (!sEluna->MovementInform(me, point.first, point.second))
ScriptedAI::MovementInform(point.first, point.second);
}
movepoints.clear();
}
if (!sEluna->UpdateAI(me, diff))
{
if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC))
ScriptedAI::UpdateAI(diff);
}
}
// Called for reaction when initially engaged - this will always happen _after_ JustEnteredCombat
// Called at creature aggro either by MoveInLOS or Attack Start
void JustEngagedWith(Unit* target) override
{
if (!sEluna->EnterCombat(me, target))
ScriptedAI::JustEngagedWith(target);
}
// Called at any Damage from any attacker (before damage apply)
void DamageTaken(Unit* attacker, uint32& damage, DamageEffectType damagetype, SpellSchoolMask damageSchoolMask) override
{
if (!sEluna->DamageTaken(me, attacker, damage))
{
ScriptedAI::DamageTaken(attacker, damage, damagetype, damageSchoolMask);
}
}
//Called at creature death
void JustDied(Unit* killer) override
{
if (!sEluna->JustDied(me, killer))
ScriptedAI::JustDied(killer);
}
//Called at creature killing another unit
void KilledUnit(Unit* victim) override
{
if (!sEluna->KilledUnit(me, victim))
ScriptedAI::KilledUnit(victim);
}
// Called when the creature summon successfully other creature
void JustSummoned(Creature* summon) override
{
if (!sEluna->JustSummoned(me, summon))
ScriptedAI::JustSummoned(summon);
}
// Called when a summoned creature is despawned
void SummonedCreatureDespawn(Creature* summon) override
{
if (!sEluna->SummonedCreatureDespawn(me, summon))
ScriptedAI::SummonedCreatureDespawn(summon);
}
//Called at waypoint reached or PointMovement end
void MovementInform(uint32 type, uint32 id) override
{
// delayed since hook triggers before actually reaching the point
// and starting new movement would bug
movepoints.push_back(std::make_pair(type, id));
}
// Called before EnterCombat even before the creature is in combat.
void AttackStart(Unit* target) override
{
if (!sEluna->AttackStart(me, target))
ScriptedAI::AttackStart(target);
}
// Called for reaction at stopping attack at no attackers or targets
void EnterEvadeMode(EvadeReason /*why*/) override
{
if (!sEluna->EnterEvadeMode(me))
ScriptedAI::EnterEvadeMode();
}
// Called when creature is spawned or respawned (for reseting variables)
void JustRespawned() override
{
if (!sEluna->JustRespawned(me))
ScriptedAI::JustRespawned();
}
// Called at reaching home after evade
void JustReachedHome() override
{
if (!sEluna->JustReachedHome(me))
ScriptedAI::JustReachedHome();
}
// Called at text emote receive from player
void ReceiveEmote(Player* player, uint32 emoteId) override
{
if (!sEluna->ReceiveEmote(me, player, emoteId))
ScriptedAI::ReceiveEmote(player, emoteId);
}
// called when the corpse of this creature gets removed
void CorpseRemoved(uint32& respawnDelay) override
{
if (!sEluna->CorpseRemoved(me, respawnDelay))
ScriptedAI::CorpseRemoved(respawnDelay);
}
void MoveInLineOfSight(Unit* who) override
{
if (!sEluna->MoveInLineOfSight(me, who))
ScriptedAI::MoveInLineOfSight(who);
}
// Called when hit by a spell
void SpellHit(Unit* caster, SpellInfo const* spell) override
{
if (!sEluna->SpellHit(me, caster, spell))
ScriptedAI::SpellHit(caster, spell);
}
// Called when spell hits a target
void SpellHitTarget(Unit* target, SpellInfo const* spell) override
{
if (!sEluna->SpellHitTarget(me, target, spell))
ScriptedAI::SpellHitTarget(target, spell);
}
// Called when the creature is summoned successfully by other creature
void IsSummonedBy(WorldObject* summoner) override
{
if (!summoner->ToUnit() || !sEluna->OnSummoned(me, summoner->ToUnit()))
ScriptedAI::IsSummonedBy(summoner);
}
void SummonedCreatureDies(Creature* summon, Unit* killer) override
{
if (!sEluna->SummonedCreatureDies(me, summon, killer))
ScriptedAI::SummonedCreatureDies(summon, killer);
}
// Called when owner takes damage
void OwnerAttackedBy(Unit* attacker) override
{
if (!sEluna->OwnerAttackedBy(me, attacker))
ScriptedAI::OwnerAttackedBy(attacker);
}
// Called when owner attacks something
void OwnerAttacked(Unit* target) override
{
if (!sEluna->OwnerAttacked(me, target))
ScriptedAI::OwnerAttacked(target);
}
};
#endif
modules/mod-eluna/src/LuaEngine/ElunaDBCRegistry.cpp
+7
View File
@@ -0,0 +1,7 @@
#include "ElunaDBCRegistry.h"
std::vector<DBCDefinition> dbcRegistry = {
REGISTER_DBC(GemProperties, GemPropertiesEntry, sGemPropertiesStore),
REGISTER_DBC(Spell, SpellEntry, sSpellStore),
};
modules/mod-eluna/src/LuaEngine/ElunaDBCRegistry.h
+38
View File
@@ -0,0 +1,38 @@
#ifndef ELUNADBCREGISTRY_H
#define ELUNADBCREGISTRY_H
#include <string>
#include <vector>
#include <functional>
#include <typeinfo>
#include "DBCStores.h"
#include "LuaEngine.h"
struct DBCDefinition
{
std::string name;
void* storage;
const std::type_info& type;
std::function<const void*(uint32)> lookupFunction;
std::function<void(lua_State*, const void*)> pushFunction;
};
extern std::vector<DBCDefinition> dbcRegistry;
#define REGISTER_DBC(dbcName, entryType, store) \
{ \
#dbcName, \
reinterpret_cast<void*>(&store), \
typeid(DBCStorage<entryType>), \
[](uint32 id) -> const void* { \
return store.LookupEntry(id); \
}, \
[](lua_State* L, const void* entry) { \
auto cast_entry = static_cast<const entryType*>(entry); \
Eluna::Push(L, *cast_entry); \
} \
}
#endif // ELUNADBCREGISTRY_H
modules/mod-eluna/src/LuaEngine/ElunaEventMgr.cpp
+160
View File
@@ -0,0 +1,160 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "ElunaEventMgr.h"
#include "LuaEngine.h"
#include "Object.h"
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
};
ElunaEventProcessor::ElunaEventProcessor(Eluna** _E, WorldObject* _obj) : m_time(0), obj(_obj), E(_E)
{
// can be called from multiple threads
if (obj)
{
EventMgr::Guard guard((*E)->eventMgr->GetLock());
(*E)->eventMgr->processors.insert(this);
}
}
ElunaEventProcessor::~ElunaEventProcessor()
{
// can be called from multiple threads
{
LOCK_ELUNA;
RemoveEvents_internal();
}
if (obj && Eluna::IsInitialized())
{
EventMgr::Guard guard((*E)->eventMgr->GetLock());
(*E)->eventMgr->processors.erase(this);
}
}
void ElunaEventProcessor::Update(uint32 diff)
{
m_time += diff;
for (EventList::iterator it = eventList.begin(); it != eventList.end() && it->first <= m_time; it = eventList.begin())
{
LuaEvent* luaEvent = it->second;
eventList.erase(it);
if (luaEvent->state != LUAEVENT_STATE_ERASE)
eventMap.erase(luaEvent->funcRef);
if (luaEvent->state == LUAEVENT_STATE_RUN)
{
uint32 delay = luaEvent->delay;
bool remove = luaEvent->repeats == 1;
if (!remove)
AddEvent(luaEvent); // Reschedule before calling incase RemoveEvents used
// Call the timed event
(*E)->OnTimedEvent(luaEvent->funcRef, delay, luaEvent->repeats ? luaEvent->repeats-- : luaEvent->repeats, obj);
if (!remove)
continue;
}
// Event should be deleted (executed last time or set to be aborted)
RemoveEvent(luaEvent);
}
}
void ElunaEventProcessor::SetStates(LuaEventState state)
{
for (EventList::iterator it = eventList.begin(); it != eventList.end(); ++it)
it->second->SetState(state);
if (state == LUAEVENT_STATE_ERASE)
eventMap.clear();
}
void ElunaEventProcessor::RemoveEvents_internal()
{
//if (!final)
//{
// for (EventList::iterator it = eventList.begin(); it != eventList.end(); ++it)
// it->second->to_Abort = true;
// return;
//}
for (EventList::iterator it = eventList.begin(); it != eventList.end(); ++it)
RemoveEvent(it->second);
eventList.clear();
eventMap.clear();
}
void ElunaEventProcessor::SetState(int eventId, LuaEventState state)
{
if (eventMap.find(eventId) != eventMap.end())
eventMap[eventId]->SetState(state);
if (state == LUAEVENT_STATE_ERASE)
eventMap.erase(eventId);
}
void ElunaEventProcessor::AddEvent(LuaEvent* luaEvent)
{
luaEvent->GenerateDelay();
eventList.insert(std::pair<uint64, LuaEvent*>(m_time + luaEvent->delay, luaEvent));
eventMap[luaEvent->funcRef] = luaEvent;
}
void ElunaEventProcessor::AddEvent(int funcRef, uint32 min, uint32 max, uint32 repeats)
{
AddEvent(new LuaEvent(funcRef, min, max, repeats));
}
void ElunaEventProcessor::RemoveEvent(LuaEvent* luaEvent)
{
// Unreference if should and if Eluna was not yet uninitialized and if the lua state still exists
if (luaEvent->state != LUAEVENT_STATE_ERASE && Eluna::IsInitialized() && (*E)->HasLuaState())
{
// Free lua function ref
luaL_unref((*E)->L, LUA_REGISTRYINDEX, luaEvent->funcRef);
}
delete luaEvent;
}
EventMgr::EventMgr(Eluna** _E) : globalProcessor(new ElunaEventProcessor(_E, NULL)), E(_E)
{
}
EventMgr::~EventMgr()
{
{
Guard guard(GetLock());
if (!processors.empty())
for (ProcessorSet::const_iterator it = processors.begin(); it != processors.end(); ++it) // loop processors
(*it)->RemoveEvents_internal();
globalProcessor->RemoveEvents_internal();
}
delete globalProcessor;
globalProcessor = NULL;
}
void EventMgr::SetStates(LuaEventState state)
{
Guard guard(GetLock());
if (!processors.empty())
for (ProcessorSet::const_iterator it = processors.begin(); it != processors.end(); ++it) // loop processors
(*it)->SetStates(state);
globalProcessor->SetStates(state);
}
void EventMgr::SetState(int eventId, LuaEventState state)
{
Guard guard(GetLock());
if (!processors.empty())
for (ProcessorSet::const_iterator it = processors.begin(); it != processors.end(); ++it) // loop processors
(*it)->SetState(eventId, state);
globalProcessor->SetState(eventId, state);
}
modules/mod-eluna/src/LuaEngine/ElunaEventMgr.h
+104
View File
@@ -0,0 +1,104 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _ELUNA_EVENT_MGR_H
#define _ELUNA_EVENT_MGR_H
#include "ElunaUtility.h"
#include "Common.h"
#include "Util.h"
#include <map>
#include "Define.h"
class Eluna;
class EventMgr;
class ElunaEventProcessor;
class WorldObject;
enum LuaEventState
{
LUAEVENT_STATE_RUN, // On next call run the function normally
LUAEVENT_STATE_ABORT, // On next call unregisters reffed function and erases the data
LUAEVENT_STATE_ERASE, // On next call just erases the data
};
struct LuaEvent
{
LuaEvent(int _funcRef, uint32 _min, uint32 _max, uint32 _repeats) :
min(_min), max(_max), delay(0), repeats(_repeats), funcRef(_funcRef), state(LUAEVENT_STATE_RUN)
{
}
void SetState(LuaEventState _state)
{
if (state != LUAEVENT_STATE_ERASE)
state = _state;
}
void GenerateDelay()
{
delay = urand(min, max);
}
uint32 min; // Minimum delay between event calls
uint32 max; // Maximum delay between event calls
uint32 delay; // The currently used waiting time
uint32 repeats; // Amount of repeats to make, 0 for infinite
int funcRef; // Lua function reference ID, also used as event ID
LuaEventState state; // State for next call
};
class ElunaEventProcessor
{
friend class EventMgr;
public:
typedef std::multimap<uint64, LuaEvent*> EventList;
typedef std::unordered_map<int, LuaEvent*> EventMap;
ElunaEventProcessor(Eluna** _E, WorldObject* _obj);
~ElunaEventProcessor();
void Update(uint32 diff);
// removes all timed events on next tick or at tick end
void SetStates(LuaEventState state);
// set the event to be removed when executing
void SetState(int eventId, LuaEventState state);
void AddEvent(int funcRef, uint32 min, uint32 max, uint32 repeats);
EventMap eventMap;
private:
void RemoveEvents_internal();
void AddEvent(LuaEvent* luaEvent);
void RemoveEvent(LuaEvent* luaEvent);
EventList eventList;
uint64 m_time;
WorldObject* obj;
Eluna** E;
};
class EventMgr : public ElunaUtil::Lockable
{
public:
typedef std::unordered_set<ElunaEventProcessor*> ProcessorSet;
ProcessorSet processors;
ElunaEventProcessor* globalProcessor;
Eluna** E;
EventMgr(Eluna** _E);
~EventMgr();
// Set the state of all timed events
// Execute only in safe env
void SetStates(LuaEventState state);
// Sets the eventId's state in all processors
// Execute only in safe env
void SetState(int eventId, LuaEventState state);
};
#endif
modules/mod-eluna/src/LuaEngine/ElunaFileWatcher.cpp
+216
View File
@@ -0,0 +1,216 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "ElunaFileWatcher.h"
#include "LuaEngine.h"
#include "ElunaUtility.h"
#include <boost/filesystem.hpp>
ElunaFileWatcher::ElunaFileWatcher() : running(false), checkInterval(1)
{
}
ElunaFileWatcher::~ElunaFileWatcher()
{
StopWatching();
}
void ElunaFileWatcher::StartWatching(const std::string& scriptPath, uint32 intervalSeconds)
{
if (running.load())
{
ELUNA_LOG_DEBUG("[ElunaFileWatcher]: Already watching files");
return;
}
if (scriptPath.empty())
{
ELUNA_LOG_ERROR("[ElunaFileWatcher]: Cannot start watching - script path is empty");
return;
}
watchPath = scriptPath;
checkInterval = intervalSeconds;
running.store(true);
ScanDirectory(watchPath);
watcherThread = std::thread(&ElunaFileWatcher::WatchLoop, this);
ELUNA_LOG_INFO("[ElunaFileWatcher]: Started watching '{}' (interval: {}s)", watchPath, checkInterval);
}
void ElunaFileWatcher::StopWatching()
{
if (!running.load())
return;
running.store(false);
if (watcherThread.joinable())
watcherThread.join();
fileTimestamps.clear();
ELUNA_LOG_INFO("[ElunaFileWatcher]: Stopped watching files");
}
void ElunaFileWatcher::WatchLoop()
{
while (running.load())
{
try
{
CheckForChanges();
}
catch (const std::exception& e)
{
ELUNA_LOG_ERROR("[ElunaFileWatcher]: Error during file watching: {}", e.what());
}
std::this_thread::sleep_for(std::chrono::seconds(checkInterval));
}
}
bool ElunaFileWatcher::IsWatchedFileType(const std::string& filename) {
return (filename.length() >= 4 && filename.substr(filename.length() - 4) == ".lua") ||
(filename.length() >= 4 && filename.substr(filename.length() - 4) == ".ext") ||
(filename.length() >= 5 && filename.substr(filename.length() - 5) == ".moon");
}
void ElunaFileWatcher::ScanDirectory(const std::string& path)
{
try
{
boost::filesystem::path dir(path);
if (!boost::filesystem::exists(dir) || !boost::filesystem::is_directory(dir))
return;
boost::filesystem::directory_iterator end_iter;
for (boost::filesystem::directory_iterator dir_iter(dir); dir_iter != end_iter; ++dir_iter)
{
std::string fullpath = dir_iter->path().generic_string();
if (boost::filesystem::is_directory(dir_iter->status()))
{
ScanDirectory(fullpath);
}
else if (boost::filesystem::is_regular_file(dir_iter->status()))
{
std::string filename = dir_iter->path().filename().generic_string();
if (IsWatchedFileType(filename))
{
fileTimestamps[fullpath] = boost::filesystem::last_write_time(dir_iter->path());
}
}
}
}
catch (const std::exception& e)
{
ELUNA_LOG_ERROR("[ElunaFileWatcher]: Error scanning directory '{}': {}", path, e.what());
}
}
void ElunaFileWatcher::CheckForChanges()
{
bool hasChanges = false;
try
{
boost::filesystem::path dir(watchPath);
if (!boost::filesystem::exists(dir) || !boost::filesystem::is_directory(dir))
return;
boost::filesystem::directory_iterator end_iter;
for (boost::filesystem::directory_iterator dir_iter(dir); dir_iter != end_iter; ++dir_iter)
{
if (ShouldReloadFile(dir_iter->path().generic_string()))
hasChanges = true;
}
for (auto it = fileTimestamps.begin(); it != fileTimestamps.end();)
{
if (!boost::filesystem::exists(it->first))
{
ELUNA_LOG_DEBUG("[ElunaFileWatcher]: File deleted: {}", it->first);
it = fileTimestamps.erase(it);
hasChanges = true;
}
else
{
++it;
}
}
}
catch (const std::exception& e)
{
ELUNA_LOG_ERROR("[ElunaFileWatcher]: Error checking for changes: {}", e.what());
return;
}
if (hasChanges)
{
ELUNA_LOG_INFO("[ElunaFileWatcher]: Lua script changes detected - triggering reload");
Eluna::ReloadEluna();
ScanDirectory(watchPath);
}
}
bool ElunaFileWatcher::ShouldReloadFile(const std::string& filepath)
{
try
{
boost::filesystem::path file(filepath);
if (boost::filesystem::is_directory(file))
{
boost::filesystem::directory_iterator end_iter;
for (boost::filesystem::directory_iterator dir_iter(file); dir_iter != end_iter; ++dir_iter)
{
if (ShouldReloadFile(dir_iter->path().generic_string()))
return true;
}
return false;
}
if (!boost::filesystem::is_regular_file(file))
return false;
std::string filename = file.filename().generic_string();
if (!IsWatchedFileType(filename)) return false;
auto currentTime = boost::filesystem::last_write_time(file);
auto it = fileTimestamps.find(filepath);
if (it == fileTimestamps.end())
{
ELUNA_LOG_DEBUG("[ElunaFileWatcher]: New file detected: {}", filepath);
fileTimestamps[filepath] = currentTime;
return true;
}
if (it->second != currentTime)
{
ELUNA_LOG_DEBUG("[ElunaFileWatcher]: File modified: {}", filepath);
it->second = currentTime;
return true;
}
}
catch (const std::exception& e)
{
ELUNA_LOG_ERROR("[ElunaFileWatcher]: Error checking file '{}': {}", filepath, e.what());
}
return false;
}
modules/mod-eluna/src/LuaEngine/ElunaFileWatcher.h
+43
View File
@@ -0,0 +1,43 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef ELUNA_FILE_WATCHER_H
#define ELUNA_FILE_WATCHER_H
#include <thread>
#include <atomic>
#include <map>
#include <string>
#include <chrono>
#include <boost/filesystem.hpp>
#include "Common.h"
class ElunaFileWatcher
{
public:
ElunaFileWatcher();
~ElunaFileWatcher();
void StartWatching(const std::string& scriptPath, uint32 intervalSeconds = 1);
void StopWatching();
bool IsWatching() const { return running.load(); }
private:
void WatchLoop();
void ScanDirectory(const std::string& path);
void CheckForChanges();
bool ShouldReloadFile(const std::string& filepath);
bool IsWatchedFileType(const std::string& filename);
std::thread watcherThread;
std::atomic<bool> running;
std::string watchPath;
uint32 checkInterval;
std::map<std::string, std::time_t> fileTimestamps;
};
#endif
modules/mod-eluna/src/LuaEngine/ElunaIncludes.h
+76
View File
@@ -0,0 +1,76 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _ELUNA_INCLUDES_H
#define _ELUNA_INCLUDES_H
// Required
#include "AccountMgr.h"
#include "AuctionHouseMgr.h"
#include "Cell.h"
#include "CellImpl.h"
#include "Chat.h"
#include "Channel.h"
#include "DBCStores.h"
#include "GameEventMgr.h"
#include "GossipDef.h"
#include "GridNotifiers.h"
#include "GridNotifiersImpl.h"
#include "Group.h"
#include "Guild.h"
#include "GuildMgr.h"
#include "Language.h"
#include "Mail.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "Opcodes.h"
#include "Player.h"
#include "Pet.h"
#include "ReputationMgr.h"
#include "ScriptMgr.h"
#include "Spell.h"
#include "SpellAuras.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "TemporarySummon.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "MapMgr.h"
#include "Config.h"
#include "GameEventMgr.h"
#include "GitRevision.h"
#include "GroupMgr.h"
#include "ScriptedCreature.h"
#include "WeatherMgr.h"
#include "Battleground.h"
#include "MotionMaster.h"
#include "DatabaseEnv.h"
#include "Bag.h"
#include "Vehicle.h"
#include "ArenaTeam.h"
#include "WorldSessionMgr.h"
typedef Opcodes OpcodesList;
/*
* Note: if you add or change a CORE_NAME or CORE_VERSION #define,
* please update LuaGlobalFunctions::GetCoreName or LuaGlobalFunctions::GetCoreVersion documentation example string.
*/
#define CORE_NAME "AzerothCore"
#define CORE_VERSION (GitRevision::GetFullVersion())
#define eWorldSessionMgr (sWorldSessionMgr)
#define eWorld (sWorld)
#define eMapMgr (sMapMgr)
#define eConfigMgr (sConfigMgr)
#define eGuildMgr (sGuildMgr)
#define eObjectMgr (sObjectMgr)
#define eAccountMgr (sAccountMgr)
#define eAuctionMgr (sAuctionMgr)
#define eGameEventMgr (sGameEventMgr)
#define eObjectAccessor() ObjectAccessor::
#endif // _ELUNA_INCLUDES_H
modules/mod-eluna/src/LuaEngine/ElunaInstanceAI.cpp
+228
View File
@@ -0,0 +1,228 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "ElunaInstanceAI.h"
#include "ElunaUtility.h"
#include "lmarshal.h"
void ElunaInstanceAI::Initialize()
{
LOCK_ELUNA;
ASSERT(!sEluna->HasInstanceData(instance));
// Create a new table for instance data.
lua_State* L = sEluna->L;
lua_newtable(L);
sEluna->CreateInstanceData(instance);
sEluna->OnInitialize(this);
}
void ElunaInstanceAI::Load(const char* data)
{
LOCK_ELUNA;
// If we get passed NULL (i.e. `Reload` was called) then use
// the last known save data (or maybe just an empty string).
if (!data)
{
data = lastSaveData.c_str();
}
else // Otherwise, copy the new data into our buffer.
{
lastSaveData.assign(data);
}
if (data[0] == '\0')
{
ASSERT(!sEluna->HasInstanceData(instance));
// Create a new table for instance data.
lua_State* L = sEluna->L;
lua_newtable(L);
sEluna->CreateInstanceData(instance);
sEluna->OnLoad(this);
// Stack: (empty)
return;
}
size_t decodedLength;
const unsigned char* decodedData = ElunaUtil::DecodeData(data, &decodedLength);
lua_State* L = sEluna->L;
if (decodedData)
{
// Stack: (empty)
lua_pushcfunction(L, mar_decode);
lua_pushlstring(L, (const char*)decodedData, decodedLength);
// Stack: mar_decode, decoded_data
// Call `mar_decode` and check for success.
if (lua_pcall(L, 1, 1, 0) == 0)
{
// Stack: data
// Only use the data if it's a table.
if (lua_istable(L, -1))
{
sEluna->CreateInstanceData(instance);
// Stack: (empty)
sEluna->OnLoad(this);
// WARNING! lastSaveData might be different after `OnLoad` if the Lua code saved data.
}
else
{
ELUNA_LOG_ERROR("Error while loading instance data: Expected data to be a table (type 5), got type {} instead", lua_type(L, -1));
lua_pop(L, 1);
// Stack: (empty)
Initialize();
}
}
else
{
// Stack: error_message
ELUNA_LOG_ERROR("Error while parsing instance data with lua-marshal: {}", lua_tostring(L, -1));
lua_pop(L, 1);
// Stack: (empty)
Initialize();
}
delete[] decodedData;
}
else
{
ELUNA_LOG_ERROR("Error while decoding instance data: Data is not valid base-64");
Initialize();
}
}
const char* ElunaInstanceAI::Save() const
{
LOCK_ELUNA;
lua_State* L = sEluna->L;
// Stack: (empty)
/*
* Need to cheat because this method actually does modify this instance,
* even though it's declared as `const`.
*
* Declaring virtual methods as `const` is BAD!
* Don't dictate to children that their methods must be pure.
*/
ElunaInstanceAI* self = const_cast<ElunaInstanceAI*>(this);
lua_pushcfunction(L, mar_encode);
sEluna->PushInstanceData(L, self, false);
// Stack: mar_encode, instance_data
if (lua_pcall(L, 1, 1, 0) != 0)
{
// Stack: error_message
ELUNA_LOG_ERROR("Error while saving: {}", lua_tostring(L, -1));
lua_pop(L, 1);
return NULL;
}
// Stack: data
size_t dataLength;
const unsigned char* data = (const unsigned char*)lua_tolstring(L, -1, &dataLength);
ElunaUtil::EncodeData(data, dataLength, self->lastSaveData);
lua_pop(L, 1);
// Stack: (empty)
return lastSaveData.c_str();
}
uint32 ElunaInstanceAI::GetData(uint32 key) const
{
LOCK_ELUNA;
lua_State* L = sEluna->L;
// Stack: (empty)
sEluna->PushInstanceData(L, const_cast<ElunaInstanceAI*>(this), false);
// Stack: instance_data
Eluna::Push(L, key);
// Stack: instance_data, key
lua_gettable(L, -2);
// Stack: instance_data, value
uint32 value = Eluna::CHECKVAL<uint32>(L, -1, 0);
lua_pop(L, 2);
// Stack: (empty)
return value;
}
void ElunaInstanceAI::SetData(uint32 key, uint32 value)
{
LOCK_ELUNA;
lua_State* L = sEluna->L;
// Stack: (empty)
sEluna->PushInstanceData(L, this, false);
// Stack: instance_data
Eluna::Push(L, key);
Eluna::Push(L, value);
// Stack: instance_data, key, value
lua_settable(L, -3);
// Stack: instance_data
lua_pop(L, 1);
// Stack: (empty)
}
uint64 ElunaInstanceAI::GetData64(uint32 key) const
{
LOCK_ELUNA;
lua_State* L = sEluna->L;
// Stack: (empty)
sEluna->PushInstanceData(L, const_cast<ElunaInstanceAI*>(this), false);
// Stack: instance_data
Eluna::Push(L, key);
// Stack: instance_data, key
lua_gettable(L, -2);
// Stack: instance_data, value
uint64 value = Eluna::CHECKVAL<uint64>(L, -1, 0);
lua_pop(L, 2);
// Stack: (empty)
return value;
}
void ElunaInstanceAI::SetData64(uint32 key, uint64 value)
{
LOCK_ELUNA;
lua_State* L = sEluna->L;
// Stack: (empty)
sEluna->PushInstanceData(L, this, false);
// Stack: instance_data
Eluna::Push(L, key);
Eluna::Push(L, value);
// Stack: instance_data, key, value
lua_settable(L, -3);
// Stack: instance_data
lua_pop(L, 1);
// Stack: (empty)
}
modules/mod-eluna/src/LuaEngine/ElunaInstanceAI.h
+133
View File
@@ -0,0 +1,133 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _ELUNA_INSTANCE_DATA_H
#define _ELUNA_INSTANCE_DATA_H
#include "LuaEngine.h"
#include "InstanceScript.h"
/*
* This class is a small wrapper around `InstanceData`,
* allowing instances to be scripted with Eluna.
*
*
* Note 1
* ======
*
* Instances of `ElunaInstanceAI` are owned by the core, so they
* are not deleted when Eluna is reloaded. Thus `Load` is only called
* by the core once, no matter how many times Eluna is reloaded.
*
* However, when Eluna reloads, all instance data in Eluna is lost.
* So the solution is as follows:
*
* 1. Store the last save data in the member var `lastSaveData`.
*
* At first this is just the data given to us by the core when it calls `Load`,
* but later on once we start saving new data this is from Eluna.
*
* 2. When retrieving instance data from Eluna, check if it's missing.
*
* The data will be missing if Eluna is reloaded, since a new Lua state is created.
*
* 3. If it *is* missing, call `Reload`.
*
* This reloads the last known instance save data into Eluna, and calls the appropriate hooks.
*
*
* Note 2
* ======
*
* CMaNGOS expects some of these methods to be `const`. However, any of these
* methods are free to call `Save`, resulting in mutation of `lastSaveData`.
*
* Therefore, none of the hooks are `const`-safe, and `const_cast` is used
* to escape from these restrictions.
*/
class ElunaInstanceAI : public InstanceData
{
private:
// The last save data to pass through this class,
// either through `Load` or `Save`.
std::string lastSaveData;
public:
ElunaInstanceAI(Map* map) : InstanceData(map)
{
}
void Initialize() override;
/*
* These are responsible for serializing/deserializing the instance's
* data table to/from the core.
*/
void Load(const char* data) override;
// Simply calls Save, since the functions are a bit different in name and data types on different cores
std::string GetSaveData() override
{
return Save();
}
const char* Save() const;
/*
* Calls `Load` with the last save data that was passed to
* or from Eluna.
*
* See: big documentation blurb at the top of this class.
*/
void Reload()
{
Load(NULL);
}
/*
* These methods allow non-Lua scripts (e.g. DB, C++) to get/set instance data.
*/
uint32 GetData(uint32 key) const override;
void SetData(uint32 key, uint32 value) override;
uint64 GetData64(uint32 key) const override;
void SetData64(uint32 key, uint64 value) override;
/*
* These methods are just thin wrappers around Eluna.
*/
void Update(uint32 diff) override
{
// If Eluna is reloaded, it will be missing our instance data.
// Reload here instead of waiting for the next hook call (possibly never).
// This avoids having to have an empty Update hook handler just to trigger the reload.
if (!sEluna->HasInstanceData(instance))
Reload();
sEluna->OnUpdateInstance(this, diff);
}
bool IsEncounterInProgress() const override
{
return sEluna->OnCheckEncounterInProgress(const_cast<ElunaInstanceAI*>(this));
}
void OnPlayerEnter(Player* player) override
{
sEluna->OnPlayerEnterInstance(this, player);
}
void OnGameObjectCreate(GameObject* gameobject) override
{
sEluna->OnGameObjectCreate(this, gameobject);
}
void OnCreatureCreate(Creature* creature) override
{
sEluna->OnCreatureCreate(this, creature);
}
};
#endif // _ELUNA_INSTANCE_DATA_H
modules/mod-eluna/src/LuaEngine/ElunaTemplate.h
+389
View File
@@ -0,0 +1,389 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _ELUNA_TEMPLATE_H
#define _ELUNA_TEMPLATE_H
extern "C"
{
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
};
#include "LuaEngine.h"
#include "ElunaCompat.h"
#include "ElunaUtility.h"
#include "SharedDefines.h"
class ElunaGlobal
{
public:
static int thunk(lua_State* L)
{
luaL_Reg* l = static_cast<luaL_Reg*>(lua_touserdata(L, lua_upvalueindex(1)));
int top = lua_gettop(L);
int expected = l->func(L);
int args = lua_gettop(L) - top;
if (args < 0 || args > expected)
{
ELUNA_LOG_ERROR("[Eluna]: {} returned unexpected amount of arguments {} out of {}. Report to devs", l->name, args, expected);
ASSERT(false);
}
lua_settop(L, top + expected);
return expected;
}
static void SetMethods(Eluna* E, luaL_Reg* methodTable)
{
ASSERT(E);
ASSERT(methodTable);
lua_pushglobaltable(E->L);
for (; methodTable && methodTable->name && methodTable->func; ++methodTable)
{
lua_pushstring(E->L, methodTable->name);
lua_pushlightuserdata(E->L, (void*)methodTable);
lua_pushcclosure(E->L, thunk, 1);
lua_rawset(E->L, -3);
}
lua_remove(E->L, -1);
}
};
class ElunaObject
{
public:
template<typename T>
ElunaObject(T * obj, bool manageMemory);
~ElunaObject()
{
}
// Get wrapped object pointer
void* GetObj() const { return object; }
// Returns whether the object is valid or not
bool IsValid() const { return !callstackid || callstackid == sEluna->GetCallstackId(); }
// Returns whether the object can be invalidated or not
bool CanInvalidate() const { return _invalidate; }
// Returns pointer to the wrapped object's type name
const char* GetTypeName() const { return type_name; }
// Sets the object pointer that is wrapped
void SetObj(void* obj)
{
ASSERT(obj);
object = obj;
SetValid(true);
}
// Sets the object pointer to valid or invalid
void SetValid(bool valid)
{
ASSERT(!valid || (valid && object));
if (valid)
if (CanInvalidate())
callstackid = sEluna->GetCallstackId();
else
callstackid = 0;
else
callstackid = 1;
}
// Sets whether the pointer will be invalidated at end of calls
void SetValidation(bool invalidate)
{
_invalidate = invalidate;
}
// Invalidates the pointer if it should be invalidated
void Invalidate()
{
if (CanInvalidate())
callstackid = 1;
}
private:
uint64 callstackid;
bool _invalidate;
void* object;
const char* type_name;
};
template<typename T>
struct ElunaRegister
{
const char* name;
int(*mfunc)(lua_State*, T*);
};
template<typename T>
class ElunaTemplate
{
public:
static const char* tname;
static bool manageMemory;
// name will be used as type name
// If gc is true, lua will handle the memory management for object pushed
// gc should be used if pushing for example WorldPacket,
// that will only be needed on lua side and will not be managed by TC/mangos/<core>
static void Register(Eluna* E, const char* name, bool gc = false)
{
ASSERT(E);
ASSERT(name);
// check that metatable isn't already there
lua_getglobal(E->L, name);
ASSERT(lua_isnoneornil(E->L, -1));
// pop nil
lua_pop(E->L, 1);
tname = name;
manageMemory = gc;
// create metatable for userdata of this type
luaL_newmetatable(E->L, tname);
int metatable = lua_gettop(E->L);
// push methodtable to stack to be accessed and modified by users
lua_pushvalue(E->L, metatable);
lua_setglobal(E->L, tname);
// tostring
lua_pushcfunction(E->L, ToString);
lua_setfield(E->L, metatable, "__tostring");
// garbage collecting
lua_pushcfunction(E->L, CollectGarbage);
lua_setfield(E->L, metatable, "__gc");
// make methods accessible through metatable
lua_pushvalue(E->L, metatable);
lua_setfield(E->L, metatable, "__index");
// make new indexes saved to methods
lua_pushcfunction(E->L, Add);
lua_setfield(E->L, metatable, "__add");
// make new indexes saved to methods
lua_pushcfunction(E->L, Substract);
lua_setfield(E->L, metatable, "__sub");
// make new indexes saved to methods
lua_pushcfunction(E->L, Multiply);
lua_setfield(E->L, metatable, "__mul");
// make new indexes saved to methods
lua_pushcfunction(E->L, Divide);
lua_setfield(E->L, metatable, "__div");
// make new indexes saved to methods
lua_pushcfunction(E->L, Mod);
lua_setfield(E->L, metatable, "__mod");
// make new indexes saved to methods
lua_pushcfunction(E->L, Pow);
lua_setfield(E->L, metatable, "__pow");
// make new indexes saved to methods
lua_pushcfunction(E->L, UnaryMinus);
lua_setfield(E->L, metatable, "__unm");
// make new indexes saved to methods
lua_pushcfunction(E->L, Concat);
lua_setfield(E->L, metatable, "__concat");
// make new indexes saved to methods
lua_pushcfunction(E->L, Length);
lua_setfield(E->L, metatable, "__len");
// make new indexes saved to methods
lua_pushcfunction(E->L, Equal);
lua_setfield(E->L, metatable, "__eq");
// make new indexes saved to methods
lua_pushcfunction(E->L, Less);
lua_setfield(E->L, metatable, "__lt");
// make new indexes saved to methods
lua_pushcfunction(E->L, LessOrEqual);
lua_setfield(E->L, metatable, "__le");
// make new indexes saved to methods
lua_pushcfunction(E->L, Call);
lua_setfield(E->L, metatable, "__call");
// special method to get the object type
lua_pushcfunction(E->L, GetType);
lua_setfield(E->L, metatable, "GetObjectType");
// special method to decide object invalidation at end of call
lua_pushcfunction(E->L, SetInvalidation);
lua_setfield(E->L, metatable, "SetInvalidation");
// pop metatable
lua_pop(E->L, 1);
}
template<typename C>
static void SetMethods(Eluna* E, ElunaRegister<C>* methodTable)
{
ASSERT(E);
ASSERT(tname);
ASSERT(methodTable);
// get metatable
lua_pushstring(E->L, tname);
lua_rawget(E->L, LUA_REGISTRYINDEX);
ASSERT(lua_istable(E->L, -1));
for (; methodTable && methodTable->name && methodTable->mfunc; ++methodTable)
{
lua_pushstring(E->L, methodTable->name);
lua_pushlightuserdata(E->L, (void*)methodTable);
lua_pushcclosure(E->L, CallMethod, 1);
lua_rawset(E->L, -3);
}
lua_pop(E->L, 1);
}
static int Push(lua_State* L, T const* obj)
{
if (!obj)
{
lua_pushnil(L);
return 1;
}
// Create new userdata
ElunaObject** ptrHold = static_cast<ElunaObject**>(lua_newuserdata(L, sizeof(ElunaObject*)));
if (!ptrHold)
{
ELUNA_LOG_ERROR("{} could not create new userdata", tname);
lua_pushnil(L);
return 1;
}
*ptrHold = new ElunaObject(const_cast<T*>(obj), manageMemory);
// Set metatable for it
lua_pushstring(L, tname);
lua_rawget(L, LUA_REGISTRYINDEX);
if (!lua_istable(L, -1))
{
ELUNA_LOG_ERROR("{} missing metatable", tname);
lua_pop(L, 2);
lua_pushnil(L);
return 1;
}
lua_setmetatable(L, -2);
return 1;
}
static T* Check(lua_State* L, int narg, bool error = true)
{
ElunaObject* elunaObj = Eluna::CHECKTYPE(L, narg, tname, error);
if (!elunaObj)
return NULL;
if (!elunaObj->IsValid())
{
char buff[256];
snprintf(buff, 256, "%s expected, got pointer to nonexisting (invalidated) object (%s). Check your code.", tname, luaL_typename(L, narg));
if (error)
{
luaL_argerror(L, narg, buff);
}
else
{
ELUNA_LOG_ERROR("{}", buff);
}
return NULL;
}
return static_cast<T*>(elunaObj->GetObj());
}
static int GetType(lua_State* L)
{
lua_pushstring(L, tname);
return 1;
}
static int SetInvalidation(lua_State* L)
{
ElunaObject* elunaObj = Eluna::CHECKOBJ<ElunaObject>(L, 1);
bool invalidate = Eluna::CHECKVAL<bool>(L, 2);
elunaObj->SetValidation(invalidate);
return 0;
}
static int CallMethod(lua_State* L)
{
T* obj = Eluna::CHECKOBJ<T>(L, 1); // get self
if (!obj)
return 0;
ElunaRegister<T>* l = static_cast<ElunaRegister<T>*>(lua_touserdata(L, lua_upvalueindex(1)));
int top = lua_gettop(L);
int expected = l->mfunc(L, obj);
int args = lua_gettop(L) - top;
if (args < 0 || args > expected)
{
ELUNA_LOG_ERROR("[Eluna]: {} returned unexpected amount of arguments {} out of {}. Report to devs", l->name, args, expected);
ASSERT(false);
}
lua_settop(L, top + expected);
return expected;
}
// Metamethods ("virtual")
// Remember special cases like ElunaTemplate<Vehicle>::CollectGarbage
static int CollectGarbage(lua_State* L)
{
// Get object pointer (and check type, no error)
ElunaObject* obj = Eluna::CHECKOBJ<ElunaObject>(L, 1, false);
if (obj && manageMemory)
delete static_cast<T*>(obj->GetObj());
delete obj;
return 0;
}
static int ToString(lua_State* L)
{
T* obj = Eluna::CHECKOBJ<T>(L, 1, true); // get self
lua_pushfstring(L, "%s: %p", tname, obj);
return 1;
}
static int ArithmeticError(lua_State* L) { return luaL_error(L, "attempt to perform arithmetic on a %s value", tname); }
static int CompareError(lua_State* L) { return luaL_error(L, "attempt to compare %s", tname); }
static int Add(lua_State* L) { return ArithmeticError(L); }
static int Substract(lua_State* L) { return ArithmeticError(L); }
static int Multiply(lua_State* L) { return ArithmeticError(L); }
static int Divide(lua_State* L) { return ArithmeticError(L); }
static int Mod(lua_State* L) { return ArithmeticError(L); }
static int Pow(lua_State* L) { return ArithmeticError(L); }
static int UnaryMinus(lua_State* L) { return ArithmeticError(L); }
static int Concat(lua_State* L) { return luaL_error(L, "attempt to concatenate a %s value", tname); }
static int Length(lua_State* L) { return luaL_error(L, "attempt to get length of a %s value", tname); }
static int Equal(lua_State* L) { Eluna::Push(L, Eluna::CHECKOBJ<T>(L, 1) == Eluna::CHECKOBJ<T>(L, 2)); return 1; }
static int Less(lua_State* L) { return CompareError(L); }
static int LessOrEqual(lua_State* L) { return CompareError(L); }
static int Call(lua_State* L) { return luaL_error(L, "attempt to call a %s value", tname); }
};
template<typename T>
ElunaObject::ElunaObject(T * obj, bool manageMemory) : callstackid(1), _invalidate(!manageMemory), object(obj), type_name(ElunaTemplate<T>::tname)
{
SetValid(true);
}
template<typename T> const char* ElunaTemplate<T>::tname = NULL;
template<typename T> bool ElunaTemplate<T>::manageMemory = false;
#endif
modules/mod-eluna/src/LuaEngine/ElunaUtility.cpp
+188
View File
@@ -0,0 +1,188 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "ElunaUtility.h"
#include "World.h"
#include "Object.h"
#include "Unit.h"
#include "GameObject.h"
#include "DBCStores.h"
uint32 ElunaUtil::GetCurrTime()
{
return getMSTime();
}
uint32 ElunaUtil::GetTimeDiff(uint32 oldMSTime)
{
return GetMSTimeDiffToNow(oldMSTime);
}
ElunaUtil::ObjectGUIDCheck::ObjectGUIDCheck(ObjectGuid guid) : _guid(guid)
{
}
bool ElunaUtil::ObjectGUIDCheck::operator()(WorldObject* object)
{
return object->GET_GUID() == _guid;
}
ElunaUtil::ObjectDistanceOrderPred::ObjectDistanceOrderPred(WorldObject const* pRefObj, bool ascending) : m_refObj(pRefObj), m_ascending(ascending)
{
}
bool ElunaUtil::ObjectDistanceOrderPred::operator()(WorldObject const* pLeft, WorldObject const* pRight) const
{
return m_ascending ? m_refObj->GetDistanceOrder(pLeft, pRight) : !m_refObj->GetDistanceOrder(pLeft, pRight);
}
ElunaUtil::WorldObjectInRangeCheck::WorldObjectInRangeCheck(bool nearest, WorldObject const* obj, float range,
uint16 typeMask, uint32 entry, uint32 hostile, uint32 dead) :
i_obj(obj), i_obj_unit(nullptr), i_obj_fact(nullptr), i_hostile(hostile), i_entry(entry), i_range(range), i_typeMask(typeMask), i_dead(dead), i_nearest(nearest)
{
i_obj_unit = i_obj->ToUnit();
if (!i_obj_unit)
if (GameObject const* go = i_obj->ToGameObject())
i_obj_unit = go->GetOwner();
if (!i_obj_unit)
i_obj_fact = sFactionTemplateStore.LookupEntry(14);
}
WorldObject const& ElunaUtil::WorldObjectInRangeCheck::GetFocusObject() const
{
return *i_obj;
}
bool ElunaUtil::WorldObjectInRangeCheck::operator()(WorldObject* u)
{
if (i_typeMask && !u->isType(TypeMask(i_typeMask)))
return false;
if (i_entry && u->GetEntry() != i_entry)
return false;
if (i_obj->GET_GUID() == u->GET_GUID())
return false;
if (!i_obj->IsWithinDistInMap(u, i_range))
return false;
Unit const* target = u->ToUnit();
if (!target)
if (GameObject const* go = u->ToGameObject())
target = go->GetOwner();
if (target)
{
if (i_dead && (i_dead == 1) != target->IsAlive())
return false;
if (i_hostile)
{
if (!i_obj_unit)
{
if (i_obj_fact)
{
if ((i_obj_fact->IsHostileTo(*target->GetFactionTemplateEntry())) != (i_hostile == 1))
return false;
}
else if (i_hostile == 1)
return false;
}
else if ((i_hostile == 1) != i_obj_unit->IsHostileTo(target))
return false;
}
}
if (i_nearest)
i_range = i_obj->GetDistance(u);
return true;
}
static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'};
static char decoding_table[256];
static int mod_table[] = {0, 2, 1};
static void build_decoding_table()
{
for (int i = 0; i < 64; i++)
decoding_table[(unsigned char)encoding_table[i]] = i;
}
void ElunaUtil::EncodeData(const unsigned char* data, size_t input_length, std::string& output)
{
size_t output_length = 4 * ((input_length + 2) / 3);
char* buffer = new char[output_length];
for (size_t i = 0, j = 0; i < input_length;)
{
uint32 octet_a = i < input_length ? (unsigned char)data[i++] : 0;
uint32 octet_b = i < input_length ? (unsigned char)data[i++] : 0;
uint32 octet_c = i < input_length ? (unsigned char)data[i++] : 0;
uint32 triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
buffer[j++] = encoding_table[(triple >> (3 * 6)) & 0x3F];
buffer[j++] = encoding_table[(triple >> (2 * 6)) & 0x3F];
buffer[j++] = encoding_table[(triple >> (1 * 6)) & 0x3F];
buffer[j++] = encoding_table[(triple >> (0 * 6)) & 0x3F];
}
for (int i = 0; i < mod_table[input_length % 3]; i++)
buffer[output_length - 1 - i] = '=';
output.assign(buffer, output_length); // Need length because `buffer` is not terminated!
delete[] buffer;
}
unsigned char* ElunaUtil::DecodeData(const char *data, size_t *output_length)
{
if (decoding_table[(unsigned char)'B'] == 0)
build_decoding_table();
size_t input_length = strlen(data);
if (input_length % 4 != 0)
return NULL;
// Make sure there's no invalid characters in the data.
for (size_t i = 0; i < input_length; ++i)
{
unsigned char byte = data[i];
if (byte == '=')
continue;
// Every invalid character (and 'A') will map to 0 (due to `calloc`).
if (decoding_table[byte] == 0 && byte != 'A')
return NULL;
}
*output_length = input_length / 4 * 3;
if (data[input_length - 1] == '=') (*output_length)--;
if (data[input_length - 2] == '=') (*output_length)--;
unsigned char *decoded_data = new unsigned char[*output_length];
if (!decoded_data)
return NULL;
for (size_t i = 0, j = 0; i < input_length;)
{
uint32 sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)data[i++]];
uint32 sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)data[i++]];
uint32 sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)data[i++]];
uint32 sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[(unsigned char)data[i++]];
uint32 triple = (sextet_a << (3 * 6))
+ (sextet_b << (2 * 6))
+ (sextet_c << (1 * 6))
+ (sextet_d << (0 * 6));
if (j < *output_length) decoded_data[j++] = (triple >> (2 * 8)) & 0xFF;
if (j < *output_length) decoded_data[j++] = (triple >> (1 * 8)) & 0xFF;
if (j < *output_length) decoded_data[j++] = (triple >> (0 * 8)) & 0xFF;
}
return decoded_data;
}
modules/mod-eluna/src/LuaEngine/ElunaUtility.h
+135
View File
@@ -0,0 +1,135 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _ELUNA_UTIL_H
#define _ELUNA_UTIL_H
#include <unordered_map>
#include <unordered_set>
#include <mutex>
#include <memory>
#include "Common.h"
#include "SharedDefines.h"
#include "ObjectGuid.h"
#include "Database/QueryResult.h"
#include "Log.h"
typedef QueryResult ElunaQuery;
#define GET_GUID GetGUID
#define HIGHGUID_PLAYER HighGuid::Player
#define HIGHGUID_UNIT HighGuid::Unit
#define HIGHGUID_ITEM HighGuid::Item
#define HIGHGUID_GAMEOBJECT HighGuid::GameObject
#define HIGHGUID_PET HighGuid::Pet
#define HIGHGUID_TRANSPORT HighGuid::Transport
#define HIGHGUID_VEHICLE HighGuid::Vehicle
#define HIGHGUID_CONTAINER HighGuid::Container
#define HIGHGUID_DYNAMICOBJECT HighGuid::DynamicObject
#define HIGHGUID_CORPSE HighGuid::Corpse
#define HIGHGUID_MO_TRANSPORT HighGuid::Mo_Transport
#define HIGHGUID_INSTANCE HighGuid::Instance
#define HIGHGUID_GROUP HighGuid::Group
#define ELUNA_LOG_INFO(...) LOG_INFO("eluna", __VA_ARGS__);
#define ELUNA_LOG_ERROR(...) LOG_ERROR("eluna", __VA_ARGS__);
#define ELUNA_LOG_DEBUG(...) LOG_DEBUG("eluna", __VA_ARGS__);
#ifndef MAKE_NEW_GUID
#define MAKE_NEW_GUID(l, e, h) ObjectGuid(h, e, l)
#endif
#ifndef GUID_ENPART
#define GUID_ENPART(guid) ObjectGuid(guid).GetEntry()
#endif
#ifndef GUID_LOPART
#define GUID_LOPART(guid) ObjectGuid(guid).GetCounter()
#endif
#ifndef GUID_HIPART
#define GUID_HIPART(guid) ObjectGuid(guid).GetHigh()
#endif
class Unit;
class WorldObject;
struct FactionTemplateEntry;
namespace ElunaUtil
{
uint32 GetCurrTime();
uint32 GetTimeDiff(uint32 oldMSTime);
class ObjectGUIDCheck
{
public:
ObjectGUIDCheck(ObjectGuid guid);
bool operator()(WorldObject* object);
ObjectGuid _guid;
};
// Binary predicate to sort WorldObjects based on the distance to a reference WorldObject
class ObjectDistanceOrderPred
{
public:
ObjectDistanceOrderPred(WorldObject const* pRefObj, bool ascending = true);
bool operator()(WorldObject const* pLeft, WorldObject const* pRight) const;
WorldObject const* m_refObj;
const bool m_ascending;
};
// Doesn't get self
class WorldObjectInRangeCheck
{
public:
WorldObjectInRangeCheck(bool nearest, WorldObject const* obj, float range,
uint16 typeMask = 0, uint32 entry = 0, uint32 hostile = 0, uint32 dead = 0);
WorldObject const& GetFocusObject() const;
bool operator()(WorldObject* u);
WorldObject const* const i_obj;
Unit const* i_obj_unit;
FactionTemplateEntry const* i_obj_fact;
uint32 const i_hostile; // 0 both, 1 hostile, 2 friendly
uint32 const i_entry;
float i_range;
uint16 const i_typeMask;
uint32 const i_dead; // 0 both, 1 alive, 2 dead
bool const i_nearest;
};
/*
* Usage:
* Inherit this class, then when needing lock, use
* Guard guard(GetLock());
*
* The lock is automatically released at end of scope
*/
class Lockable
{
public:
typedef std::mutex LockType;
typedef std::lock_guard<LockType> Guard;
LockType& GetLock() { return _lock; }
private:
LockType _lock;
};
/*
* Encodes `data` in Base-64 and store the result in `output`.
*/
void EncodeData(const unsigned char* data, size_t input_length, std::string& output);
/*
* Decodes `data` from Base-64 and returns a pointer to the result, or `NULL` on error.
*
* The returned result buffer must be `delete[]`ed by the caller.
*/
unsigned char* DecodeData(const char* data, size_t *output_length);
};
#endif
modules/mod-eluna/src/LuaEngine/HookHelpers.h
+121
View File
@@ -0,0 +1,121 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _HOOK_HELPERS_H
#define _HOOK_HELPERS_H
#include "LuaEngine.h"
#include "ElunaUtility.h"
/*
* Sets up the stack so that event handlers can be called.
*
* Returns the number of functions that were pushed onto the stack.
*/
template<typename K1, typename K2>
int Eluna::SetupStack(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, int number_of_arguments)
{
ASSERT(number_of_arguments == this->push_counter);
ASSERT(key1.event_id == key2.event_id);
// Stack: [arguments]
Push(key1.event_id);
this->push_counter = 0;
++number_of_arguments;
// Stack: [arguments], event_id
int arguments_top = lua_gettop(L);
int first_argument_index = arguments_top - number_of_arguments + 1;
ASSERT(arguments_top >= number_of_arguments);
lua_insert(L, first_argument_index);
// Stack: event_id, [arguments]
bindings1->PushRefsFor(key1);
if (bindings2)
bindings2->PushRefsFor(key2);
// Stack: event_id, [arguments], [functions]
int number_of_functions = lua_gettop(L) - arguments_top;
return number_of_functions;
}
/*
* Replace one of the arguments pushed before `SetupStack` with a new value.
*/
template<typename T>
void Eluna::ReplaceArgument(T value, uint8 index)
{
ASSERT(index < lua_gettop(L) && index > 0);
// Stack: event_id, [arguments], [functions], [results]
Eluna::Push(L, value);
// Stack: event_id, [arguments], [functions], [results], value
lua_replace(L, index + 1);
// Stack: event_id, [arguments and value], [functions], [results]
}
/*
* Call all event handlers registered to the event ID/entry combination and ignore any results.
*/
template<typename K1, typename K2>
void Eluna::CallAllFunctions(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2)
{
int number_of_arguments = this->push_counter;
// Stack: [arguments]
int number_of_functions = SetupStack(bindings1, bindings2, key1, key2, number_of_arguments);
// Stack: event_id, [arguments], [functions]
while (number_of_functions > 0)
{
CallOneFunction(number_of_functions, number_of_arguments, 0);
--number_of_functions;
// Stack: event_id, [arguments], [functions - 1]
}
// Stack: event_id, [arguments]
CleanUpStack(number_of_arguments);
// Stack: (empty)
}
/*
* Call all event handlers registered to the event ID/entry combination,
* and returns `default_value` if ALL event handlers returned `default_value`,
* otherwise returns the opposite of `default_value`.
*/
template<typename K1, typename K2>
bool Eluna::CallAllFunctionsBool(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, bool default_value/* = false*/)
{
bool result = default_value;
// Note: number_of_arguments here does not count in eventID, which is pushed in SetupStack
int number_of_arguments = this->push_counter;
// Stack: [arguments]
int number_of_functions = SetupStack(bindings1, bindings2, key1, key2, number_of_arguments);
// Stack: event_id, [arguments], [functions]
while (number_of_functions > 0)
{
int r = CallOneFunction(number_of_functions, number_of_arguments, 1);
--number_of_functions;
// Stack: event_id, [arguments], [functions - 1], result
if (lua_isboolean(L, r) && (lua_toboolean(L, r) == 1) != default_value)
result = !default_value;
lua_pop(L, 1);
// Stack: event_id, [arguments], [functions - 1]
}
// Stack: event_id, [arguments]
CleanUpStack(number_of_arguments);
// Stack: (empty)
return result;
}
#endif // _HOOK_HELPERS_H
modules/mod-eluna/src/LuaEngine/Hooks.h
+403
View File
@@ -0,0 +1,403 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _HOOKS_H
#define _HOOKS_H
/*
* A hook should be written in one of the following forms:
*
* A. If results will be IGNORED:
*
* // Return early if there are no bindings.
* if (!WhateverBindings->HasBindingsFor(SOME_EVENT_TYPE))
* return;
*
* // Lock out any other threads.
* LOCK_ELUNA;
*
* // Push extra arguments, if any.
* Push(a);
* Push(b);
* Push(c);
*
* // Call all event handlers.
* CallAllFunctions(WhateverBindings, SOME_EVENT_TYPE);
*
*
* B. If results will be USED:
*
* // Return early if there are no bindings.
* if (!WhateverBindings->HasBindingsFor(SOME_EVENT_TYPE))
* return;
*
* // Lock out any other threads.
* LOCK_ELUNA;
*
* // Push extra arguments, if any.
* Push(a);
* Push(b);
* Push(c);
*
* // Setup the stack and get the number of functions pushed.
* // Last argument is 3 because we did 3 Pushes.
* int n = SetupStack(WhateverBindings, SOME_EVENT_TYPE, 3);
*
* // Call each event handler in order and check results.
* while (n > 0)
* {
* // Call an event handler and decrement the function counter afterward.
* // Second-last argument is 3 because we did 3 Pushes.
* // Last argument is 2 because we want 2 results.
* int r = CallOneFunction(n--, 3, 2);
*
* // Results can be popped using `r`.
* int first = CHECKVAL<int>(L, r + 0);
* int second = CHECKVAL<int>(L, r + 1);
*
* // Pop the results off the stack.
* lua_pop(L, 2);
* }
*
* // Clean-up the stack. Argument is 3 because we did 3 Pushes.
* CleanUpStack(3);
*/
namespace Hooks
{
enum RegisterTypes
{
REGTYPE_PACKET,
REGTYPE_SERVER,
REGTYPE_PLAYER,
REGTYPE_GUILD,
REGTYPE_GROUP,
REGTYPE_CREATURE,
REGTYPE_VEHICLE,
REGTYPE_CREATURE_GOSSIP,
REGTYPE_GAMEOBJECT,
REGTYPE_GAMEOBJECT_GOSSIP,
REGTYPE_ITEM,
REGTYPE_ITEM_GOSSIP,
REGTYPE_PLAYER_GOSSIP,
REGTYPE_BG,
REGTYPE_MAP,
REGTYPE_INSTANCE,
REGTYPE_TICKET,
REGTYPE_SPELL,
REGTYPE_COUNT
};
enum PacketEvents
{
PACKET_EVENT_ON_PACKET_RECEIVE = 5, // (event, packet, player) - Player only if accessible. Can return false, newPacket
PACKET_EVENT_ON_PACKET_RECEIVE_UNKNOWN = 6, // Not Implemented
PACKET_EVENT_ON_PACKET_SEND = 7, // (event, packet, player) - Player only if accessible. Can return false, newPacket
PACKET_EVENT_COUNT
};
enum ServerEvents
{
// Server
SERVER_EVENT_ON_NETWORK_START = 1, // Not Implemented
SERVER_EVENT_ON_NETWORK_STOP = 2, // Not Implemented
SERVER_EVENT_ON_SOCKET_OPEN = 3, // Not Implemented
SERVER_EVENT_ON_SOCKET_CLOSE = 4, // Not Implemented
SERVER_EVENT_ON_PACKET_RECEIVE = 5, // (event, packet, player) - Player only if accessible. Can return false, newPacket
SERVER_EVENT_ON_PACKET_RECEIVE_UNKNOWN = 6, // Not Implemented
SERVER_EVENT_ON_PACKET_SEND = 7, // (event, packet, player) - Player only if accessible. Can return false, newPacket
// World
WORLD_EVENT_ON_OPEN_STATE_CHANGE = 8, // (event, open) - Needs core support on Mangos
WORLD_EVENT_ON_AFTER_CONFIG_LOAD = 9, // (event, reload)
// UNUSED = 10,
WORLD_EVENT_ON_SHUTDOWN_INIT = 11, // (event, code, mask)
WORLD_EVENT_ON_SHUTDOWN_CANCEL = 12, // (event)
WORLD_EVENT_ON_UPDATE = 13, // (event, diff)
WORLD_EVENT_ON_STARTUP = 14, // (event)
WORLD_EVENT_ON_SHUTDOWN = 15, // (event)
// Eluna
ELUNA_EVENT_ON_LUA_STATE_CLOSE = 16, // (event) - triggers just before shutting down eluna (on shutdown and restart)
// Map
MAP_EVENT_ON_CREATE = 17, // (event, map)
MAP_EVENT_ON_DESTROY = 18, // (event, map)
MAP_EVENT_ON_GRID_LOAD = 19, // Not Implemented
MAP_EVENT_ON_GRID_UNLOAD = 20, // Not Implemented
MAP_EVENT_ON_PLAYER_ENTER = 21, // (event, map, player)
MAP_EVENT_ON_PLAYER_LEAVE = 22, // (event, map, player)
MAP_EVENT_ON_UPDATE = 23, // (event, map, diff)
// Area trigger
TRIGGER_EVENT_ON_TRIGGER = 24, // (event, player, triggerId) - Can return true
// Weather
WEATHER_EVENT_ON_CHANGE = 25, // (event, zoneId, state, grade)
// Auction house
AUCTION_EVENT_ON_ADD = 26, // (event, auctionId, owner, item, expireTime, buyout, startBid, currentBid, bidderGUIDLow)
AUCTION_EVENT_ON_REMOVE = 27, // (event, auctionId, owner, item, expireTime, buyout, startBid, currentBid, bidderGUIDLow)
AUCTION_EVENT_ON_SUCCESSFUL = 28, // (event, auctionId, owner, item, expireTime, buyout, startBid, currentBid, bidderGUIDLow)
AUCTION_EVENT_ON_EXPIRE = 29, // (event, auctionId, owner, item, expireTime, buyout, startBid, currentBid, bidderGUIDLow)
// AddOns
ADDON_EVENT_ON_MESSAGE = 30, // (event, sender, type, prefix, msg, target) - target can be nil/whisper_target/guild/group/channel. Can return false
WORLD_EVENT_ON_DELETE_CREATURE = 31, // (event, creature)
WORLD_EVENT_ON_DELETE_GAMEOBJECT = 32, // (event, gameobject)
// Eluna
ELUNA_EVENT_ON_LUA_STATE_OPEN = 33, // (event) - triggers after all scripts are loaded
GAME_EVENT_START = 34, // (event, gameeventid)
GAME_EVENT_STOP = 35, // (event, gameeventid)
WORLD_EVENT_ON_BEFORE_WORLD_INITIALIZED = 36, // (event)
WORLD_EVENT_ON_BEFORE_CONFIG_LOAD = 37, // (event, reload)
SERVER_EVENT_COUNT
};
enum PlayerEvents
{
PLAYER_EVENT_ON_CHARACTER_CREATE = 1, // (event, player)
PLAYER_EVENT_ON_CHARACTER_DELETE = 2, // (event, guid)
PLAYER_EVENT_ON_LOGIN = 3, // (event, player)
PLAYER_EVENT_ON_LOGOUT = 4, // (event, player)
PLAYER_EVENT_ON_SPELL_CAST = 5, // (event, player, spell, skipCheck)
PLAYER_EVENT_ON_KILL_PLAYER = 6, // (event, killer, killed)
PLAYER_EVENT_ON_KILL_CREATURE = 7, // (event, killer, killed)
PLAYER_EVENT_ON_KILLED_BY_CREATURE = 8, // (event, killer, killed)
PLAYER_EVENT_ON_DUEL_REQUEST = 9, // (event, target, challenger)
PLAYER_EVENT_ON_DUEL_START = 10, // (event, player1, player2)
PLAYER_EVENT_ON_DUEL_END = 11, // (event, winner, loser, type)
PLAYER_EVENT_ON_GIVE_XP = 12, // (event, player, amount, victim, source) - Can return new XP amount
PLAYER_EVENT_ON_LEVEL_CHANGE = 13, // (event, player, oldLevel)
PLAYER_EVENT_ON_MONEY_CHANGE = 14, // (event, player, amount) - Can return new money amount
PLAYER_EVENT_ON_REPUTATION_CHANGE = 15, // (event, player, factionId, standing, incremental) - Can return new standing -> if standing == -1, it will prevent default action (rep gain)
PLAYER_EVENT_ON_TALENTS_CHANGE = 16, // (event, player, points)
PLAYER_EVENT_ON_TALENTS_RESET = 17, // (event, player, noCost)
PLAYER_EVENT_ON_CHAT = 18, // (event, player, msg, Type, lang) - Can return false, newMessage
PLAYER_EVENT_ON_WHISPER = 19, // (event, player, msg, Type, lang, receiver) - Can return false, newMessage
PLAYER_EVENT_ON_GROUP_CHAT = 20, // (event, player, msg, Type, lang, group) - Can return false, newMessage
PLAYER_EVENT_ON_GUILD_CHAT = 21, // (event, player, msg, Type, lang, guild) - Can return false, newMessage
PLAYER_EVENT_ON_CHANNEL_CHAT = 22, // (event, player, msg, Type, lang, channel) - channel is negative for custom channels. Can return false, newMessage
PLAYER_EVENT_ON_EMOTE = 23, // (event, player, emote) - Not triggered on any known emote
PLAYER_EVENT_ON_TEXT_EMOTE = 24, // (event, player, textEmote, emoteNum, guid)
PLAYER_EVENT_ON_SAVE = 25, // (event, player)
PLAYER_EVENT_ON_BIND_TO_INSTANCE = 26, // (event, player, difficulty, mapid, permanent)
PLAYER_EVENT_ON_UPDATE_ZONE = 27, // (event, player, newZone, newArea)
PLAYER_EVENT_ON_MAP_CHANGE = 28, // (event, player)
// Custom
PLAYER_EVENT_ON_EQUIP = 29, // (event, player, item, bag, slot)
PLAYER_EVENT_ON_FIRST_LOGIN = 30, // (event, player)
PLAYER_EVENT_ON_CAN_USE_ITEM = 31, // (event, player, itemEntry) - Can return InventoryResult enum value
PLAYER_EVENT_ON_LOOT_ITEM = 32, // (event, player, item, count)
PLAYER_EVENT_ON_ENTER_COMBAT = 33, // (event, player, enemy)
PLAYER_EVENT_ON_LEAVE_COMBAT = 34, // (event, player)
PLAYER_EVENT_ON_REPOP = 35, // (event, player)
PLAYER_EVENT_ON_RESURRECT = 36, // (event, player)
PLAYER_EVENT_ON_LOOT_MONEY = 37, // (event, player, amount)
PLAYER_EVENT_ON_QUEST_ABANDON = 38, // (event, player, questId)
PLAYER_EVENT_ON_LEARN_TALENTS = 39, // (event, player, talentId, talentRank, spellid)
// UNUSED = 40, // (event, player)
// UNUSED = 41, // (event, player)
PLAYER_EVENT_ON_COMMAND = 42, // (event, player, command, chatHandler) - player is nil if command used from console. Can return false
PLAYER_EVENT_ON_PET_ADDED_TO_WORLD = 43, // (event, player, pet)
PLAYER_EVENT_ON_LEARN_SPELL = 44, // (event, player, spellId)
PLAYER_EVENT_ON_ACHIEVEMENT_COMPLETE = 45, // (event, player, achievement)
PLAYER_EVENT_ON_FFAPVP_CHANGE = 46, // (event, player, hasFfaPvp)
PLAYER_EVENT_ON_UPDATE_AREA = 47, // (event, player, oldArea, newArea)
PLAYER_EVENT_ON_CAN_INIT_TRADE = 48, // (event, player, target) - Can return false to prevent the trade
PLAYER_EVENT_ON_CAN_SEND_MAIL = 49, // (event, player, receiverGuid, mailbox, subject, body, money, cod, item) - Can return false to prevent sending the mail
PLAYER_EVENT_ON_CAN_JOIN_LFG = 50, // (event, player, roles, dungeons, comment) - Can return false to prevent queueing
PLAYER_EVENT_ON_QUEST_REWARD_ITEM = 51, // (event, player, item, count)
PLAYER_EVENT_ON_CREATE_ITEM = 52, // (event, player, item, count)
PLAYER_EVENT_ON_STORE_NEW_ITEM = 53, // (event, player, item, count)
PLAYER_EVENT_ON_COMPLETE_QUEST = 54, // (event, player, quest)
PLAYER_EVENT_ON_CAN_GROUP_INVITE = 55, // (event, player, memberName) - Can return false to prevent inviting
PLAYER_EVENT_ON_GROUP_ROLL_REWARD_ITEM = 56, // (event, player, item, count, voteType, roll)
PLAYER_EVENT_ON_BG_DESERTION = 57, // (event, player, type)
PLAYER_EVENT_ON_PET_KILL = 58, // (event, player, killer)
PLAYER_EVENT_ON_CAN_RESURRECT = 59, // (event, player)
PLAYER_EVENT_ON_CAN_UPDATE_SKILL = 60, // (event, player, skill_id) - Can return true or false
PLAYER_EVENT_ON_BEFORE_UPDATE_SKILL = 61, // (event, player, skill_id, value, max, step) -- Can return new amount
PLAYER_EVENT_ON_UPDATE_SKILL = 62, // (event, player, skill_id, value, max, step, new_value)
PLAYER_EVENT_ON_QUEST_ACCEPT = 63, // (event, player, quest)
PLAYER_EVENT_ON_AURA_APPLY = 64, // (event, player, aura)
PLAYER_EVENT_ON_HEAL = 65, // (event, player, target, gain) - Can return new heal amount
PLAYER_EVENT_ON_DAMAGE = 66, // (event, player, target, damage) - Can return new damage amount
PLAYER_EVENT_COUNT
};
enum GuildEvents
{
// Guild
GUILD_EVENT_ON_ADD_MEMBER = 1, // (event, guild, player, rank)
GUILD_EVENT_ON_REMOVE_MEMBER = 2, // (event, guild, player, isDisbanding)
GUILD_EVENT_ON_MOTD_CHANGE = 3, // (event, guild, newMotd)
GUILD_EVENT_ON_INFO_CHANGE = 4, // (event, guild, newInfo)
GUILD_EVENT_ON_CREATE = 5, // (event, guild, leader, name) // Not on TC
GUILD_EVENT_ON_DISBAND = 6, // (event, guild)
GUILD_EVENT_ON_MONEY_WITHDRAW = 7, // (event, guild, player, amount, isRepair) - Can return new money amount
GUILD_EVENT_ON_MONEY_DEPOSIT = 8, // (event, guild, player, amount) - Can return new money amount
GUILD_EVENT_ON_ITEM_MOVE = 9, // (event, guild, player, item, isSrcBank, srcContainer, srcSlotId, isDestBank, destContainer, destSlotId) // TODO
GUILD_EVENT_ON_EVENT = 10, // (event, guild, eventType, plrGUIDLow1, plrGUIDLow2, newRank) // TODO
GUILD_EVENT_ON_BANK_EVENT = 11, // (event, guild, eventType, tabId, playerGUIDLow, itemOrMoney, itemStackCount, destTabId)
GUILD_EVENT_COUNT
};
enum GroupEvents
{
// Group
GROUP_EVENT_ON_MEMBER_ADD = 1, // (event, group, guid)
GROUP_EVENT_ON_MEMBER_INVITE = 2, // (event, group, guid)
GROUP_EVENT_ON_MEMBER_REMOVE = 3, // (event, group, guid, method, kicker, reason)
GROUP_EVENT_ON_LEADER_CHANGE = 4, // (event, group, newLeaderGuid, oldLeaderGuid)
GROUP_EVENT_ON_DISBAND = 5, // (event, group)
GROUP_EVENT_ON_CREATE = 6, // (event, group, leaderGuid, groupType)
GROUP_EVENT_COUNT
};
enum VehicleEvents
{
VEHICLE_EVENT_ON_INSTALL = 1, // (event, vehicle)
VEHICLE_EVENT_ON_UNINSTALL = 2, // (event, vehicle)
// UNUSED = 3, // (event, vehicle)
VEHICLE_EVENT_ON_INSTALL_ACCESSORY = 4, // (event, vehicle, creature)
VEHICLE_EVENT_ON_ADD_PASSENGER = 5, // (event, vehicle, unit, seatId)
VEHICLE_EVENT_ON_REMOVE_PASSENGER = 6, // (event, vehicle, unit)
VEHICLE_EVENT_COUNT
};
enum CreatureEvents
{
CREATURE_EVENT_ON_ENTER_COMBAT = 1, // (event, creature, target) - Can return true to stop normal action
CREATURE_EVENT_ON_LEAVE_COMBAT = 2, // (event, creature) - Can return true to stop normal action
CREATURE_EVENT_ON_TARGET_DIED = 3, // (event, creature, victim) - Can return true to stop normal action
CREATURE_EVENT_ON_DIED = 4, // (event, creature, killer) - Can return true to stop normal action
CREATURE_EVENT_ON_SPAWN = 5, // (event, creature) - Can return true to stop normal action
CREATURE_EVENT_ON_REACH_WP = 6, // (event, creature, type, id) - Can return true to stop normal action
CREATURE_EVENT_ON_AIUPDATE = 7, // (event, creature, diff) - Can return true to stop normal action
CREATURE_EVENT_ON_RECEIVE_EMOTE = 8, // (event, creature, player, emoteid) - Can return true to stop normal action
CREATURE_EVENT_ON_DAMAGE_TAKEN = 9, // (event, creature, attacker, damage) - Can return true to stop normal action, can return new damage as second return value.
CREATURE_EVENT_ON_PRE_COMBAT = 10, // (event, creature, target) - Can return true to stop normal action
// UNUSED
CREATURE_EVENT_ON_OWNER_ATTACKED = 12, // (event, creature, target) - Can return true to stop normal action // Not on mangos
CREATURE_EVENT_ON_OWNER_ATTACKED_AT = 13, // (event, creature, attacker) - Can return true to stop normal action // Not on mangos
CREATURE_EVENT_ON_HIT_BY_SPELL = 14, // (event, creature, caster, spellid) - Can return true to stop normal action
CREATURE_EVENT_ON_SPELL_HIT_TARGET = 15, // (event, creature, target, spellid) - Can return true to stop normal action
// UNUSED = 16, // (event, creature)
// UNUSED = 17, // (event, creature)
// UNUSED = 18, // (event, creature)
CREATURE_EVENT_ON_JUST_SUMMONED_CREATURE = 19, // (event, creature, summon) - Can return true to stop normal action
CREATURE_EVENT_ON_SUMMONED_CREATURE_DESPAWN = 20, // (event, creature, summon) - Can return true to stop normal action
CREATURE_EVENT_ON_SUMMONED_CREATURE_DIED = 21, // (event, creature, summon, killer) - Can return true to stop normal action // Not on mangos
CREATURE_EVENT_ON_SUMMONED = 22, // (event, creature, summoner) - Can return true to stop normal action
CREATURE_EVENT_ON_RESET = 23, // (event, creature)
CREATURE_EVENT_ON_REACH_HOME = 24, // (event, creature) - Can return true to stop normal action
// UNUSED = 25, // (event, creature)
CREATURE_EVENT_ON_CORPSE_REMOVED = 26, // (event, creature, respawndelay) - Can return true to stop normal action, can return new respawndelay as second return value
CREATURE_EVENT_ON_MOVE_IN_LOS = 27, // (event, creature, unit) - Can return true to stop normal action. Does not actually check LOS, just uses the sight range
// UNUSED = 28, // (event, creature)
// UNUSED = 29, // (event, creature)
CREATURE_EVENT_ON_DUMMY_EFFECT = 30, // (event, caster, spellid, effindex, creature)
CREATURE_EVENT_ON_QUEST_ACCEPT = 31, // (event, player, creature, quest) - Can return true
// UNUSED = 32, // (event, creature)
// UNUSED = 33, // (event, creature)
CREATURE_EVENT_ON_QUEST_REWARD = 34, // (event, player, creature, quest, opt) - Can return true
CREATURE_EVENT_ON_DIALOG_STATUS = 35, // (event, player, creature)
CREATURE_EVENT_ON_ADD = 36, // (event, creature)
CREATURE_EVENT_ON_REMOVE = 37, // (event, creature)
CREATURE_EVENT_ON_AURA_APPLY = 38, // (event, creature, aura)
CREATURE_EVENT_ON_HEAL = 39, // (event, creature, target, gain) - Can return new heal amount
CREATURE_EVENT_ON_DAMAGE = 40, // (event, creature, target, damage) - Can return new damage amount
CREATURE_EVENT_COUNT
};
enum GameObjectEvents
{
GAMEOBJECT_EVENT_ON_AIUPDATE = 1, // (event, go, diff)
GAMEOBJECT_EVENT_ON_SPAWN = 2, // (event, go)
GAMEOBJECT_EVENT_ON_DUMMY_EFFECT = 3, // (event, caster, spellid, effindex, go) - Can return true to stop normal action
GAMEOBJECT_EVENT_ON_QUEST_ACCEPT = 4, // (event, player, go, quest) - Can return true to stop normal action
GAMEOBJECT_EVENT_ON_QUEST_REWARD = 5, // (event, player, go, quest, opt) - Can return true to stop normal action
GAMEOBJECT_EVENT_ON_DIALOG_STATUS = 6, // (event, player, go)
GAMEOBJECT_EVENT_ON_DESTROYED = 7, // (event, go, attacker)
GAMEOBJECT_EVENT_ON_DAMAGED = 8, // (event, go, attacker)
GAMEOBJECT_EVENT_ON_LOOT_STATE_CHANGE = 9, // (event, go, state)
GAMEOBJECT_EVENT_ON_GO_STATE_CHANGED = 10, // (event, go, state)
// UNUSED = 11, // (event, gameobject)
GAMEOBJECT_EVENT_ON_ADD = 12, // (event, gameobject)
GAMEOBJECT_EVENT_ON_REMOVE = 13, // (event, gameobject)
GAMEOBJECT_EVENT_ON_USE = 14, // (event, go, player) - Can return true to stop normal action
GAMEOBJECT_EVENT_COUNT
};
enum ItemEvents
{
ITEM_EVENT_ON_DUMMY_EFFECT = 1, // (event, caster, spellid, effindex, item)
ITEM_EVENT_ON_USE = 2, // (event, player, item, target) - Can return false to stop the spell casting
ITEM_EVENT_ON_QUEST_ACCEPT = 3, // (event, player, item, quest) - Can return true
ITEM_EVENT_ON_EXPIRE = 4, // (event, player, itemid) - Can return true
ITEM_EVENT_ON_REMOVE = 5, // (event, player, item) - Can return true
ITEM_EVENT_COUNT
};
enum GossipEvents
{
GOSSIP_EVENT_ON_HELLO = 1, // (event, player, object) - Object is the Creature/GameObject/Item. Can return false to do default action. For item gossip can return false to stop spell casting.
GOSSIP_EVENT_ON_SELECT = 2, // (event, player, object, sender, intid, code, menu_id) - Object is the Creature/GameObject/Item/Player, menu_id is only for player gossip. Can return false to do default action.
GOSSIP_EVENT_COUNT
};
enum BGEvents
{
BG_EVENT_ON_START = 1, // (event, bg, bgId, instanceId) - Needs to be added to TC
BG_EVENT_ON_END = 2, // (event, bg, bgId, instanceId, winner) - Needs to be added to TC
BG_EVENT_ON_CREATE = 3, // (event, bg, bgId, instanceId) - Needs to be added to TC
BG_EVENT_ON_PRE_DESTROY = 4, // (event, bg, bgId, instanceId) - Needs to be added to TC
BG_EVENT_COUNT
};
enum InstanceEvents
{
INSTANCE_EVENT_ON_INITIALIZE = 1, // (event, instance_data, map)
INSTANCE_EVENT_ON_LOAD = 2, // (event, instance_data, map)
INSTANCE_EVENT_ON_UPDATE = 3, // (event, instance_data, map, diff)
INSTANCE_EVENT_ON_PLAYER_ENTER = 4, // (event, instance_data, map, player)
INSTANCE_EVENT_ON_CREATURE_CREATE = 5, // (event, instance_data, map, creature)
INSTANCE_EVENT_ON_GAMEOBJECT_CREATE = 6, // (event, instance_data, map, go)
INSTANCE_EVENT_ON_CHECK_ENCOUNTER_IN_PROGRESS = 7, // (event, instance_data, map)
INSTANCE_EVENT_COUNT
};
enum TicketEvents
{
TICKET_EVENT_ON_CREATE = 1, // (event, ticket)
TICKET_EVENT_UPDATE_LAST_CHANGE = 2, // (event, ticket, message)
TICKET_EVENT_ON_CLOSE = 3, // (event, ticket)
TICKET_EVENT_ON_RESOLVE = 4, // (event, ticket)
TICKET_EVENT_COUNT
};
enum SpellEvents
{
SPELL_EVENT_ON_PREPARE = 1, // (event, caster, spell)
SPELL_EVENT_ON_CAST = 2, // (event, caster, spell, skipCheck)
SPELL_EVENT_ON_CAST_CANCEL = 3, // (event, caster, spell, bySelf)
SPELL_EVENT_COUNT
};
};
#endif // _HOOKS_H
modules/mod-eluna/src/LuaEngine/HttpManager.cpp
+275
View File
@@ -0,0 +1,275 @@
#include <thread>
extern "C"
{
#include "lua.h"
#include "lauxlib.h"
};
#define CPPHTTPLIB_OPENSSL_SUPPORT
#include "libs/httplib.h"
#include "HttpManager.h"
#include "LuaEngine.h"
HttpWorkItem::HttpWorkItem(int funcRef, const std::string& httpVerb, const std::string& url, const std::string& body, const std::string& contentType, const httplib::Headers& headers)
: funcRef(funcRef),
httpVerb(httpVerb),
url(url),
body(body),
contentType(contentType),
headers(headers)
{ }
HttpResponse::HttpResponse(int funcRef, int statusCode, const std::string& body, const httplib::Headers& headers)
: funcRef(funcRef),
statusCode(statusCode),
body(body),
headers(headers)
{ }
HttpManager::HttpManager()
: workQueue(16),
responseQueue(16),
startedWorkerThread(false),
cancelationToken(false),
condVar(),
condVarMutex(),
parseUrlRegex("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?")
{
StartHttpWorker();
}
HttpManager::~HttpManager()
{
StopHttpWorker();
}
void HttpManager::PushRequest(HttpWorkItem* item)
{
std::unique_lock<std::mutex> lock(condVarMutex);
workQueue.push(item);
condVar.notify_one();
}
void HttpManager::StartHttpWorker()
{
ClearQueues();
if (!startedWorkerThread)
{
cancelationToken.store(false);
workerThread = std::thread(&HttpManager::HttpWorkerThread, this);
startedWorkerThread = true;
}
}
void HttpManager::ClearQueues()
{
while (workQueue.front())
{
HttpWorkItem* item = *workQueue.front();
if (item != nullptr)
{
delete item;
}
workQueue.pop();
}
while (responseQueue.front())
{
HttpResponse* item = *responseQueue.front();
if (item != nullptr)
{
delete item;
}
responseQueue.pop();
}
}
void HttpManager::StopHttpWorker()
{
if (!startedWorkerThread)
{
return;
}
cancelationToken.store(true);
condVar.notify_one();
workerThread.join();
ClearQueues();
startedWorkerThread = false;
}
void HttpManager::HttpWorkerThread()
{
while (true)
{
{
std::unique_lock<std::mutex> lock(condVarMutex);
condVar.wait(lock, [&] { return workQueue.front() != nullptr || cancelationToken.load(); });
}
if (cancelationToken.load())
{
break;
}
if (!workQueue.front())
{
continue;
}
HttpWorkItem* req = *workQueue.front();
workQueue.pop();
if (!req)
{
continue;
}
try
{
std::string host;
std::string path;
if (!ParseUrl(req->url, host, path)) {
ELUNA_LOG_ERROR("[Eluna]: Could not parse URL {}", req->url);
continue;
}
httplib::Client cli(host);
cli.set_connection_timeout(0, 3000000); // 3 seconds
cli.set_read_timeout(5, 0); // 5 seconds
cli.set_write_timeout(5, 0); // 5 seconds
httplib::Result res = DoRequest(cli, req, path);
httplib::Error err = res.error();
if (err != httplib::Error::Success)
{
ELUNA_LOG_ERROR("[Eluna]: HTTP request error: {}", httplib::to_string(err));
continue;
}
if (res->status == 301)
{
std::string location = res->get_header_value("Location");
std::string host;
std::string path;
if (!ParseUrl(location, host, path))
{
ELUNA_LOG_ERROR("[Eluna]: Could not parse URL after redirect: {}", location);
continue;
}
httplib::Client cli2(host);
cli2.set_connection_timeout(0, 3000000); // 3 seconds
cli2.set_read_timeout(5, 0); // 5 seconds
cli2.set_write_timeout(5, 0); // 5 seconds
res = DoRequest(cli2, req, path);
}
responseQueue.push(new HttpResponse(req->funcRef, res->status, res->body, res->headers));
}
catch (const std::exception& ex)
{
ELUNA_LOG_ERROR("[Eluna]: HTTP request error: {}", ex.what());
}
delete req;
}
}
httplib::Result HttpManager::DoRequest(httplib::Client& client, HttpWorkItem* req, const std::string& urlPath)
{
const char* path = urlPath.c_str();
if (req->httpVerb == "GET")
{
return client.Get(path, req->headers);
}
if (req->httpVerb == "HEAD")
{
return client.Head(path, req->headers);
}
if (req->httpVerb == "POST")
{
return client.Post(path, req->headers, req->body, req->contentType.c_str());
}
if (req->httpVerb == "PUT")
{
return client.Put(path, req->headers, req->body, req->contentType.c_str());
}
if (req->httpVerb == "PATCH")
{
return client.Patch(path, req->headers, req->body, req->contentType.c_str());
}
if (req->httpVerb == "DELETE")
{
return client.Delete(path, req->headers);
}
if (req->httpVerb == "OPTIONS")
{
return client.Options(path, req->headers);
}
ELUNA_LOG_ERROR("[Eluna]: HTTP request error: invalid HTTP verb {}", req->httpVerb);
return client.Get(path, req->headers);
}
bool HttpManager::ParseUrl(const std::string& url, std::string& host, std::string& path)
{
std::smatch matches;
if (!std::regex_search(url, matches, parseUrlRegex))
{
return false;
}
std::string scheme = matches[2];
std::string authority = matches[4];
std::string query = matches[7];
host = scheme + "://" + authority;
path = matches[5];
if (path.empty())
{
path = "/";
}
path += (query.empty() ? "" : "?") + query;
return true;
}
void HttpManager::HandleHttpResponses()
{
while (!responseQueue.empty())
{
HttpResponse* res = *responseQueue.front();
responseQueue.pop();
if (res == nullptr)
{
continue;
}
LOCK_ELUNA;
lua_State* L = Eluna::GEluna->L;
// Get function
lua_rawgeti(L, LUA_REGISTRYINDEX, res->funcRef);
// Push parameters
Eluna::Push(L, res->statusCode);
Eluna::Push(L, res->body);
lua_newtable(L);
for (const auto& item : res->headers) {
Eluna::Push(L, item.first);
Eluna::Push(L, item.second);
lua_settable(L, -3);
}
// Call function
Eluna::GEluna->ExecuteCall(3, 0);
luaL_unref(L, LUA_REGISTRYINDEX, res->funcRef);
delete res;
}
}
modules/mod-eluna/src/LuaEngine/HttpManager.h
+61
View File
@@ -0,0 +1,61 @@
#ifndef ELUNA_HTTP_MANAGER_H
#define ELUNA_HTTP_MANAGER_H
#include <regex>
#include "libs/httplib.h"
#include "libs/rigtorp/SPSCQueue.h"
struct HttpWorkItem
{
public:
HttpWorkItem(int funcRef, const std::string& httpVerb, const std::string& url, const std::string& body, const std::string &contentType, const httplib::Headers& headers);
int funcRef;
std::string httpVerb;
std::string url;
std::string body;
std::string contentType;
httplib::Headers headers;
};
struct HttpResponse
{
public:
HttpResponse(int funcRef, int statusCode, const std::string& body, const httplib::Headers& headers);
int funcRef;
int statusCode;
std::string body;
httplib::Headers headers;
};
class HttpManager
{
public:
HttpManager();
~HttpManager();
void StartHttpWorker();
void StopHttpWorker();
void PushRequest(HttpWorkItem* item);
void HandleHttpResponses();
private:
void ClearQueues();
void HttpWorkerThread();
bool ParseUrl(const std::string& url, std::string& host, std::string& path);
httplib::Result DoRequest(httplib::Client& client, HttpWorkItem* req, const std::string& path);
rigtorp::SPSCQueue<HttpWorkItem*> workQueue;
rigtorp::SPSCQueue<HttpResponse*> responseQueue;
std::thread workerThread;
bool startedWorkerThread;
std::atomic_bool cancelationToken;
std::condition_variable condVar;
std::mutex condVarMutex;
std::regex parseUrlRegex;
};
#endif // #ifndef ELUNA_HTTP_MANAGER_H
modules/mod-eluna/src/LuaEngine/LuaEngine.cpp
+1699
View File
File diff suppressed because it is too large Load Diff
modules/mod-eluna/src/LuaEngine/LuaEngine.h
+598
View File
@@ -0,0 +1,598 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#ifndef _LUA_ENGINE_H
#define _LUA_ENGINE_H
#include "Common.h"
#include "SharedDefines.h"
#include "DBCEnums.h"
#include "Group.h"
#include "Item.h"
#include "Chat.h"
#include "Player.h"
#include "Weather.h"
#include "World.h"
#include "Hooks.h"
#include "LFG.h"
#include "ElunaUtility.h"
#include "HttpManager.h"
#include "EventEmitter.h"
#include "TicketMgr.h"
#include "LootMgr.h"
#include "ElunaFileWatcher.h"
#include "ElunaConfig.h"
#include <mutex>
#include <memory>
#include <vector>
#include <ctime>
#include <unordered_map>
extern "C"
{
#include "lua.h"
};
struct ItemTemplate;
typedef BattlegroundTypeId BattleGroundTypeId;
typedef AreaTrigger AreaTriggerEntry;
class AuctionHouseObject;
struct AuctionEntry;
class Battleground;
typedef Battleground BattleGround;
class Channel;
class Corpse;
class Creature;
class CreatureAI;
class GameObject;
class GameObjectAI;
class Guild;
class Group;
class InstanceScript;
typedef InstanceScript InstanceData;
class ElunaInstanceAI;
class Item;
class Pet;
class Player;
class Quest;
class Spell;
class SpellCastTargets;
class TempSummon;
// class Transport;
class Unit;
class Weather;
class WorldPacket;
class Vehicle;
struct lua_State;
class EventMgr;
class ElunaObject;
template<typename T> class ElunaTemplate;
template<typename K> class BindingMap;
template<typename T> struct EventKey;
template<typename T> struct EntryKey;
template<typename T> struct UniqueObjectKey;
// Type definition for bytecode buffer
typedef std::vector<uint8> BytecodeBuffer;
// Global bytecode cache entry
struct GlobalCacheEntry
{
BytecodeBuffer bytecode;
std::time_t last_modified;
std::string filepath;
GlobalCacheEntry() : last_modified(0) {}
GlobalCacheEntry(const BytecodeBuffer& code, std::time_t modTime, const std::string& path)
: bytecode(code), last_modified(modTime), filepath(path) {}
};
struct LuaScript
{
std::string fileext;
std::string filename;
std::string filepath;
std::string modulepath;
LuaScript() {}
};
#define ELUNA_STATE_PTR "Eluna State Ptr"
#define LOCK_ELUNA Eluna::Guard __guard(Eluna::GetLock())
#define ELUNA_GAME_API AC_GAME_API
class ELUNA_GAME_API Eluna
{
public:
typedef std::list<LuaScript> ScriptList;
typedef std::recursive_mutex LockType;
typedef std::lock_guard<LockType> Guard;
const std::string& GetRequirePath() const { return lua_requirepath; }
const std::string& GetRequireCPath() const { return lua_requirecpath; }
private:
static bool reload;
static bool initialized;
static LockType lock;
static std::unique_ptr<ElunaFileWatcher> fileWatcher;
// Lua script locations
static ScriptList lua_scripts;
static ScriptList lua_extensions;
// Lua script folder path
static std::string lua_folderpath;
// lua path variable for require() function
static std::string lua_requirepath;
static std::string lua_requirecpath;
// A counter for lua event stacks that occur (see event_level).
// This is used to determine whether an object belongs to the current call stack or not.
// 0 is reserved for always belonging to the call stack
// 1 is reserved for a non valid callstackid
uint64 callstackid = 2;
// A counter for the amount of nested events. When the event_level
// reaches 0 we are about to return back to C++. At this point the
// objects used during the event stack are invalidated.
uint32 event_level;
// When a hook pushes arguments to be passed to event handlers,
// this is used to keep track of how many arguments were pushed.
uint8 push_counter;
// Map from instance ID -> Lua table ref
std::unordered_map<uint32, int> instanceDataRefs;
// Map from map ID -> Lua table ref
std::unordered_map<uint32, int> continentDataRefs;
Eluna();
~Eluna();
// Prevent copy
Eluna(Eluna const&) = delete;
Eluna& operator=(const Eluna&) = delete;
void OpenLua();
void CloseLua();
void DestroyBindStores();
void CreateBindStores();
void InvalidateObjects();
// Use ReloadEluna() to make eluna reload
// This is called on world update to reload eluna
static void _ReloadEluna();
static void LoadScriptPaths();
static void GetScripts(std::string path);
static void AddScriptPath(std::string filename, const std::string& fullpath);
static int LoadCompiledScript(lua_State* L, const std::string& filepath);
static std::time_t GetFileModTime(const std::string& filepath);
static std::time_t GetFileModTimeWithCache(const std::string& filepath);
// Global cache management
static bool CompileScriptToGlobalCache(const std::string& filepath);
static bool CompileMoonScriptToGlobalCache(const std::string& filepath);
static int TryLoadFromGlobalCache(lua_State* L, const std::string& filepath);
static int LoadScriptWithCache(lua_State* L, const std::string& filepath, bool isMoonScript, uint32* compiledCount = nullptr, uint32* cachedCount = nullptr);
static void ClearGlobalCache();
static void ClearTimestampCache();
static size_t GetGlobalCacheSize();
static int StackTrace(lua_State *_L);
static void Report(lua_State* _L);
// Some helpers for hooks to call event handlers.
// The bodies of the templates are in HookHelpers.h, so if you want to use them you need to #include "HookHelpers.h".
template<typename K1, typename K2> int SetupStack(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, int number_of_arguments);
int CallOneFunction(int number_of_functions, int number_of_arguments, int number_of_results);
void CleanUpStack(int number_of_arguments);
template<typename T> void ReplaceArgument(T value, uint8 index);
template<typename K1, typename K2> void CallAllFunctions(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2);
template<typename K1, typename K2> bool CallAllFunctionsBool(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, bool default_value = false);
// Same as above but for only one binding instead of two.
// `key` is passed twice because there's no NULL for references, but it's not actually used if `bindings2` is NULL.
template<typename K> int SetupStack(BindingMap<K>* bindings, const K& key, int number_of_arguments)
{
return SetupStack<K, K>(bindings, NULL, key, key, number_of_arguments);
}
template<typename K> void CallAllFunctions(BindingMap<K>* bindings, const K& key)
{
CallAllFunctions<K, K>(bindings, NULL, key, key);
}
template<typename K> bool CallAllFunctionsBool(BindingMap<K>* bindings, const K& key, bool default_value = false)
{
return CallAllFunctionsBool<K, K>(bindings, NULL, key, key, default_value);
}
// Non-static pushes, to be used in hooks.
// These just call the correct static version with the main thread's Lua state.
void Push() { Push(L); ++push_counter; }
void Push(const long long value) { Push(L, value); ++push_counter; }
void Push(const unsigned long long value) { Push(L, value); ++push_counter; }
void Push(const long value) { Push(L, value); ++push_counter; }
void Push(const unsigned long value) { Push(L, value); ++push_counter; }
void Push(const int value) { Push(L, value); ++push_counter; }
void Push(const unsigned int value) { Push(L, value); ++push_counter; }
void Push(const bool value) { Push(L, value); ++push_counter; }
void Push(const float value) { Push(L, value); ++push_counter; }
void Push(const double value) { Push(L, value); ++push_counter; }
void Push(const std::string& value) { Push(L, value); ++push_counter; }
void Push(const char* value) { Push(L, value); ++push_counter; }
void Push(ObjectGuid const value) { Push(L, value); ++push_counter; }
template<typename T>
void Push(T const* ptr) { Push(L, ptr); ++push_counter; }
public:
static Eluna* GEluna;
lua_State* L;
EventMgr* eventMgr;
HttpManager httpManager;
QueryCallbackProcessor queryProcessor;
EventEmitter<void(std::string)> OnError;
BindingMap< EventKey<Hooks::ServerEvents> >* ServerEventBindings;
BindingMap< EventKey<Hooks::PlayerEvents> >* PlayerEventBindings;
BindingMap< EventKey<Hooks::GuildEvents> >* GuildEventBindings;
BindingMap< EventKey<Hooks::GroupEvents> >* GroupEventBindings;
BindingMap< EventKey<Hooks::VehicleEvents> >* VehicleEventBindings;
BindingMap< EventKey<Hooks::BGEvents> >* BGEventBindings;
BindingMap< EntryKey<Hooks::PacketEvents> >* PacketEventBindings;
BindingMap< EntryKey<Hooks::CreatureEvents> >* CreatureEventBindings;
BindingMap< EntryKey<Hooks::GossipEvents> >* CreatureGossipBindings;
BindingMap< EntryKey<Hooks::GameObjectEvents> >* GameObjectEventBindings;
BindingMap< EntryKey<Hooks::GossipEvents> >* GameObjectGossipBindings;
BindingMap< EntryKey<Hooks::ItemEvents> >* ItemEventBindings;
BindingMap< EntryKey<Hooks::GossipEvents> >* ItemGossipBindings;
BindingMap< EntryKey<Hooks::GossipEvents> >* PlayerGossipBindings;
BindingMap< EntryKey<Hooks::InstanceEvents> >* MapEventBindings;
BindingMap< EntryKey<Hooks::InstanceEvents> >* InstanceEventBindings;
BindingMap< EventKey<Hooks::TicketEvents> >* TicketEventBindings;
BindingMap< EntryKey<Hooks::SpellEvents> >* SpellEventBindings;
BindingMap< UniqueObjectKey<Hooks::CreatureEvents> >* CreatureUniqueBindings;
static void Initialize();
static void Uninitialize();
// This function is used to make eluna reload
static void ReloadEluna() { LOCK_ELUNA; reload = true; }
static LockType& GetLock() { return lock; };
static bool IsInitialized() { return initialized; }
// Never returns nullptr
static Eluna* GetEluna(lua_State* L)
{
lua_pushstring(L, ELUNA_STATE_PTR);
lua_rawget(L, LUA_REGISTRYINDEX);
ASSERT(lua_islightuserdata(L, -1));
Eluna* E = static_cast<Eluna*>(lua_touserdata(L, -1));
lua_pop(L, 1);
ASSERT(E);
return E;
}
// Static pushes, can be used by anything, including methods.
static void Push(lua_State* luastate); // nil
static void Push(lua_State* luastate, const long long);
static void Push(lua_State* luastate, const unsigned long long);
static void Push(lua_State* luastate, const long);
static void Push(lua_State* luastate, const unsigned long);
static void Push(lua_State* luastate, const int);
static void Push(lua_State* luastate, const unsigned int);
static void Push(lua_State* luastate, const bool);
static void Push(lua_State* luastate, const float);
static void Push(lua_State* luastate, const double);
static void Push(lua_State* luastate, const std::string&);
static void Push(lua_State* luastate, const char*);
static void Push(lua_State* luastate, Object const* obj);
static void Push(lua_State* luastate, WorldObject const* obj);
static void Push(lua_State* luastate, Unit const* unit);
static void Push(lua_State* luastate, Pet const* pet);
static void Push(lua_State* luastate, TempSummon const* summon);
static void Push(lua_State* luastate, ObjectGuid const guid);
static void Push(lua_State* luastate, GemPropertiesEntry const& gemProperties);
static void Push(lua_State* luastate, SpellEntry const& spell);
template<typename T>
static void Push(lua_State* luastate, T const* ptr)
{
ElunaTemplate<T>::Push(luastate, ptr);
}
static std::string FormatQuery(lua_State* L, const char* query);
bool ExecuteCall(int params, int res);
/*
* Returns `true` if Eluna has instance data for `map`.
*/
bool HasInstanceData(Map const* map);
/*
* Use the top element of the stack as the instance data table for `map`,
* then pops it off the stack.
*/
void CreateInstanceData(Map const* map);
/*
* Retrieve the instance data for the `Map` scripted by `ai` and push it
* onto the stack.
*
* An `ElunaInstanceAI` is needed because the instance data might
* not exist (i.e. Eluna has been reloaded).
*
* In that case, the AI is "reloaded" (new instance data table is created
* and loaded with the last known save state, and `Load`/`Initialize`
* hooks are called).
*/
void PushInstanceData(lua_State* L, ElunaInstanceAI* ai, bool incrementCounter = true);
void RunScripts();
bool ShouldReload() const { return reload; }
bool HasLuaState() const { return L != NULL; }
uint64 GetCallstackId() const { return callstackid; }
int Register(lua_State* L, uint8 reg, uint32 entry, ObjectGuid guid, uint32 instanceId, uint32 event_id, int functionRef, uint32 shots);
// Checks
template<typename T> static T CHECKVAL(lua_State* luastate, int narg);
template<typename T> static T CHECKVAL(lua_State* luastate, int narg, T def)
{
return lua_isnoneornil(luastate, narg) ? def : CHECKVAL<T>(luastate, narg);
}
template<typename T> static T* CHECKOBJ(lua_State* luastate, int narg, bool error = true)
{
return ElunaTemplate<T>::Check(luastate, narg, error);
}
static ElunaObject* CHECKTYPE(lua_State* luastate, int narg, const char *tname, bool error = true);
CreatureAI* GetAI(Creature* creature);
InstanceData* GetInstanceData(Map* map);
void FreeInstanceId(uint32 instanceId);
/* Custom */
void OnTimedEvent(int funcRef, uint32 delay, uint32 calls, WorldObject* obj);
bool OnCommand(ChatHandler& handler, const char* text);
void OnWorldUpdate(uint32 diff);
void OnLootItem(Player* pPlayer, Item* pItem, uint32 count, ObjectGuid guid);
void OnLootMoney(Player* pPlayer, uint32 amount);
void OnFirstLogin(Player* pPlayer);
void OnEquip(Player* pPlayer, Item* pItem, uint8 bag, uint8 slot);
void OnRepop(Player* pPlayer);
void OnResurrect(Player* pPlayer);
void OnQuestAbandon(Player* pPlayer, uint32 questId);
void OnLearnTalents(Player* pPlayer, uint32 talentId, uint32 talentRank, uint32 spellid);
InventoryResult OnCanUseItem(const Player* pPlayer, uint32 itemEntry);
void OnLuaStateClose();
void OnLuaStateOpen();
bool OnAddonMessage(Player* sender, uint32 type, std::string& msg, Player* receiver, Guild* guild, Group* group, Channel* channel);
void OnPetAddedToWorld(Player* player, Creature* pet);
void OnQuestRewardItem(Player* player, Item* item, uint32 count);
void OnCreateItem(Player* player, Item* item, uint32 count);
void OnStoreNewItem(Player* player, Item* item, uint32 count);
void OnPlayerCompleteQuest(Player* player, Quest const* quest);
/* Item */
void OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, Item* pTarget);
bool OnQuestAccept(Player* pPlayer, Item* pItem, Quest const* pQuest);
bool OnUse(Player* pPlayer, Item* pItem, SpellCastTargets const& targets);
bool OnItemUse(Player* pPlayer, Item* pItem, SpellCastTargets const& targets);
bool OnItemGossip(Player* pPlayer, Item* pItem, SpellCastTargets const& targets);
bool OnExpire(Player* pPlayer, ItemTemplate const* pProto);
bool OnRemove(Player* pPlayer, Item* item);
void HandleGossipSelectOption(Player* pPlayer, Item* item, uint32 sender, uint32 action, const std::string& code);
/* Creature */
void OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, Creature* pTarget);
bool OnGossipHello(Player* pPlayer, Creature* pCreature);
bool OnGossipSelect(Player* pPlayer, Creature* pCreature, uint32 sender, uint32 action);
bool OnGossipSelectCode(Player* pPlayer, Creature* pCreature, uint32 sender, uint32 action, const char* code);
bool OnQuestAccept(Player* pPlayer, Creature* pCreature, Quest const* pQuest);
bool OnQuestReward(Player* pPlayer, Creature* pCreature, Quest const* pQuest, uint32 opt);
void GetDialogStatus(const Player* pPlayer, const Creature* pCreature);
bool OnSummoned(Creature* creature, Unit* summoner);
bool UpdateAI(Creature* me, const uint32 diff);
bool EnterCombat(Creature* me, Unit* target);
bool DamageTaken(Creature* me, Unit* attacker, uint32& damage);
bool JustDied(Creature* me, Unit* killer);
bool KilledUnit(Creature* me, Unit* victim);
bool JustSummoned(Creature* me, Creature* summon);
bool SummonedCreatureDespawn(Creature* me, Creature* summon);
bool MovementInform(Creature* me, uint32 type, uint32 id);
bool AttackStart(Creature* me, Unit* target);
bool EnterEvadeMode(Creature* me);
bool JustRespawned(Creature* me);
bool JustReachedHome(Creature* me);
bool ReceiveEmote(Creature* me, Player* player, uint32 emoteId);
bool CorpseRemoved(Creature* me, uint32& respawnDelay);
bool MoveInLineOfSight(Creature* me, Unit* who);
bool SpellHit(Creature* me, WorldObject* caster, SpellInfo const* spell);
bool SpellHitTarget(Creature* me, WorldObject* target, SpellInfo const* spell);
bool SummonedCreatureDies(Creature* me, Creature* summon, Unit* killer);
bool OwnerAttackedBy(Creature* me, Unit* attacker);
bool OwnerAttacked(Creature* me, Unit* target);
void On_Reset(Creature* me);
void OnCreatureAuraApply(Creature* me, Aura* aura);
void OnCreatureHeal(Creature* me, Unit* target, uint32& gain);
void OnCreatureDamage(Creature* me, Unit* target, uint32& gain);
/* GameObject */
void OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, GameObject* pTarget);
bool OnGameObjectUse(Player* pPlayer, GameObject* pGameObject);
bool OnGossipHello(Player* pPlayer, GameObject* pGameObject);
bool OnGossipSelect(Player* pPlayer, GameObject* pGameObject, uint32 sender, uint32 action);
bool OnGossipSelectCode(Player* pPlayer, GameObject* pGameObject, uint32 sender, uint32 action, const char* code);
bool OnQuestAccept(Player* pPlayer, GameObject* pGameObject, Quest const* pQuest);
bool OnQuestReward(Player* pPlayer, GameObject* pGameObject, Quest const* pQuest, uint32 opt);
void GetDialogStatus(const Player* pPlayer, const GameObject* pGameObject);
void OnDestroyed(GameObject* pGameObject, WorldObject* attacker);
void OnDamaged(GameObject* pGameObject, WorldObject* attacker);
void OnLootStateChanged(GameObject* pGameObject, uint32 state);
void OnGameObjectStateChanged(GameObject* pGameObject, uint32 state);
void UpdateAI(GameObject* pGameObject, uint32 diff);
void OnSpawn(GameObject* gameobject);
/* Packet */
bool OnPacketSend(WorldSession* session, const WorldPacket& packet);
void OnPacketSendAny(Player* player, const WorldPacket& packet, bool& result);
void OnPacketSendOne(Player* player, const WorldPacket& packet, bool& result);
bool OnPacketReceive(WorldSession* session, WorldPacket& packet);
void OnPacketReceiveAny(Player* player, WorldPacket& packet, bool& result);
void OnPacketReceiveOne(Player* player, WorldPacket& packet, bool& result);
/* Player */
void OnPlayerEnterCombat(Player* pPlayer, Unit* pEnemy);
void OnPlayerLeaveCombat(Player* pPlayer);
void OnPVPKill(Player* pKiller, Player* pKilled);
void OnCreatureKill(Player* pKiller, Creature* pKilled);
void OnPlayerKilledByCreature(Creature* pKiller, Player* pKilled);
void OnLevelChanged(Player* pPlayer, uint8 oldLevel);
void OnFreeTalentPointsChanged(Player* pPlayer, uint32 newPoints);
void OnTalentsReset(Player* pPlayer, bool noCost);
void OnMoneyChanged(Player* pPlayer, int32& amount);
void OnGiveXP(Player* pPlayer, uint32& amount, Unit* pVictim, uint8 xpSource);
bool OnReputationChange(Player* pPlayer, uint32 factionID, int32& standing, bool incremental);
void OnDuelRequest(Player* pTarget, Player* pChallenger);
void OnDuelStart(Player* pStarter, Player* pChallenger);
void OnDuelEnd(Player* pWinner, Player* pLoser, DuelCompleteType type);
bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg);
bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Group* pGroup);
bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Guild* pGuild);
bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Channel* pChannel);
bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Player* pReceiver);
void OnEmote(Player* pPlayer, uint32 emote);
void OnTextEmote(Player* pPlayer, uint32 textEmote, uint32 emoteNum, ObjectGuid guid);
void OnPlayerSpellCast(Player* pPlayer, Spell* pSpell, bool skipCheck);
void OnLogin(Player* pPlayer);
void OnLogout(Player* pPlayer);
void OnCreate(Player* pPlayer);
void OnDelete(uint32 guid);
void OnSave(Player* pPlayer);
void OnBindToInstance(Player* pPlayer, Difficulty difficulty, uint32 mapid, bool permanent);
void OnUpdateArea(Player* pPlayer, uint32 oldArea, uint32 newArea);
void OnUpdateZone(Player* pPlayer, uint32 newZone, uint32 newArea);
void OnMapChanged(Player* pPlayer);
void HandleGossipSelectOption(Player* pPlayer, uint32 menuId, uint32 sender, uint32 action, const std::string& code);
void OnLearnSpell(Player* player, uint32 spellId);
void OnAchiComplete(Player* player, AchievementEntry const* achievement);
void OnFfaPvpStateUpdate(Player* player, bool hasFfaPvp);
bool OnCanInitTrade(Player* player, Player* target);
bool OnCanSendMail(Player* player, ObjectGuid receiverGuid, ObjectGuid mailbox, std::string& subject, std::string& body, uint32 money, uint32 cod, Item* item);
bool OnCanJoinLfg(Player* player, uint8 roles, lfg::LfgDungeonSet& dungeons, const std::string& comment);
bool OnCanGroupInvite(Player* player, std::string& memberName);
void OnGroupRollRewardItem(Player* player, Item* item, uint32 count, RollVote voteType, Roll* roll);
void OnBattlegroundDesertion(Player* player, const BattlegroundDesertionType type);
void OnCreatureKilledByPet(Player* player, Creature* killed);
bool OnPlayerCanUpdateSkill(Player* player, uint32 skill_id);
void OnPlayerBeforeUpdateSkill(Player* player, uint32 skill_id, uint32& value, uint32 max, uint32 step);
void OnPlayerUpdateSkill(Player* player, uint32 skill_id, uint32 value, uint32 max, uint32 step, uint32 new_value);
bool CanPlayerResurrect(Player* player);
void OnPlayerQuestAccept(Player* player, Quest const* quest);
void OnPlayerAuraApply(Player* player, Aura* aura);
void OnPlayerHeal(Player* player, Unit* target, uint32& gain);
void OnPlayerDamage(Player* player, Unit* target, uint32& gain);
/* Vehicle */
void OnInstall(Vehicle* vehicle);
void OnUninstall(Vehicle* vehicle);
void OnInstallAccessory(Vehicle* vehicle, Creature* accessory);
void OnAddPassenger(Vehicle* vehicle, Unit* passenger, int8 seatId);
void OnRemovePassenger(Vehicle* vehicle, Unit* passenger);
/* AreaTrigger */
bool OnAreaTrigger(Player* pPlayer, AreaTriggerEntry const* pTrigger);
/* Weather */
void OnChange(Weather* weather, uint32 zone, WeatherState state, float grade);
/* Auction House */
void OnAdd(AuctionHouseObject* ah, AuctionEntry* entry);
void OnRemove(AuctionHouseObject* ah, AuctionEntry* entry);
void OnSuccessful(AuctionHouseObject* ah, AuctionEntry* entry);
void OnExpire(AuctionHouseObject* ah, AuctionEntry* entry);
/* Guild */
void OnAddMember(Guild* guild, Player* player, uint32 plRank);
void OnRemoveMember(Guild* guild, Player* player, bool isDisbanding);
void OnMOTDChanged(Guild* guild, const std::string& newMotd);
void OnInfoChanged(Guild* guild, const std::string& newInfo);
void OnCreate(Guild* guild, Player* leader, const std::string& name);
void OnDisband(Guild* guild);
void OnMemberWitdrawMoney(Guild* guild, Player* player, uint32& amount, bool isRepair);
void OnMemberDepositMoney(Guild* guild, Player* player, uint32& amount);
void OnItemMove(Guild* guild, Player* player, Item* pItem, bool isSrcBank, uint8 srcContainer, uint8 srcSlotId, bool isDestBank, uint8 destContainer, uint8 destSlotId);
void OnEvent(Guild* guild, uint8 eventType, uint32 playerGuid1, uint32 playerGuid2, uint8 newRank);
void OnBankEvent(Guild* guild, uint8 eventType, uint8 tabId, uint32 playerGuid, uint32 itemOrMoney, uint16 itemStackCount, uint8 destTabId);
/* Group */
void OnAddMember(Group* group, ObjectGuid guid);
void OnInviteMember(Group* group, ObjectGuid guid);
void OnRemoveMember(Group* group, ObjectGuid guid, uint8 method);
void OnChangeLeader(Group* group, ObjectGuid newLeaderGuid, ObjectGuid oldLeaderGuid);
void OnDisband(Group* group);
void OnCreate(Group* group, ObjectGuid leaderGuid, GroupType groupType);
/* Map */
void OnCreate(Map* map);
void OnDestroy(Map* map);
void OnPlayerEnter(Map* map, Player* player);
void OnPlayerLeave(Map* map, Player* player);
void OnUpdate(Map* map, uint32 diff);
void OnAddToWorld(Creature* creature);
void OnRemoveFromWorld(Creature* creature);
void OnAddToWorld(GameObject* gameobject);
void OnRemoveFromWorld(GameObject* gameobject);
void OnRemove(Creature* creature);
void OnRemove(GameObject* gameobject);
/* Instance */
void OnInitialize(ElunaInstanceAI* ai);
void OnLoad(ElunaInstanceAI* ai);
void OnUpdateInstance(ElunaInstanceAI* ai, uint32 diff);
void OnPlayerEnterInstance(ElunaInstanceAI* ai, Player* player);
void OnCreatureCreate(ElunaInstanceAI* ai, Creature* creature);
void OnGameObjectCreate(ElunaInstanceAI* ai, GameObject* gameobject);
bool OnCheckEncounterInProgress(ElunaInstanceAI* ai);
/* World */
void OnOpenStateChange(bool open);
void OnAfterConfigLoad(bool reload);
void OnShutdownInitiate(ShutdownExitCode code, ShutdownMask mask);
void OnShutdownCancel();
void OnStartup();
void OnShutdown();
void OnGameEventStart(uint32 eventid);
void OnGameEventStop(uint32 eventid);
void OnBeforeWorldInitialized();
void OnBeforeConfigLoad(bool reload);
/* Battle Ground */
void OnBGStart(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId);
void OnBGEnd(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId, TeamId winner);
void OnBGCreate(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId);
void OnBGDestroy(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId);
/* Ticket */
void OnTicketCreate(GmTicket* ticket);
void OnTicketClose(GmTicket* ticket);
void OnTicketUpdateLastChange(GmTicket* ticket);
void OnTicketResolve(GmTicket* ticket);
/* Spell */
void OnSpellPrepare(Unit* caster, Spell* spell, SpellInfo const* spellInfo);
void OnSpellCast(Unit* caster, Spell* spell, SpellInfo const* spellInfo, bool skipCheck);
void OnSpellCastCancel(Unit* caster, Spell* spell, SpellInfo const* spellInfo, bool bySelf);
};
template<> Unit* Eluna::CHECKOBJ<Unit>(lua_State* L, int narg, bool error);
template<> Object* Eluna::CHECKOBJ<Object>(lua_State* L, int narg, bool error);
template<> WorldObject* Eluna::CHECKOBJ<WorldObject>(lua_State* L, int narg, bool error);
template<> ElunaObject* Eluna::CHECKOBJ<ElunaObject>(lua_State* L, int narg, bool error);
#define sEluna Eluna::GEluna
#endif
modules/mod-eluna/src/LuaEngine/LuaFunctions.cpp
+1947
View File
File diff suppressed because it is too large Load Diff
modules/mod-eluna/src/LuaEngine/docs/.gitignore
+2
View File
@@ -0,0 +1,2 @@
# Ignore the temporary "build" folder.
build
modules/mod-eluna/src/LuaEngine/docs/CONTRIBUTING.md
+19
View File
@@ -0,0 +1,19 @@
# Contributing
Eluna uses C for the Lua engine, C++ for the server modifications and system code, Lua for scripting side code and scripts, python for the web documentation generation - but you do not have to be able to code to help.
You can contribute to Eluna in various ways:
* Improve our documentation: [Documentation generation](DOC_GEN.md)
* Create new features or enhance old features: [Eluna source](https://github.com/ElunaLuaEngine/Eluna)
* Notify us about your concerns, problems and needs regarding Eluna: [Issue tracker](https://github.com/ElunaLuaEngine/Eluna/issues)
* Create and improve Lua scripts, systems, releases and guides: [Eluna forum section](https://www.getmangos.eu/forums/forum/118-eluna-lua-engine/)
### Features and documentation
To contribute to the source code and documentation within it, create a pull request for our github repository:
1. [Set up git](https://help.github.com/articles/set-up-git/)
2. [Fork](https://help.github.com/articles/fork-a-repo/) our repository: [Eluna repository](https://github.com/ElunaLuaEngine/Eluna)
3. Create a branch: `git checkout -b mybranch`
4. Make your contribution changes
5. Commit your changes `git commit -a -m "commit message"`
6. Push your commit to github: `git push`
7. Open a [pull request](https://help.github.com/articles/using-pull-requests/)
modules/mod-eluna/src/LuaEngine/docs/DOC_GEN.md
+165
View File
@@ -0,0 +1,165 @@
# Documentation generation
Eluna uses a custom made documentation generator to create it's [web documentation](http://elunaluaengine.github.io/).
The generator is written in python by Patman. It works by parsing Eluna's source files for comments and then generates the HTML and javascript for the documentation based on them.
This page guides you through generating the web documentation locally and explains the standards of the documentation comments for you to help us improve our documentation. To contribute with your documentation changes, create a [pull request](https://help.github.com/articles/using-pull-requests/)
# Generating locally
- install [python](https://www.python.org/)(2)
- when installing, tick to install the path variable
- you may need restart afterwards for the installation to properly take effect
- install a package manager like [pip](https://pip.pypa.io/en/latest/)
- if you installed pip and it does not work, restart or try easy_install command
- install the dependencies with manager
- [Jinja2](https://pypi.python.org/pypi/Jinja2)
- [typedecorator](https://pypi.python.org/pypi/typedecorator)
- [markdown](https://pypi.python.org/pypi/Markdown)
- Run in cmd `python -m ElunaDoc` when at `\LuaEngine\docs\`
# Documenting
You can document functions in the Eluna source code. To find examples simply open a method header file like `PlayerMethods.h` and see the comments.
## Templates
Here are some basic templates for a function documentation. When defining a parameter or a return value the type and value name are mandatory, unless the parameter type is `...`, which is used for variable arguments; do not include a name in this case.
```c++
/**
* Short description (about 80 characters long).
*
* @param Type paramName
* @return Type returnName
*/
```
```c++
/**
* Short description (about 80 characters long).
*
* @param Type paramName = defaultValue : parameter description
* @return Type returnName : return value description
*/
```
This is a template for a function that takes in different parameters. When defining a parameter or a return value, the type and value name are mandatory.
```c++
/**
* Short description (about 80 characters long).
*
* @proto returnValue = (object)
* @proto returnValue = (x, y, z)
* @param [WorldObject] object = defaultValue : parameter description
* @param float x = defaultValue : parameter description
* @param float y = defaultValue : parameter description
* @param float z = defaultValue : parameter description
* @return Type returnName : return value description
*/
```
## Standard
A documentation comment block will always start with `/**` and end with `*/`.
All lines start with `*` character followed by one space before any content.
The first paragrph is used as a short description of the function/class, so it should be kept to about 80 characters. The other paragraphs can be as long as desired.
All paragraphs in the description (including the first) should start with a capital letter and end with a period.
**Paragraphs must be separated by an empty line**, e.g.:
```c++
/**
* This is a short description (about 80 characters).
*
* Here's another paragraph with more info. NOTE THE EMPTY LINE BETWEEN THE PARAGRAPHS.
* This does need to be short, and this line is still part of the same paragraph because
* there is no empty line.
*/
```
The parameter and return value descriptions should start with a lowercase letter and not end with a period. If more than one sentence is needed, start the *first* without a capital letter and end the *last* without a period.
Any class, enum or function can be referenced (made a link to) with square brackets.
`[Player]` will reference a player. `[WeatherType]` will reference an enum. `[Player:GetName]` will reference a function.
Use correct indentation with documentation comments.
```c++
/**
* Correct indentation.
*/
```
```c++
/**
* Invalid indentation.
*/
```
## Markdown
You can use [markdown](http://pythonhosted.org//Markdown/) in your descriptions.
For syntax see http://daringfireball.net/projects/markdown/syntax and http://pythonhosted.org//Markdown/#differences
```
/**
* Description.
*
* - list item
* - list item
* - list item
*
*
* // Codeblock
* // Code goes here.
* // Note the 4-space indent.
*
*
* `code line`
*
* *italic*
* **bold**
*/
```
**The above markdown code produces the output below:**
Description.
- list item
- list item
- list item
```
// Codeblock
// Code goes here.
// Note the 4-space indent.
```
`code line`
*italic*
**bold**
## Types
Here are some examples of possible types and most commonly used ones:
```
string
uint64
uint32
uint16
uint8
int64
int32
int16
int8
double
float
...
[EnumName]
[Player]
[Creature]
[GameObject]
[Item]
[Unit]
[WorldObject]
[Object]
```
modules/mod-eluna/src/LuaEngine/docs/Eluna.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.5 KiB

modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/.gitignore
+2
View File
@@ -0,0 +1,2 @@
*.pyc
.idea
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/__init__.py
View File
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/__main__.py
+169
View File
@@ -0,0 +1,169 @@
import os
import shutil
import typing
from jinja2 import Environment, FileSystemLoader
from typedecorator import params, returns
from ElunaDoc.parser import ClassParser, MethodDoc
import glob
import time
@returns([(str, typing.IO)])
@params(search_path=str)
def find_class_files(search_path):
"""Find and open all files containing Eluna class methods in `search_path`.
:param search_path: the path to search for Eluna methods in
:return: a list of all files containing Eluna methods, and the name of their respective classes
"""
# Search for all files ending in "Methods.h".
method_file_names = glob.glob(os.path.join(search_path, '**', '*Methods.h'))
# Open each file.
method_files = [open(file_name, 'r') for file_name in method_file_names]
return method_files
def make_renderer(template_path, link_parser_factory):
"""Return a function that can be used to render Jinja2 templates from the `template_path` directory."""
# Set up jinja2 environment to load templates from the templates folder.
env = Environment(loader=FileSystemLoader(template_path))
def inner(template_name, output_path, level, **kwargs):
env.filters['parse_links'], env.filters['parse_data_type'] = link_parser_factory(level)
template = env.get_template(template_name)
static = make_static(level)
root = make_root(level)
with open('build/' + output_path, 'w') as out:
out.write(template.render(level=level, static=static, root=root, **kwargs))
return inner
def make_static(level):
return lambda file_name: ('../' * level) + 'static/' + file_name
def make_root(level):
return lambda file_name: ('../' * level) + file_name
if __name__ == '__main__':
# Recreate the build folder and copy static files over.
if os.path.exists('build'):
shutil.rmtree('build')
os.mkdir('build')
shutil.copytree('ElunaDoc/static', 'build/static')
# Load up all files with methods we need to parse.
print('Finding Eluna method files...')
class_files = find_class_files('../')
# Parse all the method files.
classes = []
for f in class_files:
print(f'Parsing file {f.name}...')
classes.append(ClassParser.parse_file(f))
f.close()
# Sort the classes so they are in the correct order in lists.
classes.sort(key=lambda c: c.name)
def make_parsers(level):
"""Returns a function that parses content for refs to other classes, methods, or enums,
and automatically inserts the correct link.
"""
# Make lists of all class names and method names.
class_names = []
method_names = []
for class_ in classes:
class_names.append('[' + class_.name + ']')
for method in class_.methods:
method_names.append('[' + class_.name + ':' + method.name + ']')
def link_parser(content):
# Replace all occurrencies of &Class:Function and then &Class with a link to given func or class
for name in method_names:
# Take the [] off the front of the method's name.
full_name = name[1:-1]
# Split "Class:Method" into "Class" and "Method".
class_name, method_name = full_name.split(':')
url = '{}{}/{}.html'.format(('../' * level), class_name, method_name)
# Replace occurrencies of &Class:Method with the url created
content = content.replace(name, '<a class="fn" href="{}">{}</a>'.format(url, full_name))
for name in class_names:
# Take the [] off the front of the class's name.
class_name = name[1:-1]
url = '{}{}/index.html'.format(('../' * level), class_name)
# Replace occurrencies of &Class:Method with the url created
content = content.replace(name, '<a class="mod" href="{}">{}</a>'.format(url, class_name))
return content
# Links to the "Programming in Lua" documentation for each Lua type.
lua_type_documentation = {
'nil': 'http://www.lua.org/pil/2.1.html',
'boolean': 'http://www.lua.org/pil/2.2.html',
'number': 'http://www.lua.org/pil/2.3.html',
'string': 'http://www.lua.org/pil/2.4.html',
'table': 'http://www.lua.org/pil/2.5.html',
'function': 'http://www.lua.org/pil/2.6.html',
'...': 'http://www.lua.org/pil/5.2.html',
}
def data_type_parser(content):
# If the type is a Lua type, return a link to Lua documentation.
if content in lua_type_documentation:
url = lua_type_documentation[content]
return '<strong><a href="{}">{}</a></strong>'.format(url, content)
# Otherwise try to build a link to the proper page.
if content in class_names:
class_name = content[1:-1]
url = '{}{}/index.html'.format(('../' * level), class_name)
return '<strong><a class="mod" href="{}">{}</a></strong>'.format(url, class_name)
# Case for enums to direct to a search on github
enum_name = content[1:-1]
url = 'https://github.com/ElunaLuaEngine/ElunaTrinityWotlk/search?l=cpp&q=%22enum+{}%22&type=Code&utf8=%E2%9C%93'.format(enum_name)
return '<strong><a href="{}">{}</a></strong>'.format(url, enum_name)
# By default we just return the name without the [] around it
return content[1:-1]
return link_parser, data_type_parser
# Create the render function with the template path and parser maker.
render = make_renderer('ElunaDoc/templates', make_parsers)
# Render the index.
render('index.html', 'index.html', level=0, classes=classes)
# Render the search index.
render('search-index.js', 'search-index.js', level=0, classes=classes)
# Render the date.
render('date.js', 'date.js', level=0, currdate=time.strftime("%d/%m/%Y"))
for class_ in classes:
print(f'Rendering pages for class {class_.name}...')
# Make a folder for the class.
os.mkdir('build/' + class_.name)
index_path = '{}/index.html'.format(class_.name)
sidebar_path = '{}/sidebar.js'.format(class_.name)
# Render the class's index page.
render('class.html', index_path, level=1, classes=classes, current_class=class_)
# Render the class's sidebar script.
render('sidebar.js', sidebar_path, level=1, classes=classes, current_class=class_)
# Render each method's page.
for method in class_.methods:
method_path = '{}/{}.html'.format(class_.name, method.name)
render('method.html', method_path, level=1, current_class=class_, current_method=method)
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/parser.py
+334
View File
@@ -0,0 +1,334 @@
import os
import re
import typing
import markdown
from typedecorator import params, returns, Nullable
class ParameterDoc(object):
"""The documentation data of a parameter or return value for an Eluna method."""
# The integer ranges that each C++ type is valid for. None means valid for all numbers.
valid_ranges = {
'float': None,
'double': None,
'int': ('-2,147,483,647', '2,147,483,647'), # This should be -32767..32767, but it's pretty safe to assume 32-bit.
'int8': ('-127', '127'),
'uint8': ('0', '255'),
'int16': ('-32,767', '32,767'),
'uint16': ('0', '65,535'),
'int32': ('-2,147,483,647', '2,147,483,647'),
'uint32': ('0', '4,294,967,295'),
'int64': ('-9,223,372,036,854,775,808', '9,223,372,036,854,775,807'),
'uint64': ('0', '18,446,744,073,709,551,615'),
'ObjectGuid': ('0', '18,446,744,073,709,551,615'),
}
@params(self=object, name=Nullable(str), data_type=str, description=str, default_value=Nullable(str))
def __init__(self, name, data_type, description, default_value=None):
"""If `name` is not provided, the Parameter is a returned value instead of a parameter."""
self.name = name
self.data_type = data_type
self.default_value = default_value
if self.data_type == '...':
self.name = '...'
else:
assert(self.name is not None)
if description:
# Capitalize the first letter, add a period, and parse as Markdown.
self.description = '{}{}. '.format(description[0].capitalize(), description[1:])
self.description = markdown.markdown(self.description)
else:
self.description = ''
# If the data type is a C++ number, convert to Lua number and add range info to description.
if self.data_type in self.valid_ranges.keys():
range = ParameterDoc.valid_ranges[self.data_type]
if range:
self.description += '<p><em>Valid numbers</em>: integers from {0} to {1}.</p>'.format(range[0], range[1])
else:
self.description += '<p><em>Valid numbers</em>: all decimal numbers.</p>'
self.data_type = 'number'
elif self.data_type == 'bool':
self.data_type = 'boolean'
elif self.data_type == 'int64' or self.data_type == 'uint64':
self.data_type = '[' + self.data_type + ']'
elif not self.data_type in ['nil', 'boolean', 'number', 'string', 'table', 'function', '...'] and self.data_type[:1] != '[':
print(f"Missing angle brackets [] around the data type name: `{self.data_type}`")
class MethodDoc(object):
"""The documentation data of an Eluna method."""
@params(self=object, name=str, description=str, prototypes=[str], parameters=[ParameterDoc], returned=[ParameterDoc])
def __init__(self, name, description, prototypes, parameters, returned):
self.name = name
self.prototypes = prototypes
self.parameters = parameters
self.returned = returned
# Parse the description as Markdown.
self.description = markdown.markdown(description)
# Pull the first paragraph out of the description as the short description.
self.short_description = self.description.split('</p>')[0][3:]
# If it has a description, it is "documented".
self.documented = self.description != ''
class MangosClassDoc(object):
"""The documentation of a MaNGOS class that has Lua methods."""
@params(self=object, name=str, description=str, methods=[MethodDoc])
def __init__(self, name, description, methods):
self.name = name
# Parse the description as Markdown.
self.description = markdown.markdown(description)
# Pull the first paragraph out of the description as the short description.
self.short_description = self.description.split('</p>')[0][3:]
# Sort the methods by their names.
self.methods = sorted(methods, key=lambda m: m.name)
# If any of our methods are not documented, we aren't fully documented.
for method in methods:
if not method.documented:
self.fully_documented = False
break
else:
self.fully_documented = True
# In the same vein, if any of our methods are documented, we aren't fully *un*documented.
for method in methods:
if method.documented:
self.fully_undocumented = False
break
else:
self.fully_undocumented = True
class ClassParser(object):
"""Parses a file line-by-line and returns methods when enough information is received to build them."""
# Various regular expressions to parse different parts of the doc string.
# There are used to parse the class's description.
class_start_regex = re.compile(r"\s*/\*\*\*") # The start of class documentation, i.e. /***
class_body_regex = re.compile(r"\s*\*\s*(.*)") # The "body", i.e. a * and optionally some descriptive text.
class_end_regex = re.compile(r"\s*\*/") # The end of the comment portion, i.e. */
# These are used to parse method documentation.
start_regex = re.compile(r"\s*/\*\*") # The start of documentation, i.e. /**
body_regex = re.compile(r"\s*\s?\*\s?(.*)") # The "body", i.e. a * and optionally some descriptive text.
# An extra optional space (\s?) was thrown in to make it different from `class_body_regex`.
param_regex = re.compile(r"""\s*\*\s@param\s # The @param tag starts with opt. whitespace followed by "* @param ".
([^\s]+)\s(\w+)? # The data type, a space, and the name of the param.
(?:\s=\s(\w+))? # The default value: a = surrounded by spaces, followed by text.
(?:\s:\s(.+))? # The description: a colon surrounded by spaces, followed by text.
""", re.X)
# This is the same as the @param tag, minus the default value part.
return_regex = re.compile(r"""\s*\*\s@return\s
([\[\]\w]+)\s(\w+)
(?:\s:\s(.+))?
""", re.X)
proto_regex = re.compile(r"""\s*\*\s@proto\s
([\w\s,]+)? # The list of arguments.
(?:=\s)? # An equals sign and a space separate the args and returns.
(?:\(([\w\s,]+)\))? # The list of return values, in parens.
""", re.X)
comment_end_regex = re.compile(r"\s*\*/") # The end of the comment portion, i.e. */
end_regex = re.compile(r"\s*int\s(\w+)\s*\(") # The end of the documentation, i.e. int MethodName(
def __init__(self, class_name):
assert ClassParser.class_body_regex is not ClassParser.body_regex
# The methods that have been parsed.
self.methods = []
# The name of the class being parsed.
self.class_name = class_name
# The description of the class being parsed.
self.class_description = ''
# Reset the parser's state machine.
self.reset()
def reset(self):
# What the last handled regex was, to determine what the next should be.
self.last_regex = None
# These are used to piece together the next `Method`.
self.description = ''
self.params = []
self.returned = []
self.method_name = None
self.prototypes = []
def handle_class_body(self, match):
text = match.group(1)
self.class_description += text + '\n'
def handle_body(self, match):
text = match.group(1)
self.description += text + '\n'
def handle_param(self, match):
data_type, name, default, description = match.group(1), match.group(2), match.group(3), match.group(4)
self.params.append(ParameterDoc(name, data_type, description, default))
def handle_return(self, match):
data_type, name, description = match.group(1), match.group(2), match.group(3)
self.returned.append(ParameterDoc(name, data_type, description))
def handle_proto(self, match):
return_values, parameters = match.group(1), match.group(2)
parameters = ' '+parameters+' ' if parameters else ''
return_values = return_values + '= ' if return_values else ''
if self.class_name == 'Global':
prototype = '{0}{{0}}({1})'.format(return_values, parameters)
else:
prototype = '{0}{1}:{{0}}({2})'.format(return_values, self.class_name, parameters)
self.prototypes.append(prototype)
def handle_end(self, match):
self.method_name = match.group(1)
def make_prototype(parameters):
if parameters != '':
parameters = ' ' + parameters + ' '
if self.class_name == 'Global':
if self.returned:
return_values = ', '.join([param.name for param in self.returned])
prototype = '{0} = {1}({2})'.format(return_values, self.method_name, parameters)
else:
prototype = '{0}({1})'.format(self.method_name, parameters)
else:
if self.returned:
return_values = ', '.join([param.name for param in self.returned])
prototype = '{0} = {1}:{2}({3})'.format(return_values, self.class_name, self.method_name, parameters)
else:
prototype = '{0}:{1}({2})'.format(self.class_name, self.method_name, parameters)
return prototype
# If there's no prototype, make one with all params and returns.
if not self.prototypes:
# A list of all parameters with default values.
params_with_default = []
# The index of the last non-default parameter.
last_non_default_i = 0
# If False, a parameter WITHOUT a default value follows one WITH a default value.
# In this case, don't bother generating prototypes.
simple_order = True
for i, param in enumerate(self.params):
if param.default_value:
params_with_default.append(param)
else:
last_non_default_i = i
if params_with_default:
simple_order = False
if not params_with_default or not simple_order:
# Just generate one prototype with all the parameters.
parameters = ', '.join([param.name for param in self.params])
self.prototypes.append(make_prototype(parameters))
else:
# Generate a prototype for all the non-default parameters,
# then one for each default parameter with all the previous parameters.
for i in range(last_non_default_i, len(self.params)):
parameters = ', '.join([param.name for param in self.params[:i+1]])
self.prototypes.append(make_prototype(parameters))
else:
# Format the method name into each prototype.
self.prototypes = [proto.format(self.method_name) for proto in self.prototypes]
self.methods.append(MethodDoc(self.method_name, self.description, self.prototypes, self.params, self.returned))
# Table of which handler is used to handle each regular expressions.
regex_handlers = {
class_start_regex: None,
class_body_regex: handle_class_body,
class_end_regex: None,
start_regex: None,
body_regex: handle_body,
param_regex: handle_param,
return_regex: handle_return,
proto_regex: handle_proto,
comment_end_regex: None,
end_regex: handle_end,
}
# Table of which regular expressions can follow the last handled regex.
# `body_regex` must always come LAST when used, since it also matches param, return, and comment_end.
next_regexes = {
None: [class_start_regex, start_regex, end_regex],
class_start_regex: [class_end_regex, class_body_regex],
class_body_regex: [class_end_regex, class_body_regex],
class_end_regex: [],
start_regex: [param_regex, return_regex, proto_regex, comment_end_regex, body_regex],
body_regex: [param_regex, return_regex, proto_regex, comment_end_regex, body_regex],
proto_regex: [param_regex, return_regex, proto_regex, comment_end_regex, body_regex],
param_regex: [param_regex, return_regex, comment_end_regex, body_regex],
return_regex: [return_regex, comment_end_regex],
comment_end_regex: [end_regex],
end_regex: [],
}
@returns(Nullable(MethodDoc))
@params(self=object, line=str)
def next_line(self, line):
"""Parse the next line of the file.
This method returns a `Method` when enough data to form a `Method` has been parsed.
Otherwise, it returns None.
"""
# Get the list of expected regular expressions using the last one handled.
valid_regexes = self.next_regexes[self.last_regex]
# Try to find a match.
for regex in valid_regexes:
match = regex.match(line)
if match:
handler = self.regex_handlers[regex]
if handler:
handler(self, match)
# Not every regex has a handler, but keep track of where we are anyway.
self.last_regex = regex
# Break at the first match.
break
else:
# No valid regex was found, reset everything.
self.reset()
@returns(MangosClassDoc)
def to_class_doc(self):
"""Create an instance of `MangosClassDoc` from the parser's data.
Is called by `parse_file` once parsing is finished.
"""
return MangosClassDoc(self.class_name, self.class_description, self.methods)
@staticmethod
@returns(MangosClassDoc)
@params(file=typing.IO)
def parse_file(file):
"""Parse the file `file` into a documented class."""
# Get the class name from "ClassMethods.h" by stripping off "Methods.h".
class_name = os.path.basename(file.name)[:-len('Methods.h')]
parser = ClassParser(class_name)
line = file.readline()
while line:
parser.next_line(line)
line = file.readline()
return parser.to_class_doc()
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/FiraSans-Medium.woff
BIN
View File
Binary file not shown.
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/FiraSans-Regular.woff
BIN
View File
Binary file not shown.
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/Heuristica-Italic.woff
BIN
View File
Binary file not shown.
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/SourceCodePro-Regular.woff
BIN
View File
Binary file not shown.
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/SourceCodePro-Semibold.woff
BIN
View File
Binary file not shown.
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/SourceSerifPro-Bold.woff
BIN
View File
Binary file not shown.
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/SourceSerifPro-Regular.woff
BIN
View File
Binary file not shown.
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/dark.css
+361
View File
@@ -0,0 +1,361 @@
/*
_______
/ \
.==. .==.
(( ))==(( ))
/ "==" "=="\
/____|| || ||___\
________ ____ ________ ___ ___
| ___ \ / \ | ___ \ | | / /
| | \ \ / /\ \ | | \ \| |_/ /
| | ) / /__\ \ | |__/ /| ___ \
| |__/ / ______ \| ____ \| | \ \
_______|_______/__/ ____ \__\__|___\__\__|___\__\____
| ___ \ | ____/ / \ | ___ \ | ____| ___ \
| | \ \| |___ / /\ \ | | \ \| |___| | \ \
| |__/ /| ____/ /__\ \ | | ) | ____| |__/ /
| ____ \| |__/ ______ \| |__/ /| |___| ____ \
|__| \__\____/__/ \__\_______/ |______|__| \__\
https://darkreader.org
*/
/*! Dark reader generated CSS | Licensed under MIT https://github.com/darkreader/darkreader/blob/main/LICENSE */
/* User-Agent Style */
html {
background-color: #181a1b !important;
}
html {
color-scheme: dark !important;
}
html, body, input, textarea, select, button, dialog {
background-color: #181a1b;
}
html, body, input, textarea, select, button {
border-color: #736b5e;
color: #e8e6e3;
}
a {
color: #3391ff;
}
table {
border-color: #545b5e;
}
::placeholder {
color: #b2aba1;
}
input:-webkit-autofill,
textarea:-webkit-autofill,
select:-webkit-autofill {
background-color: #404400 !important;
color: #e8e6e3 !important;
}
::-webkit-scrollbar {
background-color: #202324;
color: #aba499;
}
::-webkit-scrollbar-thumb {
background-color: #454a4d;
}
::-webkit-scrollbar-thumb:hover {
background-color: #575e62;
}
::-webkit-scrollbar-thumb:active {
background-color: #484e51;
}
::-webkit-scrollbar-corner {
background-color: #181a1b;
}
::selection {
background-color: #004daa !important;
color: #e8e6e3 !important;
}
::-moz-selection {
background-color: #004daa !important;
color: #e8e6e3 !important;
}
/* Invert Style */
.jfk-bubble.gtx-bubble, .captcheck_answer_label > input + img, span#closed_text > img[src^="https://www.gstatic.com/images/branding/googlelogo"], span[data-href^="https://www.hcaptcha.com/"] > #icon, #bit-notification-bar-iframe, ::-webkit-calendar-picker-indicator {
filter: invert(100%) hue-rotate(180deg) contrast(90%) !important;
}
/* Variables Style */
:root {
--darkreader-neutral-background: #131516;
--darkreader-neutral-text: #d8d4cf;
--darkreader-selection-background: #004daa;
--darkreader-selection-text: #e8e6e3;
}
/* Modified CSS */
body {
color: rgb(200, 195, 188);
}
h1,
h2,
h3:not(.impl):not(.method),
h4:not(.method) {
color: rgb(232, 230, 227);
}
h1.fqn {
border-bottom-color: rgb(60, 65, 67);
}
h2,
h3:not(.impl):not(.method),
h4:not(.method) {
border-bottom-color: rgb(58, 62, 65);
}
.docblock code {
background-color: rgb(30, 32, 33);
}
pre {
background-color: rgb(30, 32, 33);
}
.sidebar .location {
background-image: initial;
background-color: rgb(41, 44, 46);
color: rgb(200, 195, 188);
}
.block a:hover {
background-image: initial;
background-color: rgb(30, 32, 33);
}
.content pre.line-numbers {
border-color: initial;
}
.line-numbers span {
color: rgb(214, 149, 75);
}
.line-numbers .line-highlighted {
background-color: rgb(68, 73, 2);
}
.content .highlighted {
background-color: rgb(53, 57, 59);
color: rgb(232, 230, 227) !important;
}
.content .highlighted a {
color: rgb(232, 230, 227) !important;
}
.content .highlighted.trait {
background-color: rgb(128, 80, 1);
}
.content .highlighted.mod {
background-color: rgb(29, 54, 86);
}
.content .highlighted.enum {
background-color: rgb(47, 77, 58);
}
.content .highlighted.struct {
background-color: rgb(98, 42, 25);
}
.content .highlighted.fn {
background-color: rgb(78, 55, 59);
}
.docblock h1,
.docblock h2,
.docblock h3,
.docblock h4,
.docblock h5 {
border-bottom-color: rgb(58, 62, 65);
}
nav {
border-bottom-color: rgb(57, 61, 64);
}
nav.main .current {
border-top-color: rgb(140, 130, 115);
border-bottom-color: rgb(140, 130, 115);
}
nav.main .separator {
border-color: rgb(140, 130, 115);
}
a {
text-decoration-color: initial;
color: rgb(232, 230, 227);
background-image: initial;
background-color: transparent;
}
p a {
color: rgb(92, 155, 206);
}
p a:hover {
text-decoration-color: initial;
}
.content a.trait,
.block a.current.trait {
color: rgb(252, 173, 39);
}
.content a.mod,
.block a.current.mod {
color: rgb(115, 156, 193);
}
.content a.enum,
.block a.current.enum {
color: rgb(155, 146, 133);
}
.content a.struct,
.block a.current.struct {
color: rgb(255, 94, 44);
}
.content a.fn,
.block a.current.fn {
color: rgb(157, 149, 136);
}
.content .fnname {
color: rgb(157, 149, 136);
}
.search-input {
outline-color: initial;
border-color: initial;
color: rgb(178, 172, 162);
box-shadow: rgb(42, 45, 47) 0px 0px 0px 1px,
rgba(0, 0, 0, 0) 0px 0px 0px 2px;
}
.search-input:focus {
border-color: initial;
outline-color: initial;
box-shadow: rgb(6, 113, 173) 0px 0px 8px;
}
#help {
background-image: initial;
background-color: rgb(36, 39, 41);
box-shadow: rgba(0, 0, 0, 0.2) 0px 0px 6px;
border-color: rgb(66, 72, 74);
}
#help dt {
border-color: rgb(66, 72, 74);
background-image: initial;
background-color: rgb(24, 26, 27);
}
.stability {
border-left-color: initial;
}
.stability.Deprecated {
border-color: rgb(100, 65, 106);
color: rgb(179, 123, 188);
}
.stability.Experimental {
border-color: rgb(124, 38, 36);
color: rgb(202, 101, 98);
}
.stability.Unstable {
border-color: rgb(124, 95, 36);
color: rgb(202, 167, 98);
}
.stability.Stable {
border-color: rgb(60, 120, 64);
color: rgb(123, 211, 128);
}
.stability.Frozen {
border-color: rgb(0, 211, 70);
color: rgb(121, 255, 164);
}
.stability.Locked {
border-color: rgb(0, 145, 200);
color: rgb(106, 215, 255);
}
.stability.Unmarked {
border-color: rgb(67, 73, 76);
}
.summary.Deprecated {
background-color: rgb(110, 72, 117);
}
.summary.Experimental {
background-color: rgb(129, 40, 37);
}
.summary.Unstable {
background-color: rgb(97, 74, 28);
}
.summary.Stable {
background-color: rgb(67, 134, 71);
}
.summary.Unmarked {
background-color: rgb(62, 68, 70);
}
:target {
background-image: initial;
background-color: rgb(56, 58, 0);
}
pre.rust .kw {
color: rgb(149, 105, 177);
}
pre.rust .kw-2,
pre.rust .prelude-ty {
color: rgb(114, 160, 201);
}
pre.rust .number,
pre.rust .string {
color: rgb(226, 255, 106);
}
pre.rust .self,
pre.rust .boolval,
pre.rust .prelude-val,
pre.rust .attribute,
pre.rust .attribute .ident {
color: rgb(219, 73, 73);
}
pre.rust .comment {
color: rgb(161, 152, 140);
}
pre.rust .doccomment {
color: rgb(184, 178, 168);
}
pre.rust .macro,
pre.rust .macro-nonterminal {
color: rgb(107, 192, 197);
}
pre.rust .lifetime {
color: rgb(236, 158, 81);
}
.methods .section-header {
border-bottom-color: initial !important;
}
.collapse-toggle {
color: rgb(168, 160, 149);
}
.toggle-label {
color: rgb(168, 160, 149);
}
/* Override Style */
.vimvixen-hint {
background-color: #7b5300 !important;
border-color: #d8b013 !important;
color: #f3e8c8 !important;
}
::placeholder {
opacity: 0.5 !important;
}
#edge-translate-panel-body,
.MuiTypography-body1,
.nfe-quote-text {
color: var(--darkreader-neutral-text) !important;
}
gr-main-header {
background-color: #0f3a48 !important;
}
.tou-z65h9k,
.tou-mignzq,
.tou-1b6i2ox,
.tou-lnqlqk {
background-color: var(--darkreader-neutral-background) !important;
}
.tou-75mvi {
background-color: #032029 !important;
}
.tou-ta9e87,
.tou-1w3fhi0,
.tou-1b8t2us,
.tou-py7lfi,
.tou-1lpmd9d,
.tou-1frrtv8,
.tou-17ezmgn {
background-color: #0a0a0a !important;
}
.tou-uknfeu {
background-color: #231603 !important;
}
.tou-6i3zyv {
background-color: #19576c !important;
}
embed[type="application/pdf"][src="about:blank"] { filter: invert(100%) contrast(90%); }
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/eluna-logo.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.3 KiB

modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/favicon.ico
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.0 KiB

modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/jquery.js
Vendored
+4
View File
File diff suppressed because one or more lines are too long
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/main.css
+520
View File
@@ -0,0 +1,520 @@
/**
* Copyright 2013 The Rust Project Developers. See the COPYRIGHT
* file at the top-level directory of this distribution and at
* http://rust-lang.org/COPYRIGHT.
*
* Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
* http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
* <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
* option. This file may not be copied, modified, or distributed
* except according to those terms.
*/
@font-face {
font-family: 'Fira Sans';
font-style: normal;
font-weight: 400;
src: local('Fira Sans'), url("FiraSans-Regular.woff") format('woff');
}
@font-face {
font-family: 'Fira Sans';
font-style: normal;
font-weight: 500;
src: local('Fira Sans Medium'), url("FiraSans-Medium.woff") format('woff');
}
@font-face {
font-family: 'Source Serif Pro';
font-style: normal;
font-weight: 400;
src: local('Source Serif Pro'), url("SourceSerifPro-Regular.woff") format('woff');
}
@font-face {
font-family: 'Source Serif Pro';
font-style: italic;
font-weight: 400;
src: url("Heuristica-Italic.woff") format('woff');
}
@font-face {
font-family: 'Source Serif Pro';
font-style: normal;
font-weight: 700;
src: local('Source Serif Pro Bold'), url("SourceSerifPro-Bold.woff") format('woff');
}
@font-face {
font-family: 'Source Code Pro';
font-style: normal;
font-weight: 400;
src: local('Source Code Pro'), url("SourceCodePro-Regular.woff") format('woff');
}
@font-face {
font-family: 'Source Code Pro';
font-style: normal;
font-weight: 600;
src: local('Source Code Pro Semibold'), url("SourceCodePro-Semibold.woff") format('woff');
}
@import "normalize.css";
* {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
/* General structure and fonts */
body {
color: #333;
min-width: 500px;
font: 16px/1.4 "Source Serif Pro", "Helvetica Neue", Helvetica, Arial, sans-serif;
margin: 0;
position: relative;
padding: 10px 15px 20px 15px;
}
h1 {
font-size: 1.5em;
}
h2 {
font-size: 1.4em;
}
h3 {
font-size: 1.3em;
}
h1, h2, h3:not(.impl):not(.method), h4:not(.method) {
color: black;
font-weight: 500;
margin: 20px 0 15px 0;
padding-bottom: 6px;
}
h1.fqn {
border-bottom: 1px dashed #D5D5D5;
margin-top: 0;
}
h2, h3:not(.impl):not(.method), h4:not(.method) {
border-bottom: 1px solid #DDDDDD;
}
h3.impl, h3.method, h4.method {
font-weight: 600;
margin-top: 10px;
margin-bottom: 10px;
}
h3.impl, h3.method {
margin-top: 15px;
}
h1, h2, h3, h4, section.sidebar, a.source, .search-input, .content table a, .collapse-toggle {
font-family: "Fira Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
}
ol, ul {
padding-left: 25px;
}
ul ul, ol ul, ul ol, ol ol {
margin-bottom: 0;
}
p {
margin: 0 0 .6em 0;
}
code, pre {
font-family: "Source Code Pro", Menlo, Monaco, Consolas, "DejaVu Sans Mono", Inconsolata, monospace;
white-space: pre-wrap;
}
.docblock code {
background-color: #F5F5F5;
border-radius: 3px;
/*padding: 0 0.2em;*/
}
pre {
background-color: #F5F5F5;
padding: 14px;
}
.source pre {
padding: 20px;
}
.content.source {
margin-top: 50px;
max-width: none;
overflow: visible;
margin-left: 0px;
min-width: 70em;
}
nav.sub {
font-size: 16px;
text-transform: uppercase;
}
.sidebar {
width: 200px;
position: absolute;
left: 0;
top: 0;
min-height: 100%;
}
.content, nav { max-width: 960px; }
/* Everything else */
.js-only, .hidden { display: none; }
.sidebar {
padding: 10px;
}
.sidebar img {
margin: 20px auto;
display: block;
}
.sidebar .location {
font-size: 17px;
margin: 30px 0 20px 0;
background: #e1e1e1;
text-align: center;
color: #333;
}
.block {
padding: 0 10px;
margin-bottom: 14px;
}
.block h2 {
margin-top: 0;
margin-bottom: 8px;
text-align: center;
}
.block a {
display: block;
text-overflow: ellipsis;
overflow: hidden;
line-height: 15px;
padding: 7px 5px;
font-size: 14px;
font-weight: 300;
transition: border 500ms ease-out;
}
.block a:hover {
background: #F5F5F5;
}
.content {
padding: 15px 0;
}
.content.source pre.rust {
white-space: pre;
overflow: auto;
padding-left: 0;
}
.content pre.line-numbers { float: left; border: none; }
.line-numbers span { color: #c67e2d; }
.line-numbers .line-highlighted {
background-color: #f6fdb0;
}
.content .highlighted {
cursor: pointer;
color: #000 !important;
background-color: #ccc;
}
.content .highlighted a { color: #000 !important; }
.content .highlighted.trait { background-color: #fece7e; }
.content .highlighted.mod { background-color: #afc6e4; }
.content .highlighted.enum { background-color: #b4d1b9; }
.content .highlighted.struct { background-color: #e7b1a0; }
.content .highlighted.fn { background-color: #c6afb3; }
.docblock.short.nowrap {
display: block;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
.docblock.short p {
overflow: hidden;
text-overflow: ellipsis;
margin: 0;
}
.docblock.short code { white-space: nowrap; }
.docblock h1, .docblock h2, .docblock h3, .docblock h4, .docblock h5 {
border-bottom: 1px solid #DDD;
}
.docblock h1 { font-size: 1.3em; }
.docblock h2 { font-size: 1.15em; }
.docblock h3, .docblock h4, .docblock h5 { font-size: 1em; }
.content .out-of-band {
float: right;
font-size: 23px;
}
.content table {
border-spacing: 0 5px;
border-collapse: separate;
}
.content td { vertical-align: top; }
.content td:first-child { padding-right: 20px; }
.content td p:first-child { margin-top: 0; }
.content td h1, .content td h2 { margin-left: 0; font-size: 1.1em; }
.content .item-list {
list-style-type: none;
padding: 0;
}
.content .item-list li { margin-bottom: 3px; }
.content .multi-column {
-moz-column-count: 5;
-moz-column-gap: 2.5em;
-webkit-column-count: 5;
-webkit-column-gap: 2.5em;
column-count: 5;
column-gap: 2.5em;
}
.content .multi-column li { width: 100%; display: inline-block; }
.content .method {
font-size: 1em;
position: relative;
}
.content .methods .docblock { margin-left: 40px; }
.content .impl-methods .docblock { margin-left: 40px; }
nav {
border-bottom: 1px solid #e0e0e0;
padding-bottom: 10px;
margin-bottom: 10px;
}
nav.main {
padding: 20px 0;
text-align: center;
}
nav.main .current {
border-top: 1px solid #000;
border-bottom: 1px solid #000;
}
nav.main .separator {
border: 1px solid #000;
display: inline-block;
height: 23px;
margin: 0 20px;
}
nav.sum { text-align: right; }
nav.sub form { display: inline; }
nav, .content {
margin-left: 230px;
}
a {
text-decoration: none;
color: #000;
background: transparent;
}
p a { color: #4e8bca; }
p a:hover { text-decoration: underline; }
.content a.trait, .block a.current.trait { color: #ed9603; }
.content a.mod, .block a.current.mod { color: #4d76ae; }
.content a.enum, .block a.current.enum { color: #5e9766; }
.content a.struct, .block a.current.struct { color: #e53700; }
.content a.fn, .block a.current.fn { color: #8c6067; }
.content .fnname { color: #8c6067; }
.search-input {
width: 100%;
/* Override Normalize.css: we have margins and do
not want to overflow - the `moz` attribute is necessary
until Firefox 29, too early to drop at this point */
-moz-box-sizing: border-box !important;
box-sizing: border-box !important;
outline: none;
border: none;
border-radius: 1px;
color: #555;
margin-top: 5px;
padding: 10px 16px;
font-size: 17px;
box-shadow: 0 0 0 1px #e0e0e0, 0 0 0 2px transparent;
transition: border-color 300ms ease;
transition: border-radius 300ms ease-in-out;
transition: box-shadow 300ms ease-in-out;
}
.search-input:focus {
border-color: #66afe9;
border-radius: 2px;
border: 0;
outline: 0;
box-shadow: 0 0 8px #078dd8;
}
.search-results .desc {
white-space: nowrap;
text-overflow: ellipsis;
overflow: hidden;
display: block;
}
#help {
background: #e9e9e9;
border-radius: 4px;
box-shadow: 0 0 6px rgba(0,0,0,.2);
position: absolute;
top: 300px;
left: 50%;
margin-top: -125px;
margin-left: -275px;
width: 550px;
height: 300px;
border: 1px solid #bfbfbf;
}
#help dt {
float: left;
border-radius: 3px;
border: 1px solid #bfbfbf;
background: #fff;
width: 23px;
text-align: center;
clear: left;
display: block;
margin-top: -1px;
}
#help dd { margin: 5px 33px; }
#help .infos { padding-left: 0; }
#help h1 { margin-top: 0; }
#help div {
width: 50%;
float: left;
padding: 20px;
}
.stability {
border-left: 6px solid;
padding: 3px 6px;
border-radius: 3px;
}
h1 .stability {
text-transform: lowercase;
font-weight: 400;
margin-left: 14px;
padding: 4px 10px;
}
.impl-methods .stability, .methods .stability {
margin-right: 20px;
}
.stability.Deprecated { border-color: #A071A8; color: #82478C; }
.stability.Experimental { border-color: #D46D6A; color: #AA3C39; }
.stability.Unstable { border-color: #D4B16A; color: #AA8439; }
.stability.Stable { border-color: #54A759; color: #2D8632; }
.stability.Frozen { border-color: #009431; color: #007726; }
.stability.Locked { border-color: #0084B6; color: #00668c; }
.stability.Unmarked { border-color: #BBBBBB; }
.summary {
padding-right: 0px;
}
.summary.Deprecated { background-color: #A071A8; }
.summary.Experimental { background-color: #D46D6A; }
.summary.Unstable { background-color: #D4B16A; }
.summary.Stable { background-color: #54A759; }
.summary.Unmarked { background-color: #BBBBBB; }
:target { background: #FDFFD3; }
/* Code highlighting */
pre.rust .kw { color: #8959A8; }
pre.rust .kw-2, pre.rust .prelude-ty { color: #4271AE; }
pre.rust .number, pre.rust .string { color: #718C00; }
pre.rust .self, pre.rust .boolval, pre.rust .prelude-val,
pre.rust .attribute, pre.rust .attribute .ident { color: #C82829; }
pre.rust .comment { color: #8E908C; }
pre.rust .doccomment { color: #4D4D4C; }
pre.rust .macro, pre.rust .macro-nonterminal { color: #3E999F; }
pre.rust .lifetime { color: #B76514; }
.rusttest { display: none; }
pre.rust { position: relative; }
.test-arrow {
display: inline-block;
position: absolute;
top: 0;
right: 10px;
font-size: 150%;
-webkit-transform: scaleX(-1);
transform: scaleX(-1);
}
.methods .section-header {
/* Override parent class attributes. */
border-bottom: none !important;
font-size: 1.1em !important;
margin: 0 0 -5px;
padding: 0;
}
.section-header:hover a:after {
content: '\2002\00a7\2002';
}
/* Media Queries */
@media (max-width: 700px) {
.sidebar {
display: none;
}
.content {
margin-left: 0px;
}
nav.sub {
margin: 0 auto;
}
}
.collapse-toggle {
font-weight: 100;
position: absolute;
left: 13px;
color: #999;
margin-top: 2px;
}
.toggle-wrapper > .collapse-toggle {
left: -24px;
margin-top: 0px;
}
.toggle-wrapper {
position: relative;
}
.toggle-wrapper.collapsed {
height: 1em;
transition: height .2s;
}
.collapse-toggle > .inner {
display: inline-block;
width: 1ch;
text-align: center;
}
.toggle-label {
color: #999;
font-style: italic;
}
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/main.js
+782
View File
@@ -0,0 +1,782 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
/*jslint browser: true, es5: true */
/*globals $: true, rootPath: true */
(function() {
"use strict";
var resizeTimeout, interval;
$('.js-only').removeClass('js-only');
function getQueryStringParams() {
var params = {};
window.location.search.substring(1).split("&").
map(function(s) {
var pair = s.split("=");
params[decodeURIComponent(pair[0])] =
typeof pair[1] === "undefined" ?
null : decodeURIComponent(pair[1]);
});
return params;
}
function browserSupportsHistoryApi() {
return window.history && typeof window.history.pushState === "function";
}
function resizeShortBlocks() {
if (resizeTimeout) {
clearTimeout(resizeTimeout);
}
resizeTimeout = setTimeout(function() {
var contentWidth = $('.content').width();
$('.docblock.short').width(function() {
return contentWidth - 40 - $(this).prev().width();
}).addClass('nowrap');
$('.summary-column').width(function() {
return contentWidth - 40 - $(this).prev().width();
})
}, 150);
}
resizeShortBlocks();
$(window).on('resize', resizeShortBlocks);
function highlightSourceLines() {
var i, from, to, match = window.location.hash.match(/^#?(\d+)(?:-(\d+))?$/);
if (match) {
from = parseInt(match[1], 10);
to = Math.min(50000, parseInt(match[2] || match[1], 10));
from = Math.min(from, to);
if ($('#' + from).length === 0) {
return;
}
$('#' + from)[0].scrollIntoView();
$('.line-numbers span').removeClass('line-highlighted');
for (i = from; i <= to; ++i) {
$('#' + i).addClass('line-highlighted');
}
}
}
highlightSourceLines();
$(window).on('hashchange', highlightSourceLines);
$(document).on('keyup', function(e) {
if (document.activeElement.tagName === 'INPUT') {
return;
}
if (e.which === 191 && $('#help').hasClass('hidden')) { // question mark
e.preventDefault();
$('#help').removeClass('hidden');
} else if (e.which === 27) { // esc
if (!$('#help').hasClass('hidden')) {
e.preventDefault();
$('#help').addClass('hidden');
} else if (!$('#search').hasClass('hidden')) {
e.preventDefault();
$('#search').addClass('hidden');
$('#main').removeClass('hidden');
}
} else if (e.which === 83) { // S
e.preventDefault();
$('.search-input').focus();
}
}).on('click', function(e) {
if (!$(e.target).closest('#help').length) {
$('#help').addClass('hidden');
}
});
$('.version-selector').on('change', function() {
var i, match,
url = document.location.href,
stripped = '',
len = rootPath.match(/\.\.\//g).length + 1;
for (i = 0; i < len; ++i) {
match = url.match(/\/[^\/]*$/);
if (i < len - 1) {
stripped = match[0] + stripped;
}
url = url.substring(0, url.length - match[0].length);
}
url += '/' + $('.version-selector').val() + stripped;
document.location.href = url;
});
/**
* A function to compute the Levenshtein distance between two strings
* Licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported
* Full License can be found at http://creativecommons.org/licenses/by-sa/3.0/legalcode
* This code is an unmodified version of the code written by Marco de Wit
* and was found at http://stackoverflow.com/a/18514751/745719
*/
var levenshtein = (function() {
var row2 = [];
return function(s1, s2) {
if (s1 === s2) {
return 0;
} else {
var s1_len = s1.length, s2_len = s2.length;
if (s1_len && s2_len) {
var i1 = 0, i2 = 0, a, b, c, c2, row = row2;
while (i1 < s1_len)
row[i1] = ++i1;
while (i2 < s2_len) {
c2 = s2.charCodeAt(i2);
a = i2;
++i2;
b = i2;
for (i1 = 0; i1 < s1_len; ++i1) {
c = a + (s1.charCodeAt(i1) !== c2 ? 1 : 0);
a = row[i1];
b = b < a ? (b < c ? b + 1 : c) : (a < c ? a + 1 : c);
row[i1] = b;
}
}
return b;
} else {
return s1_len + s2_len;
}
}
};
})();
function initSearch(rawSearchIndex) {
var currentResults, index, searchIndex;
var MAX_LEV_DISTANCE = 3;
var params = getQueryStringParams();
// Populate search bar with query string search term when provided,
// but only if the input bar is empty. This avoid the obnoxious issue
// where you start trying to do a search, and the index loads, and
// suddenly your search is gone!
if ($(".search-input")[0].value === "") {
$(".search-input")[0].value = params.search || '';
}
/**
* Executes the query and builds an index of results
* @param {[Object]} query [The user query]
* @param {[type]} max [The maximum results returned]
* @param {[type]} searchWords [The list of search words to query
* against]
* @return {[type]} [A search index of results]
*/
function execQuery(query, max, searchWords) {
var valLower = query.query.toLowerCase(),
val = valLower,
typeFilter = itemTypeFromName(query.type),
results = [],
split = valLower.split("::");
//remove empty keywords
for (var j = 0; j < split.length; ++j) {
split[j].toLowerCase();
if (split[j] === "") {
split.splice(j, 1);
}
}
// quoted values mean literal search
var nSearchWords = searchWords.length;
if ((val.charAt(0) === "\"" || val.charAt(0) === "'") &&
val.charAt(val.length - 1) === val.charAt(0))
{
val = val.substr(1, val.length - 2);
for (var i = 0; i < nSearchWords; ++i) {
if (searchWords[i] === val) {
// filter type: ... queries
if (typeFilter < 0 || typeFilter === searchIndex[i].ty) {
results.push({id: i, index: -1});
}
}
if (results.length === max) {
break;
}
}
} else {
// gather matching search results up to a certain maximum
val = val.replace(/\_/g, "");
for (var i = 0; i < split.length; ++i) {
for (var j = 0; j < nSearchWords; ++j) {
var lev_distance;
if (searchWords[j].indexOf(split[i]) > -1 ||
searchWords[j].indexOf(val) > -1 ||
searchWords[j].replace(/_/g, "").indexOf(val) > -1)
{
// filter type: ... queries
if (typeFilter < 0 || typeFilter === searchIndex[j].ty) {
results.push({
id: j,
index: searchWords[j].replace(/_/g, "").indexOf(val),
lev: 0,
});
}
} else if (
(lev_distance = levenshtein(searchWords[j], val)) <=
MAX_LEV_DISTANCE) {
if (typeFilter < 0 || typeFilter === searchIndex[j].ty) {
results.push({
id: j,
index: 0,
// we want lev results to go lower than others
lev: lev_distance,
});
}
}
if (results.length === max) {
break;
}
}
}
}
var nresults = results.length;
for (var i = 0; i < nresults; ++i) {
results[i].word = searchWords[results[i].id];
results[i].item = searchIndex[results[i].id] || {};
}
// if there are no results then return to default and fail
if (results.length === 0) {
return [];
}
results.sort(function(aaa, bbb) {
var a, b;
// Sort by non levenshtein results and then levenshtein results by the distance
// (less changes required to match means higher rankings)
a = (aaa.lev);
b = (bbb.lev);
if (a !== b) return a - b;
// sort by crate (non-current crate goes later)
a = (aaa.item.crate !== window.currentCrate);
b = (bbb.item.crate !== window.currentCrate);
if (a !== b) return a - b;
// sort by exact match (mismatch goes later)
a = (aaa.word !== valLower);
b = (bbb.word !== valLower);
if (a !== b) return a - b;
// sort by item name length (longer goes later)
a = aaa.word.length;
b = bbb.word.length;
if (a !== b) return a - b;
// sort by item name (lexicographically larger goes later)
a = aaa.word;
b = bbb.word;
if (a !== b) return (a > b ? +1 : -1);
// sort by index of keyword in item name (no literal occurrence goes later)
a = (aaa.index < 0);
b = (bbb.index < 0);
if (a !== b) return a - b;
// (later literal occurrence, if any, goes later)
a = aaa.index;
b = bbb.index;
if (a !== b) return a - b;
// sort by description (no description goes later)
a = (aaa.item.desc === '');
b = (bbb.item.desc === '');
if (a !== b) return a - b;
// sort by type (later occurrence in `itemTypes` goes later)
a = aaa.item.ty;
b = bbb.item.ty;
if (a !== b) return a - b;
// sort by path (lexicographically larger goes later)
a = aaa.item.path;
b = bbb.item.path;
if (a !== b) return (a > b ? +1 : -1);
// que sera, sera
return 0;
});
// remove duplicates, according to the data provided
for (var i = results.length - 1; i > 0; i -= 1) {
if (results[i].word === results[i - 1].word &&
results[i].item.ty === results[i - 1].item.ty &&
results[i].item.path === results[i - 1].item.path)
{
results[i].id = -1;
}
}
for (var i = 0; i < results.length; ++i) {
var result = results[i],
name = result.item.name.toLowerCase(),
path = result.item.path.toLowerCase(),
parent = result.item.parent;
var valid = validateResult(name, path, split, parent);
if (!valid) {
result.id = -1;
}
}
return results;
}
/**
* Validate performs the following boolean logic. For example:
* "File::open" will give IF A PARENT EXISTS => ("file" && "open")
* exists in (name || path || parent) OR => ("file" && "open") exists in
* (name || path )
*
* This could be written functionally, but I wanted to minimise
* functions on stack.
*
* @param {[string]} name [The name of the result]
* @param {[string]} path [The path of the result]
* @param {[string]} keys [The keys to be used (["file", "open"])]
* @param {[object]} parent [The parent of the result]
* @return {[boolean]} [Whether the result is valid or not]
*/
function validateResult(name, path, keys, parent) {
for (var i=0; i < keys.length; ++i) {
// each check is for validation so we negate the conditions and invalidate
if (!(
// check for an exact name match
name.toLowerCase().indexOf(keys[i]) > -1 ||
// then an exact path match
path.toLowerCase().indexOf(keys[i]) > -1 ||
// next if there is a parent, check for exact parent match
(parent !== undefined &&
parent.name.toLowerCase().indexOf(keys[i]) > -1) ||
// lastly check to see if the name was a levenshtein match
levenshtein(name.toLowerCase(), keys[i]) <=
MAX_LEV_DISTANCE)) {
return false;
}
}
return true;
}
function getQuery() {
var matches, type, query = $('.search-input').val();
matches = query.match(/^(fn|mod|str(uct)?|enum|trait|t(ype)?d(ef)?)\s*:\s*/i);
if (matches) {
type = matches[1].replace(/^td$/, 'typedef')
.replace(/^str$/, 'struct')
.replace(/^tdef$/, 'typedef')
.replace(/^typed$/, 'typedef');
query = query.substring(matches[0].length);
}
return {
query: query,
type: type,
id: query + type,
};
}
function initSearchNav() {
var hoverTimeout, $results = $('.search-results .result');
$results.on('click', function() {
var dst = $(this).find('a')[0];
if (window.location.pathname == dst.pathname) {
$('#search').addClass('hidden');
$('#main').removeClass('hidden');
}
document.location.href = dst.href;
}).on('mouseover', function() {
var $el = $(this);
clearTimeout(hoverTimeout);
hoverTimeout = setTimeout(function() {
$results.removeClass('highlighted');
$el.addClass('highlighted');
}, 20);
});
$(document).off('keydown.searchnav');
$(document).on('keydown.searchnav', function(e) {
var $active = $results.filter('.highlighted');
if (e.which === 38) { // up
e.preventDefault();
if (!$active.length || !$active.prev()) {
return;
}
$active.prev().addClass('highlighted');
$active.removeClass('highlighted');
} else if (e.which === 40) { // down
e.preventDefault();
if (!$active.length) {
$results.first().addClass('highlighted');
} else if ($active.next().length) {
$active.next().addClass('highlighted');
$active.removeClass('highlighted');
}
} else if (e.which === 13) { // return
e.preventDefault();
if ($active.length) {
document.location.href = $active.find('a').prop('href');
}
}
});
}
function escape(content) {
return $('<h1/>').text(content).html();
}
function showResults(results) {
var output, shown, query = getQuery();
currentResults = query.id;
output = '<h1>Results for ' + escape(query.query) +
(query.type ? ' (type: ' + escape(query.type) + ')' : '') + '</h1>';
output += '<table class="search-results">';
if (results.length > 0) {
shown = [];
results.forEach(function(item) {
var name, type;
if (shown.indexOf(item) !== -1) {
return;
}
shown.push(item);
name = item.name;
type = itemTypes[item.ty];
output += '<tr class="' + type + ' result"><td>';
if (type === 'mod') {
output += item.path +
'::<a href="' + rootPath +
item.path.replace(/::/g, '/') + // '/' +
name + '/index.html" class="' +
type + '">' + name + '</a>';
} else if (type === 'static' || type === 'reexport') {
output += item.path +
'::<a href="' + rootPath +
item.path.replace(/::/g, '/') +
'/index.html" class="' + type +
'">' + name + '</a>';
} else if (item.parent !== undefined) {
var myparent = item.parent;
var anchor = '#' + type + '.' + name;
output += item.path + '::' + myparent.name +
'::<a href="' + rootPath +
item.path.replace(/::/g, '/') +
'/' + myparent.name +
'.html' + anchor +
'" class="' + type +
'">' + name + '</a>';
} else {
output += item.path +
'::<a href="' + rootPath +
item.path.replace(/::/g, '/') +
'/' + name +
'.html" class="' + type +
'">' + name + '</a>';
}
output += '</td><td><span class="desc">' + item.desc +
'</span></td></tr>';
});
} else {
output += 'No results - Request function at <a href="https://github.com/ElunaLuaEngine/Eluna/issues">Eluna issue tracker</a>';
}
output += "</p>";
$('#main.content').addClass('hidden');
$('#search.content').removeClass('hidden').html(output);
$('#search .desc').width($('#search').width() - 40 -
$('#search td:first-child').first().width());
initSearchNav();
}
function search(e) {
var query,
filterdata = [],
obj, i, len,
results = [],
maxResults = 200,
resultIndex;
var params = getQueryStringParams();
query = getQuery();
if (e) {
e.preventDefault();
}
if (!query.query || query.id === currentResults) {
return;
}
// Because searching is incremental by character, only the most
// recent search query is added to the browser history.
// Do not do this on local due to chrome security errors.
// http://stackoverflow.com/a/32454237/3586583
if (browserSupportsHistoryApi() && window.location.protocol != "file:") {
if (!history.state && !params.search) {
history.pushState(query, "", "?search=" +
encodeURIComponent(query.query));
} else {
history.replaceState(query, "", "?search=" +
encodeURIComponent(query.query));
}
}
resultIndex = execQuery(query, 20000, index);
len = resultIndex.length;
for (i = 0; i < len; ++i) {
if (resultIndex[i].id > -1) {
obj = searchIndex[resultIndex[i].id];
filterdata.push([obj.name, obj.ty, obj.path, obj.desc]);
results.push(obj);
}
if (results.length >= maxResults) {
break;
}
}
showResults(results);
}
// This mapping table should match the discriminants of
// `rustdoc::html::item_type::ItemType` type in Rust.
var itemTypes = ["mod",
"struct",
"type",
"fn",
"type",
"static",
"trait",
"impl",
"viewitem",
"tymethod",
"method",
"structfield",
"variant",
"ffi",
"ffs",
"macro",
"primitive"];
function itemTypeFromName(typename) {
for (var i = 0; i < itemTypes.length; ++i) {
if (itemTypes[i] === typename) return i;
}
return -1;
}
function buildIndex(rawSearchIndex) {
searchIndex = [];
var searchWords = [];
for (var crate in rawSearchIndex) {
if (!rawSearchIndex.hasOwnProperty(crate)) { continue }
// an array of [(Number) item type,
// (String) name,
// (String) full path or empty string for previous path,
// (String) description,
// (optional Number) the parent path index to `paths`]
var items = rawSearchIndex[crate].items;
// an array of [(Number) item type,
// (String) name]
var paths = rawSearchIndex[crate].paths;
// convert `paths` into an object form
var len = paths.length;
for (var i = 0; i < len; ++i) {
paths[i] = {ty: paths[i][0], name: paths[i][1]};
}
// convert `items` into an object form, and construct word indices.
//
// before any analysis is performed lets gather the search terms to
// search against apart from the rest of the data. This is a quick
// operation that is cached for the life of the page state so that
// all other search operations have access to this cached data for
// faster analysis operations
var len = items.length;
var lastPath = "";
for (var i = 0; i < len; ++i) {
var rawRow = items[i];
var row = {crate: crate, ty: rawRow[0], name: rawRow[1],
path: rawRow[2] || lastPath, desc: rawRow[3],
parent: paths[rawRow[4]]};
searchIndex.push(row);
if (typeof row.name === "string") {
var word = row.name.toLowerCase();
searchWords.push(word);
} else {
searchWords.push("");
}
lastPath = row.path;
}
}
return searchWords;
}
function startSearch() {
var keyUpTimeout;
$('.do-search').on('click', search);
$('.search-input').on('keyup', function() {
clearTimeout(keyUpTimeout);
keyUpTimeout = setTimeout(search, 100);
});
// Push and pop states are used to add search results to the browser
// history.
if (browserSupportsHistoryApi()) {
$(window).on('popstate', function(e) {
var params = getQueryStringParams();
// When browsing back from search results the main page
// visibility must be reset.
if (!params.search) {
$('#main.content').removeClass('hidden');
$('#search.content').addClass('hidden');
}
// When browsing forward to search results the previous
// search will be repeated, so the currentResults are
// cleared to ensure the search is successful.
currentResults = null;
// Synchronize search bar with query string state and
// perform the search. This will empty the bar if there's
// nothing there, which lets you really go back to a
// previous state with nothing in the bar.
$('.search-input').val(params.search);
// Some browsers fire 'onpopstate' for every page load
// (Chrome), while others fire the event only when actually
// popping a state (Firefox), which is why search() is
// called both here and at the end of the startSearch()
// function.
search();
});
}
search();
}
index = buildIndex(rawSearchIndex);
startSearch();
// Draw a convenient sidebar of known crates if we have a listing
if (rootPath == '../') {
var sidebar = $('.sidebar');
var div = $('<div>').attr('class', 'block crate');
div.append($('<h2>').text('All Classes'));
var crates = [];
for (var crate in rawSearchIndex) {
if (!rawSearchIndex.hasOwnProperty(crate)) { continue }
crates.push(crate);
}
crates.sort();
for (var i = 0; i < crates.length; ++i) {
var klass = 'crate';
if (crates[i] == window.currentCrate) {
klass += ' current';
}
div.append($('<a>', {'href': '../' + crates[i] + '/index.html',
'class': klass}).text(crates[i]));
}
sidebar.append(div);
}
}
window.initSearch = initSearch;
window.register_implementors = function(imp) {
var list = $('#implementors-list');
var libs = Object.getOwnPropertyNames(imp);
for (var i = 0; i < libs.length; ++i) {
if (libs[i] == currentCrate) continue;
var structs = imp[libs[i]];
for (var j = 0; j < structs.length; ++j) {
var code = $('<code>').append(structs[j]);
$.each(code.find('a'), function(idx, a) {
var href = $(a).attr('href');
if (!href.startsWith('http')) {
$(a).attr('href', rootPath + $(a).attr('href'));
}
});
var li = $('<li>').append(code);
list.append(li);
}
}
};
if (window.pending_implementors) {
window.register_implementors(window.pending_implementors);
}
// See documentation in html/render.rs for what this is doing.
var query = getQueryStringParams();
if (query['gotosrc']) {
window.location = $('#src-' + query['gotosrc']).attr('href');
}
$("#expand-all").on("click", function() {
$(".docblock").show();
$(".toggle-label").hide();
$(".toggle-wrapper").removeClass("collapsed");
$(".collapse-toggle").children(".inner").html("-");
});
$("#collapse-all").on("click", function() {
$(".docblock").hide();
$(".toggle-label").show();
$(".toggle-wrapper").addClass("collapsed");
$(".collapse-toggle").children(".inner").html("+");
});
$(document).on("click", ".collapse-toggle", function() {
var toggle = $(this);
var relatedDoc = toggle.parent().next();
if (relatedDoc.is(".docblock")) {
if (relatedDoc.is(":visible")) {
relatedDoc.slideUp({duration:'fast', easing:'linear'});
toggle.parent(".toggle-wrapper").addClass("collapsed");
toggle.children(".inner").html("+");
toggle.children(".toggle-label").fadeIn();
} else {
relatedDoc.slideDown({duration:'fast', easing:'linear'});
toggle.parent(".toggle-wrapper").removeClass("collapsed");
toggle.children(".inner").html("-");
toggle.children(".toggle-label").hide();
}
}
});
$(function() {
var toggle = "<a href='javascript:void(0)'"
+ "class='collapse-toggle'>[<span class='inner'>-</span>]</a>";
$(".method").each(function() {
if ($(this).next().is(".docblock")) {
$(this).children().first().after(toggle);
}
});
var mainToggle = $(toggle);
mainToggle.append("<span class='toggle-label' style='display:none'>"
+ "&nbsp;Expand&nbsp;description</span></a>")
var wrapper = $("<div class='toggle-wrapper'>");
wrapper.append(mainToggle);
$("#main > .docblock").before(wrapper);
});
}());
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/static/normalize.css
Vendored
+1
View File
@@ -0,0 +1 @@
/*! normalize.css v3.0.0 | MIT License | git.io/normalize */html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:bold}dfn{font-style:italic}h1{font-size:2em;margin:.67em 0}mark{background:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-0.5em}sub{bottom:-0.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0}button{overflow:visible}button,select{text-transform:none}button,html input[type="button"],input[type="reset"],input[type="submit"]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}input{line-height:normal}input[type="checkbox"],input[type="radio"]{box-sizing:border-box;padding:0}input[type="number"]::-webkit-inner-spin-button,input[type="number"]::-webkit-outer-spin-button{height:auto}input[type="search"]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}input[type="search"]::-webkit-search-cancel-button,input[type="search"]::-webkit-search-decoration{-webkit-appearance:none}fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}legend{border:0;padding:0}textarea{overflow:auto}optgroup{font-weight:bold}table{border-collapse:collapse;border-spacing:0}td,th{padding:0}
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/_base.html
+106
View File
@@ -0,0 +1,106 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="{% block description %}API documentation for the Eluna engine.{% endblock %}">
<meta name="keywords" content="eluna, lua, lua engine, azerothcore, script, scripting, doc, docs, documentation">
<title>{% block title %}Eluna API{% endblock %}</title>
<link rel="stylesheet" type="text/css" href="{{ static('main.css') }}">
<link rel="stylesheet" type="text/css" href="{{ static('dark.css') }}">
<link rel="shortcut icon" href="{{ static('favicon.ico') }}">
</head>
<body class="rustdoc">
<!--[if lte IE 8]>
<div class="warning">
This old browser is unsupported and will most likely display funky
things.
</div>
<![endif]-->
<section class="sidebar">
<a href='{{ root('index.html') }}'><img src='{{ static('eluna-logo.png') }}' alt='Eluna Logo' width='100'></a>
<div class="block">
{% block sidebar %}
<h2>All Classes</h2>
{% for class in classes -%}
<a class="mod {{ 'current' if class == current_class }}" href="{{ root(class.name + '/index.html') }}">{{ class.name }}</a>
{%- endfor %}
{% endblock %}
</div>
</section>
<nav class="sub">
<form class="search-form js-only">
<div class="search-container">
<input class="search-input" name="search"
autocomplete="off"
placeholder="Click or press 'S' to search, '?' for more options..."
type="search">
</div>
</form>
</nav>
<section id='main' class="content mod">
<h1 class='fqn'>
{% block document_title %}Title Missing{% endblock %}
<span class='out-of-band'>
<span id='render-detail'>
<a id="collapse-all" href="#">[-]</a>
<a id="expand-all" href="#">[+]</a>
</span>
</span>
</h1>
{% block content %}<h2>Content missing.</h2>{% endblock %}
</section>
<section id='search' class="content hidden"></section>
<section class="footer"></section>
<div id="help" class="hidden">
<div class="shortcuts">
<h1>Keyboard shortcuts</h1>
<dl>
<dt>?</dt>
<dd>Show this help dialog</dd>
<dt>S</dt>
<dd>Focus the search field</dd>
<dt>&larrb;</dt>
<dd>Move up in search results</dd>
<dt>&rarrb;</dt>
<dd>Move down in search results</dd>
<dt>&#9166;</dt>
<dd>Go to active search result</dd>
</dl>
</div>
<div class="infos">
<h1>Search tricks</h1>
<p>
Prefix searches with a type followed by a colon (e.g.
<code>fn:</code>) to restrict the search to a given type.
</p>
<p>
Accepted types are: <code>fn</code>, <code>mod</code>,
<code>struct</code> (or <code>str</code>), <code>enum</code>,
<code>trait</code>, <code>typedef</code> (or
<code>tdef</code>).
</p>
</div>
</div>
<script>
window.rootPath = "{{ ('../' * level) if level }}";
</script>
<script src="{{ static('jquery.js') }}"></script>
<script src="{{ static('main.js') }}"></script>
<script async src="{{ root('search-index.js') }}"></script>
<center>Generated on <script src="{{ root('date.js') }}"></script></center>
<center>&copy;2016 - Eluna Lua Engine</center>
</body>
</html>
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/class.html
+40
View File
@@ -0,0 +1,40 @@
{% extends '_base.html' %}
{% block title -%}
{{ current_class.name }} - {{ super() }}
{%- endblock %}
{% block description -%}
API documentation for the {{ current_class.name }} class in the Eluna engine.
{%- endblock %}
{% block document_title -%}
Class <a class="mod" href="">{{ current_class.name }}</a>
{%- endblock %}
{% block sidebar %}
{% endblock %}
{% block content %}
{{ current_class.description|parse_links }}
<h2 id='methods' class='section-header'><a href="#methods">Methods</a></h2>
<table>
{%- for method in current_class.methods %}
<tr>
<td>
<a class='stability {{ 'Stable' if method.documented else 'Experimental' }}' title='{{ 'Documented' if method.documented else 'Undocumented' }}'></a>
<a class='fn' href='{{ method.name }}.html'>{{ method.name }}</a>
</td>
<td class='docblock short'>
<p>{{ method.short_description|parse_links }}</p>
</td>
</tr>
{%- endfor %}
</table>
{% endblock %}
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/date.js
+1
View File
@@ -0,0 +1 @@
document.write("{{ currdate }}");
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/enum.html
+1
View File
@@ -0,0 +1 @@
{% extends '_base.html' %}
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/index.html
+90
View File
@@ -0,0 +1,90 @@
{% extends '_base.html' %}
{% block document_title -%}
Eluna API Documentation
{%- endblock %}
{% block content %}
<div class='docblock'>
<h1 id="the-eluna-engine-api" class='section-header'>
<a href="#the-eluna-engine-api">The Eluna Lua Engine&copy; API</a>
</h1>
<p>
The Eluna Lua Engine&copy; API allows you to add your own Lua code to be executed when certain events (called "hooks") occur.
</p>
<p>
Add a new in-game command, give life to creatures with new AI, or even light players who try to duel on fire!
If the hook exists, you can script it.
</p>
<h2 id="about-eluna" class='section-header'>
<a href="#about-eluna">About Eluna</a>
</h2>
<p>
Eluna is a <a href="http://www.lua.org/">Lua</a> engine for World of Warcraft emulators.
These pages are for <a href="https://www.azerothcore.org/">AzerothCore</a>'s version, but Eluna also supports
<a href="https://cmangos.net/">CMaNGOS</a>/<a href="https://www.getmangos.eu/">MaNGOS</a> and <a href="https://www.trinitycore.org/">TrinityCore</a>.
</p>
<p>
If you come from the TypeScript / JavaScript world, or would prefer to use a typed language instead of Lua, check out <a href="https://github.com/azerothcore/eluna-ts">eluna-ts</a>!
</p>
<p>
You can get support in the <code>#eluna-ac</code> channel of <a href="https://discord.com/invite/V3Dkwxvh">AzerothCore's Discord server</a>.
</p>
<p>
You can also join the <a href="https://discord.com/invite/bjkCVWqqfX">official Eluna Discord server</a>, where you'll be able to find resources, releases and support provided by the Eluna community.
</p>
<h2 id="installation" class='section-header'>
<a href="#installation">How to Install</a>
</h2>
<p>
<ol>
<li>If you haven't already, clone AzerothCore from <a href="https://github.com/azerothcore/azerothcore-wotlk">our GitHub repository</a></li>
<li>Go to the modules directory and run the following command: <pre>git clone https://github.com/azerothcore/mod-eluna.git mod-eluna</pre></li>
<li>Run CMake</li>
<li>Build AzerothCore</li>
</ol>
</p>
<!-- <h2 id="tutorials-and-guides" class='section-header'>
<a href="#tutorials-and-guides">Tutorials & Guides</a>
</h2>
<p>
We haven't written tutorials yet, but when we do, we'll put the links here.
</p> -->
<h2 id="about-this-documentation" class='section-header'>
<a href="#about-this-documentation">About this Documentation</a>
</h2>
<p>
The layout, CSS, and Javascript code for this documentation was borrowed from <a href="http://doc.rust-lang.org/">doc.rust-lang.org</a>.
</p>
<p>
The documentation generator was originally written by <a href="https://github.com/Patman64">Patman64</a> and is maintained by the Eluna team.
</p>
</div>
<h2 id='modules' class='section-header'><a href="#modules">Classes</a></h2>
<table>
{%- for class in classes %}
<tr>
<td>
{%- if class.fully_documented %}
<a class='stability Stable' title='Fully Documented'></a>
{%- elif class.fully_undocumented %}
<a class='stability Experimental' title='Fully Undocumented'></a>
{%- else %}
<a class='stability Unstable' title='Partially Documented'></a>
{%- endif %}
<a class='mod' href='{{ root(class.name + '/index.html') }}'>{{ class.name }}</a>
</td>
<td class='docblock short'>
<p>{{ class.short_description|parse_links }}</p>
</td>
</tr>
{%- endfor %}
</table>
{% endblock %}
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/method.html
+95
View File
@@ -0,0 +1,95 @@
{% extends '_base.html' %}
{% block title -%}
{{ current_class.name }}:{{ current_method.name }} - Eluna
{%- endblock %}
{% block description -%}
API documentation for the {{ current_class.name }}:{{ current_method.name }} method in the Eluna engine.
{%- endblock %}
{% block document_title -%}
Method
<a class="mod" href="{{ root(current_class.name + '/index.html') }}">
{{- current_class.name -}}
</a>:<a class="fn" href="{{ root(current_class.name + '/' + current_method.name + '.html') }}">
{{- current_method.name -}}
</a>
{%- endblock %}
{% block sidebar %}
<h2>{{ current_class.name }} Methods</h2>
<script src="sidebar.js"></script>
<script>
// Highlight current method by adding "current" class to it
var element = document.getElementById("{{ current_class.name + ':' + current_method.name }}");
if (element) {
var classname = "current";
arr = element.className.split(" ");
if (arr.indexOf(classname) == -1) {
element.className += " " + classname;
}
}
</script>
{% endblock %}
{% block content %}
<div class='docblock'>
{%- if current_method.documented %}
{{ current_method.description|parse_links }}
{%- else %}
<p>This method is <em>undocumented</em>. <strong>Use at your own risk.</strong></p>
<p>For temporary documentation, please check the <a href="https://github.com/ElunaLuaEngine/Eluna/blob/master/LuaFunctions.cpp">LuaFunctions</a> source file.</p>
{%- endif %}
<h2 id="synopsis" class='section-header'>
<a href="#synopsis">Synopsis</a>
</h2>
{%- for prototype in current_method.prototypes %}
<p>
<code>{{ prototype }}</code>
</p>
{%- endfor %}
<h2 id="arguments" class='section-header'>
<a href="#arguments">Arguments</a>
</h2>
<p>
{%- if current_method.parameters|length > 0 %}
{%- for param in current_method.parameters %}
<dl>
<dt><code>{{ param.data_type|escape|parse_data_type }} {{ param.name if param.data_type != '...' }} {{- ' (' + param.default_value + ')' if param.default_value }}</code></dt>
<dd class="docblock">{{ param.description|parse_links if param.description else '<em>See method description.</em>' }}</dd>
</dl>
{%- endfor %}
{%- elif not current_method.documented %}
Unknown.
{%- else %}
None.
{%- endif %}
</p>
<h2 id="returns" class='section-header'>
<a href="#returns">Returns</a>
</h2>
<p>
{%- if current_method.returned|length > 0 %}
{%- for returned in current_method.returned %}
<dl>
<dt><code>{{ returned.data_type|escape|parse_data_type }} {{ returned.name }}</code></dt>
<dd class="docblock">{{ returned.description|parse_links if returned.description else '<em>See method description.</em>' }}</dd>
</dl>
{%- endfor %}
{%- elif not current_method.documented %}
Unknown.
{%- else %}
Nothing.
{%- endif %}
</p>
</div>
{% endblock %}
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/search-index.js
+15
View File
@@ -0,0 +1,15 @@
var searchIndex = {};
{% for class in classes -%}
searchIndex["{{ class.name }}"] = {
"items": [
[0, "", "{{ class.name }}", "{{ class.short_description|replace('\n', ' ')|replace('\"', '&#34;')|parse_links|replace('"', '\\"') }}"],
{%- for method in class.methods %}
[3, "{{ method.name }}", "", "{{ method.short_description|replace('\n', ' ')|replace('\"', '&#34;')|parse_links|replace('"', '\\"') }}"],
{%- endfor %}
],
"paths": []
};
{%- endfor %}
initSearch(searchIndex);
modules/mod-eluna/src/LuaEngine/docs/ElunaDoc/templates/sidebar.js
+5
View File
@@ -0,0 +1,5 @@
document.write(`
{%- for method in current_class.methods %}
<a id="{{ current_class.name + ':' + method.name }}" class="fn" href="{{ root(current_class.name + '/' + method.name + '.html') }}">{{ method.name }}</a>
{%- endfor %}
`);
modules/mod-eluna/src/LuaEngine/docs/IMPL_DETAILS.md
+102
View File
@@ -0,0 +1,102 @@
# Eluna features
This article contains information about features and important notes regarding Eluna.
## Settings
Eluna has some settings in the server configuration file.
It is important that you use the new configuration file that you get from compiling after adding Eluna. If the new configuration file is not used you will not receive any error log or output to console.
The configuration file includes at least the following settings:
- enable and disable Eluna
- enable and disable traceback function - this adds extra debug information if you have the default Eluna extensions.
- configure script folder location
- configure Eluna logging settings
## Reloading
To make testing easier it is good to know that Eluna scripts can be reloaded by using the command `.reload eluna`.
However this command should be used for development purposes __ONLY__. If you are having issues getting something working __restart__ the server.
It is important to know that reloading does not trigger for example the login hook for players that are already logged in when reloading.
## Script loading
Eluna loads scripts from the `lua_scripts` folder by default. You can configure the folder name and location in the server configuration file.
Any hidden folders are not loaded. All script files must have an unique name, otherwise an error is printed and only the first file found is loaded.
The loading order is not guaranteed to be alphabetic.
Any file having `.ext` extension, for example `test.ext`, is loaded before normal lua files.
Instead of the ext special feature however it is recommended to use the basic lua `require` function.
The whole script folder structure is added automatically to the lua require path so using require is as simple as providing the file name without any extension for example `require("runfirst")` to require the file `runfirst.lua`.
## Automatic conversion
In C++ level code you have types like `Unit` and `Creature` and `Player`.
When in code you have an object of type `Unit` you need to convert it to a `Creature` or a `Player` object to be able to access the methods of the subclass.
In Eluna this is automatic. All objects are automatically converted to the correct type and you will always have full access to all member functions of an object.
## Storing userdata
Storing userdata objects over time that are memory managed by C++ is a bad idea.
For example you should never save a player to a global variable and then try access it in a timed event. The reason is that the player object in C++ is a pointer to an object that C++ can delete at any time. When time passes the player may have logged out and using the pointer after player object no longer exists can be catastrophic.
To prevent users from doing this objects that are memory managed by C++ are automatically turned into nil when they are no longer safe to be accessed - this means usually after the hooked function ends.
Instead of storing the object itself you can use store guids `player:GetGUID()` and fetch the object by the guid with `map:GetWorldObject(guid)`.
Any userdata object that is memory managed by lua is safe to store over time. These objects include but are not limited to: query results, worldpackets, uint64 and int64 numbers.
## Userdata metamethods
All userdata objects in Eluna have tostring metamethod implemented.
This allows you to print the player object for example and to use `tostring(player)`.
The userdata uses metatables that contain the methods and functions it uses.
These tables are globally accessible by using the type name. For example `Player` is a global table containing all Player methods.
You can define new methods in lua for a class using these global tables.
```lua
function Player:CustomFunc(param1)
-- self is the player the method is used on
self:SendBroadcastMessage(param1)
end
function GameObject:CustomFunc(param1)
-- self is the gameobject the method is used on
print(self:GetName())
end
-- Example use:
player:CustomFunc("test")
gob:CustomFunc("test2")
```
It is recommended that in normal code these global tables and their names (variables starting with capital letters like Player, Creature, GameObject, Spell..) are avoided so they are not unintentionally edited or deleted causing other scripts possibly not to function.
## Database
Database is a great thing, but it has it's own issues.
### Querying
Database queries are slow. The whole server has to wait for the script to fetch the data from disk before continuing. Compared to reading cache or RAM reading from disk is the same as going to the moon to fetch the data (no pun intended).
Depending on what you need, prefer database Execute over Query when not selecting anything from the database. Database Executes are made asynchronously and they will not keep the server waiting.
Move all database queries possible to the script loading, server startup or similar one time event and use cache tables to manage the data in scripts.
### Types
__Database types should be followed strictly.__
Mysql does math in bigint and decimal formats which is why a simple select like `SELECT 1;` actually returns a bigint.
If you fetch a bigint or decimal using a function for a smaller type it is possible the value is read incorrectly.
For example the same code for fetching the result of `SELECT 1;` returned 1 on one machine and 0 on another. Using the correct function, in this case GetInt64, the right result was returned on both. https://github.com/ElunaLuaEngine/Eluna/issues/89#issuecomment-64121361
| base type | defined type | database type |
|---------------------------|--------------|-----------------------|
| char | int8 | tinyint(3) |
| short int | int16 | smallint(5) |
| (long int / int) | int32 | mediumint(8) |
| (long int / int) | int32 | int(10) |
| long long int | int64 | bigint(20) |
| unsigned char | uint8 | tinyint(3) unsigned |
| unsigned short int | uint16 | smallint(5) unsigned |
| unsigned (long int / int) | uint32 | mediumint(8) unsigned |
| unsigned (long int / int) | uint32 | int(10) unsigned |
| unsigned long long int | uint64 | bigint(20) unsigned |
| float | float | float |
| double | double | double and decimal |
| std::string | std::string | any text type |
modules/mod-eluna/src/LuaEngine/docs/INSTALL.md
+42
View File
@@ -0,0 +1,42 @@
# Installing and updating
This page will help you get a cMaNGOS and a TrinityCore source with Eluna.
If you are looking to get MaNGOS source with Eluna head over to [MaNGOS forum](http://getmangos.eu/) for the installation and updating instructions - however read this page also as it contains important information.
If you are having trouble with the installation or updating the core source, head over to our [support forum](../README.md#documentation).
If you are looking for a way to merge eluna with a fork of the official repositories see [merging](MERGING.md).
### Requirements and dependencies:
**Eluna uses `C++11` so you need a compiler that supports it.**
**Eluna can use ACE or BOOST for filesystem library.**
Additionally see you desired core's documentation and installation instructions for it's requirements and dependencies.
### Installation
1. Open [git bash](http://git-scm.com/) and navigate to where you want the core source
2. Choose the git address of your desired core and patch below and clone the core with `git clone <address>`.
For example `git clone https://github.com/ElunaLuaEngine/ElunaTrinityWotlk.git`
* TrinityCore WoTLK: `https://github.com/ElunaLuaEngine/ElunaTrinityWotlk.git`
* cMaNGOS Classic: `https://github.com/ElunaLuaEngine/ElunaMangosClassic.git`
* cMaNGOS TBC: `https://github.com/ElunaLuaEngine/ElunaMangosTbc.git`
* cMaNGOS WoTLK: `https://github.com/ElunaLuaEngine/ElunaMangosWotlk.git`
3. Navigate to the newly created source folder with `git bash`
4. Use the git command `git submodule init` followed by `git submodule update`
* If you really do not get how to use git bash (and do try!) you can navigate to the `LuaEngine` folder and clone the [eluna repository](https://github.com/ElunaLuaEngine/Eluna) there. This is not recommended though.
4. Continue compiling the core normally using the official instructions
* [TrinityCore](http://collab.kpsn.org/display/tc/Installation+Guide)
* [cMaNGOS](https://github.com/cmangos/issues/wiki/Installation-Instructions)
__Important!__ After compiling use the new configuration files. They contain Eluna settings and without them Eluna may not function correctly. For example you do not get any error messages or error log.
After installing Eluna you should check out these:
- [Eluna getting started](USAGE.md)
- [Eluna features](IMPL_DETAILS.md)
### Updating
Updating is essentially handled in the same manner as you would normally update the core and database.
To get the newest core source code open `git bash` and navigate to your local source folder.
Then execute use `git pull` followed by `git submodule init` and `git submodule update`.
After updating the source you need to recompile the core normally. Simply use `CMake` if needed and compile.
To update the databases refer to the core's or database's official updating documents:
* [TrinityCore](http://collab.kpsn.org/display/tc/Databases+Installation)
* [cMaNGOS](https://github.com/cmangos/issues/wiki/Installation-Instructions)
modules/mod-eluna/src/LuaEngine/docs/MERGING.md
+42
View File
@@ -0,0 +1,42 @@
# Merging Eluna
Eluna can be added to various sources by applying the core changes required for Eluna to function.
Below you find the guides for merging Eluna with each core or a fork of it.
If you choose to merge you should be able to maintain and update yourself - we do not maintain your core. View Unofficial Merging below.
We also do not fix any merging errors you may have, but you are free to ask about them on the [support forum](../README.md#documentation) and we may assist.
We recommend using the [installation guide](INSTALL.md) especially if you are not familiar with git and updating the code.
It allows you to simply use `git pull` followed by `git submodule update` to update your source and we will handle the merging and maintenance with the official core source. Naturally you still need to handle updating the database as instructed by the core's wiki or instructions.
### Merging Eluna with MaNGOS
Eluna is merged with [official MaNGOS](http://getmangos.eu/) by default.
### Merging Eluna with cMaNGOS
```
git clone https://github.com/cmangos/mangos-wotlk.git
cd mangos-wotlk
git pull --recurse-submodules https://github.com/ElunaLuaEngine/ElunaMangosWotlk.git
```
Steps explained:
1. clone the core or fork source or get the it by other means
2. navigate to the source folder
3. pull the Eluna fork. This will fetch the repository and merge it with your source.
* `--recurse-submodules` will automatically pull the submodules (Eluna repository). You may need to use `git submodule init` followed by `git submodule update` if your Eluna folder is empty
* it is important that you choose the correct Eluna fork for your core andpatch:
* [Eluna cMaNGOS Classic](https://github.com/ElunaLuaEngine/ElunaMangosClassic)
* [Eluna cMaNGOS TBC](https://github.com/ElunaLuaEngine/ElunaMangosTbc)
* [Eluna cMaNGOS WotLK](https://github.com/ElunaLuaEngine/ElunaMangosWotlk)
### Merging Eluna with TrinityCore
```
git clone https://github.com/TrinityCore/TrinityCore.git -b3.3.5
cd TrinityCore
git pull --recurse-submodules https://github.com/ElunaLuaEngine/ElunaTrinityWotlk.git
```
Steps explained:
1. clone the core or fork source or get the it by other means
2. navigate to the source folder
3. pull the Eluna fork. This will fetch the repository and merge it with your source.
* `--recurse-submodules` will automatically pull the submodules (Eluna repository). You may need to use `git submodule init` followed by `git submodule update` if your Eluna folder is empty
* it is important that you choose the correct Eluna fork for your core and patch:
* [Eluna TrinityCore WotLK](https://github.com/ElunaLuaEngine/ElunaTrinityWotlk)
* [Eluna TrinityCore Cataclysm](https://github.com/ElunaLuaEngine/ElunaTrinityCata)
modules/mod-eluna/src/LuaEngine/docs/USAGE.md
+116
View File
@@ -0,0 +1,116 @@
# Using Eluna
Eluna is a lua engine implementation for world of warcraft emulators.
It can be used to create different kind of scripts from AI to events.
This article helps you to get started with Eluna. We go through adding a simple script, where to get information from and a few language basics.
This article assumes you have already installed Eluna successfully. If you have not, see [installation](INSTALL.md).
## Basic script
Here is a simple "Hello world" example.
Create a file named `hello world.lua` that contains the following code and place the file inside the scripts folder in your server folder. By default the scripts folder is called `lua_scripts`. The server folder is the folder which contains server executables.
```lua
local PLAYER_EVENT_ON_LOGIN = 3
local function OnLogin(event, player)
player:SendBroadcastMessage("Hello world")
end
RegisterPlayerEvent(PLAYER_EVENT_ON_LOGIN, OnLogin)
```
If you now restart your server and log in game you are greeted with "Hello world" in your chat.
### What happened
As you have witnessed here no core compiling was needed and your script runs from the file you just created.
The file is compiled and run by the lua engine when the server starts up or Eluna is reloaded.
The code in the file registers a function to be run when a player logs in and the function sends a message to the player that logged in.
## Lua basics
It is good to get to know a bit of lua to code lua scripts. In this article we do not go that much into explaining lua syntax. Here are some pointers to important sources of information and things to get to know about.
### Sources of information
- lua users wiki
- http://lua-users.org/wiki/LuaDirectory
- http://lua-users.org/wiki/TutorialDirectory
- http://lua-users.org/wiki/SampleCode
- programming in lua http://www.lua.org/pil/1.html
- lua reference manual http://www.lua.org/manual/5.2/
### some highlights
- Print function outputs to server console. Very useful for simple debugging `print("anything here")`.
- control structures - especially loops:
- http://lua-users.org/wiki/ControlStructureTutorial
- http://www.lua.org/manual/5.2/manual.html#3.3.5
- lua string library:
- http://lua-users.org/wiki/StringLibraryTutorial
- http://www.wowwiki.com/Pattern_matching
- Lua tables are the only container in lua and they are essential for good code. Lua tables can be compared to arrays and hash maps.
Table functions and tutorials:
- http://www.lua.org/manual/5.2/manual.html#6.5
- http://www.lua.org/manual/5.2/manual.html#4.3
- http://lua-users.org/wiki/TablesTutorial
- http://www.lua.org/pil/2.5.html
- prefer local variables over global. While global variables may work they can create issues with other scripts that use same variable names.
All local variables outside of functions in a script are shared by everything running the same script - the variables are locally global.
## Eluna basics
It is good to know where you can find information about Eluna and Eluna's API as well as the basic elements of a script. Here are links to the main sources of information:
- Eluna features [Eluna details](IMPL_DETAILS.md)
- Eluna documentation http://elunaluaengine.github.io/
### Error messages
If Eluna is installed correctly, the default installation should make errors output to the console as well as a log file in the server folder. If you can not get your script to work, be sure to check the log file for any errors you might have missed.
Check out the configuration file for settings if you want to tweak the logging settings.
### Global functions
Global functions are functions you can run from anywhere in a script file and they do not require any object to be run.
In addition to normal global functions lua provides like `print` Eluna has it's own gobal functions. You can find them in the documentation under `global` class: [global functions](http://elunaluaengine.github.io/Global/index.html).
```lua
-- print the return value of GetLuaEngine function
print(GetLuaEngine())
```
### Member functions
Member functions, also called methods, are functions that require an userdata object to run. There are several different classes of objects that have different member functions. You can find all the member functions and their documentations from the [Eluna documentation](http://elunaluaengine.github.io/).
Classes in C++ inherit each other. In Eluna member functions are also inherited. For example objects of classes `Player` and `Creature` inherit all methods from `Unit` class.
Methods are called by using `:` notation on the object. For example to get the player name you can call the GetName methods like this: `player:GetName()`
```lua
local entry = 6
local on_combat = 1
local function OnCombat(event, creature, target)
-- creature is of type Creature
-- target is of type Creature or Player depending on who the creature is attacking
print(creature:GetLevel())
print(target:GetLevel())
end
RegisterCreatureEvent(entry, on_combat, OnCombat)
```
### Registering functions to events
Scripts register functions to events and the functions are executed when the event happens.
There are special global functions in Eluna API for registering functions for events.
You should be able to find all such functions from [Eluna documentation](http://elunaluaengine.github.io/) by searching `register`.
Functions used to register other functions for events need the ID of the event you want the hook to be registered for passed to them. You can find these ID numbers from the registering function documentation page.
Eluna passes some arguments to the functions executed. The arguments are always in same order. You can name them in any way you want. In the above script example the event `PLAYER_EVENT_ON_LOGIN` passes the event id and the player who logs in to the registered function. This is why the registered function has these parameters defined: `(event, player)`.
Some events allow the registered function to return different values. Sometimes you can return more than one value. The possibility to return is documented on the registering function's documentation page. Simply using the `return` keyword returns normally as if the function would end.
For example in this script we register the function `OnCombat` to be run on event `1`, which triggers on combat, for the creature entry `6`. All needed information can be found here: http://elunaluaengine.github.io/Global/RegisterCreatureEvent.html
```lua
local entry = 6
local on_combat = 1
local function OnCombat(event, creature, target)
creature:SendUnitYell("Yiee, me run!", 0)
end
RegisterCreatureEvent(entry, on_combat, OnCombat)
```
modules/mod-eluna/src/LuaEngine/extensions/ObjectVariables.ext
+115
View File
@@ -0,0 +1,115 @@
--
-- Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
-- This program is free software licensed under GPL version 3
-- Please see the included DOCS/LICENSE.md for more information
--
-- filename.ext files are loaded before normal .lua files
--
-- This extension allows saving data to specific object for it's lifetime in current runtime session
-- Supports Map, Player, Creature, GameObject
--
-- SetData sets a value
-- obj:SetData(key, val)
--
-- GetData gets the data table or a specific value by key from it
-- local tbl = obj:GetData()
-- local val = obj:GetData(key)
--
local pairs = pairs
local variableStores = {
Map = {},
Player = {},
Creature = {},
GameObject = {},
}
local function DestroyMapData(event, obj)
local map = obj:GetMapId()
local inst = obj:GetInstanceId()
for k,v in pairs(variableStores) do
local mapdata = v[map]
if mapdata then
mapdata[inst] = nil
end
end
end
local function DestroyObjData(event, obj)
local otype = obj:GetObjectType()
local guid = otype == "Map" and 1 or obj:GetGUIDLow()
if otype == "Player" then
variableStores[otype][guid] = nil
return
end
local map = obj:GetMapId()
local inst = obj:GetInstanceId()
local mapdata = variableStores[otype][map]
if mapdata then
local instancedata = mapdata[inst]
if instancedata then
instancedata[guid] = nil
end
end
end
local function GetData(self, field)
local otype = self:GetObjectType()
local guid = otype == "Map" and 1 or self:GetGUIDLow()
local varStore = variableStores[otype]
if otype == "Player" then
varStore[guid] = varStore[guid] or {}
if field ~= nil then
return varStore[guid][field]
end
return varStore[guid]
end
local map = self:GetMapId()
local inst = self:GetInstanceId()
varStore[map] = varStore[map] or {}
varStore[map][inst] = varStore[map][inst] or {}
varStore[map][inst][guid] = varStore[map][inst][guid] or {}
if field ~= nil then
return varStore[map][inst][guid][field]
end
return varStore[map][inst][guid]
end
local function SetData(self, field, val)
local otype = self:GetObjectType()
local guid = otype == "Map" and 1 or self:GetGUIDLow()
local varStore = variableStores[otype]
if otype == "Player" then
varStore[guid] = varStore[guid] or {}
varStore[guid][field] = val
return
end
local map = self:GetMapId()
local inst = self:GetInstanceId()
varStore[map] = varStore[map] or {}
varStore[map][inst] = varStore[map][inst] or {}
varStore[map][inst][guid] = varStore[map][inst][guid] or {}
varStore[map][inst][guid][field] = val
end
for k,v in pairs(variableStores) do
_G[k].GetData = GetData
_G[k].SetData = SetData
end
RegisterPlayerEvent(4, DestroyObjData) -- logout
RegisterServerEvent(31, DestroyObjData) -- creature delete
RegisterServerEvent(32, DestroyObjData) -- gameobject delete
RegisterServerEvent(17, DestroyMapData) -- map create
RegisterServerEvent(18, DestroyMapData) -- map destroy
modules/mod-eluna/src/LuaEngine/extensions/StackTracePlus/LICENSE
+21
View File
@@ -0,0 +1,21 @@
The MIT License
Copyright (c) 2010 Ignacio Burgueño
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
modules/mod-eluna/src/LuaEngine/extensions/StackTracePlus/README.md
+128
View File
@@ -0,0 +1,128 @@
# StackTracePlus #
[![Build Status](https://travis-ci.org/ignacio/StackTracePlus.png?branch=master)](https://travis-ci.org/ignacio/StackTracePlus)
[StackTracePlus](https://github.com/ignacio/StackTracePlus) provides enhanced stack traces for [Lua 5.1, Lua 5.2][1] and [LuaJIT][2].
StackTracePlus can be used as a replacement for debug.traceback. It gives detailed information about locals, tries to guess
function names when they're not available, etc, so, instead of
lua5.1.exe: D:\trunk_git\sources\stacktraceplus\test\test.lua:10: attempt to concatenate a nil value
stack traceback:
D:\trunk_git\sources\stacktraceplus\test\test.lua:10: in function <D:\trunk_git\sources\stacktraceplus\test\test.lua:7>
(tail call): ?
D:\trunk_git\sources\stacktraceplus\test\test.lua:15: in main chunk
[C]: ?
you'll get
lua5.1.exe: D:\trunk_git\sources\stacktraceplus\test\test.lua:10: attempt to concatenate a nil value
Stack Traceback
===============
(2) C function 'function: 00A8F418'
(3) Lua function 'g' at file 'D:\trunk_git\sources\stacktraceplus\test\test.lua:10' (best guess)
Local variables:
fun = table module
str = string: "hey"
tb = table: 027DCBE0 {dummy:1, blah:true, foo:bar}
(*temporary) = nil
(*temporary) = string: "text"
(*temporary) = string: "attempt to concatenate a nil value"
(4) tail call
(5) main chunk of file 'D:\trunk_git\sources\stacktraceplus\test\test.lua' at line 15
(6) C function 'function: 002CA480'
## Usage #
StackTracePlus can be used as a replacement for `debug.traceback`, as an `xpcall` error handler or even from C code. Note that
only the Lua 5.1 interpreter allows the traceback function to be replaced "on the fly". LuaJIT and Lua 5.2 always calls luaL_traceback internally so there is no easy way to override that.
```lua
local STP = require "StackTracePlus"
debug.traceback = STP.stacktrace
function test()
local s = "this is a string"
local n = 42
local t = { foo = "bar" }
local co = coroutine
local cr = coroutine.create
error("an error")
end
test()
```
That script will output (only with Lua 5.1):
lua5.1: example.lua:11: an error
Stack Traceback
===============
(2) C function 'function: 006B5758'
(3) global C function 'error'
(4) Lua global 'test' at file 'example.lua:11'
Local variables:
s = string: "this is a string"
n = number: 42
t = table: 006E5220 {foo:bar}
co = coroutine table
cr = C function: 003C7080
(5) main chunk of file 'example.lua' at line 14
(6) C function 'function: 00637B30'
**StackTracePlus** is aware of the usual Lua libraries, like *coroutine*, *table*, *string*, *io*, etc and functions like
*print*, *pcall*, *assert*, and so on.
You can also make STP aware of your own tables and functions by calling *add_known_function* and *add_known_table*.
```lua
local STP = require "StackTracePlus"
debug.traceback = STP.stacktrace
local my_table = {
f = function() end
}
function my_function()
end
function test(data, func)
local s = "this is a string"
error("an error")
end
STP.add_known_table(my_table, "A description for my_table")
STP.add_known_function(my_function, "A description for my_function")
test( my_table, my_function )
```
Will output:
lua5.1: ..\test\example2.lua:13: an error
Stack Traceback
===============
(2) C function 'function: 0073AAA8'
(3) global C function 'error'
(4) Lua global 'test' at file '..\test\example2.lua:13'
Local variables:
data = A description for my_table
func = Lua function 'A description for my_function' (defined at line 7 of chunk ..\test\example2.lua)
s = string: "this is a string"
(5) main chunk of file '..\test\example2.lua' at line 19
(6) C function 'function: 00317B30'
## Installation #
The easiest way to install is with [LuaRocks][3].
- luarocks install stacktraceplus
If you don't want to use LuaRocks, just copy StackTracePlus.lua to Lua's path.
## License #
**StackTracePlus** is available under the MIT license.
[1]: http://www.lua.org/
[2]: http://luajit.org/
[3]: http://luarocks.org/
modules/mod-eluna/src/LuaEngine/extensions/StackTracePlus/StackTracePlus.ext
+411
View File
@@ -0,0 +1,411 @@
-- tables
local _G = _G
local string, io, debug, coroutine = string, io, debug, coroutine
-- functions
local tostring, print, require = tostring, print, require
local next, assert = next, assert
local pcall, type, pairs, ipairs = pcall, type, pairs, ipairs
local error = error
assert(debug, "debug table must be available at this point")
local io_open = io.open
local string_gmatch = string.gmatch
local string_sub = string.sub
local table_concat = table.concat
local _M = {
max_tb_output_len = 70 -- controls the maximum length of the 'stringified' table before cutting with ' (more...)'
}
-- this tables should be weak so the elements in them won't become uncollectable
local m_known_tables = { [_G] = "_G (global table)" }
local function add_known_module(name, desc)
local ok, mod = pcall(require, name)
if ok then
m_known_tables[mod] = desc
end
end
add_known_module("string", "string module")
add_known_module("io", "io module")
add_known_module("os", "os module")
add_known_module("table", "table module")
add_known_module("math", "math module")
add_known_module("package", "package module")
add_known_module("debug", "debug module")
add_known_module("coroutine", "coroutine module")
-- lua5.2
add_known_module("bit32", "bit32 module")
-- luajit
add_known_module("bit", "bit module")
add_known_module("jit", "jit module")
local m_user_known_tables = {}
local m_known_functions = {}
for _, name in ipairs{
-- Lua 5.2, 5.1
"assert",
"collectgarbage",
"dofile",
"error",
"getmetatable",
"ipairs",
"load",
"loadfile",
"next",
"pairs",
"pcall",
"print",
"rawequal",
"rawget",
"rawlen",
"rawset",
"require",
"select",
"setmetatable",
"tonumber",
"tostring",
"type",
"xpcall",
-- Lua 5.1
"gcinfo",
"getfenv",
"loadstring",
"module",
"newproxy",
"setfenv",
"unpack",
-- TODO: add table.* etc functions
} do
if _G[name] then
m_known_functions[_G[name]] = name
end
end
local m_user_known_functions = {}
local function safe_tostring (value)
local ok, err = pcall(tostring, value)
if ok then return err else return ("<failed to get printable value>: '%s'"):format(err) end
end
-- Private:
-- Parses a line, looking for possible function definitions (in a very na?ve way)
-- Returns '(anonymous)' if no function name was found in the line
local function ParseLine(line)
assert(type(line) == "string")
--print(line)
local match = line:match("^%s*function%s+(%w+)")
if match then
--print("+++++++++++++function", match)
return match
end
match = line:match("^%s*local%s+function%s+(%w+)")
if match then
--print("++++++++++++local", match)
return match
end
match = line:match("^%s*local%s+(%w+)%s+=%s+function")
if match then
--print("++++++++++++local func", match)
return match
end
match = line:match("%s*function%s*%(") -- this is an anonymous function
if match then
--print("+++++++++++++function2", match)
return "(anonymous)"
end
return "(anonymous)"
end
-- Private:
-- Tries to guess a function's name when the debug info structure does not have it.
-- It parses either the file or the string where the function is defined.
-- Returns '?' if the line where the function is defined is not found
local function GuessFunctionName(info)
--print("guessing function name")
if type(info.source) == "string" and info.source:sub(1,1) == "@" then
local file, err = io_open(info.source:sub(2), "r")
if not file then
print("file not found: "..tostring(err)) -- whoops!
return "?"
end
local line
for i = 1, info.linedefined do
line = file:read("*l")
end
if not line then
print("line not found") -- whoops!
return "?"
end
return ParseLine(line)
else
local line
local lineNumber = 0
for l in string_gmatch(info.source, "([^\n]+)\n-") do
lineNumber = lineNumber + 1
if lineNumber == info.linedefined then
line = l
break
end
end
if not line then
print("line not found") -- whoops!
return "?"
end
return ParseLine(line)
end
end
---
-- Dumper instances are used to analyze stacks and collect its information.
--
local Dumper = {}
Dumper.new = function(thread)
local t = { lines = {} }
for k,v in pairs(Dumper) do t[k] = v end
t.dumping_same_thread = (thread == coroutine.running())
-- if a thread was supplied, bind it to debug.info and debug.get
-- we also need to skip this additional level we are introducing in the callstack (only if we are running
-- in the same thread we're inspecting)
if type(thread) == "thread" then
t.getinfo = function(level, what)
if t.dumping_same_thread and type(level) == "number" then
level = level + 1
end
return debug.getinfo(thread, level, what)
end
t.getlocal = function(level, loc)
if t.dumping_same_thread then
level = level + 1
end
return debug.getlocal(thread, level, loc)
end
else
t.getinfo = debug.getinfo
t.getlocal = debug.getlocal
end
return t
end
-- helpers for collecting strings to be used when assembling the final trace
function Dumper:add (text)
self.lines[#self.lines + 1] = text
end
function Dumper:add_f (fmt, ...)
self:add(fmt:format(...))
end
function Dumper:concat_lines ()
return table_concat(self.lines)
end
---
-- Private:
-- Iterates over the local variables of a given function.
--
-- @param level The stack level where the function is.
--
function Dumper:DumpLocals (level)
local prefix = "\t "
local i = 1
if self.dumping_same_thread then
level = level + 1
end
local name, value = self.getlocal(level, i)
if not name then
return
end
self:add("\tLocal variables:\r\n")
while name do
if type(value) == "number" then
self:add_f("%s%s = number: %g\r\n", prefix, name, value)
elseif type(value) == "boolean" then
self:add_f("%s%s = boolean: %s\r\n", prefix, name, tostring(value))
elseif type(value) == "string" then
self:add_f("%s%s = string: %q\r\n", prefix, name, value)
elseif type(value) == "userdata" then
self:add_f("%s%s = %s\r\n", prefix, name, safe_tostring(value))
elseif type(value) == "nil" then
self:add_f("%s%s = nil\r\n", prefix, name)
elseif type(value) == "table" then
if m_known_tables[value] then
self:add_f("%s%s = %s\r\n", prefix, name, m_known_tables[value])
elseif m_user_known_tables[value] then
self:add_f("%s%s = %s\r\n", prefix, name, m_user_known_tables[value])
else
local txt = "{"
for k,v in pairs(value) do
txt = txt..safe_tostring(k)..":"..safe_tostring(v)
if #txt > _M.max_tb_output_len then
txt = txt.." (more...)"
break
end
if next(value, k) then txt = txt..", " end
end
self:add_f("%s%s = %s %s\r\n", prefix, name, safe_tostring(value), txt.."}")
end
elseif type(value) == "function" then
local info = self.getinfo(value, "nS")
local fun_name = info.name or m_known_functions[value] or m_user_known_functions[value]
if info.what == "C" then
self:add_f("%s%s = C %s\r\n", prefix, name, (fun_name and ("function: " .. fun_name) or tostring(value)))
else
local source = info.short_src
if source:sub(2,7) == "string" then
source = source:sub(9) -- uno m?s, por el espacio que viene (string "Baragent.Main", por ejemplo)
end
--for k,v in pairs(info) do print(k,v) end
fun_name = fun_name or GuessFunctionName(info)
self:add_f("%s%s = Lua function '%s' (defined at line %d of chunk %s)\r\n", prefix, name, fun_name, info.linedefined, source)
end
elseif type(value) == "thread" then
self:add_f("%sthread %q = %s\r\n", prefix, name, tostring(value))
end
i = i + 1
name, value = self.getlocal(level, i)
end
end
---
-- Public:
-- Collects a detailed stack trace, dumping locals, resolving function names when they're not available, etc.
-- This function is suitable to be used as an error handler with pcall or xpcall
--
-- @param thread An optional thread whose stack is to be inspected (defaul is the current thread)
-- @param message An optional error string or object.
-- @param level An optional number telling at which level to start the traceback (default is 1)
--
-- Returns a string with the stack trace and a string with the original error.
--
function _M.stacktrace(thread, message, level)
if type(thread) ~= "thread" then
-- shift parameters left
thread, message, level = nil, thread, message
end
thread = thread or coroutine.running()
level = level or 1
local dumper = Dumper.new(thread)
local original_error
if type(message) == "table" then
dumper:add("an error object {\r\n")
local first = true
for k,v in pairs(message) do
if first then
dumper:add(" ")
first = false
else
dumper:add(",\r\n ")
end
dumper:add(safe_tostring(k))
dumper:add(": ")
dumper:add(safe_tostring(v))
end
dumper:add("\r\n}")
original_error = dumper:concat_lines()
elseif type(message) == "string" then
dumper:add(message)
original_error = message
end
dumper:add("\r\n")
dumper:add[[
Stack Traceback
===============
]]
--print(error_message)
local level_to_show = level
if dumper.dumping_same_thread then level = level + 1 end
local info = dumper.getinfo(level, "nSlf")
while info do
if info.what == "main" then
if string_sub(info.source, 1, 1) == "@" then
dumper:add_f("(%d) main chunk of file '%s' at line %d\r\n", level_to_show, string_sub(info.source, 2), info.currentline)
else
dumper:add_f("(%d) main chunk of %s at line %d\r\n", level_to_show, info.short_src, info.currentline)
end
elseif info.what == "C" then
--print(info.namewhat, info.name)
--for k,v in pairs(info) do print(k,v, type(v)) end
local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name or tostring(info.func)
dumper:add_f("(%d) %s C function '%s'\r\n", level_to_show, info.namewhat, function_name)
--dumper:add_f("%s%s = C %s\r\n", prefix, name, (m_known_functions[value] and ("function: " .. m_known_functions[value]) or tostring(value)))
elseif info.what == "tail" then
--print("tail")
--for k,v in pairs(info) do print(k,v, type(v)) end--print(info.namewhat, info.name)
dumper:add_f("(%d) tail call\r\n", level_to_show)
dumper:DumpLocals(level)
elseif info.what == "Lua" then
local source = info.short_src
local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name
if source:sub(2, 7) == "string" then
source = source:sub(9)
end
local was_guessed = false
if not function_name or function_name == "?" then
--for k,v in pairs(info) do print(k,v, type(v)) end
function_name = GuessFunctionName(info)
was_guessed = true
end
-- test if we have a file name
local function_type = (info.namewhat == "") and "function" or info.namewhat
if info.source and info.source:sub(1, 1) == "@" then
dumper:add_f("(%d) Lua %s '%s' at file '%s:%d'%s\r\n", level_to_show, function_type, function_name, info.source:sub(2), info.currentline, was_guessed and " (best guess)" or "")
elseif info.source and info.source:sub(1,1) == '#' then
dumper:add_f("(%d) Lua %s '%s' at template '%s:%d'%s\r\n", level_to_show, function_type, function_name, info.source:sub(2), info.currentline, was_guessed and " (best guess)" or "")
else
dumper:add_f("(%d) Lua %s '%s' at line %d of chunk '%s'\r\n", level_to_show, function_type, function_name, info.currentline, source)
end
dumper:DumpLocals(level)
else
dumper:add_f("(%d) unknown frame %s\r\n", level_to_show, info.what)
end
level = level + 1
level_to_show = level_to_show + 1
info = dumper.getinfo(level, "nSlf")
end
return dumper:concat_lines(), original_error
end
--
-- Adds a table to the list of known tables
function _M.add_known_table(tab, description)
if m_known_tables[tab] then
error("Cannot override an already known table")
end
m_user_known_tables[tab] = description
end
--
-- Adds a function to the list of known functions
function _M.add_known_function(fun, description)
if m_known_functions[fun] then
error("Cannot override an already known function")
end
m_user_known_functions[fun] = description
end
return _M
modules/mod-eluna/src/LuaEngine/extensions/_Misc.ext
+14
View File
@@ -0,0 +1,14 @@
--
-- Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
-- This program is free software licensed under GPL version 3
-- Please see the included DOCS/LICENSE.md for more information
--
-- filename.ext files are loaded before normal .lua files
-- Randomize random
math.randomseed(tonumber(tostring(os.time()):reverse():sub(1,6)))
-- Set debug.traceback to use StackTracePlus to print full stack trace
local trace = require("StackTracePlus")
debug.traceback = trace.stacktrace
modules/mod-eluna/src/LuaEngine/hooks/BattleGroundHooks.cpp
+58
View File
@@ -0,0 +1,58 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "Hooks.h"
#include "HookHelpers.h"
#include "LuaEngine.h"
#include "BindingMap.h"
#include "ElunaTemplate.h"
using namespace Hooks;
#define START_HOOK(EVENT) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return;\
auto key = EventKey<BGEvents>(EVENT);\
if (!BGEventBindings->HasBindingsFor(key))\
return;\
LOCK_ELUNA
void Eluna::OnBGStart(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId)
{
START_HOOK(BG_EVENT_ON_START);
Push(bg);
Push(bgId);
Push(instanceId);
CallAllFunctions(BGEventBindings, key);
}
void Eluna::OnBGEnd(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId, TeamId winner)
{
START_HOOK(BG_EVENT_ON_END);
Push(bg);
Push(bgId);
Push(instanceId);
Push(winner);
CallAllFunctions(BGEventBindings, key);
}
void Eluna::OnBGCreate(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId)
{
START_HOOK(BG_EVENT_ON_CREATE);
Push(bg);
Push(bgId);
Push(instanceId);
CallAllFunctions(BGEventBindings, key);
}
void Eluna::OnBGDestroy(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId)
{
START_HOOK(BG_EVENT_ON_PRE_DESTROY);
Push(bg);
Push(bgId);
Push(instanceId);
CallAllFunctions(BGEventBindings, key);
}
modules/mod-eluna/src/LuaEngine/hooks/CreatureHooks.cpp
+387
View File
@@ -0,0 +1,387 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "Hooks.h"
#include "HookHelpers.h"
#include "LuaEngine.h"
#include "BindingMap.h"
#include "ElunaIncludes.h"
#include "ElunaTemplate.h"
using namespace Hooks;
#define START_HOOK(EVENT, CREATURE) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return;\
auto entry_key = EntryKey<CreatureEvents>(EVENT, CREATURE->GetEntry());\
auto unique_key = UniqueObjectKey<CreatureEvents>(EVENT, CREATURE->GET_GUID(), CREATURE->GetInstanceId());\
if (!CreatureEventBindings->HasBindingsFor(entry_key))\
if (!CreatureUniqueBindings->HasBindingsFor(unique_key))\
return;\
LOCK_ELUNA
#define START_HOOK_WITH_RETVAL(EVENT, CREATURE, RETVAL) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return RETVAL;\
auto entry_key = EntryKey<CreatureEvents>(EVENT, CREATURE->GetEntry());\
auto unique_key = UniqueObjectKey<CreatureEvents>(EVENT, CREATURE->GET_GUID(), CREATURE->GetInstanceId());\
if (!CreatureEventBindings->HasBindingsFor(entry_key))\
if (!CreatureUniqueBindings->HasBindingsFor(unique_key))\
return RETVAL;\
LOCK_ELUNA
void Eluna::OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, Creature* pTarget)
{
START_HOOK(CREATURE_EVENT_ON_DUMMY_EFFECT, pTarget);
Push(pCaster);
Push(spellId);
Push(effIndex);
Push(pTarget);
CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
bool Eluna::OnQuestAccept(Player* pPlayer, Creature* pCreature, Quest const* pQuest)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_QUEST_ACCEPT, pCreature, false);
Push(pPlayer);
Push(pCreature);
Push(pQuest);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
bool Eluna::OnQuestReward(Player* pPlayer, Creature* pCreature, Quest const* pQuest, uint32 opt)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_QUEST_REWARD, pCreature, false);
Push(pPlayer);
Push(pCreature);
Push(pQuest);
Push(opt);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
void Eluna::GetDialogStatus(const Player* pPlayer, const Creature* pCreature)
{
START_HOOK(CREATURE_EVENT_ON_DIALOG_STATUS, pCreature);
Push(pPlayer);
Push(pCreature);
CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
void Eluna::OnAddToWorld(Creature* pCreature)
{
START_HOOK(CREATURE_EVENT_ON_ADD, pCreature);
Push(pCreature);
CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
void Eluna::OnRemoveFromWorld(Creature* pCreature)
{
START_HOOK(CREATURE_EVENT_ON_REMOVE, pCreature);
Push(pCreature);
CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
bool Eluna::OnSummoned(Creature* pCreature, Unit* pSummoner)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SUMMONED, pCreature, false);
Push(pCreature);
Push(pSummoner);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
bool Eluna::UpdateAI(Creature* me, const uint32 diff)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_AIUPDATE, me, false);
Push(me);
Push(diff);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
//Called for reaction at enter to combat if not in combat yet (enemy can be NULL)
//Called at creature aggro either by MoveInLOS or Attack Start
bool Eluna::EnterCombat(Creature* me, Unit* target)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_ENTER_COMBAT, me, false);
Push(me);
Push(target);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called at any Damage from any attacker (before damage apply)
bool Eluna::DamageTaken(Creature* me, Unit* attacker, uint32& damage)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_DAMAGE_TAKEN, me, false);
bool result = false;
Push(me);
Push(attacker);
Push(damage);
int damageIndex = lua_gettop(L);
int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 3);
while (n > 0)
{
int r = CallOneFunction(n--, 3, 2);
if (lua_isboolean(L, r + 0) && lua_toboolean(L, r + 0))
result = true;
if (lua_isnumber(L, r + 1))
{
damage = Eluna::CHECKVAL<uint32>(L, r + 1);
// Update the stack for subsequent calls.
ReplaceArgument(damage, damageIndex);
}
lua_pop(L, 2);
}
CleanUpStack(3);
return result;
}
//Called at creature death
bool Eluna::JustDied(Creature* me, Unit* killer)
{
On_Reset(me);
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_DIED, me, false);
Push(me);
Push(killer);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
//Called at creature killing another unit
bool Eluna::KilledUnit(Creature* me, Unit* victim)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_TARGET_DIED, me, false);
Push(me);
Push(victim);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called when the creature summon successfully other creature
bool Eluna::JustSummoned(Creature* me, Creature* summon)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_JUST_SUMMONED_CREATURE, me, false);
Push(me);
Push(summon);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called when a summoned creature is despawned
bool Eluna::SummonedCreatureDespawn(Creature* me, Creature* summon)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SUMMONED_CREATURE_DESPAWN, me, false);
Push(me);
Push(summon);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
//Called at waypoint reached or PointMovement end
bool Eluna::MovementInform(Creature* me, uint32 type, uint32 id)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_REACH_WP, me, false);
Push(me);
Push(type);
Push(id);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called before EnterCombat even before the creature is in combat.
bool Eluna::AttackStart(Creature* me, Unit* target)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_PRE_COMBAT, me, false);
Push(me);
Push(target);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called for reaction at stopping attack at no attackers or targets
bool Eluna::EnterEvadeMode(Creature* me)
{
On_Reset(me);
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_LEAVE_COMBAT, me, false);
Push(me);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called when creature is spawned or respawned (for reseting variables)
bool Eluna::JustRespawned(Creature* me)
{
On_Reset(me);
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SPAWN, me, false);
Push(me);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called at reaching home after evade
bool Eluna::JustReachedHome(Creature* me)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_REACH_HOME, me, false);
Push(me);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called at text emote receive from player
bool Eluna::ReceiveEmote(Creature* me, Player* player, uint32 emoteId)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_RECEIVE_EMOTE, me, false);
Push(me);
Push(player);
Push(emoteId);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// called when the corpse of this creature gets removed
bool Eluna::CorpseRemoved(Creature* me, uint32& respawnDelay)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_CORPSE_REMOVED, me, false);
bool result = false;
Push(me);
Push(respawnDelay);
int respawnDelayIndex = lua_gettop(L);
int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 2);
while (n > 0)
{
int r = CallOneFunction(n--, 2, 2);
if (lua_isboolean(L, r + 0) && lua_toboolean(L, r + 0))
result = true;
if (lua_isnumber(L, r + 1))
{
respawnDelay = Eluna::CHECKVAL<uint32>(L, r + 1);
// Update the stack for subsequent calls.
ReplaceArgument(respawnDelay, respawnDelayIndex);
}
lua_pop(L, 2);
}
CleanUpStack(2);
return result;
}
bool Eluna::MoveInLineOfSight(Creature* me, Unit* who)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_MOVE_IN_LOS, me, false);
Push(me);
Push(who);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called on creature initial spawn, respawn, death, evade (leave combat)
void Eluna::On_Reset(Creature* me) // Not an override, custom
{
START_HOOK(CREATURE_EVENT_ON_RESET, me);
Push(me);
CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called when hit by a spell
bool Eluna::SpellHit(Creature* me, WorldObject* caster, SpellInfo const* spell)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_HIT_BY_SPELL, me, false);
Push(me);
Push(caster);
Push(spell->Id); // Pass spell object?
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called when spell hits a target
bool Eluna::SpellHitTarget(Creature* me, WorldObject* target, SpellInfo const* spell)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SPELL_HIT_TARGET, me, false);
Push(me);
Push(target);
Push(spell->Id); // Pass spell object?
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
bool Eluna::SummonedCreatureDies(Creature* me, Creature* summon, Unit* killer)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SUMMONED_CREATURE_DIED, me, false);
Push(me);
Push(summon);
Push(killer);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called when owner takes damage
bool Eluna::OwnerAttackedBy(Creature* me, Unit* attacker)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_OWNER_ATTACKED_AT, me, false);
Push(me);
Push(attacker);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
// Called when owner attacks something
bool Eluna::OwnerAttacked(Creature* me, Unit* target)
{
START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_OWNER_ATTACKED, me, false);
Push(me);
Push(target);
return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
void Eluna::OnCreatureAuraApply(Creature* me, Aura* aura)
{
START_HOOK(CREATURE_EVENT_ON_AURA_APPLY, me);
Push(me);
Push(aura);
CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
}
void Eluna::OnCreatureHeal(Creature* me, Unit* target, uint32& gain)
{
START_HOOK(CREATURE_EVENT_ON_HEAL, me);
Push(me);
Push(target);
Push(gain);
int gainIndex = lua_gettop(L);
int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 3);
while (n > 0)
{
int r = CallOneFunction(n--, 3, 1);
if (lua_isnumber(L, r))
{
gain = CHECKVAL<uint32>(L, r);
// Update the stack for subsequent calls.
ReplaceArgument(gain, gainIndex);
}
lua_pop(L, 1);
}
CleanUpStack(3);
}
void Eluna::OnCreatureDamage(Creature* me, Unit* target, uint32& damage)
{
START_HOOK(CREATURE_EVENT_ON_DAMAGE, me);
Push(me);
Push(target);
Push(damage);
int damageIndex = lua_gettop(L);
int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 3);
while (n > 0)
{
int r = CallOneFunction(n--, 3, 1);
if (lua_isnumber(L, r))
{
damage = CHECKVAL<uint32>(L, r);
// Update the stack for subsequent calls.
ReplaceArgument(damage, damageIndex);
}
lua_pop(L, 1);
}
CleanUpStack(3);
}
modules/mod-eluna/src/LuaEngine/hooks/GameObjectHooks.cpp
+138
View File
@@ -0,0 +1,138 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "Hooks.h"
#include "HookHelpers.h"
#include "LuaEngine.h"
#include "BindingMap.h"
#include "ElunaIncludes.h"
#include "ElunaEventMgr.h"
#include "ElunaTemplate.h"
using namespace Hooks;
#define START_HOOK(EVENT, ENTRY) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return;\
auto key = EntryKey<GameObjectEvents>(EVENT, ENTRY);\
if (!GameObjectEventBindings->HasBindingsFor(key))\
return;\
LOCK_ELUNA
#define START_HOOK_WITH_RETVAL(EVENT, ENTRY, RETVAL) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return RETVAL;\
auto key = EntryKey<GameObjectEvents>(EVENT, ENTRY);\
if (!GameObjectEventBindings->HasBindingsFor(key))\
return RETVAL;\
LOCK_ELUNA
void Eluna::OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, GameObject* pTarget)
{
START_HOOK(GAMEOBJECT_EVENT_ON_DUMMY_EFFECT, pTarget->GetEntry());
Push(pCaster);
Push(spellId);
Push(effIndex);
Push(pTarget);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::UpdateAI(GameObject* pGameObject, uint32 diff)
{
pGameObject->elunaEvents->Update(diff);
START_HOOK(GAMEOBJECT_EVENT_ON_AIUPDATE, pGameObject->GetEntry());
Push(pGameObject);
Push(diff);
CallAllFunctions(GameObjectEventBindings, key);
}
bool Eluna::OnQuestAccept(Player* pPlayer, GameObject* pGameObject, Quest const* pQuest)
{
START_HOOK_WITH_RETVAL(GAMEOBJECT_EVENT_ON_QUEST_ACCEPT, pGameObject->GetEntry(), false);
Push(pPlayer);
Push(pGameObject);
Push(pQuest);
return CallAllFunctionsBool(GameObjectEventBindings, key);
}
bool Eluna::OnQuestReward(Player* pPlayer, GameObject* pGameObject, Quest const* pQuest, uint32 opt)
{
START_HOOK_WITH_RETVAL(GAMEOBJECT_EVENT_ON_QUEST_REWARD, pGameObject->GetEntry(), false);
Push(pPlayer);
Push(pGameObject);
Push(pQuest);
Push(opt);
return CallAllFunctionsBool(GameObjectEventBindings, key);
}
void Eluna::GetDialogStatus(const Player* pPlayer, const GameObject* pGameObject)
{
START_HOOK(GAMEOBJECT_EVENT_ON_DIALOG_STATUS, pGameObject->GetEntry());
Push(pPlayer);
Push(pGameObject);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::OnDestroyed(GameObject* pGameObject, WorldObject* attacker)
{
START_HOOK(GAMEOBJECT_EVENT_ON_DESTROYED, pGameObject->GetEntry());
Push(pGameObject);
Push(attacker);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::OnDamaged(GameObject* pGameObject, WorldObject* attacker)
{
START_HOOK(GAMEOBJECT_EVENT_ON_DAMAGED, pGameObject->GetEntry());
Push(pGameObject);
Push(attacker);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::OnLootStateChanged(GameObject* pGameObject, uint32 state)
{
START_HOOK(GAMEOBJECT_EVENT_ON_LOOT_STATE_CHANGE, pGameObject->GetEntry());
Push(pGameObject);
Push(state);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::OnGameObjectStateChanged(GameObject* pGameObject, uint32 state)
{
START_HOOK(GAMEOBJECT_EVENT_ON_GO_STATE_CHANGED, pGameObject->GetEntry());
Push(pGameObject);
Push(state);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::OnSpawn(GameObject* pGameObject)
{
START_HOOK(GAMEOBJECT_EVENT_ON_SPAWN, pGameObject->GetEntry());
Push(pGameObject);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::OnAddToWorld(GameObject* pGameObject)
{
START_HOOK(GAMEOBJECT_EVENT_ON_ADD, pGameObject->GetEntry());
Push(pGameObject);
CallAllFunctions(GameObjectEventBindings, key);
}
void Eluna::OnRemoveFromWorld(GameObject* pGameObject)
{
START_HOOK(GAMEOBJECT_EVENT_ON_REMOVE, pGameObject->GetEntry());
Push(pGameObject);
CallAllFunctions(GameObjectEventBindings, key);
}
bool Eluna::OnGameObjectUse(Player* pPlayer, GameObject* pGameObject)
{
START_HOOK_WITH_RETVAL(GAMEOBJECT_EVENT_ON_USE, pGameObject->GetEntry(), false);
Push(pGameObject);
Push(pPlayer);
return CallAllFunctionsBool(GameObjectEventBindings, key);
}
modules/mod-eluna/src/LuaEngine/hooks/GossipHooks.cpp
+147
View File
@@ -0,0 +1,147 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "Hooks.h"
#include "HookHelpers.h"
#include "LuaEngine.h"
#include "BindingMap.h"
#include "ElunaIncludes.h"
#include "ElunaTemplate.h"
using namespace Hooks;
#define START_HOOK(BINDINGS, EVENT, ENTRY) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return;\
auto key = EntryKey<GossipEvents>(EVENT, ENTRY);\
if (!BINDINGS->HasBindingsFor(key))\
return;\
LOCK_ELUNA
#define START_HOOK_WITH_RETVAL(BINDINGS, EVENT, ENTRY, RETVAL) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return RETVAL;\
auto key = EntryKey<GossipEvents>(EVENT, ENTRY);\
if (!BINDINGS->HasBindingsFor(key))\
return RETVAL;\
LOCK_ELUNA
bool Eluna::OnGossipHello(Player* pPlayer, GameObject* pGameObject)
{
START_HOOK_WITH_RETVAL(GameObjectGossipBindings, GOSSIP_EVENT_ON_HELLO, pGameObject->GetEntry(), false);
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pGameObject);
return CallAllFunctionsBool(GameObjectGossipBindings, key, true);
}
bool Eluna::OnGossipSelect(Player* pPlayer, GameObject* pGameObject, uint32 sender, uint32 action)
{
START_HOOK_WITH_RETVAL(GameObjectGossipBindings, GOSSIP_EVENT_ON_SELECT, pGameObject->GetEntry(), false);
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pGameObject);
Push(sender);
Push(action);
return CallAllFunctionsBool(GameObjectGossipBindings, key, true);
}
bool Eluna::OnGossipSelectCode(Player* pPlayer, GameObject* pGameObject, uint32 sender, uint32 action, const char* code)
{
START_HOOK_WITH_RETVAL(GameObjectGossipBindings, GOSSIP_EVENT_ON_SELECT, pGameObject->GetEntry(), false);
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pGameObject);
Push(sender);
Push(action);
Push(code);
return CallAllFunctionsBool(GameObjectGossipBindings, key, true);
}
void Eluna::HandleGossipSelectOption(Player* pPlayer, uint32 menuId, uint32 sender, uint32 action, const std::string& code)
{
START_HOOK(PlayerGossipBindings, GOSSIP_EVENT_ON_SELECT, menuId);
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer); // receiver
Push(pPlayer); // sender, just not to mess up the amount of args.
Push(sender);
Push(action);
if (code.empty())
Push();
else
Push(code);
CallAllFunctions(PlayerGossipBindings, key);
}
bool Eluna::OnItemGossip(Player* pPlayer, Item* pItem, SpellCastTargets const& /*targets*/)
{
START_HOOK_WITH_RETVAL(ItemGossipBindings, GOSSIP_EVENT_ON_HELLO, pItem->GetEntry(), true);
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pItem);
return CallAllFunctionsBool(ItemGossipBindings, key, true);
}
void Eluna::HandleGossipSelectOption(Player* pPlayer, Item* pItem, uint32 sender, uint32 action, const std::string& code)
{
START_HOOK(ItemGossipBindings, GOSSIP_EVENT_ON_SELECT, pItem->GetEntry());
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pItem);
Push(sender);
Push(action);
if (code.empty())
Push();
else
Push(code);
CallAllFunctions(ItemGossipBindings, key);
}
bool Eluna::OnGossipHello(Player* pPlayer, Creature* pCreature)
{
START_HOOK_WITH_RETVAL(CreatureGossipBindings, GOSSIP_EVENT_ON_HELLO, pCreature->GetEntry(), false);
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pCreature);
return CallAllFunctionsBool(CreatureGossipBindings, key, true);
}
bool Eluna::OnGossipSelect(Player* pPlayer, Creature* pCreature, uint32 sender, uint32 action)
{
START_HOOK_WITH_RETVAL(CreatureGossipBindings, GOSSIP_EVENT_ON_SELECT, pCreature->GetEntry(), false);
auto originalMenu = *pPlayer->PlayerTalkClass;
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pCreature);
Push(sender);
Push(action);
auto preventDefault = CallAllFunctionsBool(CreatureGossipBindings, key, true);
if (!preventDefault) {
*pPlayer->PlayerTalkClass = originalMenu;
}
return preventDefault;
}
bool Eluna::OnGossipSelectCode(Player* pPlayer, Creature* pCreature, uint32 sender, uint32 action, const char* code)
{
START_HOOK_WITH_RETVAL(CreatureGossipBindings, GOSSIP_EVENT_ON_SELECT, pCreature->GetEntry(), false);
auto originalMenu = *pPlayer->PlayerTalkClass;
pPlayer->PlayerTalkClass->ClearMenus();
Push(pPlayer);
Push(pCreature);
Push(sender);
Push(action);
Push(code);
auto preventDefault = CallAllFunctionsBool(CreatureGossipBindings, key, true);
if (!preventDefault) {
*pPlayer->PlayerTalkClass = originalMenu;
}
return preventDefault;
}
modules/mod-eluna/src/LuaEngine/hooks/GroupHooks.cpp
+71
View File
@@ -0,0 +1,71 @@
/*
* Copyright (C) 2010 - 2016 Eluna Lua Engine <http://emudevs.com/>
* This program is free software licensed under GPL version 3
* Please see the included DOCS/LICENSE.md for more information
*/
#include "Hooks.h"
#include "HookHelpers.h"
#include "LuaEngine.h"
#include "BindingMap.h"
#include "ElunaTemplate.h"
using namespace Hooks;
#define START_HOOK(EVENT) \
if (!ElunaConfig::GetInstance().IsElunaEnabled())\
return;\
auto key = EventKey<GroupEvents>(EVENT);\
if (!GroupEventBindings->HasBindingsFor(key))\
return;\
LOCK_ELUNA
void Eluna::OnAddMember(Group* group, ObjectGuid guid)
{
START_HOOK(GROUP_EVENT_ON_MEMBER_ADD);
Push(group);
Push(guid);
CallAllFunctions(GroupEventBindings, key);
}
void Eluna::OnInviteMember(Group* group, ObjectGuid guid)
{
START_HOOK(GROUP_EVENT_ON_MEMBER_INVITE);
Push(group);
Push(guid);
CallAllFunctions(GroupEventBindings, key);
}
void Eluna::OnRemoveMember(Group* group, ObjectGuid guid, uint8 method)
{
START_HOOK(GROUP_EVENT_ON_MEMBER_REMOVE);
Push(group);
Push(guid);
Push(method);
CallAllFunctions(GroupEventBindings, key);
}
void Eluna::OnChangeLeader(Group* group, ObjectGuid newLeaderGuid, ObjectGuid oldLeaderGuid)
{
START_HOOK(GROUP_EVENT_ON_LEADER_CHANGE);
Push(group);
Push(newLeaderGuid);
Push(oldLeaderGuid);
CallAllFunctions(GroupEventBindings, key);
}
void Eluna::OnDisband(Group* group)
{
START_HOOK(GROUP_EVENT_ON_DISBAND);
Push(group);
CallAllFunctions(GroupEventBindings, key);
}
void Eluna::OnCreate(Group* group, ObjectGuid leaderGuid, GroupType groupType)
{
START_HOOK(GROUP_EVENT_ON_CREATE);
Push(group);
Push(leaderGuid);
Push(groupType);
CallAllFunctions(GroupEventBindings, key);
}

Some files were not shown because too many files have changed in this diff Show More