🐾 PetCareScript - Documentação Completa

Uma linguagem de programação moderna, expressiva e amigável para humanos com suporte completo a async, HTTP, banco de dados e testes

🌐 Site Oficial • 📖 Documentação • 🧩 Extensão VS Code • 💬 Comunidade • 🎓 Tutoriais

🌟 Por que PetCareScript?

PetCareScript é uma linguagem de programação revolucionária que combina simplicidade, poder e elegância. Desenvolvida pela PetCareAI, ela oferece uma sintaxe naturalmente legível que torna a programação mais humana e acessível.

✨ Características Principais

🎯 Sintaxe Natural - Escreva código que qualquer pessoa pode entender
⚡ Performance - Interpretador otimizado com execução rápida
🔧 Ferramentas Integradas - HTTP, banco de dados, testes e muito mais
🌐 Async/Await - Programação assíncrona moderna e intuitiva
🏗️ OOP Avançado - Sistema de blueprints poderoso e flexível
🧪 TDD/BDD - Framework de testes completo integrado
📦 Módulos - Sistema de importação/exportação robusto
🎨 Extensibilidade - Fácil integração com bibliotecas externas

📖 Índice

🚀 Instalação

📦 Instalação Global (Recomendada)

1# Via NPM
2npm install -g petcarescript
3
4# Via Yarn
5yarn global add petcarescript
6
7# Verificar instalação
8pcs --version

🏠 Instalação Local

1# Para projeto específico
2npm install petcarescript
3npx pcs meuarquivo.pcs

💾 Instalação via Executáveis

1# Linux/macOS - Instalação automática
2curl -sSL https://raw.githubusercontent.com/PetCareAi/petcarescript/main/install.sh | bash
3
4# Windows - PowerShell como Administrador
5irm https://raw.githubusercontent.com/PetCareAi/petcarescript/main/install.ps1 | iex

🧩 Extensão VS Code

Instale a extensão oficial para VS Code:

Recursos da Extensão:

• 🎨 Syntax highlighting
• 🔍 IntelliSense e autocompletar
• 🐛 Debugging integrado
• 📋 Snippets de código
• 🔧 Linting e formatação
• 🏃 Execução direta no editor

⚡ Início Rápido

🌟 Seu Primeiro Programa

1// hello.pcs
2show "🐾 Bem-vindo ao PetCareScript!";
3
4store name = "Desenvolvedor";
5show "Olá, " + name + "! Vamos programar?";
6
7build greet(person) {
8    give "🎉 Oi, " + person + "! Que bom ter você aqui!";
9}
10
11store message = greet(name);
12show message;

Execute:

1pcs hello.pcs

🔥 REPL Interativo

1# Iniciar REPL
2pcs
3
4# Teste comandos interativamente
5pcs> store x = 42;
6pcs> show x * 2;
7pcs> build square(n) { give n * n; }
8pcs> show square(8);
9pcs> exit

🎯 Primeiros Passos

1️⃣ Variáveis e Tipos

1// Tipos básicos
2store name = "Ana Silva";           // String
3store age = 28;                     // Number
4store isActive = yes;               // Boolean (true)
5store isInactive = no;              // Boolean (false)
6store nothing = empty;              // Null
7store items = [1, 2, 3, 4];         // Array
8store person = { 
9    name: "João", 
10    age: 35,
11    skills: ["JavaScript", "PetCareScript"]
12};                                  // Object

2️⃣ Funções Básicas

1// Função simples
2build sayHello(name) {
3    show "Olá, " + name + "!";
4}
5
6// Função com retorno
7build multiply(a, b) {
8    give a * b;  // 'give' é como 'return'
9}
10
11// Função com múltiplos parâmetros
12build createUser(name, age, email, role = "user") {
13    give {
14        name: name,
15        age: age,
16        email: email,
17        role: role,
18        createdAt: now(),
19        active: yes
20    };
21}
22
23// Usando funções
24sayHello("Maria");
25store result = multiply(7, 8);
26store newUser = createUser("Pedro", 25, "pedro@email.com", "admin");
27show newUser;

3️⃣ Condicionais Inteligentes

1store score = 87;
2
3// Condicional básica
4when (score >= 90) {
5    show "Excelente! Nota A";
6} otherwise when (score >= 80) {
7    show "Muito bom! Nota B";
8} otherwise when (score >= 70) {
9    show "Bom! Nota C";
10} otherwise {
11    show "Precisa melhorar";
12}
13
14// Unless (oposto de if)
15unless (score < 60) {
16    show "Aprovado!";
17}
18
19// Operadores amigáveis
20when (score between 80 and 90) {
21    show "Nota na faixa B+";
22}
23
24store grades = [85, 92, 78];
25when (grades contains 92) {
26    show "Tem nota excelente!";
27}

📝 Sintaxe Básica

🔢 Operadores

1// Aritméticos
2store sum = 15 + 10;        // 25
3store diff = 20 - 8;        // 12
4store product = 6 * 7;      // 42
5store quotient = 84 / 7;    // 12
6store remainder = 17 % 5;   // 2
7
8// Comparação amigável
9store isEqual = (10 is 10);          // yes (true)
10store isDifferent = (10 isnt 5);     // yes (true)
11store isGreater = (15 > 10);         // yes (true)
12store isInRange = (50 between 30 and 70);  // yes (true)
13
14// Lógicos naturais
15store both = (yes also yes);         // yes (true)
16store either = (yes either no);      // yes (true)
17store neither = (not yes);           // no (false)
18store combined = (age >= 18 and hasLicense);

🔄 Loops Avançados

1// For loop tradicional
2loop (store i = 0; i < 5; i = i + 1) {
3    show "Contador: " + i;
4}
5
6// While loop
7store count = 0;
8repeat (count < 3) {
9    show "Repetição: " + count;
10    count = count + 1;
11}
12
13// Until loop (oposto de while)
14store countdown = 5;
15until (countdown is 0) {
16    show "Contagem regressiva: " + countdown;
17    countdown = countdown - 1;
18}
19
20// ForEach para arrays
21store languages = ["JavaScript", "Python", "PetCareScript"];
22foreach (lang in languages) {
23    show "Linguagem: " + lang;
24}
25
26// ForEach para objetos
27store user = { name: "Ana", age: 30, city: "SP" };
28foreach (key in Object.keys(user)) {
29    show key + ": " + user[key];
30}
31
32// Controle de loop
33loop (store j = 0; j < 10; j = j + 1) {
34    when (j is 3) {
35        continue; // Pula para próxima iteração
36    }
37    when (j is 7) {
38        break;    // Sai do loop
39    }
40    show j;
41}

🎛️ Switch Statement

1store dayOfWeek = "monday";
2
3switch (dayOfWeek) {
4    case "monday":
5        show "Segunda-feira: Novo começo!";
6        break;
7    case "tuesday":
8        show "Terça-feira: Produtividade!";
9        break;
10    case "wednesday":
11        show "Quarta-feira: Meio da semana!";
12        break;
13    case "friday":
14        show "Sexta-feira: Quase fim de semana!";
15        break;
16    default:
17        show "Dia desconhecido";
18}

