Widgets

Nubo: robô flutuante para Mac com passos, foco e balões

Crie com IA um robozinho que passeia sobre as janelas do Mac, pisca e acompanha seu progresso. Adicione quantos passos precisar, defina tempos e intervalos e receba avisos em balões. Nome, cores e tamanho personalizáveis, foco e widgets opcionais. Inclui o código do desenho e da lógica para recriar o Nubo.

macOS

Compartilhado por Feerlucas

Nubo coral flutuante, com três passos concluídos. — Arte de apresentação renderizada com os mesmos componentes SwiftUI do aplicativo. O personagem fica sobre as janelas normais do Mac.

Três poses do Nubo: caminhando, piscando e acenando. — Poses renderizadas a partir do desenho e da lógica usados nas animações do robô.

Projeto com seis passos, quatro concluídos, ao lado do Nubo. — Exemplo ilustrativo: adicione, remova e reordene quantos passos precisar. O robô evolui pela proporção concluída.

Balão do Nubo indicando dois minutos e quatorze segundos até o próximo passo. — Arte do componente real de balão, com contagem fictícia. Defina tempos e intervalos; a conclusão continua manual.

Os quatro estágios do Nubo, de peças separadas até completo. — Exemplo de evolução com três passos. A quantidade de passos é livre e o estágio acompanha o progresso total.

Nubo nas cores coral, menta e lavanda. — Arte de personalização: escolha nome, cor e tamanho nas configurações.

Painel real do Nubo com sete passos concluídos e a opção Rotina guiada. — Captura real do aplicativo em execução, usando dados de teste. Mostra o plano, o progresso, a rotina e o foco.

Controles reais do robô flutuante com tarefas, rotina e foco. — Captura real do popover do personagem. Edite os passos, controle o passeio e acompanhe a rotina sem abrir o painel grande.

Seu ponto de partida

Copie o texto e adapte na sua ferramenta de IA.

Prompt pronto para copiar

CRIE O NUBO — ROBÔ VIVO E FLUTUANTE PARA MAC
Crie um aplicativo macOS 14+ SwiftUI/AppKit chamado Nubo. O pequeno robô fica sobre as janelas, passeia pela tela, pisca e mexe cabeça, antena, braços e pés. Clicar abre passos e foco; arrastar move a janela. Não vincule a marca à plataforma do post. Preserve os cinco arquivos abaixo para reproduzir o mesmo desenho, poses, passos e movimento. Crie os complementos numa pasta nova nubo-mac. Se só responder texto, entregue arquivos completos com os caminhos.

PLANO E FOCO
O modelo fornecido é canônico. Passos sem limite fixo: adicionar/remover/reordenar, IDs UUID estáveis para novos; preserve IDs e dados antigos. Pode haver zero passos. O progresso é concluídos/total; o robô fica completo somente com todos feitos. Use ScrollView/LazyVStack para planos longos. O editor mantém [DailyTask] com IDs; ao salvar chame updatePlan usando o estado atual para preservar checks concorrentes. Nome/cor e projeto editáveis; cores coral/menta/lavanda, claro/escuro. Foco 15/25/45/50 com início, pausa, retomada, reinício, horário de término persistido e término contado uma única vez.

JANELA E MOVIMENTO
Crie @MainActor @Observable FloatingCompanionController. Propriedades: enabled:Bool=true, scale:Double=1, roaming:Bool=true, animated:Bool=true, reducedMotion:Bool, sleeping:Bool, activity:CompanionActivity, direction:Double, controlsOpen:Bool, animationRunning:Bool. Métodos setEnabled, setScale, setRoaming, setAnimated, setHovering, dragBegan, dragEnded, openControls, openEditor, start. Mantenha o NuboStore compartilhado. Conserve um NSPanel borderless/nonactivatingPanel transparente, level=.floating, hidesOnDeactivate=false, canJoinAllSpaces/fullScreenAuxiliary. Tamanho 212×236 vezes scale; exiba o AnimatedCompanionCharacter fornecido com overlay local para clique/arraste. NSView mouseDown pausa antes de capturar a origem, mouseDragged move, mouseUp retoma e só abre controles se não arrastou mais de 3 pontos.
Use CompanionMotion: stop na posição atual; escolha alvos aleatórios a 150–380 pontos na horizontal e até 190 na vertical, limitados à área útil do monitor descontando o painel; walk(speed:55*scale); Timer 30 Hz no RunLoop.common chama advance(delta) e setFrameOrigin. Ao chegar, descanse 1,4–3,2 s; ocasionalmente acene por 2 s. Atualize activity/direction só quando mudarem. Não publique posição para todas as views a cada frame. Observe mudanças de monitor e ajuste origem. Salve posição no fim do trajeto/arraste, escala e preferências no UserDefaults.
Pause o Timer ao ocultar, pairar o ponteiro, abrir controles ou arrastar, e ao dormir/bloquear a sessão. Retome 1,5–3 s após interação. Respeite NSWorkspace.accessibilityDisplayShouldReduceMotion e sua notificação; animationRunning=false desliga também o TimelineView. Sem hooks globais ou permissão de Acessibilidade. Manter o robô após fechar o painel. Menu e popover com Ficar parado/Passear, mostrar/ocultar e abrir painel; configurações de animação, passeio e tamanho.

