邱宇

Create a food review website that utilizes Vue.js as the front-end framework, with Vue Router for routing management and Vuex for state management. Regular users can view lists of food recommendations from various locations, filter by food type, and also view detailed information about the food, including descriptions, ratings, and reviews. The website can support intelligent sorting of food items based on criteria such as click-through rates. All users can post forum topics, reply to existing topics, and also edit and delete their own posts. Administrators can manage forum posts and remove inappropriate content.

mplement a simplified animatronic game mimicking the mechanics and core features of Five Nights at Freddy's 4 (FNAF 4).
The game includes four animatronic characters: Nightmare Bonnie, Nightmare Chica, Nightmare Freddy, and Nightmare Foxy.
A flashlight system that can be toggled or flashed a specific number of times.
A door system on the left and right sides—the left door is associated with Nightmare Bonnie, and the right door is also associated with Nightmare Bonnie.
A closet system where approaching the closet triggers the appearance of Nightmare Foxy; flashing the flashlight three times will make Foxy leave.
A "Freddles" system where a plush toy is placed behind the player; after the flashlight is flashed 5 times, the Freddles will disappear one by one, but if the player reacts too slowly, Nightmare Freddy will jumpscare them.
Closing the doors can repel Nightmare Bonnie and Nightmare Chica, forcing them to retreat.

Classic Arcade Game: Create a standalone HTML file that includes both CSS and JavaScript to generate a Block Breaker game with Canvas rendering.

The game will showcase the following core modules through object-oriented design and physical simulation:

1. **Object-oriented design**: Define game objects using classes or constructors, including `Paddle` (racket), `Ball` (ball), `Brick` (brick), and `Score` (score system). These objects encapsulate their respective properties (position, speed) and methods (drawing, updating).
2. **Canvas Rendering and Game Loop**: Use HTML5 Canvas to draw all game elements. Implement a smooth animation loop using `requestAnimationFrame` to update object states and redraw within the loop.
3. **Physics and Collision System**: Implement the trajectory of small balls and integrate a collision detection system to accurately handle collisions and rebound logic between the balls and bricks, rackets, and the edges of the canvas.
4. **Game State and Interaction Controls**: Manage game states (start, pause, finish, restart), and provide interactive features such as mouse movement, directional key control for the racket, and the spacebar for pausing/resuming.
5. **Difficulty and Progression**: Design a system for calculating scores and implement mechanisms that increase difficulty as the game progresses (e.g., by speeding up the movement of the ball).

The interface features a classic arcade style, with all code integrated into a single file. JavaScript is focused on object modeling, physical simulation, collision algorithms, and state control to enable an expandable brick-breaking gameplay experience.

Craft a portfolio website for an architect with a modern and minimalist style, featuring clean lines, grid-based layouts, and showcasing their portfolio of architectural designs with stunning visual representations. Utilize a monochromatic color scheme, bold geometric shapes, and incorporate interactive 3D models or virtual tours to immerse visitors in the architectural projects.

Develop a portfolio website for a fashion designer that exudes elegance and sophistication, using a dark and moody color palette (e.g., deep purples, rich blacks), sleek typography with a mix of serif and sans-serif fonts, and incorporating parallax scrolling effects to create a sense of depth. Integrate video backgrounds or subtle animations to highlight the movement and texture of fabrics.

Design a portfolio website for a photographer with a minimalist style, focusing on clean lines, ample white space, and emphasizing the visual impact of high-quality imagery through large, full-screen photo backgrounds, grid-based image galleries with minimal captions, and elegant typography that complements the aesthetics of the photographs.

Create a portfolio website for a graphic designer that showcases their bold and vibrant style, incorporating eye-catching animations and transitions, vivid color schemes (such as neon and contrasting hues), and unconventional layouts with asymmetrical design elements. Experiment with bold typography and dynamic shapes to create an energetic and visually engaging experience.

Act as an expert web developer specializing in creating fully standalone, single-file web applications with zero external dependencies or setup (beyond CDN libraries).

Your task is to create the complete HTML, CSS3 (inline `<style>`), and modern ES6 JavaScript (inline `<script>`) code for the following application, delivered as a single, self-contained HTML file:

**App Title:** Live CSV Dashboard Builder

**Main Purpose:** Upload CSV data and interactively build a dashboard with multiple linked charts (bar, line, pie, scatter).

