Coding

Create an advanced prompt for enhancing the 'jobcreator' script interface, ensuring all progress bars, buttons, and UI elements fully match the overall theme. Add a new 'Community' tab where players who have purchased the script can share and browse jobs created by others. When a user creates a job, prompt them that the job is ready to edit, providing multiple tabs for different features such as crafting tables and other relevant elements. Use the 'Lunar Jobcreator' as a reference example to design the best possible job creation and editing experience.

Create a highly advanced, aesthetically pleasing, and very interactive level-up system represented in JSON format. The system should include detailed parameters such as experience points, levels, rewards, skill upgrades, milestones, and user progression mechanics. It should allow for customization and scalability, enabling users to track progress visually and interact with various elements dynamically. # Steps 1. Define the structure of the JSON including keys for levels, experience required per level, rewards, skill trees, and interactive elements. 2. Ensure the JSON supports aesthetic properties such as colors, animations, and badges to enhance interactivity. 3. Include examples of user progression, such as milestones or achievements. 4. Design the system to be scalable for a large number of levels and various types of rewards or skills. 5. Provide clear documentation comments within the JSON or as part of the response to explain each component. # Output Format Provide the complete JSON code that encompasses all elements of the level-up system in a clearly formatted, indented structure. Include any necessary comments or notes explaining the purpose of key sections in the system. # Notes - The JSON should be designed to easily integrate with interactive UI systems. - Prioritize clarity and scalability. - Ensure the design supports both visual and functional interactivity for the user.

Create a fully functional MQL5 trading strategy expert advisor (EA) that implements the advanced liquidity grab and order flow methodology as detailed below. This EA should be ready to copy, paste, and run without further modification, designed to open trades based on the following comprehensive rules and logic. --- **Trading Sessions:** - Only trade during London (07:00 – 11:00 UTC) and New York (12:00 – 16:00 UTC) sessions. **Liquidity Concepts:** - *External Liquidity:* Prior day's high/low and clear swing highs/lows; look for liquidity grabs (sweep wicks beyond these levels). - *Internal Liquidity:* Equal highs/lows and minor pullbacks inside the current range; targets for take profit (TP1) or break of structure (BOS) context. **Key Price Action Elements:** - Confirm overall market trend direction (bullish or bearish). - Identify order blocks (OB) or imbalance areas (FVG – Fair Value Gaps) aligned with the trend. - Detect external liquidity grabs by sweeping previous swing highs/lows with stop hunt wicks. - Confirm Break of Structure (BOS) on a 5-minute timeframe after the sweep. - Draw the breaker block as the last opposite candle before BOS (supply/demand zone). - Use Fibonacci retracement on the impulse leg (start of sweep to end of BOS), focusing on levels 0.500, 0.620, 0.705, 0.790. - Entry zone confluence: breaker block + Fibonacci 0.705–0.790 levels. **Entry Types:** 1. Limit Entry: - Place Buy/Sell Limit orders inside breaker block + Fibonacci zone. - Stop Loss (SL) just beyond the breaker block wick. - Take Profits: TP1 at nearest internal liquidity, TP2 at next external liquidity, optional TP3 at 1H order block or higher timeframe support/resistance zone. 2. Confirmation Entry: - Use a 1-minute timeframe boost setup or micro BOS inside the breaker block. - SL behind micro order block. **Order Management:** - Partial profit-taking or trailing stop beyond a 1:3 risk-to-reward ratio. **Checklist Before Every Trade:** - Confirm session timing. - Confirm external liquidity grab occurred. - Confirm BOS opposite to liquidity sweep. - Confirm breaker block + Fibonacci zone (0.705–0.790) present. - Select entry type (limit or confirmation). - Confirm SL placement tight behind zone or OB. - Set TP at internal and external liquidity levels. **Supplemental Concepts:** - *CHoCH (Change of Character):* First structure break opposite to trend after liquidity grab, signaling early reversal. - *Imbalance (Fair Value Gap):* Mark 3-candle patterns without wick overlap; price often returns to fill these gaps. - *Volume Confirmation:* Optional use of tick volume spikes during liquidity grabs and BOS to validate trade intent and entry timing. **Implementation Requirements:** - The EA must handle multi-timeframe analysis (1-min and 5-min) within MQL5. - Automatically identify and maintain structural elements (OB, FVG, liquidity zones). - Robust risk management with defined SL and TP levels. - Clear, efficient, and maintainable code with comments explaining key logic blocks. # Steps 1. Detect current timeframe and session applicability. 2. Analyze previous swing highs and lows for external liquidity zones. 3. Detect liquidity sweep wicks beyond swing highs or lows. 4. Confirm BOS on 5-min timeframe in direction opposite sweep. 5. Identify breaker block candle prior to BOS. 6. Draw Fibonacci retracement of impulse leg from sweep start to BOS end. 7. Confirm confluence zone (breaker block + Fibonacci 0.705–0.790). 8. Decide entry type: limit order within confluence zone or confirmation entry on 1-min micro BOS/boost. 9. Set SL and TP1/TP2 (and optional TP3) accordingly. 10. Monitor trade for partial exit or trailing stop after 1:3 risk:reward. # Output Format Provide a complete MQL5 Expert Advisor source code implementing the above strategy that can be compiled and tested immediately. Include comprehensive comments detailing the logic for each key segment, variables, and functions used. --- This EA should enable professional-level, automated order flow trading based on liquidity grabs, structure breaks, and confluence zones as described.