COMPLEMENTOS
Crie FloatingCharacter(state:scale:pose:) com RobotView(stage:theme:focusing:pose:) de 200×200*scale e cápsula nome/concluídos/total. Crie FloatingCompanionView com esse personagem animado, hover e overlay de clique/arraste. Popover 320 pt: projeto, lista rolável, Editar passos, Ficar parado/Passear e foco. Clique em Editar passos abre o painel e sua folha de edição.
Crie @MainActor @Observable NuboStore com state:NuboState, error:String?, editingPlan:Bool, reload(), update((inout NuboState)throws->Void), toggleTask(String), toggleFocus() e resetFocus(). JSON em App Group, flock e gravação atômica. Leia/valide/reconcile antes de modificar, preserve arquivo inválido e notifique outros processos. Observe notificações distribuídas e releia a cada dois segundos no store, sem depender da janela grande. Gere ContentView, EditDayView e NuboSettingsView, com os controles descritos.
Widgets opcionais: três tamanhos, controles App Intents. Médio exibe três passos e grande quatro, priorizando pendentes; contador/progresso total e aviso de passos adicionais no app. Widgets usam RobotPose.still, sem animação contínua. Crie ArtworkExporter com imagens das mesmas views, identificando arte e captura real.

TEMPO E BALÕES
Use o GuidedRoutine fornecido: duração opcional por passo em minutos; um campo em branco usa focusMinutes. Intervalo global entre passos, zero para pular. No editor, salve updatePlan(project:tasks:breakMinutes:). Adicione ao store métodos startRoutine, pauseRoutine (toggleRoutinePause), completeRoutineStep, startNextRoutineStep e stopRoutine (routine=nil). O fim do tempo de trabalho aguarda confirmação manual; depois vem o intervalo e, ao terminar, o botão Começar próximo. Nunca marque passos automaticamente pelo tempo. Crie RoutinePanel no painel e popover com esses controles e contagem por endsAt.
Balões de texto mostram o passo, tempo restante e tempo até o próximo. Use segundo NSPanel transparente não ativante e ignoresMouseEvents=true, 308×118, posicionado acima ou abaixo do robô, limitado à área útil. Atualize a posição junto do personagem. A view do balão observa o mesmo store e usa TimelineView de 1 s. Recados ocasionais fora da rotina, 7 s a cada 55–90 s. Toggle de balões; esconda ao ocultar o robô ou dormir. Não use voz, IA remota ou acesso global ao mouse.

PROJETO E TESTES
Crie Nubo.xcodeproj com app local.nubo.mac e extensão opcional WidgetKit. Mesma equipe e App Group $(DEVELOPMENT_TEAM).com.nubo.shared nos targets/Info.plist, sandbox na extensão. Configure sua própria equipe; nunca copie certificados pessoais. App macOS, não iOS. Crie script de build e testes. Instale em ~/Applications somente quando solicitado. Verifique passos com mais de 100 itens, vazio, reordenação e checks concorrentes, compatibilidade com os dados de três passos, foco persistido e término único, virada do dia e arquivo inválido. Teste limites de tela, pausa, frame atrasado e retomada. Compile e observe o app real; relate apenas o que foi verificado.

ARQUIVOS CANÔNICOS
===== ARQUIVO: Shared/NuboState.swift =====
````swift
import Foundation

enum NuboTheme: String, Codable, CaseIterable, Identifiable {
    case coral, mint, violet
    var id: String { rawValue }
    var title: String { switch self { case .coral: "Coral"; case .mint: "Menta"; case .violet: "Lavanda" } }
}

struct DailyTask: Codable, Equatable, Identifiable {
    var id: String
    var title: String
    var done: Bool = false
    var durationMinutes: Int?
}

enum RobotStage: Int, CaseIterable {
    case pieces, assembling, almost, ready
    var title: String { ["Um começo de cada vez", "Ganhando forma", "Quase pronto", "Você fez acontecer"][rawValue] }
    var shortTitle: String { ["Peças", "Montando", "Quase lá", "Pronto!"][rawValue] }
    var message: String {
        ["Escolha um pequeno passo para hoje.", "Seu projeto está ganhando forma. Vamos juntos!", "Você já percorreu boa parte do caminho.", "Todos os passos concluídos. Uma grande conquista."][rawValue]
    }
}

struct NuboState: Codable, Equatable {
    var version = 1
    var nickname = "Nubo"
    var project = "Meu próximo projeto"
    var theme: NuboTheme = .coral
    var tasks = [DailyTask(id: "one", title: "Planejar o primeiro passo"),
                 DailyTask(id: "two", title: "Tirar a ideia do papel"),
                 DailyTask(id: "three", title: "Registrar o que aprendi")]
    var focusMinutes = 25
    var remainingSeconds: TimeInterval = 25 * 60
    var focusEndsAt: Date?
    var focusStartedAt: Date?
    var completedSessions = 0
    var day = ""
    var routineBreakMinutes: Int?
    var routine: GuidedRoutine?
    var breakMinutes: Int { routineBreakMinutes ?? 5 }

