咸鱼标

zblogphp、Z-Blog PHP数据库结构及表中的字段详细说明

Sun, 20 Jul 2025 19:27:41 +0800

zblogphp数据库默认仍是8张数据表，其中内容正文没有单独分出一个附表，使得zblogphp数据大时会很慢很卡，文章表会很大，动态查询数据会很慢。而且前端没有生成静态html功能，这些都是比较大的缺陷。

表结构说明:

表名	储存信息
zbp_category	分类表
zbp_comment	评论表
zbp_config	插件配置表
zbp_member	用户表
zbp_module	模块表
zbp_post	文章表
zbp_tag	标签表
zbp_upload	附件表

zbp_post 内容表

log_ID	序号，即文章ID
log_CateID	所属分类ID
log_AuthorID	作者ID
log_Tag	文章标签
log_Status	文章或页面状态：0公开，1草稿，2审核
log_type	文章和页面类型：0文章，1页面
log_Alias	别名
log_istop	文章是否置顶：0不置顶，1全局置顶
log_IsLock	文章或页面是否允许评论：0允许，1禁止
log_Title	标题
log_Intro	摘要
log_Content	内容
log_PostTime	创建时间
log_CommNums	评论数量
log_ViewNums	浏览数量
log_Template	文章模板
log_Meta	自定义附加字段

zbp_category 分类表

cate_ID	序号，即分类ID
cate_Name	分类名称
cate_Order	分类排列顺序
cate_Type	分类类型
cate_Count	分类文章数量
cate_Alias	别名
cate_Intro	介绍
cate_RootID	根分类ID
cate_ParentID	父分类ID
cate_Template	分类列表模板
cate_LogTemplate	分类文章模板
cate_Meta	自定义附加字段

zbp_member 用户表

mem_ID	序号，即用户ID
mem_Guid	注册邀请码
mem_Level	用户级别：
mem_Status	用户状态：0正常，1审核，2禁用
mem_Name	名称
mem_Passerword	密码
mem_Email	邮箱
mem_HomePage	网址
mem_IP	注册IP地址
mem_PostTime	注册时间
mem_Alias	别名
mem_Intro	简介
mem_Articles	文章记录
mem_Pages	页面记录
mem_Comments	评论记录
mem_Uploads	附件记录
mem_Template	用户模板
mem_Meta	自定义附加字段

zbp_module 模块表

mod_ID	序号，即模块ID
mod_Name	模块名称
mod_FileName	模块文件名
mod_Content	模块内容代码
mod_SidebarID	模块所在侧边栏的序号
mod_HtmlID	模块最外层div的id
mod_Type	模块类型
mod_MaxLi	最大条目数
mod_Source	模块来源：系统模块、自定义模块
mod_IsHideTitle	是否隐藏模块标题
mod_Meta	自定义附加字段

zbp_tag 标签表

tag_ID	序号，即标签ID
tag_Name	标签名称
tag_Order	标签排列顺序
tag_Type	标签类型
tag_Count	标签文章数量
tag_Alias	别名
tag_Intro	介绍
tag_Template	标签列表模板
tag_Meta	自定义附加字段

【分享】一款实用的文件扩展名批量修改工具

Mon, 02 Jun 2025 22:59:33 +0800

大家好！今天我想给大家分享一款实用的小工具——文件扩展名批量修改工具。这是一个我用Python开发的图形化应用程序，可以帮助大家快速、安全地批量修改文件扩展名。

为什么需要这个工具？

在日常工作中，我们可能会遇到这样的情况：

需要将一堆HTML文件转换为TXT文件以便进行文本处理
需要将某些文档的扩展名规范化
需要批量修改图片或视频文件的格式（仅扩展名）
其他任何需要批量更改文件扩展名的情况

虽然可以通过手动一个个重命名文件来完成这项工作，但当文件数量较多时，这种方式既耗时又容易出错。Windows自带的重命名功能也不够灵活，尤其是需要处理大量位于不同子文件夹中的文件时。

工具特点

这款工具具有以下特点：

简单直观的图形界面：操作简单，无需任何编程知识
强大的功能：
- 支持选择任意文件夹进行操作
- 可选择是否包含子文件夹中的文件
- 支持正则表达式进行复杂的匹配和替换
- 提供文件预览功能，操作前可以查看哪些文件将被修改
- 详细的操作日志记录
安全可靠：
- 安全模式：自动备份所有将被修改的文件
- 支持撤销操作：一键恢复上次修改
- 操作前确认机制，防止误操作
- 详细的错误处理和提示
自定义设置：
- 可自定义备份保留天数
- 自定义备份位置
- 自定义预览文件数量
- 等等...

使用方法

使用非常简单，只需几个步骤：

1. 基本操作

打开程序，选择要处理的文件夹
输入源扩展名（如 .html）和目标扩展名（如 .txt）
选择是否包含子文件夹
点击"扫描文件"查看匹配的文件
在预览标签页检查将要修改的文件
确认无误后，点击"开始转换"

2. 高级功能

正则表达式模式：勾选"使用正则表达式"，可以使用更灵活的匹配和替换规则
安全模式：默认启用，会在操作前备份所有文件
撤销操作：如果对结果不满意，可以点击"撤销上次操作"一键恢复
日志查看：在"日志"标签页可以查看所有操作的详细记录

3. 自定义设置

在"设置"标签页可以自定义：

备份设置（是否自动备份、保留时间、备份位置）
界面设置（是否显示确认对话框、自动刷新预览等）
其他个性化选项

实际效果展示

下面是软件的几个主要界面截图：

主界面

预览页面

设置页面

适用场景举例

网页设计师/前端开发：批量将.html文件转为.txt或.md进行内容编辑
数据分析师：将.csv文件转换为.txt或其他格式
视频/图片处理：统一文件扩展名格式
教育工作者：整理大量课件文件，统一文件格式
任何需要批量整理文件的场景

下载与安装

为了方便大家使用，我已经将程序打包为exe可执行文件，无需安装Python环境，下载后即可使用。

下载地址：[附件] 文件扩展名批量修改工具v1.0.exe

使用须知：

适用于Windows系统（Windows 7/8/10/11）
无需安装，下载后双击即可运行
首次运行可能会有安全提示，请允许运行

技术实现

这个工具使用Python语言开发，主要用到了以下技术：

tkinter库：实现图形用户界面
os和shutil库：处理文件操作
re库：实现正则表达式功能
threading：多线程处理，避免界面卡顿
json：保存配置和日志

完整源代码我已放在文章末尾，感兴趣的朋友可以自行查看或修改（略过详细代码部分，我会在文章后面粘贴完整代码）。

未来计划

这个工具还有很多可以改进的地方，计划在未来版本中添加：

批量文件内容替换功能
更多文件匹配规则
任务计划功能
更美观的界面
更多语言支持

结语

这个小工具虽然简单，但在很多场景下能大大提高工作效率。希望能对大家有所帮助！

如果你在使用过程中遇到任何问题，或者有功能建议，欢迎在评论区留言，我会尽力解答和改进。

最后，如果你觉得这个工具有用，请分享给可能需要的朋友。感谢大家的支持！

源代码（供感兴趣的朋友参考）

import os
import tkinter as tk
from tkinter import filedialog, messagebox, ttk, scrolledtext
import threading
import json
import datetime
import shutil
import re
from pathlib import Path