You are an advanced Lua code deobfuscation assistant. Your task is to analyze and transform obfuscated Lua scripts into clean, readable, and well-structured code. When given an obfuscated Lua snippet, follow these steps: 1. Analyze the code to understand its functionality and behavior. 2. Identify obfuscation techniques such as variable renaming, string encoding, function wrapping, control flow obfuscation, or junk code insertion. 3. Simplify the code by renaming variables and functions to meaningful names based on their usage. 4. Decode any encoded or encrypted strings and replace them with their original form. 5. Remove any redundant or dead code. 6. Refactor the code into a clean and modular structure, adding comments for clarity where appropriate. Always provide a step-by-step explanation of your reasoning before presenting the deobfuscated code. Ensure that the final output maintains the original code's behavior and logic. If the code is large, break your explanation and output into manageable sections. # Output Format - Begin with a detailed explanation of your analysis and deobfuscation steps. - Present the cleaned and deobfuscated Lua code enclosed in triple backticks with the language specified as `lua`. - Use clear and descriptive variable/function names. - Include comments in the code where helpful to explain non-obvious parts. # Notes - If some parts remain ambiguous, clearly state your assumptions. - Prioritize readability and maintainability in your deobfuscated code. - Never omit parts of the code; ensure completeness unless some parts are clearly unreachable or irrelevant.

Create a highly advanced obfuscation method to protect user-written Lua code from easy readability and reverse engineering. The obfuscation should make the code difficult to understand while preserving its original functionality exactly. Guidelines: - Use multiple layers of obfuscation including but not limited to variable renaming with non-meaningful names, control flow flattening, string encoding or encryption, and minimization. - Avoid any changes to the code's behavior or outputs; the obfuscated code must produce the exact same results as the original. - Provide explanations or comments describing each obfuscation step only if asked; otherwise, deliver only the obfuscated code. # Steps 1. Accept the original Lua code as input. 2. Apply variable and function renaming to meaningless identifiers. 3. Use control flow transformations to flatten or complicate the logic. 4. Encode or encrypt string literals in the code. 5. Minify the code by removing unnecessary whitespace and formatting. 6. Assemble the final obfuscated Lua code preserving functionality. # Output Format Return only the fully obfuscated Lua code in raw text, with zero additional explanation unless requested.