    var completedTasks: Int { tasks.filter(\.done).count }
    var progress: Double { tasks.isEmpty ? 0 : Double(completedTasks) / Double(tasks.count) }
    var stage: RobotStage {
        guard completedTasks > 0 else { return .pieces }
        if completedTasks == tasks.count { return .ready }
        return progress >= 2.0 / 3.0 ? .almost : .assembling
    }
    func widgetTasks(limit: Int) -> [DailyTask] {
        Array((tasks.filter { !$0.done } + tasks.filter(\.done)).prefix(limit))
    }
    var isFocusing: Bool { focusEndsAt != nil }
    var isPaused: Bool { !isFocusing && remainingSeconds < Double(focusMinutes * 60) && remainingSeconds > 0 }
    func secondsLeft(at date: Date = .now) -> TimeInterval { max(0, focusEndsAt.map { $0.timeIntervalSince(date) } ?? remainingSeconds) }
    static func dayKey(_ date: Date, calendar: Calendar = .current) -> String {
        let parts = calendar.dateComponents([.year, .month, .day], from: date)
        return "\(parts.year ?? 0)-\(parts.month ?? 0)-\(parts.day ?? 0)"
    }
    static func initial(at now: Date = .now) -> NuboState { var state = NuboState(); state.day = dayKey(now); return state }

    mutating func reconcile(at now: Date = .now, calendar: Calendar = .current) {
        let today = Self.dayKey(now, calendar: calendar)
        if day != today {
            day = today
            for index in tasks.indices { tasks[index].done = false }
            completedSessions = 0
        }
        if let end = focusEndsAt, end <= now {
            completedSessions += 1; focusEndsAt = nil; focusStartedAt = nil
            remainingSeconds = Double(focusMinutes * 60)
        }
        reconcileRoutine(at: now)
    }
    mutating func toggleTask(_ id: String, at now: Date = .now) {
        reconcile(at: now)
        if let index = tasks.firstIndex(where: { $0.id == id }) { tasks[index].done.toggle() }
        reconcileRoutine(at: now)
    }
    mutating func updatePlan(project: String, tasks drafts: [DailyTask], breakMinutes: Int? = nil) {
        self.project = project.trimmingCharacters(in: .whitespacesAndNewlines)
        let current = Dictionary(uniqueKeysWithValues: tasks.map { ($0.id, $0) })
        tasks = drafts.map { draft in
            let title = draft.title.trimmingCharacters(in: .whitespacesAndNewlines)
            return DailyTask(id: draft.id, title: title, done: current[draft.id].map { $0.title == title && $0.done } ?? false, durationMinutes: draft.durationMinutes)
        }
        if let breakMinutes { routineBreakMinutes = breakMinutes }
        if let routine, !tasks.contains(where: { $0.id == routine.taskID }) { self.routine = nil }
    }
    mutating func toggleFocus(at now: Date = .now) {
        reconcile(at: now)
        if focusEndsAt != nil {
            remainingSeconds = secondsLeft(at: now); focusEndsAt = nil
        } else {
            if remainingSeconds <= 0 { remainingSeconds = Double(focusMinutes * 60) }
            focusStartedAt = now; focusEndsAt = now.addingTimeInterval(remainingSeconds)
        }
    }
    mutating func resetFocus() { focusEndsAt = nil; focusStartedAt = nil; remainingSeconds = Double(focusMinutes * 60) }
    mutating func changeDuration(_ minutes: Int) {
        guard [15, 25, 45, 50].contains(minutes) else { return }
        focusMinutes = minutes; resetFocus()
    }
    func validated() throws -> NuboState {
        guard version == 1, Set(tasks.map(\.id)).count == tasks.count,
              !nickname.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, nickname.count <= 24,
              !project.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty, project.count <= 100,
              tasks.allSatisfy({ !$0.id.isEmpty && !$0.title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty && $0.title.count <= 100 && ($0.durationMinutes.map { (1...1440).contains($0) } ?? true) }),
              (0...1440).contains(breakMinutes),
              [15, 25, 45, 50].contains(focusMinutes), remainingSeconds.isFinite,
              (0...Double(focusMinutes * 60)).contains(remainingSeconds), completedSessions >= 0 else {
            throw NuboError.invalidData
        }
        if let routine {
            guard tasks.contains(where: { $0.id == routine.taskID }), routine.remainingSeconds.isFinite,
                  (0...86400).contains(routine.remainingSeconds) else { throw NuboError.invalidData }
        }
        return self
    }
    static func example(stage: Int = 2, theme: NuboTheme = .coral, focusing: Bool = false) -> NuboState {
        var state = initial(); state.project = "Minha estação meteorológica"; state.theme = theme
        state.tasks = [DailyTask(id: "one", title: "Separar os componentes", done: stage > 0),
                       DailyTask(id: "two", title: "Montar o primeiro circuito", done: stage > 1),
                       DailyTask(id: "three", title: "Testar o sensor de temperatura", done: stage > 2)]
        if focusing { state.focusStartedAt = .now; state.focusEndsAt = Date.now.addingTimeInterval(18 * 60 + 42) }
        return state
    }
}