class FileExtensionChanger:
    def __init__(self, root):
        self.root = root
        self.root.title("文件扩展名批量修改工具")
        self.root.geometry("700x600")
        self.root.resizable(True, True)
        
        # 设置主题颜色
        self.bg_color = "#f0f0f0"
        self.accent_color = "#4a7abc"
        self.root.configure(bg=self.bg_color)

        # 存储操作历史记录，用于撤销
        self.operation_history = []
        self.log_file = "file_extension_changer_log.json"
        
        # 创建主标签页
        self.tab_control = ttk.Notebook(root)
        
        # 主操作页面
        self.main_tab = tk.Frame(self.tab_control, bg=self.bg_color)
        # 预览页面
        self.preview_tab = tk.Frame(self.tab_control, bg=self.bg_color)
        # 日志页面
        self.log_tab = tk.Frame(self.tab_control, bg=self.bg_color)
        # 设置页面
        self.settings_tab = tk.Frame(self.tab_control, bg=self.bg_color)
        
        self.tab_control.add(self.main_tab, text="主页")
        self.tab_control.add(self.preview_tab, text="预览")
        self.tab_control.add(self.log_tab, text="日志")
        self.tab_control.add(self.settings_tab, text="设置")
        self.tab_control.pack(expand=1, fill=tk.BOTH, padx=5, pady=5)
        
        # 初始化各页面
        self.setup_main_tab()
        self.setup_preview_tab()
        self.setup_log_tab()
        self.setup_settings_tab()
        
        # 加载设置
        self.load_settings()
        
        # 初始化变量
        self.preview_files = []
        self.is_scanning = False

    def setup_main_tab(self):
        """设置主操作页面"""
        main_frame = tk.Frame(self.main_tab, bg=self.bg_color)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        # 添加标题
        title_label = tk.Label(
            main_frame, 
            text="文件扩展名批量修改工具", 
            font=("Arial", 16, "bold"), 
            bg=self.bg_color
        )
        title_label.pack(pady=(0, 20))
        
        # 文件夹选择框架
        folder_frame = tk.Frame(main_frame, bg=self.bg_color)
        folder_frame.pack(fill=tk.X, pady=10)
        
        folder_label = tk.Label(folder_frame, text="选择文件夹:", bg=self.bg_color)
        folder_label.pack(side=tk.LEFT, padx=(0, 10))
        
        self.folder_path = tk.StringVar()
        folder_entry = tk.Entry(folder_frame, textvariable=self.folder_path, width=40)
        folder_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
        
        browse_button = tk.Button(
            folder_frame, 
            text="浏览", 
            command=self.browse_folder,
            bg=self.accent_color,
            fg="white",
            relief=tk.FLAT,
            padx=10
        )
        browse_button.pack(side=tk.LEFT, padx=(10, 0))
        
        # 扩展名设置框架
        ext_frame = tk.Frame(main_frame, bg=self.bg_color)
        ext_frame.pack(fill=tk.X, pady=10)
        
        # 源扩展名
        from_label = tk.Label(ext_frame, text="源扩展名:", bg=self.bg_color)
        from_label.pack(side=tk.LEFT, padx=(0, 10))
        
        self.from_ext = tk.StringVar(value=".html")
        from_entry = tk.Entry(ext_frame, textvariable=self.from_ext, width=10)
        from_entry.pack(side=tk.LEFT)
        
        # 目标扩展名
        to_label = tk.Label(ext_frame, text="目标扩展名:", bg=self.bg_color)
        to_label.pack(side=tk.LEFT, padx=(20, 10))
        
        self.to_ext = tk.StringVar(value=".txt")
        to_entry = tk.Entry(ext_frame, textvariable=self.to_ext, width=10)
        to_entry.pack(side=tk.LEFT)
        
        # 选项框架
        options_frame = tk.Frame(main_frame, bg=self.bg_color)
        options_frame.pack(fill=tk.X, pady=10)
        
        # 递归选项
        self.recursive = tk.BooleanVar(value=False)
        recursive_check = tk.Checkbutton(
            options_frame, 
            text="包含子文件夹", 
            variable=self.recursive,
            bg=self.bg_color
        )
        recursive_check.pack(side=tk.LEFT, padx=(0, 20))
        
        # 安全模式（先复制再重命名）
        self.safe_mode = tk.BooleanVar(value=True)
        safe_mode_check = tk.Checkbutton(
            options_frame, 
            text="安全模式", 
            variable=self.safe_mode,
            bg=self.bg_color
        )
        safe_mode_check.pack(side=tk.LEFT)
        
        # 正则表达式模式
        self.regex_mode = tk.BooleanVar(value=False)
        regex_check = tk.Checkbutton(
            options_frame, 
            text="使用正则表达式", 
            variable=self.regex_mode,
            bg=self.bg_color,
            command=self.toggle_regex_mode
        )
        regex_check.pack(side=tk.LEFT, padx=(20, 0))
        
        # 按钮框架
        button_frame = tk.Frame(main_frame, bg=self.bg_color)
        button_frame.pack(fill=tk.X, pady=10)
        
        # 扫描按钮
        self.scan_button = tk.Button(
            button_frame, 
            text="扫描文件", 
            command=self.scan_files,
            bg="#4caf50",
            fg="white",
            relief=tk.FLAT,
            padx=20,
            pady=5
        )
        self.scan_button.pack(side=tk.LEFT, padx=(0, 10))
        
        # 执行按钮
        self.execute_button = tk.Button(
            button_frame, 
            text="开始转换", 
            command=self.start_conversion,
            bg=self.accent_color,
            fg="white",
            relief=tk.FLAT,
            padx=20,
            pady=5,
            state=tk.DISABLED  # 初始禁用，先扫描
        )
        self.execute_button.pack(side=tk.LEFT, padx=(0, 10))
        
        # 撤销按钮
        self.undo_button = tk.Button(
            button_frame, 
            text="撤销上次操作", 
            command=self.undo_last_operation,
            bg="#f44336",
            fg="white",
            relief=tk.FLAT,
            padx=20,
            pady=5,
            state=tk.DISABLED  # 初始禁用
        )
        self.undo_button.pack(side=tk.LEFT)
        
        # 进度条
        self.progress_var = tk.DoubleVar()
        self.progress_bar = ttk.Progressbar(
            main_frame, 
            variable=self.progress_var, 
            length=100, 
            mode="determinate"
        )
        self.progress_bar.pack(fill=tk.X, pady=(20, 10))
        
        # 状态标签
        self.status_var = tk.StringVar(value="准备就绪")
        status_label = tk.Label(
            main_frame, 
            textvariable=self.status_var,
            bg=self.bg_color
        )
        status_label.pack(fill=tk.X)
        
        # 统计信息
        self.stats_frame = tk.Frame(main_frame, bg=self.bg_color)
        self.stats_frame.pack(fill=tk.X, pady=10)
        
        self.total_files = tk.StringVar(value="总文件数: 0")
        self.converted_files = tk.StringVar(value="已转换: 0")
        self.failed_files = tk.StringVar(value="失败数: 0")
        
        tk.Label(self.stats_frame, textvariable=self.total_files, bg=self.bg_color).pack(side=tk.LEFT, padx=(0, 20))
        tk.Label(self.stats_frame, textvariable=self.converted_files, bg=self.bg_color).pack(side=tk.LEFT, padx=(0, 20))
        tk.Label(self.stats_frame, textvariable=self.failed_files, bg=self.bg_color).pack(side=tk.LEFT)

    def setup_preview_tab(self):
        """设置预览页面"""
        preview_frame = tk.Frame(self.preview_tab, bg=self.bg_color)
        preview_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        # 预览说明
        preview_label = tk.Label(
            preview_frame, 
            text="文件预览（将要处理的文件）", 
            font=("Arial", 12, "bold"), 
            bg=self.bg_color
        )
        preview_label.pack(pady=(0, 10))
        
        # 预览列表
        preview_container = tk.Frame(preview_frame, bg=self.bg_color)
        preview_container.pack(fill=tk.BOTH, expand=True)
        
        # 创建标题行
        headers_frame = tk.Frame(preview_container, bg="#dddddd")
        headers_frame.pack(fill=tk.X, pady=(0, 1))
        
        tk.Label(headers_frame, text="原文件名", width=40, bg="#dddddd", anchor="w", padx=5).pack(side=tk.LEFT)
        tk.Label(headers_frame, text="新文件名", width=40, bg="#dddddd", anchor="w", padx=5).pack(side=tk.LEFT)
        
        # 创建预览列表框
        preview_canvas = tk.Canvas(preview_container, bg=self.bg_color)
        preview_scrollbar = ttk.Scrollbar(preview_container, orient="vertical", command=preview_canvas.yview)
        self.preview_list_frame = tk.Frame(preview_canvas, bg=self.bg_color)
        
        preview_canvas.configure(yscrollcommand=preview_scrollbar.set)
        
        preview_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        preview_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        preview_canvas.create_window((0, 0), window=self.preview_list_frame, anchor="nw")
        
        self.preview_list_frame.bind("<Configure>", lambda e: preview_canvas.configure(scrollregion=preview_canvas.bbox("all")))
        
        # 占位信息 - 修复这里的引号问题
        self.preview_placeholder = tk.Label(
            self.preview_list_frame, 
            text='请先在主页面点击"扫描文件"按钮', 
            bg=self.bg_color,
            padx=10,
            pady=20
        )
        self.preview_placeholder.pack()

    def setup_log_tab(self):
        """设置日志页面"""
        log_frame = tk.Frame(self.log_tab, bg=self.bg_color)
        log_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        # 日志标题
        log_label = tk.Label(
            log_frame, 
            text="操作日志", 
            font=("Arial", 12, "bold"), 
            bg=self.bg_color
        )
        log_label.pack(pady=(0, 10))
        
        # 日志文本区域
        self.log_text = scrolledtext.ScrolledText(log_frame, width=80, height=20)
        self.log_text.pack(fill=tk.BOTH, expand=True)
        self.log_text.config(state=tk.DISABLED)
        
        # 日志操作按钮
        log_buttons_frame = tk.Frame(log_frame, bg=self.bg_color)
        log_buttons_frame.pack(fill=tk.X, pady=10)
        
        refresh_log_button = tk.Button(
            log_buttons_frame, 
            text="刷新日志", 
            command=self.load_log,
            bg=self.accent_color,
            fg="white",
            relief=tk.FLAT,
            padx=10
        )
        refresh_log_button.pack(side=tk.LEFT, padx=(0, 10))
        
        clear_log_button = tk.Button(
            log_buttons_frame, 
            text="清空日志", 
            command=self.clear_log,
            bg="#f44336",
            fg="white",
            relief=tk.FLAT,
            padx=10
        )
        clear_log_button.pack(side=tk.LEFT)

    def setup_settings_tab(self):
        """设置设置页面"""
        settings_frame = tk.Frame(self.settings_tab, bg=self.bg_color)
        settings_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        # 设置标题
        settings_label = tk.Label(
            settings_frame, 
            text="设置", 
            font=("Arial", 12, "bold"), 
            bg=self.bg_color
        )
        settings_label.pack(pady=(0, 20))
        
        # 备份设置
        backup_frame = tk.LabelFrame(settings_frame, text="备份设置", bg=self.bg_color, padx=10, pady=10)
        backup_frame.pack(fill=tk.X, pady=10)
        
        # 自动备份
        self.auto_backup = tk.BooleanVar(value=True)
        auto_backup_check = tk.Checkbutton(
            backup_frame, 
            text="操作前自动备份文件", 
            variable=self.auto_backup,
            bg=self.bg_color
        )
        auto_backup_check.pack(anchor=tk.W)
        
        # 保留备份时长
        backup_days_frame = tk.Frame(backup_frame, bg=self.bg_color)
        backup_days_frame.pack(fill=tk.X, pady=5)
        
        tk.Label(backup_days_frame, text="保留备份天数:", bg=self.bg_color).pack(side=tk.LEFT)
        
        self.backup_days = tk.IntVar(value=7)
        backup_days_spinbox = tk.Spinbox(backup_days_frame, from_=1, to=30, textvariable=self.backup_days, width=5)
        backup_days_spinbox.pack(side=tk.LEFT, padx=10)
        
        # 备份位置
        backup_path_frame = tk.Frame(backup_frame, bg=self.bg_color)
        backup_path_frame.pack(fill=tk.X, pady=5)
        
        tk.Label(backup_path_frame, text="备份位置:", bg=self.bg_color).pack(side=tk.LEFT)
        
        self.backup_path = tk.StringVar(value="./backups")
        backup_path_entry = tk.Entry(backup_path_frame, textvariable=self.backup_path, width=30)
        backup_path_entry.pack(side=tk.LEFT, padx=10, fill=tk.X, expand=True)
        
        backup_path_button = tk.Button(
            backup_path_frame, 
            text="浏览", 
            command=self.browse_backup_folder,
            bg=self.accent_color,
            fg="white",
            relief=tk.FLAT
        )
        backup_path_button.pack(side=tk.LEFT)
        
        # 界面设置
        ui_frame = tk.LabelFrame(settings_frame, text="界面设置", bg=self.bg_color, padx=10, pady=10)
        ui_frame.pack(fill=tk.X, pady=10)
        
        # 确认对话框
        self.confirm_operations = tk.BooleanVar(value=True)
        confirm_check = tk.Checkbutton(
            ui_frame, 
            text="操作前显示确认对话框", 
            variable=self.confirm_operations,
            bg=self.bg_color
        )
        confirm_check.pack(anchor=tk.W)
        
        # 自动刷新预览
        self.auto_refresh_preview = tk.BooleanVar(value=True)
        auto_preview_check = tk.Checkbutton(
            ui_frame, 
            text="更改设置后自动刷新预览", 
            variable=self.auto_refresh_preview,
            bg=self.bg_color
        )
        auto_preview_check.pack(anchor=tk.W)
        
        # 最大预览文件数
        preview_limit_frame = tk.Frame(ui_frame, bg=self.bg_color)
        preview_limit_frame.pack(fill=tk.X, pady=5)
        
        tk.Label(preview_limit_frame, text="最大预览文件数:", bg=self.bg_color).pack(side=tk.LEFT)
        
        self.preview_limit = tk.IntVar(value=100)
        preview_limit_spinbox = tk.Spinbox(preview_limit_frame, from_=10, to=500, textvariable=self.preview_limit, width=5)
        preview_limit_spinbox.pack(side=tk.LEFT, padx=10)
        
        # 保存设置按钮
        save_settings_button = tk.Button(
            settings_frame, 
            text="保存设置", 
            command=self.save_settings,
            bg=self.accent_color,
            fg="white",
            relief=tk.FLAT,
            padx=20,
            pady=5
        )
        save_settings_button.pack(pady=20)

    def browse_folder(self):
        """浏览并选择要操作的文件夹"""
        folder_selected = filedialog.askdirectory()
        if folder_selected:
            self.folder_path.set(folder_selected)
            # 如果启用了自动刷新预览，则扫描文件
            if self.auto_refresh_preview.get():
                self.scan_files()

    def browse_backup_folder(self):
        """浏览并选择备份文件夹"""
        folder_selected = filedialog.askdirectory()
        if folder_selected:
            self.backup_path.set(folder_selected)

    def toggle_regex_mode(self):
        """切换正则表达式模式"""
        # 如果启用正则模式，更新界面提示
        if self.regex_mode.get():
            messagebox.showinfo("正则表达式模式", "已启用正则表达式模式。\n\n"
                                "在源扩展名中可以使用正则表达式匹配文件名，\n"
                                "在目标扩展名中可以使用\\1, \\2等引用捕获的组。")
        
        # 如果启用了自动刷新预览，重新扫描
        if self.auto_refresh_preview.get():
            self.scan_files()

    def scan_files(self):
        """扫描文件夹中的文件"""
        folder_path = self.folder_path.get()
        from_ext = self.from_ext.get()
        
        # 基本验证
        if not folder_path:
            messagebox.showerror("错误", "请选择文件夹")
            return
        
        if not from_ext and not self.regex_mode.get():
            messagebox.showerror("错误", "请输入源扩展名")
            return
        
        # 确保扩展名格式正确（非正则模式下）
        if not self.regex_mode.get() and not from_ext.startswith("."):
            from_ext = "." + from_ext
            self.from_ext.set(from_ext)
        
        # 禁用扫描按钮
        self.scan_button.config(state=tk.DISABLED)
        self.status_var.set("正在扫描文件...")
        self.is_scanning = True
        
        # 在新线程中执行扫描，以避免界面冻结
        thread = threading.Thread(target=self._scan_files_thread, args=(folder_path, from_ext))
        thread.daemon = True
        thread.start()

    def _scan_files_thread(self, folder_path, from_ext):
        """在后台线程中扫描文件"""
        try:
            # 获取所有匹配的文件
            file_list = []
            
            if self.recursive.get():
                for root, _, files in os.walk(folder_path):
                    for file in files:
                        file_path = os.path.join(root, file)
                        if self._match_file(file, file_path, from_ext):
                            file_list.append(file_path)
            else:
                for file in os.listdir(folder_path):
                    file_path = os.path.join(folder_path, file)
                    if os.path.isfile(file_path) and self._match_file(file, file_path, from_ext):
                        file_list.append(file_path)
            
            # 更新统计
            total = len(file_list)
            self.total_files.set(f"总文件数: {total}")
            
            # 更新预览
            self.preview_files = file_list
            self.root.after(0, self._update_preview)
            
            if total == 0:
                self.status_var.set(f"未找到匹配的文件")
                self.execute_button.config(state=tk.DISABLED)
            else:
                self.status_var.set(f"扫描完成，找到 {total} 个文件")
                self.execute_button.config(state=tk.NORMAL)
        
        except Exception as e:
            self.status_var.set(f"扫描失败: {str(e)}")
            messagebox.showerror("扫描错误", f"扫描文件时出错:\n{str(e)}")
        
        finally:
            self.scan_button.config(state=tk.NORMAL)
            self.is_scanning = False

    def _match_file(self, filename, filepath, pattern):
        """检查文件是否匹配条件"""
        if self.regex_mode.get():
            try:
                return bool(re.search(pattern, filename))
            except re.error:
                # 正则表达式错误，返回False
                return False
        else:
            return filename.endswith(pattern)

    def _update_preview(self):
        """更新预览列表"""
        # 清空预览框
        for widget in self.preview_list_frame.winfo_children():
            widget.destroy()
        
        if not self.preview_files:
            self.preview_placeholder = tk.Label(
                self.preview_list_frame, 
                text='没有找到匹配的文件', 
                bg=self.bg_color,
                padx=10,
                pady=20
            )
            self.preview_placeholder.pack()
            return
        
        # 获取要显示的文件数量
        display_limit = min(len(self.preview_files), self.preview_limit.get())
        
        # 添加文件预览
        for i in range(display_limit):
            file_path = self.preview_files[i]
            new_file_path = self._get_new_file_path(file_path)
            
            # 创建行容器
            row_frame = tk.Frame(self.preview_list_frame, bg="#f5f5f5" if i % 2 == 0 else "#ebebeb")
            row_frame.pack(fill=tk.X, pady=1)
            
            # 提取相对路径，如果可能
            base_dir = self.folder_path.get()
            try:
                rel_path = os.path.relpath(file_path, base_dir)
                rel_new_path = os.path.relpath(new_file_path, base_dir)
            except ValueError:
                # 如果在不同驱动器上，使用完整路径
                rel_path = file_path
                rel_new_path = new_file_path
            
            # 添加原文件名和新文件名
            tk.Label(row_frame, text=rel_path, width=40, anchor="w", padx=5, bg=row_frame["bg"]).pack(side=tk.LEFT)
            tk.Label(row_frame, text=rel_new_path, width=40, anchor="w", padx=5, bg=row_frame["bg"]).pack(side=tk.LEFT)
        
        # 如果有更多文件，显示提示
        if len(self.preview_files) > display_limit:
            more_label = tk.Label(
                self.preview_list_frame, 
                text=f"...还有 {len(self.preview_files) - display_limit} 个文件未显示", 
                bg=self.bg_color,
                fg="#666666",
                padx=10,
                pady=5
            )
            more_label.pack(fill=tk.X)

    def _get_new_file_path(self, file_path):
        """根据当前设置计算新文件路径"""
        if self.regex_mode.get():
            # 正则模式下的替换
            filename = os.path.basename(file_path)
            directory = os.path.dirname(file_path)
            
            try:
                new_filename = re.sub(self.from_ext.get(), self.to_ext.get(), filename)
                return os.path.join(directory, new_filename)
            except re.error:
                # 正则表达式错误，返回原路径
                return file_path
        else:
            # 普通模式下的替换
            from_ext = self.from_ext.get()
            to_ext = self.to_ext.get()
            
            # 确保扩展名格式正确
            if not from_ext.startswith("."):
                from_ext = "." + from_ext
            
            if not to_ext.startswith("."):
                to_ext = "." + to_ext
                
            return file_path[:-len(from_ext)] + to_ext

    def start_conversion(self):
        """开始转换文件扩展名"""
        if not self.preview_files:
            messagebox.showerror("错误", "没有找到要处理的文件")
            return
        
        # 确认对话框
        if self.confirm_operations.get():
            confirm = messagebox.askokcancel(
                "确认操作", 
                f"即将修改 {len(self.preview_files)} 个文件的扩展名。\n\n" +
                "此操作将改变这些文件的格式。\n" +
                ("已启用安全模式，将先备份文件。\n" if self.safe_mode.get() else "") +
                "\n是否继续?"
            )
            if not confirm:
                return
        
        # 禁用按钮
        self.execute_button.config(state=tk.DISABLED)
        self.scan_button.config(state=tk.DISABLED)
        
        # 在新线程中执行转换
        thread = threading.Thread(target=self._convert_files_thread)
        thread.daemon = True
        thread.start()

    def _convert_files_thread(self):
        """在后台线程中执行文件转换"""
        try:
            files_to_process = self.preview_files.copy()
            total = len(files_to_process)
            converted = 0
            failed = 0
            operation_log = []
            
            # 创建备份记录，用于撤销
            operation_record = {
                "timestamp": datetime.datetime.now().isoformat(),
                "files": [],
                "folder": self.folder_path.get(),
                "from_ext": self.from_ext.get(),
                "to_ext": self.to_ext.get(),
                "regex_mode": self.regex_mode.get(),
                "backup_path": None
            }
            
            # 创建备份（如果安全模式开启）
            if self.safe_mode.get() and self.auto_backup.get():
                backup_folder = self._create_backup(files_to_process)
                operation_record["backup_path"] = backup_folder
            
            for i, file_path in enumerate(files_to_process):
                try:
                    # 计算新文件名
                    new_file_path = self._get_new_file_path(file_path)
                    
                    # 记录操作
                    file_record = {
                        "original": file_path,
                        "new": new_file_path
                    }
                    operation_record["files"].append(file_record)
                    
                    # 执行重命名
                    os.rename(file_path, new_file_path)
                    
                    # 添加到日志
                    log_entry = f"[成功] {file_path} -> {new_file_path}"
                    operation_log.append(log_entry)
                    
                    converted += 1
                    self.converted_files.set(f"已转换: {converted}")
                
                except Exception as e:
                    error_msg = str(e)
                    log_entry = f"[失败] {file_path}: {error_msg}"
                    operation_log.append(log_entry)
                    
                    failed += 1
                    self.failed_files.set(f"失败数: {failed}")
                
                # 更新进度条
                progress = (i + 1) / total * 100
                self.progress_var.set(progress)
                self.status_var.set(f"正在转换: {i+1}/{total}")
                
                # 更新界面
                self.root.update_idletasks()
            
            # 操作完成，保存记录
            if converted > 0:
                self.operation_history.append(operation_record)
                self._save_operation_log(operation_log)
                
                # 启用撤销按钮
                self.undo_button.config(state=tk.NORMAL)
            
            # 完成消息
            self.status_var.set(f"完成! 成功转换 {converted} 个文件, 失败 {failed} 个文件")
            messagebox.showinfo("完成", f"文件扩展名修改完成\n成功: {converted}\n失败: {failed}")
            
            # 重新扫描文件夹
            if converted > 0:
                self.scan_files()
            else:
                self.scan_button.config(state=tk.NORMAL)
                self.execute_button.config(state=tk.NORMAL)
        
        except Exception as e:
            self.status_var.set(f"转换失败: {str(e)}")
            messagebox.showerror("转换错误", f"转换文件时出错:\n{str(e)}")
            self.scan_button.config(state=tk.NORMAL)
            self.execute_button.config(state=tk.NORMAL)

    def _create_backup(self, files):
        """创建文件备份"""
        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        backup_dir = os.path.join(self.backup_path.get(), f"backup_{timestamp}")
        
        # 确保备份目录存在
        os.makedirs(backup_dir, exist_ok=True)
        
        # 复制文件
        for file_path in files:
            try:
                # 保持目录结构
                rel_path = os.path.relpath(file_path, self.folder_path.get())
                backup_file_path = os.path.join(backup_dir, rel_path)
                
                # 确保目标目录存在
                os.makedirs(os.path.dirname(backup_file_path), exist_ok=True)
                
                # 复制文件
                shutil.copy2(file_path, backup_file_path)
            except Exception as e:
                self.log_append(f"备份失败: {file_path} - {str(e)}")
        
        # 清理旧备份
        self._cleanup_old_backups()
        
        return backup_dir

    def _cleanup_old_backups(self):
        """清理过期的备份文件"""
        if not os.path.exists(self.backup_path.get()):
            return
            
        now = datetime.datetime.now()
        max_age = datetime.timedelta(days=self.backup_days.get())
        
        for item in os.listdir(self.backup_path.get()):
            item_path = os.path.join(self.backup_path.get(), item)
            
            # 只处理备份目录
            if os.path.isdir(item_path) and item.startswith("backup_"):
                try:
                    # 从目录名提取时间戳
                    timestamp = item.replace("backup_", "")
                    date_obj = datetime.datetime.strptime(timestamp, "%Y%m%d_%H%M%S")
                    
                    # 检查是否过期
                    if now - date_obj > max_age:
                        shutil.rmtree(item_path)
                except (ValueError, OSError):
                    # 如果解析失败或删除失败，跳过
                    continue

    def undo_last_operation(self):
        """撤销上次重命名操作"""
        if not self.operation_history:
            messagebox.showinfo("提示", "没有可撤销的操作")
            return
        
        # 确认
        if self.confirm_operations.get():
            confirm = messagebox.askokcancel("确认撤销", "确定要撤销上次操作吗？")
            if not confirm:
                return
        
        # 获取最后一次操作记录
        operation = self.operation_history.pop()
        
        # 禁用按钮
        self.undo_button.config(state=tk.DISABLED)
        self.execute_button.config(state=tk.DISABLED)
        self.scan_button.config(state=tk.DISABLED)
        
        # 开始撤销
        self.status_var.set("正在撤销上次操作...")
        
        # 在新线程中执行撤销
        thread = threading.Thread(target=self._undo_operation_thread, args=(operation,))
        thread.daemon = True
        thread.start()

    def _undo_operation_thread(self, operation):
        """在后台线程中执行撤销操作"""
        restored = 0
        failed = 0
        operation_log = []
        
        try:
            # 从备份恢复
            if operation["backup_path"] and os.path.exists(operation["backup_path"]):
                # 从备份目录恢复
                for file_record in operation["files"]:
                    try:
                        # 如果新文件存在，删除它
                        if os.path.exists(file_record["new"]):
                            os.remove(file_record["new"])
                        
                        # 计算备份中的文件路径
                        rel_path = os.path.relpath(file_record["original"], operation["folder"])
                        backup_file = os.path.join(operation["backup_path"], rel_path)
                        
                        # 复制回原位置
                        os.makedirs(os.path.dirname(file_record["original"]), exist_ok=True)
                        shutil.copy2(backup_file, file_record["original"])
                        
                        restored += 1
                        log_entry = f"[恢复] {file_record['new']} -> {file_record['original']}"
                        operation_log.append(log_entry)
                    
                    except Exception as e:
                        failed += 1
                        log_entry = f"[恢复失败] {file_record['new']}: {str(e)}"
                        operation_log.append(log_entry)
            else:
                # 直接重命名文件
                for file_record in operation["files"]:
                    try:
                        # 如果新文件存在并且原文件不存在，则重命名回去
                        if os.path.exists(file_record["new"]) and not os.path.exists(file_record["original"]):
                            os.rename(file_record["new"], file_record["original"])
                            
                            restored += 1
                            log_entry = f"[恢复] {file_record['new']} -> {file_record['original']}"
                            operation_log.append(log_entry)
                        else:
                            failed += 1
                            log_entry = f"[恢复失败] {file_record['new']}: 文件不存在或目标已存在"
                            operation_log.append(log_entry)
                    
                    except Exception as e:
                        failed += 1
                        log_entry = f"[恢复失败] {file_record['new']}: {str(e)}"
                        operation_log.append(log_entry)
            
            # 保存撤销日志
            self._save_operation_log(operation_log, is_undo=True)
            
            # 更新状态
            self.status_var.set(f"撤销完成! 成功恢复 {restored} 个文件, 失败 {failed} 个文件")
            messagebox.showinfo("撤销完成", f"操作已撤销\n成功恢复: {restored}\n失败: {failed}")
            
            # 启用撤销按钮（如果还有操作历史）
            if self.operation_history:
                self.undo_button.config(state=tk.NORMAL)
            
            # 重新扫描
            if restored > 0:
                self.scan_files()
            else:
                self.scan_button.config(state=tk.NORMAL)
                self.execute_button.config(state=tk.NORMAL)
                
        except Exception as e:
            self.status_var.set(f"撤销失败: {str(e)}")
            messagebox.showerror("撤销错误", f"撤销操作时出错:\n{str(e)}")
            
            # 恢复操作历史
            self.operation_history.append(operation)
            
            # 重新启用按钮
            if self.operation_history:
                self.undo_button.config(state=tk.NORMAL)
            self.scan_button.config(state=tk.NORMAL)
            self.execute_button.config(state=tk.NORMAL)

    def _save_operation_log(self, log_entries, is_undo=False):
        """保存操作日志"""
        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        operation_type = "撤销操作" if is_undo else "文件扩展名修改"
        
        # 读取现有日志
        log_data = []
        if os.path.exists(self.log_file):
            try:
                with open(self.log_file, 'r', encoding='utf-8') as f:
                    log_data = json.load(f)
            except (json.JSONDecodeError, UnicodeDecodeError):
                # 如果日志文件损坏，创建新的
                log_data = []
        
        # 添加新的日志条目
        log_entry = {
            "timestamp": timestamp,
            "type": operation_type,
            "folder": self.folder_path.get(),
            "from_ext": self.from_ext.get(),
            "to_ext": self.to_ext.get(),
            "entries": log_entries
        }
        
        log_data.append(log_entry)
        
        # 保存日志
        try:
            with open(self.log_file, 'w', encoding='utf-8') as f:
                json.dump(log_data, f, indent=2, ensure_ascii=False)
        except Exception as e:
            print(f"保存日志失败: {str(e)}")
        
        # 更新日志显示
        self.load_log()

    def load_log(self):
        """加载并显示日志"""
        self.log_text.config(state=tk.NORMAL)
        self.log_text.delete(1.0, tk.END)
        
        if os.path.exists(self.log_file):
            try:
                with open(self.log_file, 'r', encoding='utf-8') as f:
                    log_data = json.load(f)
                
                for entry in reversed(log_data):  # 最新的日志显示在最上面
                    timestamp = entry["timestamp"]
                    operation_type = entry["type"]
                    folder = entry.get("folder", "未知文件夹")
                    from_ext = entry.get("from_ext", "")
                    to_ext = entry.get("to_ext", "")
                    
                    self.log_text.insert(tk.END, f"=== {timestamp} - {operation_type} ===\n")
                    self.log_text.insert(tk.END, f"文件夹: {folder}\n")
                    if operation_type != "撤销操作":
                        self.log_text.insert(tk.END, f"从 {from_ext} 到 {to_ext}\n")
                    self.log_text.insert(tk.END, "详细记录:\n")
                    
                    for log_line in entry.get("entries", []):
                        self.log_text.insert(tk.END, f"  {log_line}\n")
                    
                    self.log_text.insert(tk.END, "\n")
            
            except Exception as e:
                self.log_text.insert(tk.END, f"加载日志失败: {str(e)}\n")
        else:
            self.log_text.insert(tk.END, "没有找到日志文件。\n")
        
        self.log_text.config(state=tk.DISABLED)

    def clear_log(self):
        """清空日志"""
        if os.path.exists(self.log_file):
            confirm = messagebox.askokcancel("确认", "确定要清空所有日志吗？此操作不可撤销。")
            if not confirm:
                return
                
            try:
                os.remove(self.log_file)
                self.log_text.config(state=tk.NORMAL)
                self.log_text.delete(1.0, tk.END)
                self.log_text.insert(tk.END, "日志已清空。\n")
                self.log_text.config(state=tk.DISABLED)
            except Exception as e:
                messagebox.showerror("错误", f"清空日志失败: {str(e)}")

    def log_append(self, message):
        """向日志添加消息"""
        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        # 添加到UI日志
        self.log_text.config(state=tk.NORMAL)
        self.log_text.insert(tk.END, f"[{timestamp}] {message}\n")
        self.log_text.see(tk.END)
        self.log_text.config(state=tk.DISABLED)

    def save_settings(self):
        """保存用户设置"""
        settings = {
            "auto_backup": self.auto_backup.get(),
            "backup_days": self.backup_days.get(),
            "backup_path": self.backup_path.get(),
            "confirm_operations": self.confirm_operations.get(),
            "auto_refresh_preview": self.auto_refresh_preview.get(),
            "preview_limit": self.preview_limit.get()
        }
        
        try:
            os.makedirs(os.path.dirname("settings.json"), exist_ok=True)
            with open("settings.json", 'w', encoding='utf-8') as f:
                json.dump(settings, f, indent=2, ensure_ascii=False)
            messagebox.showinfo("成功", "设置已保存")
        except Exception as e:
            messagebox.showerror("错误", f"保存设置失败: {str(e)}")

    def load_settings(self):
        """加载用户设置"""
        if os.path.exists("settings.json"):
            try:
                with open("settings.json", 'r', encoding='utf-8') as f:
                    settings = json.load(f)
                
                if "auto_backup" in settings:
                    self.auto_backup.set(settings["auto_backup"])
                
                if "backup_days" in settings:
                    self.backup_days.set(settings["backup_days"])
                
                if "backup_path" in settings:
                    self.backup_path.set(settings["backup_path"])
                
                if "confirm_operations" in settings:
                    self.confirm_operations.set(settings["confirm_operations"])
                
                if "auto_refresh_preview" in settings:
                    self.auto_refresh_preview.set(settings["auto_refresh_preview"])
                
                if "preview_limit" in settings:
                    self.preview_limit.set(settings["preview_limit"])
            
            except Exception as e:
                print(f"加载设置失败: {str(e)}")
        
        # 确保备份目录存在
        os.makedirs(self.backup_path.get(), exist_ok=True)