You are to act as an expert Lua script developer, capable of creating advanced and efficient Lua scripts tailored to complex requirements. When generating scripts, ensure that you fully understand the intended functionality, include appropriate comments for clarity, and optimize the code for both readability and performance. Follow best practices for Lua scripting and consider edge cases relevant to the task. # Steps 1. Clarify the specific functionality or problem the Lua script should address. 2. Design the script structure, including functions, variables, and control flow. 3. Write the Lua script code using advanced features as needed (e.g., metatables, coroutines, or modules). 4. Comment your code comprehensively to explain logic and decisions. 5. Test the script for correctness and optimize for performance. # Output Format Provide the complete Lua script in a markdown code block annotated with "lua" for syntax highlighting. Include thorough comments within the code explaining key parts. If applicable, also provide a brief explanation outside the code block summarizing the script's purpose and usage.

Create a fully advanced Ludo game in Python inspired by popular games like Ludo King, incorporating the best features and rich backgrounds. The game should support multiple modes including: - Single player against the computer - Two player mode - Three player mode - Four player mode with both individual and team play Implement advanced gameplay features that enhance user experience and engagement. Include polished GUI elements with attractive visual backgrounds and intuitive user interface. # Steps 1. Design the game board and visuals with appealing backgrounds. 2. Implement core game mechanics for Ludo according to official rules. 3. Develop AI logic for computer player enabling single-player mode. 4. Add support for 2, 3, and 4 player modes. 5. Implement team mode for 4 players. 6. Enhance user experience with animations, sound effects, and smooth interactions. 7. Include features such as dice roll animations, turn indicators, and scoreboards. # Output Format Provide the complete Python source code with comments explaining key sections. Ensure the code is ready to run and includes any resource files or instructions for setup. # Notes - Focus on a clean, readable codebase. - Optimize AI to provide challenging gameplay but allow difficulty customization if possible. - Use standard Python libraries or well-supported GUI frameworks (e.g., Tkinter, Pygame).

You are tasked with creating a detailed Java plugin specification for a Minecraft server that integrates with Citizen, WorldGuard, and LuckPerms, with a heavy dependency on Citizen for NPC handling. The plugin is an advanced "Mafioți Job" system focused on spawning and handling NPCs, job restrictions, and gameplay mechanics involving player interactions with NPCs and items. The plugin features should include: 1. **NPC Spawning and Limitations** - NPCs spawn randomly within a large radius, not fixed points. - Only players with the active "mafioso" job can kill these NPCs. - Each player has a maximum limit of "cadavre" (corpse items) they can carry at once. 2. **Corpse Mechanics** - Killing an NPC yields a "Cadavru" item. - The "Cadavru" has a limited-duration timer during which it must be delivered to a special zone. - Upon timer expiration, the item degrades into a "Cadavru Stricat" with reduced or no value. 3. **Alarms and Wanted System** - Some NPCs have a chance to silently alert the police upon death. - Each kill increases the player's "wanted" level. - At a certain wanted threshold, players gain a glowing effect and the police are alerted. - Wanted level decreases gradually if the player avoids conflicts. 4. **Organ Extraction Minigame** - Players can start an organ extraction minigame in the special zone. - Outcomes: - Successful extraction yields a normal organ. - Failed extraction yields a contaminated organ with low value. - Rare organ extraction yields a high-value organ but raises the wanted level automatically. # Development Notes - Integrate permissions and job roles via LuckPerms. - Use WorldGuard to define zones, including the special delivery and extraction area. - Leverage Citizen API for NPC creation, spawning, and behavior. - Implement timers, item timers, and status effects (e.g., glowing) using server capabilities. - Ensure commands exist for job management, NPC spawning controls, wanted level checks, and minigame initiation. # Output Format Provide a comprehensive, modular Java plugin design specification including: - Main features and behavior descriptions. - Required commands with usage and permission details. - API integration points and dependency handling. - Data management strategies (e.g., tracking corpses per player, wanted levels). - Event flows, including NPC spawning, killing, item handling, timer logic, and minigame sequences. This spec will guide implementation and facilitate development team understanding.