enum NuboError: LocalizedError {
    case invalidData, missingGroup, locked, unsupportedVersion
    var errorDescription: String? {
        switch self {
        case .invalidData: "A configuração é inválida. Use títulos preenchidos, passos com identificadores únicos e uma duração disponível."
        case .missingGroup: "Não foi possível abrir os dados compartilhados. Confira a equipe de assinatura e o App Group dos dois targets no Xcode."
        case .locked: "Não foi possível acessar os dados agora. Tente novamente."
        case .unsupportedVersion: "Este arquivo foi criado por uma versão diferente do Nubo."
        }
    }
}
````

===== ARQUIVO: Shared/RobotView.swift =====
````swift
import SwiftUI

struct NuboPalette {
    let theme: NuboTheme
    let scheme: ColorScheme
    var accent: Color {
        switch theme {
        case .coral: Color(red: 0.94, green: 0.52, blue: 0.44)
        case .mint: Color(red: 0.36, green: 0.71, blue: 0.61)
        case .violet: Color(red: 0.61, green: 0.55, blue: 0.82)
        }
    }
    var ink: Color { scheme == .dark ? Color(red: 0.91, green: 0.93, blue: 0.93) : Color(red: 0.14, green: 0.21, blue: 0.25) }
    var paper: Color { scheme == .dark ? Color(red: 0.12, green: 0.16, blue: 0.19) : Color(red: 0.97, green: 0.96, blue: 0.93) }
    var panel: Color { scheme == .dark ? Color(red: 0.17, green: 0.21, blue: 0.24) : .white }
    var soft: Color { accent.opacity(scheme == .dark ? 0.14 : 0.11) }
}

/// All character artwork is code. The same view is used by the app, widget and publication exports.
struct RobotView: View {
    let stage: RobotStage
    var theme: NuboTheme = .coral
    var focusing = false
    var pose: RobotPose = .still
    @Environment(\.colorScheme) private var scheme
    private var palette: NuboPalette { NuboPalette(theme: theme, scheme: scheme) }