🔤 Palavras Reservadas

Core Language (Essenciais)

Operadores Lógicos

Operadores de Comparação

Controle de Fluxo

Tratamento de Erros

Programação Assíncrona

HTTP e APIs

Testing

Módulos

Database

Tipos de Dados

Features Avançadas

🏗️ Programação Orientada a Objetos

🏛️ Blueprints (Classes)

1// Blueprint básico
2blueprint Animal {
3    build init(name, species) {
4        self.name = name;
5        self.species = species;
6        self.energy = 100;
7        self.happiness = 50;
8    }
9    
10    build eat(food) {
11        self.energy = self.energy + 15;
12        show self.name + " comeu " + food + " e ganhou energia!";
13        give self.energy;
14    }
15    
16    build play() {
17        when (self.energy > 20) {
18            self.energy = self.energy - 10;
19            self.happiness = self.happiness + 20;
20            show self.name + " está brincando! 🎾";
21        } otherwise {
22            show self.name + " está muito cansado para brincar...";
23        }
24    }
25    
26    build status() {
27        give {
28            name: self.name,
29            species: self.species,
30            energy: self.energy,
31            happiness: self.happiness,
32            mood: self.happiness > 70 ? "feliz" : "normal"
33        };
34    }
35}
36
37// Herança
38blueprint Dog extends Animal {
39    build init(name, breed) {
40        parent.init(name, "Cachorro");
41        self.breed = breed;
42        self.tricks = [];
43    }
44    
45    build bark() {
46        show self.name + " faz: AU AU! 🐕";
47        give "woof";
48    }
49    
50    build learnTrick(trick) {
51        push(self.tricks, trick);
52        self.happiness = self.happiness + 10;
53        show self.name + " aprendeu: " + trick + "! 🎉";
54    }
55    
56    build performTrick() {
57        when (size(self.tricks) > 0) {
58            store trick = randomChoice(self.tricks);
59            show self.name + " fez: " + trick + "! 👏";
60            self.happiness = self.happiness + 5;
61        } otherwise {
62            show self.name + " ainda não sabe truques...";
63        }
64    }
65}
66
67// Uso prático
68store myDog = Dog("Rex", "Golden Retriever");
69myDog.eat("ração premium");
70myDog.learnTrick("sentar");
71myDog.learnTrick("dar a patinha");
72myDog.bark();
73myDog.performTrick();
74myDog.play();
75
76store dogStatus = myDog.status();
77show "Status do " + dogStatus.name + ": " + stringifyJSON(dogStatus);

🎭 Interfaces e Enums

1// Interface
2interface Flyable {
3    fly(): void;
4    altitude: number;
5    maxSpeed: number;
6}
7
8// Enumeração
9enum OrderStatus {
10    PENDING,
11    PROCESSING,
12    SHIPPED,
13    DELIVERED,
14    CANCELLED
15}
16
17// Blueprint implementando interface
18blueprint Bird extends Animal implements Flyable {
19    build init(name, wingSpan) {
20        parent.init(name, "Pássaro");
21        self.wingSpan = wingSpan;
22        self.altitude = 0;
23        self.maxSpeed = 50;
24    }
25    
26    build fly() {
27        self.altitude = 100;
28        show self.name + " está voando! ✈️";
29    }
30}
31
32// Uso de enum
33store orderStatus = OrderStatus.PROCESSING;
34when (orderStatus is OrderStatus.DELIVERED) {
35    show "Pedido entregue!";
36}

⚡ Programação Assíncrona

🔄 Async/Await

1// Função assíncrona básica
2async build fetchUserData(userId) {
3    show "🔍 Buscando dados do usuário " + userId + "...";
4    
5    attempt {
6        store response = await get("https://api.example.com/users/" + userId);
7        store userData = parseJSON(response.data);
8        
9        show "✅ Usuário encontrado: " + userData.name;
10        give userData;
11    } catch (error) {
12        show "❌ Erro ao buscar usuário: " + error;
13        give empty;
14    }
15}
16
17// Múltiplas operações assíncronas
18async build processUserOrder(userId, orderId) {
19    show "📦 Processando pedido " + orderId + "...";
20    
21    // Buscar dados em paralelo
22    store [user, order, inventory] = await all([
23        fetchUserData(userId),
24        fetchOrderData(orderId),
25        checkInventory(orderId)
26    ]);
27    
28    when (user and order and inventory.available) {
29        store result = await processPayment(user, order);
30        when (result.success) {
31            await sendConfirmationEmail(user.email, order);
32            show "🎉 Pedido processado com sucesso!";
33            give { success: yes, orderId: orderId };
34        }
35    } otherwise {
36        show "❌ Não foi possível processar o pedido";
37        give { success: no, error: "Dados incompletos" };
38    }
39}
40
41// Usando a função
42async build main() {
43    store result = await processUserOrder(123, "ORD-456");
44    show "Resultado: " + stringifyJSON(result);
45}
46
47main();

🎯 Promises Avançadas

1// Criando promises personalizadas
2build createDownloadPromise(url, filename) {
3    give Promise(build(resolve, reject) {
4        show "📥 Iniciando download de " + filename + "...";
5        
6        timeout(build() {
7            store success = randomInt(1, 10) > 3; // 70% chance de sucesso
8            
9            when (success) {
10                show "✅ Download concluído: " + filename;
11                resolve({
12                    filename: filename,
13                    size: randomInt(100, 1000) + "KB",
14                    url: url
15                });
16            } otherwise {
17                show "❌ Falha no download: " + filename;
18                reject("Network error: " + filename);
19            }
20        }, randomInt(1000, 3000)); // 1-3 segundos
21    });
22}
23
24// Operações paralelas com controle
25async build batchDownload() {
26    store urls = [
27        "https://api.example.com/file1.pdf",
28        "https://api.example.com/file2.jpg", 
29        "https://api.example.com/file3.zip"
30    ];
31    
32    store downloadPromises = [];
33    foreach (url in urls) {
34        store filename = split(url, "/").pop();
35        push(downloadPromises, createDownloadPromise(url, filename));
36    }
37    
38    show "🚀 Iniciando downloads em paralelo...";
39    
40    attempt {
41        store results = await all(downloadPromises);
42        show "🎉 Todos os downloads concluídos!";
43        
44        foreach (result in results) {
45            show "📁 " + result.filename + " (" + result.size + ")";
46        }
47        
48        give results;
49    } catch (error) {
50        show "⚠️ Alguns downloads falharam: " + error;
51        
52        // Tentar downloads individuais para ver quais falharam
53        foreach (promise in downloadPromises) {
54            promise
55                .then(build(result) {
56                    show "✅ Recuperado: " + result.filename;
57                })
58                .catch(build(error) {
59                    show "❌ Falhou definitivamente: " + error;
60                });
61        }
62    }
63}
64
65batchDownload();