**Key Features to Implement:**
* CSV upload (PapaParse)
* Column selection for axes/values
* Chart type selection per panel
* Dynamic filtering controls (sliders, dropdowns)
* Dashboard layout persistence (LocalStorage)
* Chart image export
* Glassmorphism UI panels
* Ability to handle user input via interactive controls (sliders, forms, buttons, drag-drop, etc., as appropriate).
* Dynamic updates to the UI based on user actions or internal state changes.
* Client-side data processing and logic as required by the features.
* Data persistence using LocalStorage where appropriate (e.g., saving user settings, data, or state).
* File input using FileReader API if data import (like CSV) is explicitly mentioned or implied.
* File output/download using Blobs if data/image/file export is explicitly mentioned or implied.

**Primary Libraries to Use (via Zero-Config CDN):**
* Chart.js (use latest zero-config CDN link)
* PapaParse (use latest zero-config CDN link)
* Ensure all external libraries are loaded via reliable, versioned CDN links (e.g., from cdnjs, jsdelivr, unpkg).

**Technical & Style Requirements:**
* **Single File:** All HTML, CSS, and JavaScript MUST be contained within a single `.html` file. CSS must be within `<style>` tags in the `<head>`, and JavaScript within `<script>` tags near the end of the `<body>`. Use ES6 modules within the script tag if it helps organize complex code.
* **Zero Setup:** The app must run directly when the HTML file is opened in a modern browser (Chrome, Firefox, Edge). No build steps, installations, or API keys allowed.
* **Modern Code:** Use HTML5 semantic elements, modern CSS3 features (Flexbox/Grid for layout), and ES6+ JavaScript syntax (const/let, arrow functions, classes, async/await where appropriate).
* **Visual Polish:** Implement a clean, modern, and responsive UI. Incorporate CSS3 Glassmorphism effects (subtle background blur and transparency on relevant containers, panels, or modals) for a contemporary aesthetic. Ensure good readability, contrast, and usability across different screen sizes.
* **Complexity & Interactivity:** The implementation should match the complexity implied by the features, comparable to an advanced interactive tool or dashboard. Ensure the app feels responsive and interactive.
* **Error Handling:** Include basic client-side error handling (e.g., for file parsing issues, invalid user input, potential API errors if using browser APIs).
* **Comments:** Add comments to explain key sections and complex logic within the JavaScript code.

Generate the complete HTML file content starting with `<!DOCTYPE html>` and ending with `</html>`. Ensure the code is well-formatted and functional.

Billiards Simulation Game: Create a standalone HTML file containing CSS and JavaScript to generate a billiards game based on Canvas and a simple physics engine.
The game must display the following core modules through mouse interaction and vector mathematics:
Canvas Physics Rendering System: Use HTML5 Canvas to draw the table, pockets, and multiple balls, implementing smooth ball movement animation via requestAnimationFrame.
Mouse Interaction & Shot Control: Listen for mousedown, mousemove, and mouseup events to enable a complete interaction flow: clicking the cue ball, dragging to determine shot direction and power, and releasing to strike. Provide an aiming guideline/ghost line.
Simple Physics Engine: The core includes collision detection (ball-to-ball, ball-to-boundary), reflection angle calculations based on vector math, and friction simulation to produce basic realistic motion.
Game State & Scoring: Manage the game state. When the target ball is potted, increment the score, and potentially implement logic for resetting the cue ball.
The interface should use a classic green table style, with all code consolidated into a single file. JavaScript must focus on vector mathematics, collision logic, and event handling to achieve an interactive physics simulation game.

Frog Feeding Arcade Game: Create a standalone HTML file containing CSS and JavaScript to generate a Frog-eats-Fly arcade game based on Canvas.
The game must display the following core modules through keyboard control and a game loop:
Canvas Rendering System: Use HTML5 Canvas as the primary rendering surface, drawing basic shapes such as the frog (player) and flies (targets) using methods like fillRect.
Object-Oriented Design: Define game objects (e.g., Frog, Fly) using JavaScript classes or constructor functions, encapsulating properties such as position, velocity, state, and drawing methods.
Game Loop & State Management: Utilize requestAnimationFrame to implement a smooth main game loop that updates object positions, detects collisions, and redraws the scene. Manage global states such as score and lives.
Keyboard Interaction & Collision Detection: Listen for left and right arrow key events to control the frog's horizontal movement. Implement simple rectangular bounding box collision detection to determine if the frog has eaten a fly, updating the score or lives accordingly.
Core Game Logic: Flies spawn at random positions at the top of the canvas and fall downwards. The player must control the frog to catch them. The score increases for each fly caught, while lives decrease if a fly is missed. The game ends when lives are depleted.
The interface should adopt a minimalist Canvas graphics style, with all code consolidated into a single file. JavaScript should focus on object management, physics simulation, and event response to achieve a lightweight feeding challenge experience.