    var body: some View {
        GeometryReader { geometry in
            let scale = min(geometry.size.width, geometry.size.height) / 280
            Canvas { context, _ in
                context.scaleBy(x: scale, y: scale)
                let dark = Color(red: 0.14, green: 0.21, blue: 0.25)
                let accent = palette.accent
                func rounded(_ rect: CGRect, _ radius: CGFloat, _ color: Color) {
                    context.fill(Path(roundedRect: rect, cornerRadius: radius), with: .color(color))
                }
                func ellipse(_ rect: CGRect, _ color: Color) { context.fill(Path(ellipseIn: rect), with: .color(color)) }
                func line(_ from: CGPoint, _ to: CGPoint, _ color: Color, _ width: CGFloat = 4) {
                    var path = Path(); path.move(to: from); path.addLine(to: to)
                    context.stroke(path, with: .color(color), style: StrokeStyle(lineWidth: width, lineCap: .round))
                }
                // Platform and gentle shadow anchor every stage.
                ellipse(CGRect(x: 48, y: 243, width: 184, height: 14), dark.opacity(0.08))
                let assembled = stage.rawValue > 0
                let headY: CGFloat = assembled ? 66 : 49
                let baseContext = context
                context.translateBy(x: 140, y: headY + 50 + pose.bob)
                context.rotate(by: .radians(pose.tilt))
                context.translateBy(x: -140, y: -(headY + 50))
                // Antenna.
                line(CGPoint(x: 140, y: headY), CGPoint(x: 140 + pose.antenna, y: headY - 18), dark, 5)
                ellipse(CGRect(x: 132 + pose.antenna, y: headY - 31, width: 16, height: 16), stage == .ready ? Color(red: 0.96, green: 0.75, blue: 0.31) : accent)
                // Head, face, ears.
                rounded(CGRect(x: 58, y: headY + 30, width: 16, height: 34), 7, accent.opacity(0.65))
                rounded(CGRect(x: 206, y: headY + 30, width: 16, height: 34), 7, accent.opacity(0.65))
                rounded(CGRect(x: 69, y: headY, width: 142, height: 102), 31, accent)
                rounded(CGRect(x: 77, y: headY + 7, width: 126, height: 87), 25, Color.white.opacity(0.16))
                rounded(CGRect(x: 84, y: headY + 18, width: 112, height: 65), 20, dark)
                let eyeColor = Color(red: 0.74, green: 0.93, blue: 0.87)
                let eyeHeight = (focusing ? 7.0 : 19.0) * pose.blink
                let eyeY = headY + (focusing ? 47.5 : 45.5) - eyeHeight / 2
                rounded(CGRect(x: (focusing ? 105 : 108) + pose.look, y: eyeY, width: focusing ? 18 : 12, height: eyeHeight), 6, eyeColor)
                rounded(CGRect(x: (focusing ? 157 : 160) + pose.look, y: eyeY, width: focusing ? 18 : 12, height: eyeHeight), 6, eyeColor)
                var smile = Path(); smile.move(to: CGPoint(x: 130, y: headY + 62))
                smile.addQuadCurve(to: CGPoint(x: 150, y: headY + 62), control: CGPoint(x: 140, y: headY + (stage == .ready ? 77 : 70)))
                context.stroke(smile, with: .color(eyeColor), style: StrokeStyle(lineWidth: 3, lineCap: .round))
                context = baseContext
                context.translateBy(x: 0, y: pose.bob * 0.35)
                if assembled {
                    rounded(CGRect(x: 125, y: 166, width: 30, height: 12), 4, dark.opacity(0.6))
                    rounded(CGRect(x: 96, y: 177, width: 88, height: 56), 17, accent.opacity(0.85))
                    rounded(CGRect(x: 112, y: 186, width: 56, height: 30), 8, Color(red: 0.98, green: 0.95, blue: 0.85))
                    for index in 0..<3 {
                        rounded(CGRect(x: 120 + index * 14, y: 194, width: 10, height: 14), 3, index < stage.rawValue ? accent : dark.opacity(0.12))
                    }
                    rounded(CGRect(x: 106 + pose.step * 5, y: 230 - max(0, pose.step) * 6, width: 20, height: 15), 6, dark)
                    rounded(CGRect(x: 154 - pose.step * 5, y: 230 - max(0, -pose.step) * 6, width: 20, height: 15), 6, dark)
                    if stage.rawValue >= 2 {
                        let left = CGPoint(x: 85 - pose.step * 9, y: 220)
                        let right = pose.waving ? CGPoint(x: 211 + pose.wave * 7, y: 163 + pose.wave * 6) : CGPoint(x: 195 + pose.step * 9, y: 216)
                        line(CGPoint(x: 85, y: 192), left, dark.opacity(0.8), 14)
                        line(CGPoint(x: 195, y: 188), right, dark.opacity(0.8), 14)
                        ellipse(CGRect(x: left.x - 11, y: left.y - 11, width: 22, height: 22), accent)
                        ellipse(CGRect(x: right.x - 11, y: right.y - 11, width: 22, height: 22), accent)
                    } else {
                        rounded(CGRect(x: 55, y: 218, width: 25, height: 13), 6, dark.opacity(0.35))
                    }
                } else {
                    rounded(CGRect(x: 135, y: 196, width: 73, height: 46), 14, accent.opacity(0.65))
                    rounded(CGRect(x: 148, y: 204, width: 46, height: 24), 6, Color(red: 0.98, green: 0.95, blue: 0.85))
                    rounded(CGRect(x: 72 + pose.step * 4, y: 225, width: 32, height: 14), 7, dark)
                    rounded(CGRect(x: 88, y: 201, width: 13, height: 19), 5, accent)
                }
                if stage == .ready {
                    for point in [CGPoint(x: 43, y: 105), CGPoint(x: 235, y: 70), CGPoint(x: 224, y: 198)] {
                        line(CGPoint(x: point.x - 6, y: point.y), CGPoint(x: point.x + 6, y: point.y), accent, 3)
                        line(CGPoint(x: point.x, y: point.y - 6), CGPoint(x: point.x, y: point.y + 6), accent, 3)
                    }
                }
            }
            .frame(width: 280 * scale, height: 280 * scale)
            .frame(maxWidth: .infinity, maxHeight: .infinity)
        }
        .aspectRatio(1, contentMode: .fit)
        .accessibilityLabel("\(stage.shortTitle). Robô\(focusing ? " em uma sessão de foco" : "").")
    }
}
````

===== ARQUIVO: Shared/CompanionMotion.swift =====
````swift
import Foundation
import CoreGraphics

enum CompanionActivity: String {
    case idle, walking, waving
    var title: String {
        switch self { case .idle: "Descansando"; case .walking: "Passeando"; case .waving: "Dando um oi" }
    }
}

/// Pure movement model. Bounds describe allowed window origins, not the entire display.
struct CompanionMotion {
    private(set) var position: CGPoint = .zero
    private(set) var activity: CompanionActivity = .idle
    private(set) var direction: Double = -1
    private var origin: CGPoint = .zero
    private var destination: CGPoint = .zero
    private var elapsed: Double = 0
    private var duration: Double = 1