🌐 Servidor HTTP e APIs

🚀 API REST Completa

1// server.pcs - Servidor HTTP profissional
2import { createServer, cors, json, logger } from "http";
3import { connect, types } from "database";
4
5async build startServer() {
6    // Configuração do banco de dados
7    store db = connect("petcare_api.db");
8    await db.connect();
9    
10    // Criar tabelas
11    await db.createTable("users", {
12        id: types.PRIMARY_KEY,
13        name: types.TEXT + " NOT NULL",
14        email: types.TEXT + " UNIQUE NOT NULL",
15        password: types.TEXT + " NOT NULL",
16        role: types.TEXT + " DEFAULT 'user'",
17        avatar: types.TEXT,
18        created_at: types.TIMESTAMP,
19        updated_at: types.TIMESTAMP
20    });
21    
22    await db.createTable("posts", {
23        id: types.PRIMARY_KEY,
24        user_id: types.INTEGER + " NOT NULL",
25        title: types.TEXT + " NOT NULL",
26        content: types.TEXT,
27        published: types.BOOLEAN + " DEFAULT 0",
28        tags: types.JSON,
29        created_at: types.TIMESTAMP,
30        updated_at: types.TIMESTAMP
31    });
32    
33    // Configuração do servidor
34    store server = createServer(3000);
35    
36    // Middleware globais
37    server.use(cors({
38        origin: ["http://localhost:3000", "https://petcareai.com.br"],
39        credentials: yes
40    }));
41    server.use(json({ limit: "10mb" }));
42    server.use(logger("combined"));
43    
44    // Middleware de autenticação
45    build authMiddleware(req, res, next) {
46        store token = req.headers.authorization;
47        
48        when (token and startsWith(token, "Bearer ")) {
49            store actualToken = slice(token, 7); // Remove "Bearer "
50            
51            // Validação simples do token (em produção, use JWT)
52            when (actualToken is "valid-api-key-123") {
53                req.user = { id: 1, name: "Admin", role: "admin" };
54                next();
55            } otherwise {
56                res.status(401).json({ 
57                    error: "Token inválido",
58                    code: "INVALID_TOKEN"
59                });
60            }
61        } otherwise {
62            res.status(401).json({ 
63                error: "Token necessário",
64                code: "MISSING_TOKEN"
65            });
66        }
67    }
68    
69    // Rotas públicas
70    server.get("/health", build(req, res) {
71        res.json({
72            status: "healthy",
73            timestamp: now(),
74            version: "1.2.3",
75            uptime: process.uptime()
76        });
77    });
78    
79    // API de usuários
80    server.get("/api/users", authMiddleware, build(req, res) {
81        attempt {
82            store page = toNumber(req.query.page) or 1;
83            store limit = toNumber(req.query.limit) or 10;
84            store offset = (page - 1) * limit;
85            
86            store users = await db.select("users", {}, {
87                limit: limit,
88                offset: offset,
89                orderBy: "created_at",
90                order: "DESC"
91            });
92            
93            // Remover senhas do resultado
94            store safeUsers = map(users, build(user) {
95                store { password, ...safeUser } = user;
96                give safeUser;
97            });
98            
99            res.json({
100                data: safeUsers,
101                pagination: {
102                    page: page,
103                    limit: limit,
104                    total: size(users)
105                }
106            });
107        } catch (error) {
108            res.status(500).json({ 
109                error: "Erro interno do servidor",
110                details: error.message
111            });
112        }
113    });
114    
115    server.post("/api/users", build(req, res) {
116        attempt {
117            store { name, email, password, role } = req.body;
118            
119            // Validação
120            when (not name or not email or not password) {
121                res.status(400).json({
122                    error: "Campos obrigatórios: name, email, password"
123                });
124                give;
125            }
126            
127            when (not isEmail(email)) {
128                res.status(400).json({
129                    error: "Email inválido"
130                });
131                give;
132            }
133            
134            // Verificar se email já existe
135            store existingUser = await db.select("users", { email: email });
136            when (size(existingUser) > 0) {
137                res.status(409).json({
138                    error: "Email já cadastrado"
139                });
140                give;
141            }
142            
143            // Criar usuário
144            store hashedPassword = hashPassword(password); // Implementar hash
145            store newUser = await db.insert("users", {
146                name: name,
147                email: email,
148                password: hashedPassword,
149                role: role or "user"
150            });
151            
152            // Buscar usuário criado (sem senha)
153            store createdUser = await db.select("users", { id: newUser.lastID });
154            store { password: _, ...safeUser } = createdUser[0];
155            
156            res.status(201).json({
157                message: "Usuário criado com sucesso",
158                data: safeUser
159            });
160            
161        } catch (error) {
162            res.status(500).json({
163                error: "Erro ao criar usuário",
164                details: error.message
165            });
166        }
167    });
168    
169    // API de posts
170    server.get("/api/posts", build(req, res) {
171        attempt {
172            store posts = await db.query(`
173                SELECT p.*, u.name as author_name, u.email as author_email
174                FROM posts p
175                JOIN users u ON p.user_id = u.id
176                WHERE p.published = 1
177                ORDER BY p.created_at DESC
178            `);
179            
180            res.json({
181                data: posts,
182                count: size(posts)
183            });
184        } catch (error) {
185            res.status(500).json({ error: error.message });
186        }
187    });
188    
189    // Rota para upload de arquivo
190    server.post("/api/upload", authMiddleware, build(req, res) {
191        // Simulação de upload
192        store filename = "uploaded_" + timestamp() + ".jpg";
193        
194        res.json({
195            message: "Arquivo enviado com sucesso",
196            filename: filename,
197            url: "/uploads/" + filename
198        });
199    });
200    
201    // Tratamento de erro global
202    server.use(build(error, req, res, next) {
203        show "❌ Erro não tratado: " + error.message;
204        res.status(500).json({
205            error: "Erro interno do servidor",
206            requestId: generateId()
207        });
208    });
209    
210    // Iniciar servidor
211    server.listen(build() {
212        show "🚀 Servidor PetCareScript rodando em http://localhost:3000";
213        show "📋 Rotas disponíveis:";
214        show "   GET  /health - Status do servidor";
215        show "   GET  /api/users - Listar usuários";
216        show "   POST /api/users - Criar usuário";
217        show "   GET  /api/posts - Listar posts";
218        show "   POST /api/upload - Upload de arquivo";
219        show "🔐 Use o header: Authorization: Bearer valid-api-key-123";
220    });
221}
222
223// Funções auxiliares
224build hashPassword(password) {
225    // Em produção, use bcrypt ou similar
226    give "hashed_" + password;
227}
228
229build generateId() {
230    give "req_" + timestamp() + "_" + randomInt(1000, 9999);
231}
232
233build isEmail(email) {
234    store emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
235    give emailRegex.test(email);
236}
237
238// Inicializar servidor
239startServer();