Create a comprehensive and advanced mechanic job script for the FiveM ESX framework, incorporating the following detailed features: 1. **Vehicle Repair and Part Replacement:** Allow mechanics to repair and physically replace specific vehicle parts such as engine, battery, tires, brakes, etc., including detailed mechanics like removing and swapping wheels with various types. 2. **Breakdown Risk System:** Implement a mileage-based breakdown risk mechanism where vehicles approaching or surpassing 100,000 km incur random breakdown events like battery failure, engine trouble, or tire blowouts, using timers or mileage tracking to simulate realistic wear and tear. 3. **Tire Management:** Enable mechanics to remove tires physically using proper animations and install different tire or wheel types, affecting vehicle performance realistically. 4. **Realistic Animations:** Integrate realistic and context-appropriate mechanic animations throughout all interactions, including using tools, removing parts, replacing components, and inspecting vehicles, synchronized suitably for all nearby players. 5. **Boss Features:** Provide comprehensive boss-level management functionalities such as recruiting and firing mechanics, managing payroll, and accessing other business-related menus. 6. **Integration with ox_target, ox_lib, and ox_inventory:** Fully leverage ox_target for targeted interaction prompts, ox_lib for utilities, and ox_inventory for comprehensive inventory management including parts, tools, and stock control. 7. **High Interaction Depth:** Design the job to be immersive and feature-rich, supporting dynamic player roles and interactions with detailed UI/UX where applicable. # Steps to Implement - Define vehicle parts and their states: working, damaged, and broken. - Implement mileage tracking and a system to trigger randomized breakdowns based on vehicle usage. - Develop repair and part replacement mechanics with physical representations such as tire removal. - Script mechanic animations using suitable FiveM animation libraries, ensuring synchronization. - Construct boss menus for staff management and financial controls using ESX and ox_lib. - Use ox_target for precise contextual targeting and interaction prompts. - Integrate ox_inventory for managing inventory actions including parts, tools, and stock. - Conduct thorough testing for realism, performance, and game balance. # Output Format Provide the complete, well-documented Lua job script along with all necessary supporting resource files (client scripts, server scripts, animation files, configuration files). Organize files clearly, ready for deployment within a FiveM ESX server environment. Include comprehensive comments explaining critical code sections, installation steps, configuration guidelines, and usage instructions for integrating ox_target, ox_lib, and ox_inventory. Specify any external dependencies or assets required and their sources. # Notes - Prioritize modular, efficient code design to facilitate future updates and extensions. - Ensure compatibility with the latest stable versions of ESX, ox_target, ox_lib, and ox_inventory. - Build in safeguards against edge cases, such as attempting to repair already functional parts or replace parts not present. - Make animations seamless and synchronized for all players in proximity. # Response Format Output a structured, fully-commented Lua script and supporting files, ready for direct use or customization on a FiveM ESX server. Do not include explanations outside of code comments.

Create a comprehensive and advanced mechanic job script for the FiveM ESX framework that encompasses the following key features: - **Vehicle Repair and Part Replacement:** Enable mechanics to repair and replace specific vehicle parts, including engine, battery, tires, and brakes. Implement detailed physical interactions such as removing and swapping wheels with different types. - **Breakdown Risk System:** Develop a mileage-based system tracking vehicle usage, triggering random breakdown risks (battery failure, engine trouble, tire blowouts) when vehicles approach or exceed approximately 100,000 km. Use timers and mileage tracking to realistically simulate wear and tear. - **Tire Management:** Permit mechanics to remove tires physically with appropriate animations and install various tire or wheel types, affecting vehicle performance in game accordingly. - **Realistic Animations:** Integrate suitable mechanic animations throughout interactions, such as tool usage, removing parts, inspecting vehicles, and replacing components, using FiveM’s animation capabilities. - **Boss Features:** Include comprehensive boss management functionalities like recruitment and firing of staff, payroll management, and access to business-related menus, fully integrated with ESX and ox_lib. - **Integration with ox_target, ox_lib, and ox_inventory:** Use ox_target for precise, contextual player interactions; ox_lib for utility and UI features; and ox_inventory to manage all inventory-related tasks, such as part storage, tool usage, and stock control. - **High Interaction Depth:** Design an immersive, feature-rich job experience with dynamic player roles, detailed UI/UX where applicable, and seamless interaction flow. # Steps 1. Define vehicle parts with detailed states (working, damaged, broken). 2. Implement vehicle mileage tracking and trigger random breakdown events based on use. 3. Develop repair and replacement mechanics with physical part representation, e.g., tire removal. 4. Create and integrate animations for every mechanic action. 5. Build boss menus enabling staff recruitment/firing and financial management using ESX and ox_lib. 6. Utilize ox_target to enable contextual targeting and interaction prompts. 7. Link all inventory actions for parts and tools to ox_inventory. 8. Conduct thorough testing for realism, performance, and balanced gameplay. # Output Format Deliver a complete, modular, and well-documented FiveM ESX Lua job script along with all necessary resource files (client-side scripts, server-side scripts, animations, configuration files) organized and ready for deployment. Include extensive inline comments explaining critical functionality, clear instructions on installation and configuration, and usage guides for integrating ox_target, ox_lib, and ox_inventory. If external dependencies, assets, or use of third-party libraries are required, specify versions and how to acquire/install them clearly. # Notes - Emphasize performance optimization and modularity to enable future extension and maintenance. - Confirm compatibility with the latest stable releases of ESX, ox_target, ox_lib, and ox_inventory. - Implement safeguards against edge cases, such as attempts to repair already functional parts or replace missing components. - Ensure animations are smooth, non-invasive, and synchronized for all nearby players. # Response Formats Respond with a structured, well-commented Lua script and related resource files arranged for immediate use or straightforward adaptation within a FiveM ESX server environment.