    mutating func stop(at point: CGPoint) {
        position = point; origin = point; destination = point; elapsed = 0; activity = .idle
    }
    mutating func walk(to point: CGPoint, within bounds: CGRect, speed: Double = 55) {
        position = Self.clamp(position, to: bounds); origin = position
        destination = Self.clamp(point, to: bounds)
        let distance = hypot(destination.x - origin.x, destination.y - origin.y)
        guard distance > 1 else { activity = .idle; return }
        direction = destination.x >= origin.x ? 1 : -1
        duration = max(1, Double(distance) / max(10, speed)); elapsed = 0; activity = .walking
    }
    mutating func advance(by delta: Double, within bounds: CGRect, paused: Bool = false) {
        guard !paused else { return }
        guard activity == .walking else { position = Self.clamp(position, to: bounds); return }
        // A delayed frame or wake from sleep must never teleport the character.
        elapsed += max(0, min(delta, 0.1))
        let progress = min(1, elapsed / duration)
        let eased = progress * progress * (3 - 2 * progress)
        position = Self.clamp(CGPoint(x: origin.x + (destination.x - origin.x) * eased,
                                     y: origin.y + (destination.y - origin.y) * eased), to: bounds)
        if progress >= 1 { activity = .idle }
    }
    static func clamp(_ point: CGPoint, to bounds: CGRect) -> CGPoint {
        CGPoint(x: max(bounds.minX, min(point.x, bounds.maxX)), y: max(bounds.minY, min(point.y, bounds.maxY)))
    }
}

/// One drawing pose; static widgets/exports use .still. Only the floating character has a clock.
struct RobotPose {
    var blink: Double = 1
    var look: Double = 0
    var bob: Double = 0
    var tilt: Double = 0
    var step: Double = 0
    var antenna: Double = 0
    var waving = false
    var wave: Double = 0
    static let still = RobotPose()
    static func sample(at time: Double, activity: CompanionActivity, direction: Double) -> RobotPose {
        let blinkTime = time.truncatingRemainder(dividingBy: 4.6)
        let blink = blinkTime < 0.18 ? 0.12 + 0.88 * abs(blinkTime - 0.09) / 0.09 : 1
        let walking = activity == .walking
        let step = walking ? sin(time * 9) : 0
        return RobotPose(blink: blink, look: walking ? direction * 3 : sin(time * 0.8) * 2,
                         bob: walking ? -abs(step) * 3 : sin(time * 2) * 1.5,
                         tilt: walking ? direction * 0.025 + step * 0.012 : sin(time * 1.5) * 0.012,
                         step: step, antenna: sin(time * 3) * 3,
                         waving: activity == .waving, wave: sin(time * 13))
    }
}
````

===== ARQUIVO: Shared/GuidedRoutine.swift =====
````swift
import Foundation

struct GuidedRoutine: Codable, Equatable {
    enum Phase: String, Codable { case working, awaitingCompletion, takingBreak, ready }
    var taskID: String
    var phase: Phase
    var remainingSeconds: TimeInterval
    var endsAt: Date?
    var hasCountdown: Bool { phase == .working || phase == .takingBreak }
    var isPaused: Bool { hasCountdown && endsAt == nil }
    func secondsLeft(at now: Date = .now) -> TimeInterval {
        max(0, endsAt.map { $0.timeIntervalSince(now) } ?? remainingSeconds)
    }
}

extension NuboState {
    var routineTask: DailyTask? { routine.flatMap { running in tasks.first { $0.id == running.taskID } } }

    mutating func startRoutine(at now: Date = .now) {
        reconcile(at: now)
        guard let task = tasks.first(where: { !$0.done }) else { return }
        beginRoutineTask(task, at: now)
    }
    private mutating func beginRoutineTask(_ task: DailyTask, at now: Date) {
        let seconds = Double((task.durationMinutes ?? focusMinutes) * 60)
        routine = GuidedRoutine(taskID: task.id, phase: .working, remainingSeconds: seconds, endsAt: now.addingTimeInterval(seconds))
    }
    mutating func startNextRoutineStep(at now: Date = .now) {
        reconcile(at: now)
        guard routine?.phase == .ready, let task = routineTask else { return }
        beginRoutineTask(task, at: now)
    }
    mutating func toggleRoutinePause(at now: Date = .now) {
        reconcile(at: now)
        guard var running = routine, running.hasCountdown else { return }
        if running.endsAt != nil {
            running.remainingSeconds = min(86400, running.secondsLeft(at: now)); running.endsAt = nil
        } else { running.endsAt = now.addingTimeInterval(running.remainingSeconds) }
        routine = running
    }
    mutating func completeRoutineStep(at now: Date = .now) {
        reconcile(at: now)
        guard let running = routine, running.phase == .working || running.phase == .awaitingCompletion,
              let index = tasks.firstIndex(where: { $0.id == running.taskID }) else { return }
        tasks[index].done = true; prepareNextRoutineStep(at: now)
    }
    private mutating func prepareNextRoutineStep(at now: Date) {
        guard let next = tasks.first(where: { !$0.done }) else { routine = nil; return }
        let seconds = Double(breakMinutes * 60)
        routine = GuidedRoutine(taskID: next.id, phase: seconds > 0 ? .takingBreak : .ready,
                                remainingSeconds: seconds, endsAt: seconds > 0 ? now.addingTimeInterval(seconds) : nil)
    }
    mutating func reconcileRoutine(at now: Date) {
        guard var running = routine else { return }
        guard let task = tasks.first(where: { $0.id == running.taskID }) else { routine = nil; return }
        if task.done {
            if running.phase == .working || running.phase == .awaitingCompletion {
                prepareNextRoutineStep(at: now); return
            }
            guard let next = tasks.first(where: { !$0.done }) else { routine = nil; return }
            running.taskID = next.id
        }
        if let end = running.endsAt, end <= now {
            running.remainingSeconds = 0; running.endsAt = nil
            if running.phase == .working { running.phase = .awaitingCompletion }
            if running.phase == .takingBreak { running.phase = .ready }
        }
        routine = running
    }
}
````