AI-Assisted Space Survival Game: Create a standalone HTML file containing CSS and JavaScript to generate an "Avoid the Asteroids" Canvas mini-game rapidly developed with an AI programming assistant (e.g., Trae).
The interface must implement the following core modules through Canvas rendering and keyboard event driving:
Player & Asteroid System: Define a player spaceship object (containing coordinates, velocity) and an array of asteroids. Asteroids spawn randomly at the top of the screen with varying sizes, speeds, and colors, descending linearly.
Dual-Mode Control & Boundaries: Support spaceship movement in eight directions within the canvas using both WASD and arrow keys, with boundary detection to prevent the ship from exiting the screen.
Collision Detection & Game State: Implement Axis-Aligned Bounding Box (AABB) collision detection. The game ends immediately if the spaceship collides with any asteroid. Manage and switch between three states: start, playing, and game over.
Scoring & Visual Feedback: Track the score based on the number of asteroids successfully passed (reaching the bottom of the screen). Visually render a triangular spaceship and irregular polygon asteroids using Canvas.
Game Loop & Control: Drive the main game loop (containing state updates, collision detection, and drawing) using requestAnimationFrame, and provide start and restart buttons for control.
The interface must use a deep-space black theme with neon green accents, with all code consolidated into a single file.

Canvas Game: Create a standalone HTML file containing CSS and JavaScript to generate a modern Breakout game assisted by an AI assistant (e.g., Trae).
The interface must implement the following core modules through Canvas high-definition rendering and responsive control:
High-Definition Rendering System: The Canvas adapts to the window.devicePixelRatio (DPR) by dynamically obtaining it, sets the physical size and CSS style, and uses ctx.scale(dpr, dpr) to ensure crisp drawing on all screens.
Modular Game Objects: Define the paddle (paddle), ball (ball), and a 2D array of bricks (bricks) using object literals, and encapsulate a brick initialization function (createBricks).
Intelligent Collision & Game Logic: Implement collision detection based on Axis-Aligned Bounding Boxes (AABB). Upon hitting a brick, increment the score and increase the speed level; integrate life (lives) management and game-over conditions.
Multi-Channel Input Control: Support paddle movement control simultaneously via keyboard (arrow keys), mouse movement, and touch events designed for mobile devices.
Main Game Loop & State Control: Drive a loop containing drawing, updating, and detection using requestAnimationFrame, and provide buttons for state control such as start, pause, and reset.
The interface must use a modern CSS variable theme, with all code consolidated into a single file. The JavaScript should focus on physics simulation and state management

Modern Frontend Engineering Project: Gomoku Game — Create a single-page application based on Vue3 + TypeScript + Vite to generate a modularized, type-safe Gomoku game.
The application must display the following core modules using Composition API and reactive data:
Board Component (GomokuBoard.vue): Render a 15×15 board using Canvas or CSS Grid, listen for moves via the @click event, and accept boardData and currentPlayer as Props.
Game Logic Composable (useGomoku.ts): Encapsulate reactive states (2D board array, current player, move history), core methods (move validation makeMove, win detection checkWin, undo undo), and computed properties (win status).
UI Control Layer (App.vue): Integrate the board component, functional buttons (restart, undo, mode switch), and a status panel (current player, win info), implementing interactions by calling the useGomoku composable.
Engineering Configuration: Vite build tool, TypeScript type definitions (e.g., BoardState, Player enum), and SCSS modular styling (global variables, board themes).
The interface requires a modern minimalist design (dark board, piece shadows, interactive animations), with all code organized according to Vue SFC standards. TypeScript must define board state interfaces and implement directional traversal algorithms,  achieving an engineering-oriented and maintainable chess application.

Create a small tool that can record one’s emotional state, and name it MoodPixel.
The style is exactly what I like – minimalist, pixel-based, with a card-like feel.
The background features a white base with a gray, pixelated grid effect.
At the top is a pixel art title: “MoodPixel Daily Mood Grid.”
The central section displays a grid of mood indicators for each month. Swipe left or right to view 7 indicators per row.
The grid consists of a single color (representing an emotion) paired with an Emoji (representing a facial expression).
Clicking on a cell allows editing. A dialog box appears for modifying emojis, colors, and notes.
Two buttons at the bottom of the page: Today’s Mood, Export Image.
Overall, it somewhat resembles a “emotional pixel calendar,” but it does not display specific dates; instead, it functions more like a way to express one’s emotions through color.

