QuMod Libs

http://qumod.cc/QuModLibs
Admin
QuMod Libs is a modding library and SDK framework that provides tools and documentation for game...
Tokens:3,165
Snippets:19
Trust Score:0
Update:10 months ago
Show doc for...
Tokens:
Raw
### Inter-module Calls: NeServer.py Example

Shows how to make calls between different modules within the same thread environment. This example demonstrates a server system listening for player attacks and then calling functions and components from QMServer.

```python
import mod.server.extraServerApi as serverApi
from QMServer import TEST_FUNC, TEST_COMP    # 所有的QuMod模块都可以直接import访问
ServerSystem = serverApi.GetServerSystemCls()

class MyServer(ServerSystem):
    def __init__(self, namespace, systemName):
        ServerSystem.__init__(self, namespace, systemName)
        mcNamespace, mcSystemName = serverApi.GetEngineNamespace(), serverApi.GetEngineSystemName()
        self.ListenForEvent(mcNamespace, mcSystemName, "PlayerAttackEntityEvent", self, self.PlayerAttackEntityEvent)

    def PlayerAttackEntityEvent(self, args={}):
        playerId = args["playerId"]
        victimId = args["victimId"]
        TEST_FUNC(playerId)         # 调用QMServer.py中的TEST_FUNC
        TEST_COMP().bind(victimId)  # 为命中实体绑定QuMod组件 实现持续造成伤害
```

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

### Customize Server/Client Initialization Logic

QuMod enables developers to customize server and client initialization logic for increased flexibility. This example shows how to define and register custom initialization functions (SERVER_INIT and CLIENT_INIT) that are executed upon initialization. It also demonstrates a special case where a client component is registered conditionally based on server user context (e.g., only for the host).

```python
# modMain.py
from .QuModLibs.QuMod import *

# Executed during server initialization
def SERVER_INIT():
    # Files can be loaded directly here instead of dynamic registration
    import Server

REG_SERVER_INIT_CALL(SERVER_INIT)

# Executed during client initialization
def CLIENT_INIT():
    # Native system classes can also be registered for mixed project development
    clientApi.RegisterSystem(...)

REG_CLIENT_INIT_CALL(CLIENT_INIT)

# A special case demonstrating conditional client registration based on context
def SERVER_CLIENT():
    if IN.IsServerUser:
        myMod.Client("Client")

REG_CLIENT_INIT_CALL(SERVER_CLIENT)
```

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

### Inter-module Calls: QMServer.py Example

Provides an example of a Python module (QMServer.py) that defines functions and components intended to be called by other modules. It includes a sample function TEST_FUNC and a component TEST_COMP that binds to an entity and inflicts damage.

```python
from .QuModLibs.Server import *
from .QuModLibs.Modules.EntityComps.Server import QBaseEntityComp

def TEST_FUNC(entityId):
    print("这是个空函数: {}".format(entityId))

class TEST_COMP(QBaseEntityComp):
    def onBind(self):
        QBaseEntityComp.onBind(self)
        # 0.5s后自动解除组件
        self.addTimer(QBaseEntityComp.Timer(lambda: self.unBind(), time=0.5))
    
    def update(self):
        QBaseEntityComp.update(self)
        # 持续造成伤害
        comp = serverApi.GetEngineCompFactory().CreateHurt(self.entityId)
        comp.Hurt(1, serverApi.GetMinecraftEnum().ActorDamageCause.EntityAttack, None, None, False)
```

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

### Hybrid Development: Mixed QuMod and Native Code

Illustrates a hybrid development approach where QuMod and native code reside in the same file. This example shows a `MyServer` class that integrates with QuMod components (`TEST_COMP`) and handles player attack events, simplifying registration as only one System needs to be loaded.

