# 🐙WMS图层的加载封装
```js
//加载WMS
const initwmslayer = (data, layername) => {
  let url = 'https://www.xxxx.com/geo/geoserver/' + data.ws + '/wms';
// 创建 WMS 图层对象
  let tileLayer = new mars3d.layer.WmsLayer({
    // 图层的 Z 索引，控制图层的叠放顺序，值越大图层越靠前
    zIndex: 1000,
    // 设置图层的 WMS 服务 URL
    url: url,
    // 图层的 ID，通常用于唯一标识图层
    id: layername,

    // 图层的名称，用于显示图层信息
    name: layername,
    // 图层的透明度，取值范围为 0 到 1，0 表示完全透明，1 表示完全不透明
    opacity: 0.5,
    // 需要显示的 WMS 图层名称，`data.url` 为传入的图层名称，`.toLowerCase()` 将其转化为小写
    layers: data.url.toLowerCase(),
    // WMS 图层请求的附加参数
    parameters: {
      // 设置透明背景
      transparent: true,
      // 设置返回的图像格式为 PNG，支持透明背景
      format: 'image/png',
    },
    // 获取要素信息时的参数，限制返回的要素数量
    getFeatureInfoParameters: {
      // 返回的要素数量，设置为 10
      feature_count: 10,
    // 高亮设置，当鼠标悬浮时对图层进行高亮显示
    highlight: {
      // 高亮效果的类型，"wallP" 表示墙面效果
      type: "wallP",
      // 高亮效果的高度差，表示高亮墙面的高度差，越大越突出
      diffHeight: 100,
      // 设置高亮效果的材质类型，这里使用 LineFlow，表示线性流动效果
      materialType: mars3d.MaterialType.LineFlow,
      // 材质的详细选项
      materialOptions: {
        // 使用纹理图片作为墙面效果的纹理图
        image: "img/textures/fence.png",
        // 设置高亮效果的颜色，这里设置为黄色
        color: "#ffff00",
        // 设置线性流动效果的速度，值越大流动速度越快
        speed: 10,
        // 设置是否沿 Y 轴旋转，true 表示沿 Y 轴旋转
        axisY: true
      }
    },
    // 配置弹出框内容，鼠标点击时弹出，显示当前值的属性
    popup: '当前值：{GRAY_INDEX}',
    // 是否自动飞行到该图层，false 表示不自动飞行
    flyTo: false,
    // 是否显示图层，默认不显示
    show: false
  });
  window.map.addLayer(tileLayer)
}


```

记一次mars3D中geoserverWMS服务图层加载

本项目仅限于学习交流不可商用，不可用于非法用途（包括但不限于：用于制作游戏外挂等）。

一开始是觉得不应该讲得太详细，但实际上不管是原理还是代码，在网上都是一找一大堆了，真有心也能拿去用了，还是记录一下。

实现一个AI自瞄，基本是三步走，屏幕截图——目标检测——鼠标移动，只有目标检测这一步需要用到AI，接下来各个部分分开讲一下。



首先是屏幕截图，如果确定要用Pytorch作为框架的话，那么Python的截图方法主要是三种：

第一种是用PIL或者Pillow进行图像处理，这两个库是大部分Python图像处理类的项目都会有的库，优点是很方便，但是效率不怎么样。

第二种是用pyautogui，这个库是自动化图形界面库，除了截图以外还能够控制鼠标，但是可能是为了跨平台使用，pyautogui的运行速度也很差，在我的电脑上截一张图需要0.02s左右，额，我跑一次Yolo才0.04秒，这都占一半时间了

第三种是用win32api，这个是微软给的应用程序编程接口，可以进行截图，缺点是代码比较长，不能跨平台，但是应该也没人会用Linux，Mac打游戏吧。

除此之外还有一些其他方法，比方说OBS提供了Python的api用于构建脚本，这个效率也很高，毕竟广泛用于直播推流，但是OBS是写在C平台上的，如果是用TensorFlow会比较方便。

在GitHub上有一个快速截图的库：d3dshot，至少在我测试下来，这个速度应该是最快的，但是缺点是一旦切屏出去了，截图就会出问题，没找出问题在哪。