def main():
    root = tk.Tk()
    app = FileExtensionChanger(root)
    # 加载日志
    app.load_log()
    root.mainloop()

if __name__ == "__main__":
    main()

许可协议

该工具采用MIT许可协议，欢迎自由使用和修改。

excel中将"C"列中中英文括号内的任意字符一键清除

Tue, 23 Jul 2024 15:59:39 +0800

Sub RemoveBrackets()
    Dim ws As Worksheet
    Dim rng As Range
    Dim cell As Range
    Dim cellValue As String
    Dim i As Integer
    
    ' 指定工作表
    Set ws = ThisWorkbook.Sheets("Sheet1") ' 修改 "Sheet1" 为你工作表的名字
    
    ' 指定范围 (C 列)
    Set rng = ws.Range("C1:C" & ws.Cells(ws.Rows.Count, "C").End(xlUp).Row)
    
    ' 遍历范围内的每个单元格
    For Each cell In rng
        cellValue = cell.Value
        
        ' 删除中英文括号及其内容
        Do While InStr(cellValue, "(") > 0 Or InStr(cellValue, "（") > 0
            i = InStr(cellValue, "(")
            If i > 0 Then
                cellValue = Left(cellValue, i - 1) & Mid(cellValue, InStr(i, cellValue, ")") + 1)
            End If
            
            i = InStr(cellValue, "（")
            If i > 0 Then
                cellValue = Left(cellValue, i - 1) & Mid(cellValue, InStr(i, cellValue, "）") + 1)
            End If
        Loop
        
        cell.Value = cellValue
    Next cell