```python
from .QuModLibs.Server import *
from .QuModLibs.Modules.EntityComps.Server import QBaseEntityComp
ServerSystem = serverApi.GetServerSystemCls()

# 由于和QuMod相关业务放在同一个文件 只需要注册一次System即可加载整个文件的其他业务
class MyServer(ServerSystem):
    def __init__(self, namespace, systemName):
        ServerSystem.__init__(self, namespace, systemName)
        mcNamespace, mcSystemName = serverApi.GetEngineNamespace(), serverApi.GetEngineSystemName()
        self.ListenForEvent(mcNamespace, mcSystemName, "PlayerAttackEntityEvent", self, self.PlayerAttackEntityEvent)

    def PlayerAttackEntityEvent(self, args={}):
        playerId = args["playerId"]
        victimId = args["victimId"]
        TEST_COMP().bind(victimId)  # 为命中实体绑定QuMod组件 实现持续造成伤害

class TEST_COMP(QBaseEntityComp):
    def onBind(self):
        QBaseEntityComp.onBind(self)
        # 0.5s后自动解除组件
        self.addTimer(QBaseEntityComp.Timer(lambda: self.unBind(), time=0.5))
    
    def update(self):
        QBaseEntityComp.update(self)
        # 持续造成伤害
        comp = serverApi.GetEngineCompFactory().CreateHurt(self.entityId)
        comp.Hurt(1, serverApi.GetMinecraftEnum().ActorDamageCause.EntityAttack, None, None, False)
```

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

### Handling Complex Business Logic with QuMod Initialization Functions

Illustrates how to manage complex business logic by registering initialization functions for server and client using QuModLibs. This allows for more granular control over system and component registration beyond the basic registration functions.

```python
# modMain.py
from .QuModLibs.QuMod import *

myQuMod = EasyMod()
myQuMod.Server("...")
myQuMod.Client("...")

# 若SERVER/CLIENT_REG_NATIVE_PY_SYSTEM不能满足需求
SERVER_REG_NATIVE_PY_SYSTEM(...)
CLIENT_REG_NATIVE_PY_SYSTEM(...)

# 可以通过注册一个初始化函数来解决问题
@REG_SERVER_INIT_CALL
def SERVER_INIT():
    serverApi.RegisterSystem(...)
    serverApi.RegisterComponent(...)
    ...

@REG_CLIENT_INIT_CALL
def CLIENT_INIT():
    clientApi.RegisterSystem(...)
    clientApi.RegisterComponent(...)
    ...
```

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

### Initialize Mod Server and Client Components

This code snippet demonstrates the basic initialization of server and client components for a QuMod project. It imports all functionalities from QuModLibs.QuMod and then registers 'Server' and 'Client' components using the EasyMod class. This is essential for QuMod's modular system to recognize and load specific files on the respective threads.

```python
# modMain.py (corresponding file)
from .QuModLibs.QuMod import *
myMod = EasyMod()           # Convenient MOD construction class

# Server and client registration
myMod.Server("Server")
myMod.Client("Client")
```

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

### Registering Native Python Systems with QuModLibs

Demonstrates how to register native Python systems for both server and client using EasyMod. It covers simplified registration where paths are inferred and explicit registration using SERVER/CLIENT_REG_NATIVE_PY_SYSTEM.

```python
# modMain.py
from .QuModLibs.QuMod import *

myQuMod = EasyMod()
myQuMod.Server("...")
myQuMod.Client("...")

# 服务端与客户端的封装系统类注册
SERVER_REG_NATIVE_PY_SYSTEM(命名空间, 系统名, 路径) # 相当于 serverApi.RegisterSystem(...)
CLIENT_REG_NATIVE_PY_SYSTEM(命名空间, 系统名, 路径) # 相当于 clientApi.RegisterSystem(...)

# 特殊的封装版本 路径会自动绑定当前目录(相对路径)
myQuMod.regNativePyServer(...)
myQuMod.regNativePyClient(...)
```

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

### QuMod Calling NeServer: Function and Class Imports

Demonstrates how QuMod modules can call functions and systems defined in other modules like NeServer. It shows two primary methods: accessing singleton system methods via `GetSystem` and directly importing defined functions or non-system classes.

```python
from .QuModLibs.Server import *

def TestFunc():
    # 对于单例系统方法 需要Get后再访问
    systemNode = serverApi.GetSystem(...)
    systemNode.xxx()

def TestFunc2():
    # 对于定义出来的函数/非系统类 可以直接import
    from NeServer import xxx
    xxx()
```

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

### Dynamically Register Server and Client Scripts

This snippet illustrates dynamic script registration in QuMod, allowing the loading of files on the corresponding system side during runtime. It shows how to register server-side files (e.g., 'Server.py') and client-side files using relative paths. Multi-level directories can be specified using dot notation.

```python
# modMain.py
from .QuModLibs.QuMod import *
myMod = EasyMod()

# Dynamically register server file (relative path)
myMod.Server("Server") # This will load Script Directory/Server.py
# myMod.Server("Dir.Test") # Multi-level directories are separated by .
myMod.Client("Client")  # Client registration works similarly
```
Tokens:
Raw