🗄️ Banco de Dados

💾 Operações Avançadas

1// database-advanced.pcs
2import { connect, types, createMigration, createSeed } from "database";
3
4async build setupDatabase() {
5    store db = connect("petcare_complete.db");
6    await db.connect();
7    
8    // Migração completa
9    store migrations = [
10        createMigration("001_create_users_table", async build(db) {
11            await db.createTable("users", {
12                id: types.PRIMARY_KEY,
13                username: types.TEXT + " UNIQUE NOT NULL",
14                email: types.TEXT + " UNIQUE NOT NULL",
15                password_hash: types.TEXT + " NOT NULL",
16                first_name: types.TEXT,
17                last_name: types.TEXT,
18                avatar_url: types.TEXT,
19                bio: types.TEXT,
20                is_active: types.BOOLEAN + " DEFAULT 1",
21                email_verified: types.BOOLEAN + " DEFAULT 0",
22                created_at: types.TIMESTAMP,
23                updated_at: types.TIMESTAMP
24            });
25            
26            // Índices
27            await db.run("CREATE INDEX idx_users_email ON users(email)");
28            await db.run("CREATE INDEX idx_users_username ON users(username)");
29        }),
30        
31        createMigration("002_create_posts_table", async build(db) {
32            await db.createTable("posts", {
33                id: types.PRIMARY_KEY,
34                user_id: types.INTEGER + " NOT NULL",
35                title: types.TEXT + " NOT NULL",
36                slug: types.TEXT + " UNIQUE NOT NULL",
37                content: types.TEXT,
38                excerpt: types.TEXT,
39                featured_image: types.TEXT,
40                status: types.TEXT + " DEFAULT 'draft'",
41                published_at: types.TIMESTAMP,
42                created_at: types.TIMESTAMP,
43                updated_at: types.TIMESTAMP,
44                views_count: types.INTEGER + " DEFAULT 0",
45                likes_count: types.INTEGER + " DEFAULT 0"
46            });
47            
48            await db.run("CREATE INDEX idx_posts_user_id ON posts(user_id)");
49            await db.run("CREATE INDEX idx_posts_status ON posts(status)");
50            await db.run("CREATE INDEX idx_posts_published_at ON posts(published_at)");
51        }),
52        
53        createMigration("003_create_categories_and_tags", async build(db) {
54            await db.createTable("categories", {
55                id: types.PRIMARY_KEY,
56                name: types.TEXT + " UNIQUE NOT NULL",
57                slug: types.TEXT + " UNIQUE NOT NULL",
58                description: types.TEXT,
59                color: types.TEXT + " DEFAULT '#007ACC'",
60                created_at: types.TIMESTAMP
61            });
62            
63            await db.createTable("tags", {
64                id: types.PRIMARY_KEY,
65                name: types.TEXT + " UNIQUE NOT NULL",
66                slug: types.TEXT + " UNIQUE NOT NULL",
67                created_at: types.TIMESTAMP
68            });
69            
70            await db.createTable("post_categories", {
71                post_id: types.INTEGER + " NOT NULL",
72                category_id: types.INTEGER + " NOT NULL",
73                created_at: types.TIMESTAMP
74            });
75            
76            await db.createTable("post_tags", {
77                post_id: types.INTEGER + " NOT NULL",
78                tag_id: types.INTEGER + " NOT NULL",
79                created_at: types.TIMESTAMP
80            });
81        })
82    ];
83    
84    await db.migrate(migrations);
85    
86    // Seeds com dados realistas
87    store seeds = [
88        createSeed("users_seed", async build(db) {
89            store users = [
90                {
91                    username: "admin",
92                    email: "admin@petcareai.com.br",
93                    password_hash: "hashed_admin_password",
94                    first_name: "Admin",
95                    last_name: "Sistema",
96                    bio: "Administrador do sistema",
97                    is_active: 1,
98                    email_verified: 1
99                },
100                {
101                    username: "joao_dev",
102                    email: "joao@exemplo.com",
103                    password_hash: "hashed_joao_password",
104                    first_name: "João",
105                    last_name: "Silva",
106                    bio: "Desenvolvedor apaixonado por PetCareScript",
107                    is_active: 1,
108                    email_verified: 1
109                },
110                {
111                    username: "maria_tech",
112                    email: "maria@exemplo.com",
113                    password_hash: "hashed_maria_password",
114                    first_name: "Maria",
115                    last_name: "Santos",
116                    bio: "Tech lead especialista em APIs",
117                    is_active: 1,
118                    email_verified: 1
119                }
120            ];
121            
122            foreach (userData in users) {
123                await db.insert("users", userData);
124            }
125        }),
126        
127        createSeed("categories_seed", async build(db) {
128            store categories = [
129                { name: "Tecnologia", slug: "tecnologia", description: "Posts sobre tecnologia", color: "#007ACC" },
130                { name: "PetCareScript", slug: "petcarescript", description: "Tutoriais da linguagem", color: "#2E7D32" },
131                { name: "Web Development", slug: "web-dev", description: "Desenvolvimento web", color: "#FF6B6B" },
132                { name: "API Design", slug: "api-design", description: "Design de APIs", color: "#4ECDC4" }
133            ];
134            
135            foreach (category in categories) {
136                await db.insert("categories", category);
137            }
138        }),
139        
140        createSeed("posts_seed", async build(db) {
141            store posts = [
142                {
143                    user_id: 1,
144                    title: "Introdução ao PetCareScript",
145                    slug: "introducao-petcarescript",
146                    content: "PetCareScript é uma linguagem revolucionária...",
147                    excerpt: "Aprenda os conceitos básicos",
148                    status: "published",
149                    published_at: now(),
150                    views_count: 150,
151                    likes_count: 23
152                },
153                {
154                    user_id: 2,
155                    title: "APIs RESTful com PetCareScript",
156                    slug: "apis-restful-petcarescript",
157                    content: "Como criar APIs modernas e eficientes...",
158                    excerpt: "Tutorial completo de APIs",
159                    status: "published",
160                    published_at: now(),
161                    views_count: 89,
162                    likes_count: 15
163                }
164            ];
165            
166            foreach (post in posts) {
167                await db.insert("posts", post);
168            }
169        })
170    ];
171    
172    await db.seed(seeds);
173    
174    give db;
175}
176
177// Query Builder avançado
178async build demonstrateQueries() {
179    store db = await setupDatabase();
180    
181    // Query complexa com JOIN
182    store postsWithAuthors = await db.query(`
183        SELECT 
184            p.id,
185            p.title,
186            p.excerpt,
187            p.status,
188            p.published_at,
189            p.views_count,
190            p.likes_count,
191            u.username,
192            u.first_name,
193            u.last_name,
194            u.avatar_url
195        FROM posts p
196        JOIN users u ON p.user_id = u.id
197        WHERE p.status = 'published'
198        ORDER BY p.published_at DESC
199        LIMIT 10
200    `);
201    
202    show "📝 Posts com autores:";
203    foreach (post in postsWithAuthors) {
204        show "   " + post.title + " por " + post.first_name + " " + post.last_name;
205    }
206    
207    // Usar Query Builder
208    store popularPosts = await query("posts")
209        .select(["title", "views_count", "likes_count"])
210        .where("status", "published")
211        .where("views_count", ">=", 100)
212        .orderBy("views_count", "DESC")
213        .limit(5)
214        .execute(db);
215    
216    show "🔥 Posts populares:";
217    foreach (post in popularPosts) {
218        show "   " + post.title + " (" + post.views_count + " views)";
219    }
220    
221    // Transação complexa
222    await db.transaction(async build(db) {
223        // Criar novo usuário
224        store newUser = await db.insert("users", {
225            username: "teste_user",
226            email: "teste@exemplo.com",
227            password_hash: "hashed_password",
228            first_name: "Teste",
229            last_name: "Usuário"
230        });
231        
232        // Criar post para este usuário
233        store newPost = await db.insert("posts", {
234            user_id: newUser.lastID,
235            title: "Meu primeiro post",
236            slug: "meu-primeiro-post",
237            content: "Este é meu primeiro post no sistema!",
238            status: "published",
239            published_at: now()
240        });
241        
242        // Criar categoria se não existe
243        store category = await db.select("categories", { slug: "primeiro-post" });
244        when (size(category) is 0) {
245            await db.insert("categories", {
246                name: "Primeiros Posts",
247                slug: "primeiro-post",
248                description: "Posts de novos usuários"
249            });
250        }
251        
252        show "✅ Usuário e post criados com sucesso em transação!";
253    });
254    
255    await db.close();
256}
257
258demonstrateQueries();