===== ARQUIVO: App/AnimatedCompanionCharacter.swift =====
````swift
import SwiftUI

/// The animation clock lives only in the small floating view, never in the widget or task store.
struct AnimatedCompanionCharacter: View {
    let state: NuboState
    let companion: FloatingCompanionController
    @Environment(\.accessibilityReduceMotion) private var reduceMotion
    var body: some View {
        TimelineView(.animation(minimumInterval: 1.0 / 30.0, paused: !companion.animationRunning || reduceMotion)) { context in
            let pose = companion.animationRunning && !reduceMotion
                ? RobotPose.sample(at: context.date.timeIntervalSinceReferenceDate, activity: companion.activity, direction: companion.direction) : .still
            FloatingCharacter(state: state, scale: companion.scale, pose: pose)
        }
    }
}
````

Antes de começar

Mac com macOS 14 ou posterior, Xcode e uma equipe/certificado de desenvolvimento para assinar o aplicativo e a extensão opcional. Use Codex, Claude ou outra IA que produza arquivos de código. A compilação precisa ser concluída no Mac; uma IA que só responda por texto deve fornecer os arquivos completos e as instruções de compilação.

O que você pretende criar

Um aplicativo nativo para macOS com um robô flutuante transparente sobre as janelas normais, passeios e animações, passos sem limite fixo, temporizador de foco e rotina com tempos, intervalos e balões de texto. Nome, cor e tamanho personalizáveis, progresso salvo localmente e widgets de Mesa opcionais. Os cinco arquivos canônicos incluídos orientam o desenho e a lógica; a IA deve completar o projeto, compilar e verificar o funcionamento.

Daqui para a sua IA

Como usar

Personalize os campos para a sua ideia.
Copie o prompt e cole na ferramenta de IA que você usa.
Converse com a IA e revise o resultado antes de usar.

Ferramenta sugerida
Codex, Claude ou outra IA capaz de criar projetos Swift/macOS

Dicas para esta ideia

INTRODUÇÃO
Eu queria um pequeno companheiro que continuasse por perto enquanto eu estivesse usando meus aplicativos, em vez de ficar preso à Mesa ou a uma janela grande. Foi assim que surgiu o Nubo: um robozinho flutuante para o Mac.

Ele aparece sem moldura, por cima das janelas normais dos outros aplicativos. Ele passeia com pequenas pausas, pisca e mexe a antena. Quando o ponteiro se aproxima, para para facilitar o clique. Você pode arrastá-lo para um canto da tela e clicar nele para abrir uma caixinha com suas tarefas e seu temporizador de foco.

A ideia é escolher um projeto e adicionar quantos passos você precisar. Você pode incluir, remover e mudar a ordem dos passos. No começo do dia, o robô está em peças. Conforme as tarefas são concluídas, ele ganha corpo, braços e energia, até ficar completo. Pode acompanhar um circuito, uma impressão 3D, estudos, escrita ou outra ideia que você queira tirar do papel.

COMO USAR O ROBÔ
1. Abra o Nubo. O robô flutuante aparece automaticamente.
2. No painel, clique em “Editar meu dia” e escreva seu projeto e os passos que você quiser. Use “Adicionar passo” para criar novos e as setas para mudar a ordem.
3. Arraste o robô para o lugar da tela que preferir. A posição fica salva.
4. Clique no robô para abrir os controles rápidos. Neles você pode marcar tarefas e iniciar, pausar ou reiniciar o foco.
5. Você pode fechar a janela grande e continuar com o robô flutuante.
6. Para ocultar ou mostrar novamente, use o ícone do Nubo na barra superior. Esse menu também abre o painel e as configurações. Para encerrar o app, escolha “Sair do Nubo”.