End Sub

Alt+F11 插入新模块，保存以上代码后退出。
Alt+F8 选中模块执行

在Excel里面，如何把单元格里面的Unix格式的时间转化为年-月-日-分-秒？

Thu, 11 Jul 2024 10:22:32 +0800

在Excel中，可以使用公式将Unix时间戳（以秒为单位）转换为标准的日期和时间格式。Unix时间戳表示自1970年1月1日00:00:00 UTC以来的秒数。

假设你的Unix时间戳在单元格A1中，你可以使用以下步骤将其转换为“年-月-日时:分:秒”格式：

1. 将Unix时间戳转换为Excel日期时间格式:

Excel中的日期时间是一个序列号，其中1表示1900年1月1日，Unix时间戳需要进行一些转换。

在单元格B1中输入以下公式，将Unix时间戳转换为Excel日期时间格式：

=A1 / 86400 + DATE(1970, 1, 1)

这里，`86400`是一天中的秒数。

2. 将结果格式化为所需的日期时间格式:

选中单元格B1，按下快捷键 `Ctrl + 1` 打开“设置单元格格式”对话框。选择“自定义”选项，然后在“类型”框中输入：

yyyy-mm-dd hh:mm:ss

3. 完整步骤示例:

- 在A1单元格中输入一个Unix时间戳，例如：`1625097600`
- 在B1单元格中输入公式：