这样看来最适合的截图库就只剩下了win32api和d3dshot，时间上差不多，但是win32api似乎BUG更少。

## [](#键盘事件监听 "键盘事件监听")键盘事件监听

在开始之前我们需要监听键盘的动作，这一部分通过pynput实现：

python

```python
mode = False

def on_press(key):
    global mode
    if key == keyboard.Key.f11:
        mode = not mode

def on_release(key):
    """松开按键时执行。"""
    # if key == keyboard.Key.esc:
    #     pass
    pass

if __name__ == '__main__':
    listener = keyboard.Listener(
        on_press=on_press,
        on_release=on_release)
    listener.start()
```

这样就可以通过f11来进行开启或关闭，当然也可以改成别的按键，因为python貌似并没有哪个库支持鼠标侧键的读取，所以可以在鼠标驱动写一个简单的按键触发。

## [](#屏幕截取 "屏幕截取")屏幕截取

python

```python
def window_prepare():
    hwnd = 0  # 窗口的编号，0号表示当前活跃窗口
    # 根据窗口句柄获取窗口的设备上下文DC（Divice Context）
    hwnd_dc = win32gui.GetWindowDC(hwnd)
    # 根据窗口的DC获取mfcDC
    mfc_dc = win32ui.CreateDCFromHandle(hwnd_dc)
    # mfcDC创建可兼容的DC
    save_dc = mfc_dc.CreateCompatibleDC()
    # 创建bigmap准备保存图片
    save_bit_map = win32ui.CreateBitmap()
    # 获取监控器信息
    width = 640
    height = 360
    # 为bitmap开辟空间
    save_bit_map.CreateCompatibleBitmap(mfc_dc, width, height)
    return save_bit_map, save_dc, mfc_dc, width, height


def window_capture(save_bit_map, save_dc, mfc_dc, width, height):
    # 高度saveDC，将截图保存到saveBitmap中
    save_dc.SelectObject(save_bit_map)
    # 截取从左上角（0，0）长宽为（w，h）的图片
    # saveDC.BitBlt((0, 0), (w, h), mfcDC, (0, 0), win32con.SRCCOPY)
    save_dc.BitBlt((0, 0), (width, height), mfc_dc, (640, 360), win32con.SRCCOPY)
    signed_ints_array = save_bit_map.GetBitmapBits(True)
    img = np.frombuffer(signed_ints_array, dtype='uint8')
    img.shape = (height, width, 4)
    img0 = img[:, :, :3]
    return img0
```

程序初始化阶段先运行window\_prepare，之后通过键盘控制是否循环触发window\_capture，捕获屏幕中央640x360的空间，进行检测，移动鼠标。（我这里的分辨率是1920x1080）

检测的部分跟之前的行人检测的demo是一致的，这里就不提了。总之是把截图丢给YoloV5，跑出结果后把坐标返回。