Create a library homepage.
The basic components of the homepage:
Top section: full-screen gradient background + customizable navigation bar + search bar.
Mid section: Carousel images, categorical navigation, Continue Reading, Popular Recommendations, Daily Recommendations, Newly Added Items.
Bottom: Reading Rankings + Load More + Floating Navigation Bar
The full-screen background features a gradient from deep purple to indigo, complemented by particle effects, giving it a sense of profound futurism.
The card borders of all modules feature subtle transparency and blurring, creating a simulated glass-like texture.
The categorization navigation features icons, names, and gradient-colored backgrounds, combining recognizability with a futuristic feel.

A web watermark generator called WaterStamp.
This small tool is primarily used to add watermarks to web pages or images, facilitating copyright protection.
In a legalistic tone.
1. Watermark generation (text, color, angle, transparency adjustable) with various modes (full-page repetition, diagonal lines, corner logos).
2. Real-time preview
3. Export functionality.
4. Save the configuration template.

Create a page for categorizing books, allowing users to view books under different categories.
Gradient background color scheme (ranging from indigo to deep purple), background layer with a blurred filter applied.
All modules feature glass-like card-style designs.
The search bar is a rounded card with a semi-transparent, blurry background, accompanied by icons on the left and placeholder text. Clicking it will take you to the search page.
The categorization navigation supports horizontal scrolling. The text in tabs automatically adapts to the width. The background is highlighted when activated, with a gradient of font colors and a zoom animation.
Under each category, there is a horizontally scrollable group of book cards, each featuring the cover, title, rating, and a small label. Keywords such as “Best Seller” and “New Release” are highlighted within the cards.
Categories can be filtered, and support is provided for publication year and rating range. The filtering floating window, which is constructed using a fuzzy background, can be scrolled up and down smoothly.

Create a small tool for batch encryption of PDF files.
Project Overview
A simple Python tool for batch-encrypting PDF files, ensuring the security of your documents.
Functional features.
Batch encryption of multiple PDF files.
Support for setting user passwords and owner passwords.
Encryption strength can be customized (128-bit or 256-bit AES encryption).
Preserve the original file structure.
A simple command-line interface.

PDF to Image Converter Tool
A simple local tool for converting PDF files into image formats (such as PNG, JPEG, etc.).
Functional features.
Supports batch conversion of PDF files.
Adjustable resolution of the output image (DPI).
Supports multiple output formats (PNG, JPEG, TIFF, etc.) while preserving the original PDF’s page order. Lightweight and can be used without an internet connection.

Develop a tool for adding local watermarks.
Functions:
1. Choose “Add Image” or simply drag the image into the window.
2. Choose the type of watermark (text/image).
3. Set the watermark parameters.
4. Select the output directory.
5. Click the “Start Processing” button.
6. After processing is complete, view the results in the output directory.

Develop a tool for converting images into sketches/hand drawings.
Functional Features
Convert colored images to a black-and-white sketch style, with the ability to adjust the intensity of the sketch effect.
The simple and user-friendly command-line interface supports input and output of various common image formats.

Create a lightweight local image compression tool that doesn’t require uploading to the cloud. Process images directly on your computer, preserving privacy while reducing the file size of the images.
Functional features.
Supports common image formats: JPG/JPEG, PNG, WEBP, and others.
Quick batch processing of multiple images.
100% local processing; no data is uploaded.
Adjustable compression quality parameters.
Maintain the original file structure.

A user-friendly video merging tool that allows you to combine multiple video files into a single complete video file. It supports common video formats (MP4, AVI, MOV, etc.) and features an intuitive user interface and basic video processing capabilities.
Functional features.
Multi-format support: Supports common video formats such as MP4, AVI, MOV, MKV, etc.
Lossless merging: Merge the videos while preserving their original quality.
Easy to Use: Drag-and-drop interface; merge process completed with just one click.
Progress display: Real-time display of the merging progress and estimated remaining time.
Output Settings: The resolution, frame rate, and bitrate of the output video can be customized.

A small tool for real-time browsing of local internet speeds.
The network speed monitoring tool allows for real-time monitoring of upload and download speeds, enabling users to stay informed about the network’s operational status at all times. By simply opening the monitoring tool, users can visually see the current network speed values. The real-time monitoring enables users to promptly detect any abnormal changes in network speed.
Functional features.
Real-time network connectivity monitoring: delay statistics (average/minimum/maximum latency).
Packet loss rate calculation.
Multi-target monitoring (supports monitoring multiple IPs/domains simultaneously) Bandwidth usage monitoring
Customizable threshold alerting.
Historical data records (optional) – a mobile-friendly interface.