gaskill 2.17.0__tar.gz

gaskill-2.17.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 limo1027
+
+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.

gaskill-2.17.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: gaskill
+Version: 2.17.0
+Summary: A comprehensive Python library for game development utilities
+Home-page: https://github.com/limo1027/gaskill
+Author: Limo
+Author-email: 28009663@qq.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Mlib
+一个0依赖库
+
+不依赖random，math等标准库
+
+纯python制作，不使用C拓展
+
+快速开始
+
+```bash
+git clone https://github.com/limo1027/mlib
+cd mlib
+python -c "from gaskill.test import run_test; run_test()"
+```
+
+[Learn More?](https://limo1027.github.io/mlib)

gaskill-2.17.0/README.md

@@ -0,0 +1,16 @@
+# Mlib
+一个0依赖库
+
+不依赖random，math等标准库
+
+纯python制作，不使用C拓展
+
+快速开始
+
+```bash
+git clone https://github.com/limo1027/mlib
+cd mlib
+python -c "from gaskill.test import run_test; run_test()"
+```
+
+[Learn More?](https://limo1027.github.io/mlib)

gaskill-2.17.0/gaskill/__init__.py

@@ -0,0 +1,13 @@
+# ruff: noqa: F403
+from .gaskill import *
+from .plus import *
+print(r"""
+           _ _ _     
+ _ __ ___ | (_) |__  
+| '_ ` _ \| | | '_ \ 
+| | | | | | | | |_) |
+|_| |_| |_|_|_|_.__/ """)
+print("Hello from mlib. It isn't a serious library. Welcome to raise PRs. If you want to know the rules, please see PRlicense.")
+__PRlicense__ = "Do not use any C or Rust extensions, and ensure neither exists in the dependency tree."
+__license__ = "MIT"
+__author__ = "everyone"

gaskill-2.17.0/gaskill/gaskill/__init__.py

@@ -0,0 +1,28 @@
+# ruff: noqa: F403
+from .smath import *
+from .sfrac import *
+from .svector import *
+from .smatrix import *
+from .squaternion import *
+from .srandom import *
+from .scolor import *
+from .sgeometry import *
+from .sgeometry3d import *
+from .scurve import *
+from .seasing import *
+from .sinterp import *
+from .scache import *
+from .sevent import *
+from .sfsm import *
+from .spool import *
+from .spathfinder import *
+from .ssaver import *
+from .sformat import *
+from .snoise import *
+from .scrypt import *
+from .solver import *
+from .sstat import *
+from .sbase64 import *
+from .abc import *
+from .pickle import *
+from .hashlib import sha256, DJB2  # noqa: F401

gaskill-2.17.0/gaskill/gaskill/_roll.py

@@ -0,0 +1,169 @@
+def parse_dice(expr):
+    expr = expr.replace(' ', '')
+
+    # 按加减号分割表达式
+    parts = _split_expression(expr)
+
+    result = {
+        'expr': expr,
+        'parts': [],
+        'total': 0
+    }
+
+    for part in parts:
+        if 'd' in part.lower():
+            part_result = _parse_single_dice(part)
+        else:
+            part_result = _parse_number(part)
+
+        result['parts'].append(part_result)
+        result['total'] += part_result['value']
+
+    return result
+
+
+def _split_expression(expr):
+    parts = []
+    current = ''
+
+    for i, char in enumerate(expr):
+        if char in '+-' and i > 0:
+            parts.append(current)
+            current = char
+        else:
+            current += char
+
+    if current:
+        parts.append(current)
+
+    return parts
+
+
+def _parse_single_dice(expr):
+    d_pos = expr.lower().find('d')
+
+    # 解析骰子数量
+    count_str = expr[:d_pos]
+    count = int(count_str) if count_str else 1
+
+    # 解析剩余部分
+    rest = expr[d_pos+1:]
+
+    # 初始化结果
+    result = {
+        'expr': expr,
+        'type': 'dice',
+        'count': count,
+        'sides': 0,
+        'modifier': None,
+        'modifier_value': 0,
+        'explode': None,
+        'bonus': 0,
+        'value': 0  # 占位，实际掷骰时计算
+    }
+
+    i = 0
+    # 读骰子面数
+    sides_str = ''
+    while i < len(rest) and rest[i].isdigit():
+        sides_str += rest[i]
+        i += 1
+
+    result['sides'] = int(sides_str)
+
+    # 读修饰符
+    if i < len(rest) and rest[i].isalpha():
+        mod = rest[i]
+        i += 1
+        if i < len(rest) and rest[i].isalpha():
+            mod += rest[i]
+            i += 1
+        result['modifier'] = mod
+
+        # 读修饰符数值
+        mod_val_str = ''
+        while i < len(rest) and rest[i].isdigit():
+            mod_val_str += rest[i]
+            i += 1
+        result['modifier_value'] = int(mod_val_str) if mod_val_str else 1
+
+    # 读爆炸骰
+    if i < len(rest) and rest[i] == 'x':
+        i += 1
+        explode_str = ''
+        while i < len(rest) and rest[i].isdigit():
+            explode_str += rest[i]
+            i += 1
+        result['explode'] = int(explode_str)
+
+    # 读加减
+    if i < len(rest) and rest[i] in '+-':
+        result['bonus'] = int(rest[i:])
+
+    return result
+
+
+def _parse_number(expr):
+    return {
+        'expr': expr,
+        'type': 'number',
+        'value': int(expr)
+    }
+
+
+def roll_dice(parse_result, random_func):
+    if parse_result['type'] == 'number':
+        return parse_result['value']
+
+    # 先掷出所有骰子
+    rolls = [random_func(1, parse_result['sides'])
+             for _ in range(parse_result['count'])]
+
+    # 应用爆炸骰
+    if parse_result['explode']:
+        rolls = _apply_explode(rolls, parse_result['sides'],
+                               parse_result['explode'], random_func)
+
+    # 应用修饰符
+    if parse_result['modifier'] == 'kh':
+        rolls = sorted(rolls, reverse=True)[:parse_result['modifier_value']]
+    elif parse_result['modifier'] == 'kl':
+        rolls = sorted(rolls)[:parse_result['modifier_value']]
+    elif parse_result['modifier'] == 'd':
+        rolls = sorted(rolls)[parse_result['modifier_value']:]
+
+    return sum(rolls) + parse_result['bonus']
+
+
+def _apply_explode(rolls, sides, target, random_func):
+    """递归应用爆炸骰"""
+    result = rolls.copy()
+    for roll in rolls:
+        if roll == target:
+            extra = random_func(1, sides)
+            result.append(extra)
+            if extra == target:  # 递归爆炸
+                result.extend(_apply_explode([extra], sides, target, random_func))
+    return result
+
+
+def get_dice_info(expr):
+    result = parse_dice(expr)
+    info = {
+        'expr': expr,
+        'dice_count': 0,
+        'total_sides': 0,
+        'has_modifier': False,
+        'has_explode': False
+    }
+
+    for part in result['parts']:
+        if part['type'] == 'dice':
+            info['dice_count'] += part['count']
+            info['total_sides'] += part['sides'] * part['count']
+            if part['modifier']:
+                info['has_modifier'] = True
+            if part['explode']:
+                info['has_explode'] = True
+
+    return info

gaskill-2.17.0/gaskill/gaskill/abc.py

@@ -0,0 +1,73 @@
+"""
+gaskill.abc - 抽象基类模块（零依赖）
+"""
+
+
+class ABCMeta(type):
+    """元类：自动收集抽象方法"""
+
+    def __new__(cls, name, bases, dct):
+        # 1. 从所有父类继承抽象方法
+        abstract_methods = set()
+        for base in bases:
+            if hasattr(base, '_abstract_methods'):
+                abstract_methods.update(base._abstract_methods)
+
+        # 2. 处理当前类定义的方法
+        for key, value in dct.items():
+            # 如果当前类显式定义了抽象方法（有 _is_abstract 标记）
+            if hasattr(value, '_is_abstract') and value._is_abstract:
+                abstract_methods.add(key)
+            else:
+                # 如果当前类定义了具体实现（没有 _is_abstract 标记）
+                # 并且该方法在抽象方法集合中，则移除（即实现了该抽象方法）
+                if key in abstract_methods:
+                    abstract_methods.remove(key)
+
+        # 3. 存储最终的抽象方法集合
+        dct['_abstract_methods'] = frozenset(abstract_methods)
+        return super().__new__(cls, name, bases, dct)
+
+    def __call__(cls, *args, **kwargs):
+        """实例化时检查抽象方法是否都已实现"""
+        if cls._abstract_methods:
+            methods = ', '.join(cls._abstract_methods)
+            raise TypeError(
+                f"Can't instantiate abstract class {cls.__name__} "
+                f"with abstract methods {methods}"
+            )
+        return super().__call__(*args, **kwargs)
+
+
+class ABC(metaclass=ABCMeta):
+    """抽象基类"""
+
+    def __init__(self):
+
+        if type(self) is ABC:
+            raise TypeError(
+                "Can't instantiate abstract class ABC with abstract methods")
+
+
+def abstractmethod(func):
+    """装饰器：标记抽象方法"""
+    func._is_abstract = True
+    return func
+
+
+def abstractclassmethod(func):
+    """装饰器：标记抽象类方法"""
+    func._is_abstract = True
+    return classmethod(func)
+
+
+def abstractstaticmethod(func):
+    """装饰器：标记抽象静态方法"""
+    func._is_abstract = True
+    return staticmethod(func)
+
+
+def abstractproperty(func):
+    """装饰器：标记抽象属性"""
+    func._is_abstract = True
+    return property(func)

gaskill-2.17.0/gaskill/gaskill/hashlib.py

@@ -0,0 +1,186 @@
+
+H0 = 0x6a09e667
+H1 = 0xbb67ae85
+H2 = 0x3c6ef372
+H3 = 0xa54ff53a
+H4 = 0x510e527f
+H5 = 0x9b05688c
+H6 = 0x1f83d9ab
+H7 = 0x5be0cd19
+
+K = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]
+
+
+def rotr(x, n):
+    """循环右移 n 位（32-bit）"""
+    return (x >> n) | ((x & ((1 << n) - 1)) << (32 - n))
+
+
+def shr(x, n):
+    """逻辑右移 n 位（高位补 0）"""
+    return x >> n
+
+
+def xor3(a, b, c):
+    """三个数的异或"""
+    return a ^ b ^ c
+
+
+def add_mod32(a, b):
+    """32-bit 加法（自动截断）"""
+    return (a + b) & 0xffffffff
+
+
+def ch(x, y, z):
+    """Choose: 根据 x 的位选择 y 或 z"""
+    return (x & y) ^ ((~x) & z)
+
+
+def maj(x, y, z):
+    """Majority: 按位多数投票"""
+    return (x & y) ^ (x & z) ^ (y & z)
+
+
+def sigma0(x):
+    """Σ0：用于压缩函数"""
+    return xor3(rotr(x, 2), rotr(x, 13), rotr(x, 22))
+
+
+def sigma1(x):
+    """Σ1：用于压缩函数"""
+    return xor3(rotr(x, 6), rotr(x, 11), rotr(x, 25))
+
+
+def gamma0(x):
+    """σ0：用于消息调度"""
+    return xor3(rotr(x, 7), rotr(x, 18), shr(x, 3))
+
+
+def gamma1(x):
+    """σ1：用于消息调度"""
+    return xor3(rotr(x, 17), rotr(x, 19), shr(x, 10))
+
+
+def pad_message(msg_bytes):
+    """
+    将字节消息填充为 512-bit 整数倍
+    返回：填充后的字节数组（每个元素 0-255）
+    """
+    msg_len = len(msg_bytes)
+    bit_len = msg_len * 8
+
+    padded = list(msg_bytes)
+
+    padded.append(0x80)
+
+    while len(padded) % 64 != 56:
+        padded.append(0x00)
+
+    for i in range(7, -1, -1):
+        padded.append((bit_len >> (8 * i)) & 0xff)
+
+    return padded
+
+
+def bytes_to_words(block):
+    """block: 64 字节的 list，返回 16 个 32-bit 整数"""
+    words = []
+    for i in range(0, 64, 4):
+        w = (block[i] << 24) | (block[i+1] <<
+                                16) | (block[i+2] << 8) | block[i+3]
+        words.append(w)
+    return words
+
+
+def compress_block(block_bytes, h_vals):
+    w = bytes_to_words(block_bytes)
+
+    for t in range(16, 64):
+        w.append(
+            add_mod32(
+                add_mod32(gamma1(w[t-2]), w[t-7]),
+                add_mod32(gamma0(w[t-15]), w[t-16])
+            )
+        )
+
+    a, b, c, d = h_vals[0], h_vals[1], h_vals[2], h_vals[3]
+    e, f, g, h = h_vals[4], h_vals[5], h_vals[6], h_vals[7]
+
+    for t in range(64):
+        t1 = add_mod32(
+            add_mod32(
+                add_mod32(
+                    add_mod32(h, sigma1(e)),
+                    ch(e, f, g)
+                ),
+                K[t]
+            ),
+            w[t]
+        )
+        t2 = add_mod32(sigma0(a), maj(a, b, c))
+
+        h = g
+        g = f
+        f = e
+        e = add_mod32(d, t1)
+        d = c
+        c = b
+        b = a
+        a = add_mod32(t1, t2)
+
+    return [
+        add_mod32(h_vals[0], a),
+        add_mod32(h_vals[1], b),
+        add_mod32(h_vals[2], c),
+        add_mod32(h_vals[3], d),
+        add_mod32(h_vals[4], e),
+        add_mod32(h_vals[5], f),
+        add_mod32(h_vals[6], g),
+        add_mod32(h_vals[7], h),
+    ]
+
+
+def sha256(message):
+    # 统一转为字节
+    if isinstance(message, str):
+        msg_bytes = [ord(c) for c in message]
+    else:
+        msg_bytes = list(message)
+
+    # 填充
+    padded = pad_message(msg_bytes)
+
+    # 初始哈希值（拷贝一份，避免修改全局）
+    h_vals = [H0, H1, H2, H3, H4, H5, H6, H7]
+
+    # 逐块处理（每 64 字节一块）
+    for i in range(0, len(padded), 64):
+        block = padded[i:i+64]
+        h_vals = compress_block(block, h_vals)
+
+    # 拼接最终摘要
+    result = ''
+    for val in h_vals:
+        # 转 8 位十六进制（补零）
+        hex_str = hex(val)[2:]  # 去掉 '0x'
+        if len(hex_str) < 8:
+            hex_str = '0' * (8 - len(hex_str)) + hex_str
+        result += hex_str
+
+    return result
+
+
+def DJB2(s, capacity=0xffffffff):
+    h = 5381
+    for byte in s.encode('utf-8'):
+        h = ((h * 33) + byte) % capacity
+    return h % capacity