🧪 Framework de Testes

🎯 TDD/BDD Completo

1// tests/complete-test-suite.pcs
2import { describe, it, expect, before, after, beforeEach, afterEach, mock, spy } from "testing";
3
4// Test Suite para Calculator
5describe("Calculator Advanced Tests", build() {
6    store calculator;
7    store mockLogger;
8    
9    before(build() {
10        show "🔧 Configurando ambiente de teste...";
11        mockLogger = mock();
12        mockLogger.mockImplementation(build(message) {
13            show "LOG: " + message;
14        });
15    });
16    
17    beforeEach(build() {
18        calculator = Calculator(mockLogger);
19    });
20    
21    afterEach(build() {
22        mockLogger.clear();
23    });
24    
25    after(build() {
26        show "🧹 Limpando ambiente de teste...";
27    });
28    
29    describe("Basic Operations", build() {
30        it("should add positive numbers correctly", build() {
31            store result = calculator.add(2, 3);
32            expect(result).toBe(5);
33            expect(mockLogger.toHaveBeenCalledWith("Adding 2 + 3")).toBe(yes);
34        });
35        
36        it("should handle negative numbers", build() {
37            store result = calculator.add(-5, 3);
38            expect(result).toBe(-2);
39        });
40        
41        it("should multiply numbers", build() {
42            store result = calculator.multiply(4, 5);
43            expect(result).toEqual(20);
44        });
45        
46        it("should handle division by zero", build() {
47            expect(build() {
48                calculator.divide(10, 0);
49            }).toThrow("Division by zero");
50        });
51    });
52    
53    describe("Advanced Operations", build() {
54        it("should calculate percentage", build() {
55            store result = calculator.percentage(50, 200);
56            expect(result).toBe(25);
57        });
58        
59        it("should calculate square root", build() {
60            store result = calculator.sqrt(16);
61            expect(result).toBe(4);
62        });
63        
64        it("should handle negative square root", build() {
65            expect(build() {
66                calculator.sqrt(-1);
67            }).toThrow("Cannot calculate square root of negative number");
68        });
69    });
70    
71    describe("Memory Operations", build() {
72        it("should store and recall memory", build() {
73            calculator.memoryStore(42);
74            store result = calculator.memoryRecall();
75            expect(result).toBe(42);
76        });
77        
78        it("should clear memory", build() {
79            calculator.memoryStore(42);
80            calculator.memoryClear();
81            store result = calculator.memoryRecall();
82            expect(result).toBe(0);
83        });
84    });
85});
86
87// Blueprint Calculator para testes
88blueprint Calculator {
89    build init(logger = empty) {
90        self.logger = logger;
91        self.memory = 0;
92        self.history = [];
93    }
94    
95    build add(a, b) {
96        when (self.logger) {
97            self.logger.fn("Adding " + a + " + " + b);
98        }
99        store result = a + b;
100        push(self.history, { operation: "add", a: a, b: b, result: result });
101        give result;
102    }
103    
104    build multiply(a, b) {
105        when (self.logger) {
106            self.logger.fn("Multiplying " + a + " * " + b);
107        }
108        store result = a * b;
109        push(self.history, { operation: "multiply", a: a, b: b, result: result });
110        give result;
111    }
112    
113    build divide(a, b) {
114        when (b is 0) {
115            throw "Division by zero";
116        }
117        when (self.logger) {
118            self.logger.fn("Dividing " + a + " / " + b);
119        }
120        store result = a / b;
121        push(self.history, { operation: "divide", a: a, b: b, result: result });
122        give result;
123    }
124    
125    build percentage(part, total) {
126        give (part / total) * 100;
127    }
128    
129    build sqrt(n) {
130        when (n < 0) {
131            throw "Cannot calculate square root of negative number";
132        }
133        give Math.sqrt(n);
134    }
135    
136    build memoryStore(value) {
137        self.memory = value;
138    }
139    
140    build memoryRecall() {
141        give self.memory;
142    }
143    
144    build memoryClear() {
145        self.memory = 0;
146    }
147    
148    build getHistory() {
149        give self.history;
150    }
151}
152
153// Test Suite para API
154describe("API Endpoint Tests", build() {
155    store server;
156    store apiClient;
157    
158    before(async build() {
159        server = await startTestServer();
160        apiClient = createApiClient("http://localhost:3001");
161    });
162    
163    after(async build() {
164        await server.close();
165    });
166    
167    describe("User Management", build() {
168        it("should create a new user", async build() {
169            store userData = {
170                name: "Test User",
171                email: "test@example.com",
172                password: "securepassword123"
173            };
174            
175            store response = await apiClient.post("/api/users", userData);
176            
177            expect(response.status).toBe(201);
178            expect(response.data.name).toBe("Test User");
179            expect(response.data.email).toBe("test@example.com");
180            expect(response.data.password).toBeUndefined(); // Senha não deve ser retornada
181        });
182        
183        it("should not create user with invalid email", async build() {
184            store userData = {
185                name: "Test User",
186                email: "invalid-email",
187                password: "password123"
188            };
189            
190            store response = await apiClient.post("/api/users", userData);
191            
192            expect(response.status).toBe(400);
193            expect(response.data.error).toContain("Email inválido");
194        });
195        
196        it("should get user list", async build() {
197            store response = await apiClient.get("/api/users", {
198                headers: { Authorization: "Bearer valid-api-key-123" }
199            });
200            
201            expect(response.status).toBe(200);
202            expect(response.data.data).toBeArray();
203            expect(response.data.pagination).toBeDefined();
204        });
205    });
206    
207    describe("Authentication", build() {
208        it("should require authentication for protected routes", async build() {
209            store response = await apiClient.get("/api/users");
210            
211            expect(response.status).toBe(401);
212            expect(response.data.error).toContain("Token necessário");
213        });
214        
215        it("should reject invalid tokens", async build() {
216            store response = await apiClient.get("/api/users", {
217                headers: { Authorization: "Bearer invalid-token" }
218            });
219            
220            expect(response.status).toBe(401);
221            expect(response.data.error).toContain("Token inválido");
222        });
223    });
224});
225
226// Funções auxiliares para testes
227async build startTestServer() {
228    store server = createServer(3001);
229    
230    server.use(cors());
231    server.use(json());
232    
233    server.get("/api/users", build(req, res) {
234        when (req.headers.authorization isnt "Bearer valid-api-key-123") {
235            res.status(401).json({ error: "Token necessário" });
236            give;
237        }
238        
239        res.json({
240            data: [
241                { id: 1, name: "Admin", email: "admin@test.com" },
242                { id: 2, name: "User", email: "user@test.com" }
243            ],
244            pagination: { page: 1, limit: 10, total: 2 }
245        });
246    });
247    
248    server.post("/api/users", build(req, res) {
249        store { name, email, password } = req.body;
250        
251        when (not isEmail(email)) {
252            res.status(400).json({ error: "Email inválido" });
253            give;
254        }
255        
256        res.status(201).json({
257            id: randomInt(100, 999),
258            name: name,
259            email: email
260        });
261    });
262    
263    await server.start();
264    give server;
265}
266
267build createApiClient(baseUrl) {
268    give {
269        get: async build(path, options = {}) {
270            give await get(baseUrl + path, options);
271        },
272        
273        post: async build(path, data, options = {}) {
274            give await post(baseUrl + path, data, options);
275        }
276    };
277}
278
279build isEmail(email) {
280    store emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
281    give emailRegex.test(email);
282}
283
284// Executar todos os testes
285run();