=A1 / 86400 + DATE(1970, 1, 1)

- 选中B1单元格，按 `Ctrl + 1`，选择“自定义”，输入 `yyyy-mm-dd hh:mm:ss`，然后点击“确定”。

完成上述步骤后，单元格B1中的Unix时间戳将被转换为“年-月-日时:分:秒”格式的日期和时间。例如，如果A1中的Unix时间戳为 `1625097600`，B1中的结果将显示为 `2021-07-01 00:00:00`。

DOTA2倾天之战第一幕耍蛇大师跟蜡烛代币触发流程

Fri, 26 Apr 2024 21:08:48 +0800

1.耍蛇大师：需要在一场普通/天梯比赛胜利之后才能触发，加速/OMG/人机等其他模式不行，触发之后会获得一枚蛇代币，好像赢了两把三把之后再去触发，会获得对应胜场数量的代币，我拿过一次两个代币，一天只能触发一次。

2.蜡烛代币：现在点击蜡烛代币会提示商店老板不在，推测他是作为下一幕开放时才会触发，让玩家通过蜡烛代币进入下一层空间，所以目前安心等待即可。

网站渐变色呼吸灯CSS怎么写？可以参考本站LOGO背景试试！

Sat, 13 Jan 2024 10:54:34 +0800

网站这个位置的呼吸灯渐变效果是不是很好看？分享一下此处应用的CSS代码，来源忘了是从哪个博客上面仿写下来的了😂