[行人检测demo | 莉莉娅！ (diduseemyelk.github.io)](https://diduseemyelk.github.io/Lillia.github.io/2023/01/11/xing-ren-jian-ce-demo/)

当然我们这里还有一个小问题，YoloV5跑完之后的结果坐标默认是按照置信度进行排序的，但很显然，如果有多个目标的时候，一般采取就近原则，谁离准心近，就瞄哪，所以还有一个小函数计算哪一组坐标离准心最近。

python

```python
def closest(self, boxes):
	distance_list = []
    for (x1, y1, x2, y2, label, conf) in boxes:
		mid_x = (x1 + x2) / 2
        mid_y = (y1 + y2) / 2
        distance = (mid_x - 960)**2 + (mid_y - 540)**2
        distance_list.append(distance)
	value = min(distance_list)
	index = distance_list.index(value)
	return index
```

## [](#鼠标移动 "鼠标移动")鼠标移动

鼠标的移动也有很多库可以用，还是跟上面一样，pyautogui的效率很低，我很难想象只是移动一下鼠标的操作，在pyautogui上都需要0.02s，GitHub上有一个mouse的第三方库，用这个库实现的话耗时是检测不到的。

具体代码我们连着前面两部分一起讲

python

```python
def aiming(save_bit_map, save_dc, mfc_dc, width, height):
    # 读取每帧图片
    im = window_capture(save_bit_map, save_dc, mfc_dc, width, height)
    bboxes = detector.detect(im)
    # 如果画面中有bbox，即detector探测到待检测对象
    if len(bboxes) > 0:
        box_index = detector.closest(bboxes)
        check_point_x = int(bboxes[box_index][0] + ((bboxes[box_index][2] - bboxes[box_index][0]) * 0.5)) + 640
        check_point_y = int(bboxes[box_index][1] + ((bboxes[box_index][3] - bboxes[box_index][1]) * 0.5)) + 360
        move_x = int(1.4 * (check_point_x - 960))
        move_y = int(1.4 * (check_point_y - 540))
        mouse.move(move_x, move_y, absolute=False, duration=0)
        pass
    else:
        pass
```

check\_point\_x和check\_point\_y是目标检测的中心点，这个点是离准心最近的点。但是值得注意的是，并不是直接把这个参数扔进去move就可以了，因为这种第一人称射击游戏，他都不需要记录你鼠标的位置，只需要记录你鼠标相对位移，并根据你的DPI和鼠标灵敏度进行转向即可。虽然这个目标离你的准心差了可能200个像素点，但转动和平移是两件事情，如何保证你转动过后目标恰好就在你的准心上呢？这就需要用到球面理论去进行计算了。

但是在游戏里，人物模型是有大小的，对于很远的人物，Yolo识别不出来，对于很近的人物，人物HitBox又足够大，即便第一时间没有瞄到最中央，仍然能够命中，因此很大程度上，我们不需要百分百精确地计算出move\_x和move\_y，完全可以利用中间的线性区域作线性拟合，找到一个经验常数，能够从check\_point\_x和check\_point\_y生成出误差较小的move\_x和move\_y即可，不同的分辨率可能会有所不同，我这分辨率取1.4差不多是比较稳定的。最后用mouse.move函数进行鼠标操作，这里的duration是指延迟，就是执行这个鼠标操作的耗时，如果取0.1的话其实会看起来比较丝滑。

ok最后附上一段bot测试吧。

yolov5自瞄框架

# 🍰 指针样式
```css
cursor: pointer;
```
注释：请在此列表的末端始终定义一种普通的光标，以防没有由 URL 定义的可用光标。


- default	默认光标（通常是一个箭头）
- auto	默认。浏览器设置的光标。

- crosshair	光标呈现为十字线。
- pointer	光标呈现为指示链接的指针（一只手）
- move	此光标指示某对象可被移动。
- e-resize	此光标指示矩形框的边缘可被向右（东）移动。
- ne-resize	此光标指示矩形框的边缘可被向上及向右移动（北/东）。
- nw-resize	此光标指示矩形框的边缘可被向上及向左移动（北/西）。
- n-resize	此光标指示矩形框的边缘可被向上（北）移动。
- se-resize	此光标指示矩形框的边缘可被向下及向右移动（南/东）。
- sw-resize	此光标指示矩形框的边缘可被向下及向左移动（南/西）。
- s-resize	此光标指示矩形框的边缘可被向下移动（南）。
- w-resize	此光标指示矩形框的边缘可被向左移动（西）。
- text	此光标指示文本。
- wait	此光标指示程序正忙（通常是一只表或沙漏）。
- help	此光标指示可用的帮助（通常是一个问号或一个气球）。

css鼠标指针悬浮写法

# 🥗flex布局
### flex-direction
flex-direction属性决定主轴的方向（即项目的排列方向）。
- row（默认值）：主轴为水平方向，起点在左端。
- row-reverse：主轴为水平方向，起点在右端。
- column：主轴为垂直方向，起点在上沿。
- column-reverse：主轴为垂直方向，起点在下沿。

```css

.box {
  flex-direction: row | row-reverse | column | column-reverse;
}

```



![image.png](/static/img/fb8944d6211232f7cb54bc3853898860.image.webp)

### flex-wrap
默认情况下，项目都排在一条线（又称”轴线”）上。flex-wrap属性定义，如果一条轴线排不下，如何换行。

![image.png](/static/img/f422289dd63dd23420b5750782189c65.image.webp)

```css
.box{
  flex-wrap: nowrap | wrap | wrap-reverse;
}
```
它可能取三个值。

（1）nowrap（默认）：不换行。

![image.png](/static/img/b8b0e00f00a37183df9f170742688e47.image.webp)


（2）wrap：换行，第一行在上方。


![image.png](/static/img/d0e54a1386e1484372f52fb705d15ffa.image.webp)

（3）wrap-reverse：换行，第一行在下方。

![image.png](/static/img/84aa9500e6bd109f057f23bddb12ac15.image.webp)

### flex-flow
flex-flow属性是flex-direction属性和flex-wrap属性的简写形式，默认值为row nowrap。

```css
.box {
  flex-flow: <flex-direction> <flex-wrap>;
}
```
### justify-content
justify-content属性定义了项目在主轴上的对齐方式。

```css
.box {
  justify-content: flex-start | flex-end | center | space-between | space-around;
}
```
![image.png](/static/img/d9a6eceaac44bbd8838a35e1ba96c6d7.image.webp)

它可能取5个值，具体对齐方式与轴的方向有关。下面假设主轴为从左到右。

- flex-start（默认值）：左对齐
- flex-end：右对齐
- center： 居中
- space-between：两端对齐，项目之间的间隔都相等。
- space-around：每个项目两侧的间隔相等。所以，项目之间的间隔比项目与边框的间隔大一倍。

### align-items
align-items属性定义项目在交叉轴上如何对齐。

```css
.box {
  align-items: flex-start | flex-end | center | baseline | stretch;
}
```

![image.png](/static/img/7ef66943c640b94ce29ed3d7c649083e.image.webp)

它可能取5个值。具体的对齐方式与交叉轴的方向有关，下面假设交叉轴从上到下。

- flex-start：交叉轴的起点对齐。
- flex-end：交叉轴的终点对齐。
- center：交叉轴的中点对齐。
- baseline: 项目的第一行文字的基线对齐。
- stretch（默认值）：如果项目未设置高度或设为auto，将占满整个容器的高度。

### align-content
align-content属性定义了多根轴线的对齐方式。如果项目只有一根轴线，该属性不起作用。

```css
.box {
  align-content: flex-start | flex-end | center | space-between | space-around | stretch;
}
```

![image.png](/static/img/ae2efcca1d8ef59a06877e34ee2f05ac.image.webp)

该属性可能取6个值。

- flex-start：与交叉轴的起点对齐。
- flex-end：与交叉轴的终点对齐。
- center：与交叉轴的中点对齐。
- space-between：与交叉轴两端对齐，轴线之间的间隔平均分布。
- space-around：每根轴线两侧的间隔都相等。所以，轴线之间的间隔比轴线与边框的间隔大一倍。
- stretch（默认值）：轴线占满整个交叉轴。

常用flex布局写法

:::tip{title="💡实现"}
GSAP动画的封装，实现页面元素自动瀑布流切入切出且可以自定义切入切出方向及动画时间延时
:::

## 规则
- paused 时间线开始不自动执行
- ease 动画规则  "power4.in", // 先慢后快  "power2.inOut", // 先快后慢
- opacity 不透明度
- duration 所需时间
- , "<0.5" 后缀添加意义为上一动画后0.5秒运行
- , "<" 后缀添加意义为与上一动画同时运行
## 代码



```
//面板动画 - 切出
gsap.registerEffect({
    name: "panelEffectOut",
    effect: (targets, config) => {

        // 定义一个时间线来串联两个动画
        let tl = gsap.timeline();
        if (config.mode == "in") {
            
            if (config.direction == "left" || config.direction == "right") {

                //默认左方向
                let x1 = 100;
                let x2 = 0
                if (config.direction == "right") {
                    //右方向
                    x1 = -100;
                    x2 = 0
                }

                // 第一步动画
                tl.to(targets, {
                    x: x1,
                    opacity: 0.5,
                    duration: 0.8
                });

                // 第二步动画
                tl.to(targets, {
                    x: x2,
                    opacity: 1,
                    duration: 1
                });

            } else {

                //默认上方向
                let y1 = 100;
                let y2 = 0
                if (config.direction == "bottom") {
                    //右方向
                    y1 = -100;
                    y2 = 0
                }

                // // 第一步动画
                // tl.to(targets, {
                //     y: y1,
                //     opacity: 0.5,
                //     duration: 0.5
                // });

                // 第二步动画
                tl.to(targets, {
                    y: y2,
                    opacity: 1,
                    duration: 0.8
                });

            }
        } else {

            if (config.direction == "left" || config.direction == "right") {

                //默认左方向
                let x1 = 100;
                let x2 = -700
                if (config.direction == "right") {
                    //右方向
                    x1 = -100;
                    x2 = 700
                }

                // 第一步动画
                tl.to(targets, {
                    x: x1,
                    opacity: 0.5,
                    duration: 0.4
                });

                // 第二步动画
                tl.to(targets, {
                    x: x2,
                    opacity: 0,
                    duration: 1
                });

            } else {

                //默认上方向
                let y1 = 100;
                let y2 = -700
                if (config.direction == "bottom") {
                    //右方向
                    y1 = -100;
                    y2 = 700
                }

                // 第一步动画
                tl.to(targets, {
                    y: y1,
                    opacity: 0.5,
                    duration: 0.4
                });

                // 第二步动画
                tl.to(targets, {
                    y: y2,
                    opacity: 0,
                    duration: 1
                });

            }
        }

        return tl;


    },
    extendTimeline: true // 允许在 GSAP 时间线上直接调用这个效果
});

//元素动画 -元素切入
gsap.registerEffect({
    name: "elementsEffect",
    effect: (targets, config) => {
        // console.log("🚀元素切入 ~ targets, config:", targets, config)
        

        // 创建时间线以添加延迟
        let tl = gsap.timeline();

        // 使用 .forEach 遍历每个目标元素
        targets.forEach(target => {
            let delay = 0;
            let direction = "";

            // 从类名中提取延迟时间
            const classList = target.classList;
            classList.forEach(className => {
                const match = className.match(/hl-effect-(left|right|top|bottom)-(\d+)/);
                if (match != null) {
                    direction = match[1]
                    delay = parseInt(match[2], 10) / 1000; // 将毫秒转换为秒
                }
            });

            // 根据方向设置初始位置
            if (direction === "left") {
                gsap.set(target, { x: -300, opacity: 0 });
            } else if (direction === "right") {
                gsap.set(target, { x: 300, opacity: 0 });
            } else if (direction === "bottom") {
                gsap.set(target, { y: 300, opacity: 0 });
            } else if (direction === "top") {
                gsap.set(target, { y: -300, opacity: 0 });
            }

            // 添加动画到时间线
            if (direction === "left" || direction === "right") {

                tl.to(target, {
                    x: 0,
                    opacity: 1,
                    duration: 0.6,
                }, "<" + delay)

            } else if (direction === "top" || direction === "bottom") {

                tl.to(target, {
                    y: 0,
                    opacity: 1,
                    duration: 0.6,
                }, "<" + delay);
            }
        });

        return tl;

    },
    extendTimeline: true // 允许在 GSAP 时间线上直接调用这个效果
});



//隐藏传入元素
const hiddenelement = (element, direction = "x", px = 300) => {

    if (direction == "x") {
        gsap.set(element, {
            x: px,
            opacity: 0,
        });
    }

    if (direction == "y") {
        gsap.set(element, {
            y: px,
            opacity: 0,
        });
    }

}

//切出动画
export const cutOut = () => {
   
    // 创建一个时间线
    const tl1 = gsap.timeline({
        paused: true,
        ease: "power4.in", // 先慢后快
    });
    // 创建一个时间线
    const tl2 = gsap.timeline({
        paused: true,
        ease: "power4.in", // 先慢后快
    });

    // 创建一个时间线 面板3
    const tl3 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });

    // 创建一个时间线 面板4
    const tl4 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });

    // 创建一个时间线 图例
    const tl5 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });

    // 创建一个时间线 顶部
    const tl6 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });


    tl1.panelEffectOut("#main-box1", { direction: "left", mode: "out" })
    tl2.panelEffectOut("#main-box2", { direction: "right", mode: "out" })

    // var el1 = '.header-left';
    // var el2 = '.header-right';
    // var el3 = '.header-box';
    // var el4 = '.masklayer-main';
    // tl6.to(el4, {
    //     x: 0,
    //     opacity: 0,
    //     duration: 0.4
    // }).to(el1, {
    //     x: 100,
    //     opacity: 0.5,
    //     duration: 0.4
    // }, "<").to(el2, {
    //     x: -100,
    //     opacity: 0.5,
    //     duration: 0.4
    // }, "<").to(el1, {
    //     x: -300,
    //     opacity: 0,
    //     duration: 0.4
    // }, "<0.4").to(el2, {
    //     x: 300,
    //     opacity: 0,
    //     duration: 0.4
    // }, "<").to(el3, {
    //     y: -300,
    //     opacity: 0,
    //     duration: 0.6
    // }, "<0.4");

    tl1.play();
    tl2.play();
    // tl4.play();
    // tl6.play();
    // gsap.delayedCall(0.4, () => {
    //     tl2.play()
    //     tl3.play()
    // }
    // );
    // gsap.delayedCall(0.8, () => {
    //     tl5.play()
    // }
    // );

}

//切入动画
export const cutIn = (e) => {

    // 创建一个时间线 面板1
    const tl1 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });
 

    // 创建一个时间线 面板3
    const tl3 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });

    // 创建一个时间线 面板4
    const tl4 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });
    // 创建一个时间线 面板4
    const tl5 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });


    // 创建一个时间线 顶部
    const tl6 = gsap.timeline({
        paused: true,
        ease: "power2.inOut", // 先快后慢
    });


    tl1.panelEffectOut("#main-box1", { direction: "left", mode: "in" })
    const elemetlist1 = document.getElementById('main-box1').querySelectorAll('[class*="hl-effect-"]');
    tl1.elementsEffect(elemetlist1, {}, "<0.2")


    tl4.panelEffectOut("#main-box2", { direction: "right", mode: "in" })
    const elemetlist4 = document.getElementById('main-box2').querySelectorAll('[class*="hl-effect-"]');
    tl4.elementsEffect(elemetlist4, {}, "<0.2")


    if(e==0){
        tl3.panelEffectOut("#main-box4", { direction: "right", mode: "in" })
        tl5.panelEffectOut("#main-box5", { direction: "bottom", mode: "in" })
    }
    


    // var el1 = '.header-left';
    // var el2 = '.header-right';
    // var el3 = '.header-box';
    // var el4 = '.masklayer-main';
    // tl6.to(el4, {
    //     x: 0,
    //     opacity: 1,
    //     duration: 0.4
    // }).to(el3, {
    //     y: -300,
    //     opacity: 0,
    //     duration: 0.2
    // }, "<").to(el3, {
    //     y: 0,
    //     opacity: 1,
    //     duration: 0.6
    // }, "<0.2").to(el1, {
    //     x: 100,
    //     opacity: 0.5,
    //     duration: 0.6
    // }, "<0.6").to(el2, {
    //     x: -100,
    //     opacity: 0.5,
    //     duration: 0.6
    // }, "<").to(el1, {
    //     x: 0,
    //     opacity: 1,
    //     duration: 0.6
    // }, "<0.6").to(el2, {
    //     x: 0,
    //     opacity: 1,
    //     duration: 0.6
    // }, "<")

    tl1.play();
    tl4.play();
    tl6.play();
    
    if(e==0){
        gsap.delayedCall(1.5, () => {
            tl5.play();
            tl3.play();
        })
    }




}

export const hideBox = () => {
    hiddenelement("#main-box1", 'x', -300)
    hiddenelement("#main-box2", 'x', -300)
    hiddenelement("#main-box4", 'x', -300)
    hiddenelement("#main-box5", 'y', 100)
}

export const hideBox1 = () => {
    hiddenelement("#main-box1", 'x', -300)
    hiddenelement("#main-box2", 'x', -300)
}


```