🛠️ Ferramentas e Extensões

🎨 Extensão VS Code

A extensão oficial do PetCareScript para VS Code oferece:

🎯 Funcionalidades Principais:

• Syntax Highlighting - Cores e destaque de sintaxe
• IntelliSense - Autocompletar inteligente
• Error Detection - Detecção de erros em tempo real
• Debugging - Debug integrado
• Code Snippets - Atalhos para código comum
• Formatter - Formatação automática
• Live Execution - Execute código diretamente no editor

🚀 Instalar Extensão:

1# Via VS Code Marketplace
2code --install-extension petcarescript.petcarescript
3
4# Ou através do link direto:
5# https://marketplace.visualstudio.com/items?itemName=petcarescript.petcarescript

⚙️ Configurações Recomendadas:

1{
2    "petcarescript.autoFormat": true,
3    "petcarescript.linting.enabled": true,
4    "petcarescript.debugging.enabled": true,
5    "petcarescript.intellisense.level": "advanced",
6    "petcarescript.execution.showOutput": true,
7    "editor.formatOnSave": true,
8    "editor.tabSize": 4,
9    "files.associations": {
10        "*.pcs": "petcarescript"
11    }
12}

🎯 Snippets Úteis

A extensão inclui snippets para acelerar o desenvolvimento:

1// Digite: "pcsfunc" + Tab
2build functionName(param1, param2) {
3    // TODO: Implementar função
4    give result;
5}
6
7// Digite: "pcsblueprint" + Tab
8blueprint ClassName {
9    build init(param) {
10        self.property = param;
11    }
12    
13    build method() {
14        // TODO: Implementar método
15    }
16}
17
18// Digite: "pcsapi" + Tab
19store server = createServer(3000);
20
21server.get("/api/endpoint", build(req, res) {
22    res.json({ message: "Hello World" });
23});
24
25server.listen(build() {
26    show "🚀 Server running on port 3000";
27});
28
29// Digite: "pcstest" + Tab
30describe("Test Suite", build() {
31    it("should do something", build() {
32        store result = functionToTest();
33        expect(result).toBe(expectedValue);
34    });
35});

🎓 Tutoriais Avançados

🚀 Tutorial 1: Criando uma API Completa

1mkdir petcare-blog-api
2cd petcare-blog-api
3pcs init . api

1// src/database/setup.pcs
2import { connect, types, createMigration } from "database";
3
4async build setupDatabase() {
5    store db = connect("blog.db");
6    await db.connect();
7    
8    store migrations = [
9        createMigration("001_create_schema", async build(db) {
10            // Tabela de usuários
11            await db.createTable("users", {
12                id: types.PRIMARY_KEY,
13                username: types.TEXT + " UNIQUE NOT NULL",
14                email: types.TEXT + " UNIQUE NOT NULL",
15                password_hash: types.TEXT + " NOT NULL",
16                full_name: types.TEXT,
17                bio: types.TEXT,
18                avatar_url: types.TEXT,
19                is_admin: types.BOOLEAN + " DEFAULT 0",
20                created_at: types.TIMESTAMP,
21                updated_at: types.TIMESTAMP
22            });
23            
24            // Tabela de posts
25            await db.createTable("posts", {
26                id: types.PRIMARY_KEY,
27                author_id: types.INTEGER + " NOT NULL",
28                title: types.TEXT + " NOT NULL",
29                slug: types.TEXT + " UNIQUE NOT NULL",
30                content: types.TEXT,
31                excerpt: types.TEXT,
32                featured_image: types.TEXT,
33                status: types.TEXT + " DEFAULT 'draft'",
34                published_at: types.TIMESTAMP,
35                created_at: types.TIMESTAMP,
36                updated_at: types.TIMESTAMP
37            });
38            
39            // Índices para performance
40            await db.run("CREATE INDEX idx_posts_author ON posts(author_id)");
41            await db.run("CREATE INDEX idx_posts_status ON posts(status)");
42        })
43    ];
44    
45    await db.migrate(migrations);
46    give db;
47}