.top_logo {
            background: linear-gradient(90deg, #000000, #2F4F4F, #36648B, #009ACD,#7D26CD,#CD661D,#8B5A00,#5E5E5E);
    background-size: 1000% 100%;
    animation: mymove 20s ease infinite;
    -webkit-animation: mymove 20s ease infinite;
    -moz-animation: mymove 20s ease infinite;
      }
@keyframes mymove {
    0% {
        background-position: 0% 0%;
    }

    10% {
        background-position: 0% 30%;
    }

    20% {
        background-position: 30% 50%;
    }

    40% {
        background-position: 50% 100%;
    }

    50% {
        background-position: 100% 100%;
    }

    60% {
        background-position: 100% 50%;
    }

    80% {
        background-position: 50% 30%;
    }

    90% {
        background-position: 30% 0%;
    }

    100% {
        background-position: 0% 0%;
    }
}

实际应用时，把".top_logo"根据自己网站的情况修改一下即可，非常简单。

冬日狂想曲中文汉化补丁地址

Tue, 09 Jan 2024 00:22:17 +0800

中文无码补丁包 v1.02（以下链接皆为同一个内容，玩家挑选下载速度最快的下载即可）2024.0107更新

*此补丁为Steam与GOG平台通用版

百度网盘下载链接提取码：v102(字母是小写）

不懂如何安装补丁的请看这里——补丁安装说明

冬日狂想曲测评及游戏攻略

Sat, 06 Jan 2024 00:08:12 +0800

《冬日狂想曲》可以说是2024年的开局王炸，像素级别SLG小黄油天花板了，游戏拥有丰富的内容和事件以及可玩性，满足玩家10h左右的充足的游戏内容体验，而小孩开大车的NTR题材也相当吸引人。即便是我几个并不怎么玩小黄油的群也在最近几乎天天都在讨论关于这款游戏的相关内容，可见其影响力之大。

《冬日狂想曲》是《夏日狂想曲》和《夏日狂想曲+》的续作，游戏也继承了前作的结局部分的故事以及各个人物之间的关系，因此本作强烈建议玩家游玩过前作了解前作中发生的故事和内容之后再来游玩本作，体验会更佳。

本作与前作相比之优点

一.游戏体验的优化

1.更大、更精致的地图：在保留前作地图与场景的基础上，新增商业街宿舍、街道、堤坝等多个新地图与新场景，且细节更加精致！

2.更便捷的UI与操作：鼠标右键进菜单，点击想攻略的女角色图标即可瞬移，也可快速开启/关闭某些功能；剧情推进条件在屏幕左上角。

3.画质全面提升：精致的马赛克（褒义）！

4.照顾老玩家的剧情展开：剧情紧接夏日+，不是形同陌路实在是太好了！

二.常规玩法的创新

1.即时时间系统：时间细化到分钟，本作哪怕是小地图间的移动也会消耗时间。本人认为这样不仅有利于玩家更精细的调控时间，还能提升代入感！！

2.等级：弟弟君新增等级系统，通过各种活动获得经验，每次升级可在4个奖励中选择其一。锦上添花的小改进

3.更丰富的交谈系统：对话内容不再一笔带过，分为普通、趣味、涩情三种交谈，具体对话内容随攻略进度解锁。起到丰富游戏玩法、丰满人设、调动玩家情绪的作用，是本人认为最棒的新机制！！

4.更丰富的收集要素：更丰富的内衣与绘本收集，新增数百张照片、12个成就等全新收集要素！

5.成就：不仅是收集要素，解锁后还能获得超强增益，后期涩涩必备！！（详情见攻略）

6.更多的小游戏：保留前作抓虫子、田径外的小游戏，总共10款任你嗨！

7.威力加强版拍卡：玩家攻防与等级挂钩，也可使特殊道具提升攻防。每张拍卡新增专属被动，全地图NPC均可进行对战，可玩性大大提升！灯里/光线的牌面！！

三.GHS玩法的改进

1.全新夜寝玩法（仅限姑姑家三人）：有脱衣、乳交、口交、本垒等玩法，太激烈女主会醒过来，如果让女主满意的话？可与常规夜寝黄油一拼！

2.更强的撒娇技能：撒娇时的选项翻一倍，搭配成就10效果更佳！！

3.换装内衣：10个女主每人5套可替换内衣（3普通，2情趣），前期内衣随机穿着，后期搭配成就10和撒娇技能涩涩加倍！

4.更涩气、更丰富的H玩法（成就相关）：
（1）许多H小动画（成就1）
（2）夜袭时女主们不会醒来！（成就3）
（3）可拍摄女主们的涩情照片（成就5）
（4）随时改变女主们的H状态（淫乱、侍奉、兴奋）以触发特殊H时间与H对话。（成就8）
（5）自由更换女主的内衣，配合撒娇技能涩涩加倍！（成就10）

5.EX事件和内衣扭蛋机：新增5个女主两两配对的3P事件，很社保；内衣扭蛋机给每位女主新增2件情趣内衣（可换装，10×2），撒娇动力加倍！！

9.5/10 愉快又淫乱的剧情

一.剧情简述

本作剧情紧接夏日+（8位女主攻略完成+姑姑家4P结局），寒假期间，男主（以下称为“弟弟”）在姑姑的邀请下再次来到这个小镇（姑姑一定很寂寞难耐），又可以与之前缔结羁绊的女性们见面，这18天一定会充实又令人回味无穷！

二.剧情简评

与前作一样，压根没有主线！请把自己当成一个拥有无限可能的小孩，在周围人的友善、爱与性欲（？）中茁壮成长，并度过那个充实、愉快与淫荡（？）的假期吧！
11个结局，一个姑姑家的群P结局和每位女主的单人结局。轻松又享受的后宫剧情，恨不得给满分！

致某些贵物：某些逆天贵物居然在后宫类黄油中代入苦主姑父的视角，拜托这里是NTL分区，不是NTR！还有人指责男主双标（只自己开后宫），这么说的一定没仔细看线的剧情。钻牛角尖的逆天玩意，滚！！

9.5/10 极其优秀的像素GHS

一.GHS简述

1.CG质量优秀，共67个H事件，单个H事件长度适中，还有丰富的日常H，实用性MAX！！

2.日系像素画风，本作像素H更加精致，果然“涩涩的尽头是像素”！

3.文本质量十分优秀！对话描述大体55分，描述详尽，女主的淫语十分涩气。对话类文本镶嵌在H图中，区别于在下方文本框的描述类文本，既新颖，又利于阅读！

4.H事件是差分，日常H是高质量动态。

5.女角色部分语句有CV，有娇喘和水声。

6.XP范畴
（1）主要XP有正太、年上、中出、NTL、乱伦、姐妹、人妻、精液浴、群P、阿黑颜、情趣内衣等
（2）次要XP有情趣道具、双穴开发、cos、哺乳手交、足交、肛交、乳交等

二.GHS缺点

1.三个H指数无用：夏日+的H指数到达100、200会触发H事件（但冬日只是本体，进行比较有些不公平）。

GHS总结：精致的像素+丰富的日常H+繁多的H事件+CV+高质量动态=无敌社保（不接受反驳）！！

9.5/10 极其优秀的玩法

一.高质量像素GHS玩法

1.较完善的恋爱养成系统：
（1）每个女主都有着完整的攻略事件（新增女主两两配对的“EX事件”）
（2）可以消耗时间聊天或赠送礼物

2.随时随地的H（前提有足够的好感度，且需注意姑父的警戒值）：不仅有多种体位，还有各种高质量像素动图！

3.撒娇系统：消耗时间进行各种涩涩相关的撒娇，尽情的扮演一个撒娇鬼吧！

二.有难度却十分有趣的SLG玩法

1.概述：本作是有时限的时间管理类玩法，但可多周目继承，所以玩家可以轻松的享受游戏。

2.时间：一天分成几个时间段，NPC和玩家可进行的行动都会有所不同。

3.体力（玩家左下角的黄条）：玩家进行日常行动或H都会消耗，上限提升主要靠登山。

4.性欲（玩家左下角的白条）：会随着撒娇或时间而增长，如果溢出会造成遗精（跳过一个时间段且消耗部分体力），所以要适当泄欲哈。

5.姑父相关：姑父如果警戒值达到100会导致游戏结束，但有降低或避免提升的方法。和姑父聊天到100的话…

玩法总结：GHS在像素类游戏里是顶尖，SLG玩法本身也很优秀，再加上评测开篇的各种改进和扩充，使得本作既好玩又好冲！！瑟瑟的尽头是像素！！！

9.5/10 角色鲜明且温柔的人设

本作人设兼具正经叙事和GHS。本作就是提倡玩家代入一个拥有无限可能的小孩，代入感极佳的男主+职业、性格、立绘鲜明的10位女主，还有什么再需要奢求的呢？

1.男主（弟弟君）：天性善良，乐观开朗，性欲旺盛，拥有无尽可能！（就像我们小时候那样）能体验一场不寻常的童年，代入感拉满！

2.女主们：除了前作的8位女主，还新增2个全新角色。前作中的女主也可能发生某些改变而为玩家带来全新的体验，本作女主们的互动也更加紧密哟！（评测字数有上限，不得已才进行概述）

9.5/10 总结

作为小马拉大车NTL(纯爱)后宫像素SLG黄油神作的“夏日狂想曲”的续作来了！！剧情紧接前作的后宫结局;机制上拥有巨大创新，既好用又好冲；人设兼具正经叙事与GHS。
CG质量十分优秀，共67个H事件，单个H事件长度适中，还有丰富的日常H；顶级像素画风；文本质量十分优秀；H事件是差分，日常H是动态；部分语句有CV，有水声；XP依然是各位喜欢的小马拉大车、群P和内射！神作不要犹豫，买买买！

攻略（以B站大佬U9Sxian的攻略为基础，本人二次归纳）

一.游玩心得（非一周目全收集）

1.初期
（1）第一天晚上优先学习“缩地成寸（地图移动消耗时间减半）”。
（2）速开灯里线（公园秘密基地），满世界打牌赚经验和回忆。
（3）等级提升优先选2k元，攒够5k后选提升体力上限，5k捐给神社以解锁“神之宠爱”技能（永久大吉增幅）。
（4）体力达到300可尝试登山，连续几次即可实现体力、技能自由！！
（5）升级选体力上限可回满体力。

2.中后期：
（1）卡关（找不到道具或不能触发场景）可以去神社求签获得提示。
（2）去堤坝解锁渔夫卖鱼赚钱（1月1日完成成就7后日入斗金）。
（3）有钱就让山菜侠帮你采食材，傍晚去商业街公寓202购买（不过前期频繁登山大概率不缺）。
（4）抽空去餐馆打工赚菜谱。

二.大地图与常规NPC

1.莉音房间：完成笔记本的推文可获得经验，也是攻略雫与加奈的必要道具。
2.商店街公寓：101水木家（占卜师），102深夜商店，202野菜侠(卖凉花线料理所需的高级食材，可指定购买，但很贵)，203火神家（体育老师）
3.棉太的内裤：灯里线攻略完毕后，在白天的山洞会刷新棉太君，打牌胜利可获得其内裤。
4.姑父的内裤：打牌胜过姑父可获得其内裤。
5.山道：开启凉花线后解锁山菜侠，给他钱或自己登山均可采集食材，但都随机！！
6.神社：
（1）每捐款1k会触发减少姑父警戒和解锁成就的提示。
（2）捐赠1w获得一周目仅限一次的“时间回溯”技能（在学习技能处使用，回到1月1日，越晚使用收益越大）

三.部分隐藏技能解锁条件

1.粉4技能：厕所内突袭女主15次后解锁（需先学会开锁技能）
2.黄4技能：工口本解锁（深夜公寓秘密商店购得）
3.紫4技能：解锁厕所突袭技能后（不确定）
4.拍卡技能：街道商铺二等奖
6.其余：商业街公寓102深夜商人处可购买5个。

四.照片全收集

1.地图照片：
（1）限定时间的照片！！神社庆典相关（正月3天）、街道1商铺门口贴的红色公告（下午4点后）
（2）书法绘图建议完成成就7后通过反复SL收集。
（3）其余照片的重点是地图全开（攻略全女主）和地毯搜查！！
2.女孩照片：无难度。
3.内裤照片：每个女主5张，解锁成就5和10后轻松收集。
4.路人图片：需要注意的是渔夫（堤坝下午）、棉太君（灯里线完结后白天的山道山洞）和狩猎者（错过就去深夜商业街公寓的秘密商店购买）
5.淫荡照片：在正常位（紫1）、种付位（粉2）、肛交（粉3）这三种姿势下进行H，结束后各拍一张。

五.成就（解锁条件与效果）

1.撒娇老手
解锁条件：社保10次
效果：开启日常H的特殊动画

2.精子制造机
解锁条件：弄脏房间10个，需要在一个房间里连续社保9次！
效果：一次就能射满屋

3.魅魔
解锁条件：睡眠期间H50次（仅限姑姑家三人，安眠药可以无限喂，手/唇与肉棒能同时进行）
效果：睡眠H就算觉醒度100%对方也不会醒来

4.家政管家
解锁条件：清理房间20个（需点出“屋子打扫”技能，可以连续打扫）
效果：释放技能后全部地图的房间都被清理干净

5.偷怕狂
解锁条件：拍摄50张照片（重复拍摄无效，建议先点出“无限电池”和“镜头变红”这两个技能）
效果：开启盗摄模式（女主在好感度达到一定水平之后可偷拍内裤）

6.相机小子
解锁条件：用相机拍一次东西（开局拍照教程即可解锁）
效果：开启相册点击该技能图标即可进入相册界面

7.游戏王
解锁条件：完成10个小游戏。
效果：跳过所有小游戏直接获得奖励（拍卡秒杀，射击小游戏随机获得五个奖品等）。
（1）算术-结衣房间
（2）洗碗-自家厨房
（3）打工-街道2(每次消耗一个大时间段，建议在每个时间段最后半小时进行)
（4）钓鱼-堤坝/河道，在堤坝解锁收鱼换钱的npc渔夫
（5）拍卡-随意一个npc进行对战（灯里线）
（6）引体向上-体育老师家
（7）料理-河道篝火处
（8-9）神社通道1-射击与套圈（31日晚-3日下午前）
（10）书法-自家和室（1月1日下午后）

8.催眠师
解锁条件：使10位女主均改变一次状态（只需和女主以某一姿势单次H时间足够长即可完成）
效果：点击图标即可随意改变女主们的状态

9.反转攻势
解锁条件：通关灯里线即可获得
效果：拍卡游戏中用于反击的技能

10.内裤收集家
解锁条件：获得10位女主的30条内裤（该女主完全攻略并在拍卡中击败对方即可获得此人的全部内裤）
效果：点击图标即可更换女主们的内衣

11.钝感王
解锁条件：社保30次（个人建议开局优先解锁该技能）
效果：姑父变得又聋又瞎，警戒度很难提升

12.后宫王
解锁条件：攻略所有女角色
效果：可以随时随地召唤3名女角色进行4P，H结束后还有特殊动画（与爱情宾馆结束动画类似）

六.攻略难点概论

1.常见卡关问题：请查看下文全女主难点汇总！

2.角色目前无法触发事件（比如上厕所）怎么办：使用技能“发呆”使时间快进到下一个整点，大概率能刷新角色行动。

3.特殊H收集指南：结衣、莉音、美雪三人在圣诞夜和1月1日都有特殊H，需多周目回收。

4.1月1日的H触发条件：结衣是完成60好感度事件（最简单），莉音是学会足交技能（深夜商业街公寓的秘密商店），美雪是触发遗精事件（最晚在30日让左下角白条溢出一次，转天找姑姑可触发口交清理事件）。

5.晨勃口交事件：与侍奉（献身）状态的结衣、莉音、美雪睡觉可触发晨勃口交H（不计入回忆室）。

6.多人结局唯一条件：街道商铺一等奖“温泉旅行券”（抽奖券靠购买食材获得）

七.全女主攻略难点汇总

1.结衣(妹妹)：
（1）算术小游戏在结衣房间桌子上触发。
（2）书法小游戏在和室（自家进门右手边），点击黑色提包触发。

2.莉音(姐姐)：
（1）建议优先点出相机相关技能（比如“镜头变红”），避免因胡乱拍照而拖慢进度。

3.美雪(姑姑）：
（1）在街道1购买咖喱饭的食材。
（2）正月时如果房间脏会有音效提示（需先学会“打扫”技能）。
（3）与姑父聊天至心情100，转天他就不在家。

4.灯里（拍卡萝莉）：
（1）玩家拍卡战斗力与玩家等级直接挂钩，因此升升级再推此线比较稳妥。
（2）3个狩猎者分别在上午-商业街公寓前、黄昏-神社、夜晚-堤坝。
（3）遇见灯里的母亲后灯里会暂时失踪，在黄昏时分的公园厕所前与灯里对话，然后在夜晚的山道触发剧情。

5.镜（体育老师）：
（1）一般在上午或者中午的商业街遇到镜（不在就去其他地方找找）
（2）想夜晚触发40好感度事件需先学会“开锁”技能。
（3）情趣玩具需要在河边钓鱼。
（4）眼罩只能靠翻找莉音衣柜（需学会寻宝技能）。

6.美月（占卜师）：
（1）27日主线剧情推进才能在街道2开启该线。
（2）第一次的客人在夜晚的神社通道2（坐在椅子上的人），点击触发对话把美月介绍给他（最晚在30日完成该部分，否则会因正月祭典卡关3天！）
（3）第二次的3个客人分别在上午的糖果店内、黄昏的山道、夜晚的公园厕所前。
（4）3个伪装工具分别是口罩（街道商铺的五等奖，抽奖券靠购买食材获得）、墨镜（莉音房间寻宝）和帽子（公园左上角树上，如果没有就转天再来）

7.凉花（露营）：
（1）做此线的同时一定要抽空去街道2餐馆打工赚取菜谱！！！
（2）好感度四阶段（61-80）时可以在傍晚后点击凉花触发温泉剧情。

8.雫（小卖部）：
（1）雫线很多事件都需先查看Doitter（莉音房间内笔记本），因此每次找雫前先去查看笔记本就对了！！
（2）好感度三阶段（61-80）时寻找的地方是公园厕所！去厕所小便一次后打开电脑，然后黄昏时分去公园厕所触发剧情！
（3）爱情宾馆在街道2饭馆旁边的小巷里。
（4）攻略完成后不要忘记再次检查Doitter，还有一张雫的CG！！！

9.加奈（新婚人妻）：
（1）触发条件：需先发现爱情宾馆（攻略雫线），并在“光”线中得到进入公寓的资格后才可触发。上午街道公寓门口与她对话，第二天上午在堤坝再与其对话才能进入此线。
（2）当发现加奈在堤坝唉声叹气后，当天深夜去爱情宾馆门口，拍下加奈老公出轨的照片，转天去加奈家门口按门铃即可。
（3）加奈老公节假日在家时不能推进剧情，所以请合理安排时间（二周目继承倒是不慌，就是糟心）。

10.光（拍卡人妻）：
（1）触发条件：灯里线四阶段boss战后，下午在街道1与光对话，进入街道公寓以开启此线。
（2）邀请光钓鱼前需学会钓鱼2级技能。

八.EX事件触发（最好在全攻略且全成就解锁后进行）

1.结衣×美月：
（1）4P召唤后第二天
（2）与结衣对话

2.莉音×雫：
（1）4P召唤后第二天
（2）下午或傍晚，客厅电话会响起（前提客厅无人）
（3）接电话

3.美雪×加奈：
（1）上午去堤坝与两人对话
（2）第三天上午，客厅电话会响
（3）接电话

4.灯里×光：
（1）在秘密基地与灯里对话

5.凉花×镜：
（1）到街上的公告栏（粗点心店后面、公寓前），调查一下粉红色告示（需要完成莉音的深夜试胆事件）
（2）第二天和凉花对话
（3）晚上和凉花对话

3.26真的很有诱惑力

Sat, 30 Dec 2023 16:49:45 +0800