Create a detailed and comprehensive prompt for developing an advanced mind map web application incorporating the latest features and functionality. The prompt should include clear requirements for usability, performance, collaboration capabilities, customization options, and integration with other tools or platforms. Emphasize the need for an intuitive, responsive design optimized for both desktop and mobile devices, as well as support for real-time collaboration, cloud synchronization, rich media embedding, version control, and export/import functionality. Highlight the importance of scalability, security, and user accessibility, including support for keyboard shortcuts and screen readers. # Steps 1. Define core features such as node creation, editing, and deletion; hierarchical structure management; and intuitive navigation. 2. Specify advanced functionalities like real-time multi-user collaboration, commenting, and notifications. 3. Include customization options for styles, colors, icons, and layout templates. 4. Integrate cloud syncing with offline work capabilities and version history management. 5. Support embedding various media types (images, links, videos) within nodes. 6. Provide import/export options in multiple formats (e.g., JSON, PDF, OPML). 7. Ensure responsive design for accessibility on various devices and compliance with accessibility standards. 8. Implement security measures protecting user data and privacy. # Output Format The response should be a detailed prompt text that can be used directly or adapted for guiding a development team or AI system to build this mind map web app. It should be structured clearly and concisely, suitable for understanding by technical teams and project stakeholders.

Create an advanced mining job script for the RedM platform using Lua language and the RSG Framework. The job should integrate ox_target and ox_lib libraries to provide an immersive mining experience. Details: - The player must have a pickaxe item in their inventory managed by RSG-inventory. - Locate a cave on the map where mining props representing rocks are dynamically generated. - Using ox_target, the player can target these rock props. - Upon targeting a rock, the player performs a mining animation while breaking the rock. - After breaking a rock, reward the player with mining resources added to their inventory. - The gathered items can then be sold or smelted (processed) into higher value items for further use. Steps: 1. Check for pickaxe in player’s inventory before allowing mining. 2. Generate rock props inside the cave dynamically. 3. Use ox_target to allow targeting and interacting with rock props. 4. Play appropriate mining animations during interaction. 5. Upon successful mining, add specific resources to player inventory via rsg-inventory. 6. Implement mechanics for selling mined resources or smelting them into refined products. Output Format: Provide a fully commented Lua script implementing this mining job, clearly indicating integration points with RSG Framework, ox_target, ox_lib, and rsg-inventory. Use modular functions where appropriate, and include explanations for prop generation, targeting, animation handling, inventory interactions, and selling/smelting mechanics. Ensure the script structure is suitable for deployment and extension within the RedM environment. Notes: - Focus on clarity and robustness. - Emphasize interaction responsiveness and user feedback. - Use appropriate event handling and server-client communication based on RSG Framework standards.