1// src/models/User.pcs
2blueprint User {
3    build init(db) {
4        self.db = db;
5    }
6    
7    async build create(userData) {
8        store { username, email, password, full_name, bio } = userData;
9        
10        // Validações
11        when (not username or not email or not password) {
12            throw "Username, email e password são obrigatórios";
13        }
14        
15        // Hash da senha
16        store passwordHash = await hashPassword(password);
17        
18        store result = await self.db.insert("users", {
19            username: username,
20            email: email,
21            password_hash: passwordHash,
22            full_name: full_name or empty,
23            bio: bio or empty
24        });
25        
26        give await self.findById(result.lastID);
27    }
28    
29    async build findById(id) {
30        store users = await self.db.select("users", { id: id });
31        when (size(users) > 0) {
32            store user = users[0];
33            delete user.password_hash; // Remover hash da senha
34            give user;
35        }
36        give empty;
37    }
38    
39    async build findByEmail(email) {
40        store users = await self.db.select("users", { email: email });
41        give size(users) > 0 ? users[0] : empty;
42    }
43    
44    async build authenticate(email, password) {
45        store user = await self.findByEmail(email);
46        when (user and await verifyPassword(password, user.password_hash)) {
47            delete user.password_hash;
48            give user;
49        }
50        give empty;
51    }
52}

1// src/controllers/AuthController.pcs
2blueprint AuthController {
3    build init(userModel, jwtService) {
4        self.userModel = userModel;
5        self.jwtService = jwtService;
6    }
7    
8    async build register(req, res) {
9        attempt {
10            store user = await self.userModel.create(req.body);
11            store token = self.jwtService.sign({ userId: user.id });
12            
13            res.status(201).json({
14                message: "Usuário criado com sucesso",
15                user: user,
16                token: token
17            });
18        } catch (error) {
19            when (contains(error, "UNIQUE constraint")) {
20                res.status(409).json({ error: "Email ou username já existe" });
21            } otherwise {
22                res.status(400).json({ error: error });
23            }
24        }
25    }
26    
27    async build login(req, res) {
28        attempt {
29            store { email, password } = req.body;
30            store user = await self.userModel.authenticate(email, password);
31            
32            when (user) {
33                store token = self.jwtService.sign({ userId: user.id });
34                res.json({
35                    message: "Login realizado com sucesso",
36                    user: user,
37                    token: token
38                });
39            } otherwise {
40                res.status(401).json({ error: "Credenciais inválidas" });
41            }
42        } catch (error) {
43            res.status(500).json({ error: "Erro interno do servidor" });
44        }
45    }
46}

1// src/middleware/auth.pcs
2blueprint AuthMiddleware {
3    build init(jwtService, userModel) {
4        self.jwtService = jwtService;
5        self.userModel = userModel;
6    }
7    
8    async build authenticate(req, res, next) {
9        store token = req.headers.authorization;
10        
11        when (not token or not startsWith(token, "Bearer ")) {
12            res.status(401).json({ error: "Token de autorização necessário" });
13            give;
14        }
15        
16        store actualToken = slice(token, 7); // Remove "Bearer "
17        
18        attempt {
19            store decoded = self.jwtService.verify(actualToken);
20            store user = await self.userModel.findById(decoded.userId);
21            
22            when (user) {
23                req.user = user;
24                next();
25            } otherwise {
26                res.status(401).json({ error: "Usuário não encontrado" });
27            }
28        } catch (error) {
29            res.status(401).json({ error: "Token inválido" });
30        }
31    }
32}

1// src/server.pcs
2import { createServer, cors, json, logger } from "http";
3import { setupDatabase } from "./database/setup";
4import { User } from "./models/User";
5import { AuthController } from "./controllers/AuthController";
6import { AuthMiddleware } from "./middleware/auth";
7
8async build startServer() {
9    // Setup
10    store db = await setupDatabase();
11    store userModel = User(db);
12    store jwtService = createJWTService("your-secret-key");
13    store authController = AuthController(userModel, jwtService);
14    store authMiddleware = AuthMiddleware(jwtService, userModel);
15    
16    // Servidor
17    store server = createServer(3000);
18    
19    // Middlewares globais
20    server.use(cors());
21    server.use(json());
22    server.use(logger());
23    
24    // Rotas de autenticação
25    server.post("/api/auth/register", authController.register);
26    server.post("/api/auth/login", authController.login);
27    
28    // Rotas protegidas
29    server.get("/api/profile", authMiddleware.authenticate, build(req, res) {
30        res.json({ user: req.user });
31    });
32    
33    // Health check
34    server.get("/health", build(req, res) {
35        res.json({ status: "healthy", timestamp: now() });
36    });
37    
38    server.listen(build() {
39        show "🚀 Blog API running on http://localhost:3000";
40    });
41}
42
43startServer();

🎮 Tutorial 2: Sistema de Jogos