FUNCIONALIDADES
• Robô sem moldura, com fundo transparente, sobre as janelas normais dos aplicativos.
• Arraste para posicionar, com posição salva e ajuste quando um monitor deixa de estar disponível.
• Clique para abrir tarefas e controles do foco em uma caixinha junto ao personagem.
• Passos sem limite fixo, com adicionar/remover, reordenação e marcar/desmarcar.
• Quatro estágios visuais conforme a proporção concluída: peças, montando, quase lá e pronto.
• Caminhada automática pela tela, piscadas, pequenos balanços, antena e passos animados.
• Para ao aproximar o ponteiro, clicar ou arrastar. Use “Ficar parado” para interromper os passeios; as animações podem ser desligadas nas configurações.
• Temporizador livre de 15, 25, 45 ou 50 minutos, com início, pausa, retomada e reinício.
• Rotina guiada com tempo por passo, intervalo entre etapas e contagem persistida.
• Balões de texto com o passo atual e o tempo até continuar. Você pode desligar os balões.
• Conclusão manual: o tempo terminar avisa, mas não marca o passo como feito.
• Nome, cor e tamanho do robô personalizáveis: coral, menta ou lavanda; pequeno, médio ou grande.
• Menu na barra superior para mostrar, ocultar, abrir o painel ou sair.
• Progresso salvo localmente e contagem de sessões concluídas no dia.
• Widgets de Mesa pequeno, médio e grande disponíveis como complemento opcional.

O robô representa seu progresso e tem animações de caminhada, descanso e saudação. O movimento respeita os limites úteis da tela e a opção Reduzir Movimento do macOS. Ele não conversa com IA. O uso de IA neste projeto está na criação e adaptação do código. O temporizador desta versão é visual e não toca um alarme.

TEMPOS, INTERVALOS E BALÕES
Em “Editar meu dia”, preencha os minutos de cada passo e o intervalo entre os passos. Os tempos são opcionais: em branco, o passo usa a duração configurada do foco. Intervalo zero pula a pausa.

Clique em “Iniciar rotina” no painel ou nos controles do robô. O Nubo mostra um balão com o passo atual e o tempo restante. Você pode pausar ou retomar. Ao concluir uma etapa, clique em “Concluir passo” ou marque a tarefa; o intervalo começa, com a contagem até o próximo passo. Quando a pausa terminar, escolha “Começar próximo”. Se o tempo da etapa acabar antes de você concluir, o Nubo avisa e aguarda sua confirmação. A rotina não marca tarefas automaticamente.

Os balões também trazem pequenos recados ocasionais. São mensagens de texto locais, sem conversa com um modelo de IA ou voz. Nas configurações, “Balões do Nubo” permite desligá-los. O foco livre continua disponível separado da rotina.

COMO FUNCIONA O PROGRESSO
Nenhum passo concluído: peças separadas. Com os primeiros passos ele ganha forma; a partir de dois terços, está quase pronto. Ao concluir todos os passos, fica completo, com pequenos brilhos. A lista pode começar vazia e não tem um limite fixo de passos. As marcações recomeçam no próximo dia local, mantendo os textos do projeto e das tarefas. Você pode desmarcar uma tarefa quando precisar.

O QUE VOCÊ PRECISA
Um Mac com macOS 14 ou posterior, Xcode e uma equipe/certificado de desenvolvimento para assinar o projeto e a extensão opcional. A versão de referência foi testada em um Mac Apple Silicon; a assinatura de desenvolvimento local não equivale a uma publicação na App Store.

COMO USAR O PROMPT
1. Use “Copiar prompt” nesta página e copie todo o conteúdo, incluindo os cinco blocos de código.
2. Cole no Codex, Claude ou em outra IA voltada à programação. Se a ferramenta trabalhar em uma pasta, use uma pasta nova.
3. O prompt já inclui o modelo dos passos, o desenho, as poses animadas e a lógica de movimento do robô. Peça para completar os arquivos descritos, compilar e executar os testes. Em uma conversa que apenas responde por texto, copie os arquivos gerados para o Mac e siga as instruções de compilação.
4. Escolha sua própria equipe de assinatura no Xcode. Não compartilhe senhas, certificados ou chaves privadas no prompt.
5. Abra o aplicativo criado e experimente o robô flutuante. Para manter o desenho e os comportamentos de referência, preserve os arquivos canônicos incluídos no prompt e peça à IA os arquivos complementares completos.

Os widgets de Mesa são opcionais. Para experimentar um deles, clique com o botão direito em uma área livre da Mesa → Editar Widgets → Nubo. O robô flutuante é uma janela própria do aplicativo e funciona sobre as janelas abertas.

PERSONALIZAÇÃO
Nas configurações, você pode mudar o nome, a cor e o tamanho do robô, ativar ou parar os passeios e as animações, escolher a duração do foco e mostrar ou ocultar o personagem. Trocar a duração reinicia o temporizador atual. Para adaptar o código com IA, comece com uma pequena mudança: uma nova paleta, uma frase de incentivo ou outro projeto de exemplo.

SOBRE AS IMAGENS
As artes de apresentação usam o mesmo desenho e os componentes SwiftUI do aplicativo. Os exemplos de estação meteorológica são dados fictícios. As imagens identificadas como capturas reais mostram o app, o robô ou seus controles em execução; as outras são artes renderizadas a partir do código.

A Tinkr organiza e compartilha prompts. Você usa sua ferramenta de IA, com sua própria conta.

Uma ideia puxa outra

Transformou o prompt em algo legal? Conte como você fez para outras pessoas aprenderem também.

Compartilhar um projeto

Licença CC BY 4.0 · Ao compartilhar, dê crédito a Feerlucas e indique suas alterações.