AIGC漫剧团队协作流程：分工模式、项目管理与版本控制工业化方案

import json
from datetime import datetime
from enum import Enum

class Role(Enum):
    SCRIPTWRITER = "编剧"
    STORYBOARD = "分镜师"
    AI_ARTIST = "AI生图师"
    VIDEO_GEN = "视频生成师"
    VOICE_ACTOR = "配音师"
    EDITOR = "剪辑师"

class TaskStatus(Enum):
    PENDING = "待开始"
    IN_PROGRESS = "进行中"
    REVIEW = "待审核"
    DONE = "已完成"
    BLOCKED = "阻塞中"

class ManjuTask:
    def __init__(self, task_id, episode, title, role, priority=1):
        self.task_id = task_id
        self.episode = episode
        self.title = title
        self.role = role
        self.status = TaskStatus.PENDING
        self.priority = priority
        self.assigned_to = None
        self.version = "v0.1"
        self.created_at = datetime.now()
        self.updated_at = datetime.now()
        self.dependencies = []
        self.review_notes = []

    def assign(self, member_name):
        self.assigned_to = member_name
        self.status = TaskStatus.IN_PROGRESS
        self.updated_at = datetime.now()
        return f"[{self.episode}] {self.title} 已分配给 {member_name}"

    def update_status(self, status, note=""):
        self.status = status
        self.updated_at = datetime.now()
        if note:
            self.review_notes.append({
                "time": datetime.now().strftime("%Y-%m-%d %H:%M"),
                "note": note
            })

    def bump_version(self):
        parts = self.version.replace("v","").split(".")
        major, minor = int(parts[0]), int(parts[1])
        minor += 1
        self.version = f"v{major}.{minor}"
        return self.version

class ManjuProject:
    def __init__(self, project_name):
        self.name = project_name
        self.tasks = []
        self.members = {}
        self.episodes = {}
        self.naming_convention = "{project}_{ep}_{role}_{version}_{date}"

    def add_member(self, name, role):
        self.members[name] = role
        return f"成员 {name} ({role.value}) 已加入项目"

    def create_episode_pipeline(self, episode_num):
        """为单集创建标准化交付流程"""
        pipeline = [
            ("剧本撰写", Role.SCRIPTWRITER, []),
            ("角色卡定稿", Role.AI_ARTIST, ["剧本撰写"]),
            ("分镜生成", Role.STORYBOARD, ["剧本撰写"]),
            ("场景图生成", Role.AI_ARTIST, ["分镜生成"]),
            ("视频产出", Role.VIDEO_GEN, ["场景图生成"]),
            ("配音合成", Role.VOICE_ACTOR, ["剧本撰写"]),
            ("剪辑成片", Role.EDITOR, ["视频产出", "配音合成"]),
        ]
        ep_key = f"EP{episode_num:03d}"
        self.episodes[ep_key] = []
        for title, role, deps in pipeline:
            task = ManjuTask(
                task_id=f"{ep_key}_{role.name}",
                episode=ep_key,
                title=title,
                role=role
            )
            task.dependencies = deps
            self.tasks.append(task)
            self.episodes[ep_key].append(task)
        return f"已为 {ep_key} 创建 {len(pipeline)} 个标准任务"

    def get_progress(self, episode=None):
        target = self.episodes.get(episode, []) if episode else self.tasks
        if not target:
            return "暂无任务"
        done = sum(1 for t in target if t.status == TaskStatus.DONE)
        total = len(target)
        pct = round(done / total * 100, 1)
        return f"进度: {done}/{total} ({pct}%)"

    def generate_filename(self, episode, role, version=None):
        """标准化成片命名规范"""
        task = next((t for t in self.episodes.get(episode, [])
                     if t.role == role), None)
        ver = version or (task.version if task else "v1.0")
        date_str = datetime.now().strftime("%Y%m%d")
        filename = self.naming_convention.format(
            project=self.name,
            ep=episode,
            role=role.name,
            version=ver,
            date=date_str
        )
        return f"{filename}.mp4"

    def export_project_report(self):
        report = {
            "project": self.name,
            "total_tasks": len(self.tasks),
            "completed": sum(1 for t in self.tasks
                           if t.status == TaskStatus.DONE),
            "in_progress": sum(1 for t in self.tasks
                             if t.status == TaskStatus.IN_PROGRESS),
            "episodes": {}
        }
        for ep, tasks in self.episodes.items():
            report["episodes"][ep] = {
                "progress": self.get_progress(ep),
                "tasks": [{
                    "title": t.title,
                    "role": t.role.value,
                    "status": t.status.value,
                    "version": t.version,
                    "assigned": t.assigned_to or "未分配"
                } for t in tasks]
            }
        return json.dumps(report, ensure_ascii=False, indent=2)

# ===== 使用示例 =====
project = ManjuProject("重生之都市修仙")
project.add_member("张编剧", Role.SCRIPTWRITER)
project.add_member("李画师", Role.AI_ARTIST)
project.add_member("王视频", Role.VIDEO_GEN)

project.create_episode_pipeline(1)
project.create_episode_pipeline(2)

ep1_script = project.episodes["EP001"][0]
print(ep1_script.assign("张编剧"))
ep1_script.update_status(TaskStatus.DONE, "第一集剧本完成，含3个反转")
print(project.get_progress("EP001"))

ep1_art = project.episodes["EP001"][1]
ep1_art.assign("李画师")
ep1_art.bump_version()
print(project.generate_filename("EP001", Role.EDITOR))

print(project.export_project_report()[:500])

建议从核心双人模式起步。一人专注剧本和分镜（内容核心），一人负责制作全流程（技术执行）。这种模式沟通成本低、启动速度快，且在验证题材可行性后再扩展为专业团队更合理。关键是在双人阶段就建立基础的版本控制规范和素材管理习惯，为后续扩展打好基础。

三大常见坑：第一，版本混乱——多人同时修改同一文件导致覆盖，解决方案是强制版本号命名和云端锁定编辑。第二，角色不一致——不同生图师对同一角色的理解偏差，解决方案是建立角色卡"圣经"文档并锁定参考图。第三，沟通断层——编剧意图未传达给制作方导致返工，解决方案是分镜脚本必须包含详细的画面描述和情绪标注，每周至少一次全员同步会议。

远程协作的关键是工具链的统一和沟通的异步化。推荐配置：飞书（即时沟通+文档协同+视频会议）、Notion/Trello（任务看板+进度追踪）、Google Drive/坚果云（素材统一存储）、Git LFS或专用资产管理工具（角色卡和分镜的版本控制）。沟通方面，建立"每日站会"制度（15分钟语音同步），重要决策用飞书文档留痕，避免群聊信息淹没关键决策。

核心指标包括：月产能（集/月）、单集制作周期（小时）、返工率（%）、质量评分（满分10分）、按时交付率（%）。建议每周统计一次，用Notion的数据看板可视化追踪。重点关注返工率——如果返工率超过10%，说明流程中某个环节的质量把控出了问题，需要排查是剧本不清晰、角色卡不准确还是沟通不到位。