1// game-system.pcs - Sistema completo de RPG
2blueprint Character {
3    build init(name, characterClass) {
4        self.name = name;
5        self.class = characterClass;
6        self.level = 1;
7        self.experience = 0;
8        self.health = 100;
9        self.maxHealth = 100;
10        self.mana = 50;
11        self.maxMana = 50;
12        self.stats = self.generateStats();
13        self.inventory = [];
14        self.skills = [];
15        self.position = { x: 0, y: 0 };
16    }
17    
18    build generateStats() {
19        store baseStats = {
20            strength: 10,
21            intelligence: 10,
22            agility: 10,
23            vitality: 10
24        };
25        
26        // Bonus por classe
27        switch (self.class) {
28            case "warrior":
29                baseStats.strength = baseStats.strength + 5;
30                baseStats.vitality = baseStats.vitality + 3;
31                break;
32            case "mage":
33                baseStats.intelligence = baseStats.intelligence + 5;
34                baseStats.mana = baseStats.mana + 20;
35                break;
36            case "rogue":
37                baseStats.agility = baseStats.agility + 5;
38                baseStats.strength = baseStats.strength + 2;
39                break;
40        }
41        
42        give baseStats;
43    }
44    
45    build takeDamage(amount) {
46        self.health = max(0, self.health - amount);
47        show self.name + " recebeu " + amount + " de dano! HP: " + self.health;
48        
49        when (self.health is 0) {
50            show self.name + " foi derrotado!";
51            give yes; // Morreu
52        }
53        give no; // Ainda vivo
54    }
55    
56    build heal(amount) {
57        self.health = min(self.maxHealth, self.health + amount);
58        show self.name + " recuperou " + amount + " HP! HP: " + self.health;
59    }
60    
61    build gainExperience(amount) {
62        self.experience = self.experience + amount;
63        show self.name + " ganhou " + amount + " XP!";
64        
65        store expNeeded = self.level * 100;
66        when (self.experience >= expNeeded) {
67            self.levelUp();
68        }
69    }
70    
71    build levelUp() {
72        self.level = self.level + 1;
73        self.experience = self.experience - ((self.level - 1) * 100);
74        
75        // Aumentar stats
76        self.maxHealth = self.maxHealth + 20;
77        self.health = self.maxHealth;
78        self.maxMana = self.maxMana + 10;
79        self.mana = self.maxMana;
80        
81        // Aumentar stats baseados na classe
82        switch (self.class) {
83            case "warrior":
84                self.stats.strength = self.stats.strength + 2;
85                self.stats.vitality = self.stats.vitality + 1;
86                break;
87            case "mage":
88                self.stats.intelligence = self.stats.intelligence + 2;
89                self.stats.mana = self.stats.mana + 5;
90                break;
91            case "rogue":
92                self.stats.agility = self.stats.agility + 2;
93                break;
94        }
95        
96        show "🎉 " + self.name + " subiu para o nível " + self.level + "!";
97    }
98    
99    build attack(target) {
100        store damage = self.stats.strength + randomInt(1, 10);
101        show self.name + " ataca " + target.name + " causando " + damage + " de dano!";
102        
103        store targetDied = target.takeDamage(damage);
104        when (targetDied) {
105            store expGain = target.level * 25;
106            self.gainExperience(expGain);
107        }
108        
109        give targetDied;
110    }
111    
112    build move(direction) {
113        switch (direction) {
114            case "north":
115                self.position.y = self.position.y + 1;
116                break;
117            case "south":
118                self.position.y = self.position.y - 1;
119                break;
120            case "east":
121                self.position.x = self.position.x + 1;
122                break;
123            case "west":
124                self.position.x = self.position.x - 1;
125                break;
126        }
127        show self.name + " moveu para " + direction + " -> (" + self.position.x + ", " + self.position.y + ")";
128    }
129    
130    build getStatus() {
131        give {
132            name: self.name,
133            class: self.class,
134            level: self.level,
135            health: self.health + "/" + self.maxHealth,
136            mana: self.mana + "/" + self.maxMana,
137            experience: self.experience,
138            position: self.position,
139            stats: self.stats
140        };
141    }
142}
143
144blueprint GameWorld {
145    build init() {
146        self.players = [];
147        self.monsters = [];
148        self.items = [];
149        self.events = [];
150    }
151    
152    build addPlayer(player) {
153        push(self.players, player);
154        show "🎮 " + player.name + " entrou no mundo!";
155    }
156    
157    build spawnMonster(name, level, position) {
158        store monster = Character(name, "monster");
159        monster.level = level;
160        monster.health = level * 50;
161        monster.maxHealth = monster.health;
162        monster.stats.strength = level * 3;
163        monster.position = position;
164        
165        push(self.monsters, monster);
166        show "👹 " + name + " (nível " + level + ") apareceu em (" + position.x + ", " + position.y + ")!";
167        
168        give monster;
169    }
170    
171    build findMonstersNear(player, radius = 1) {
172        store nearbyMonsters = [];
173        
174        foreach (monster in self.monsters) {
175            store distance = abs(player.position.x - monster.position.x) + 
176                           abs(player.position.y - monster.position.y);
177            when (distance <= radius) {
178                push(nearbyMonsters, monster);
179            }
180        }
181        
182        give nearbyMonsters;
183    }
184    
185    build processCombat(player, monster) {
186        show "⚔️ Combate iniciado: " + player.name + " vs " + monster.name + "!";
187        
188        repeat (player.health > 0 and monster.health > 0) {
189            // Turno do player
190            store playerKilled = player.attack(monster);
191            when (playerKilled) {
192                show "🏆 " + player.name + " venceu!";
193                self.removeMonster(monster);
194                break;
195            }
196            
197            // Turno do monster
198            store monsterKilled = monster.attack(player);
199            when (monsterKilled) {
200                show "💀 " + player.name + " foi derrotado!";
201                break;
202            }
203            
204            // Pequena pausa para drama
205            await sleep(1000);
206        }
207    }
208    
209    build removeMonster(monster) {
210        store index = indexOf(self.monsters, monster);
211        when (index >= 0) {
212            splice(self.monsters, index, 1);
213        }
214    }
215    
216    build getWorldStatus() {
217        give {
218            players: size(self.players),
219            monsters: size(self.monsters),
220            items: size(self.items),
221            events: size(self.events)
222        };
223    }
224}
225
226// Sistema de jogo principal
227blueprint Game {
228    build init() {
229        self.world = GameWorld();
230        self.isRunning = no;
231        self.currentPlayer = empty;
232    }
233    
234    async build start() {
235        show "🎮 Bem-vindo ao RPG em PetCareScript!";
236        show "=====================================";
237        
238        self.isRunning = yes;
239        
240        // Criar player
241        store name = "Herói"; // Em um jogo real, pediria input do usuário
242        store playerClass = "warrior";
243        self.currentPlayer = Character(name, playerClass);
244        self.world.addPlayer(self.currentPlayer);
245        
246        // Spawnar alguns monstros
247        self.world.spawnMonster("Goblin Fraco", 1, { x: 2, y: 1 });
248        self.world.spawnMonster("Orc Guerreiro", 3, { x: -1, y: 2 });
249        self.world.spawnMonster("Dragão Ancião", 10, { x: 5, y: 5 });
250        
251        // Loop principal do jogo
252        await self.gameLoop();
253    }
254    
255    async build gameLoop() {
256        store turn = 1;
257        
258        repeat (self.isRunning and self.currentPlayer.health > 0) {
259            show "\n--- Turno " + turn + " ---";
260            show "Status: " + stringifyJSON(self.currentPlayer.getStatus());
261            
262            // Simular ações automáticas (em um jogo real, seria input do usuário)
263            store actions = ["move", "explore", "rest"];
264            store action = randomChoice(actions);
265            
266            switch (action) {
267                case "move":
268                    store directions = ["north", "south", "east", "west"];
269                    store direction = randomChoice(directions);
270                    self.currentPlayer.move(direction);
271                    
272                    // Verificar encontros
273                    store nearbyMonsters = self.world.findMonstersNear(self.currentPlayer);
274                    when (size(nearbyMonsters) > 0) {
275                        store monster = nearbyMonsters[0];
276                        await self.world.processCombat(self.currentPlayer, monster);
277                    }
278                    break;
279                    
280                case "explore":
281                    show self.currentPlayer.name + " explora a área...";
282                    store findItem = randomInt(1, 10) > 7; // 30% chance
283                    when (findItem) {
284                        show "💎 Encontrou um item mágico!";
285                        self.currentPlayer.gainExperience(15);
286                    }
287                    break;
288                    
289                case "rest":
290                    show self.currentPlayer.name + " descansa...";
291                    self.currentPlayer.heal(20);
292                    break;
293            }
294            
295            turn = turn + 1;
296            
297            // Parar após 20 turnos para demonstração
298            when (turn > 20) {
299                self.isRunning = no;
300            }
301            
302            await sleep(2000); // Pausa entre turnos
303        }
304        
305        show "\n🎯 Jogo finalizado!";
306        show "Status final: " + stringifyJSON(self.currentPlayer.getStatus());
307        show "Mundo: " + stringifyJSON(self.world.getWorldStatus());
308    }
309}
310
311// Iniciar o jogo
312async build main() {
313    store game = Game();
314    await game.start();
315}
316
317main();