Entity & Character System

Three hours debugging why your enemy won't attack—only to find a typo on line 487. Adding a simple NPC means touching six different files. You wanted to make a game, not wrestle with object-oriented inheritance.

CraftMyGame's Visual Entity Creator puts everything in one place: a comprehensive editor for characters, enemies, NPCs, and objects. Visuals, animation, physics, behavior, interaction, stats, events, and actions—all organized, all visual, all interconnected.

Change your goblin's aggression range? Drag a slider. Need it to drop loot on death? Add an event. Want it to patrol between waypoints? Select from a dropdown.

Traditional approach: Hunt through entity controllers, behavior scripts, physics configs, and animation state machines scattered across your codebase.

CraftMyGame: One editor. See everything. Change anything. Test instantly.

The Visual Entity Editor organizes every aspect of your characters and objects into clear, focused sections. No more jumping between files or forgetting where you configured something three months ago.

Basic Information — Name, category, and description to keep your project organized as it grows

Visuals & Appearance — Control how entities look, their size, positioning, and render order so sprites layer correctly without z-fighting headaches

Animation — Define spritesheets, sequences, timing, and state transitions visually—no animation controller code needed

Physics & Collision — Shape, mass, and interaction behavior that just works with the built-in physics engine

Gameplay & Behavior — Movement style, AI personality, and chain following for companions and formations

Instance Limiting — Prevent performance issues and maintain game balance by controlling entity populations

Events & Triggers — Define what happens when entities spawn, die, collide, or reach timer milestones

UI Elements — Attach health bars, status indicators, and custom UI that automatically follows entities

Interaction — Create interactable NPCs, objects, and proximity-triggered events without scripting

Initial Resources — Set starting health, mana, or custom resources to create entity variants instantly

Projectile Configuration — Build bullets, arrows, and spells with dedicated settings for speed, damage, and targeting

Custom Parameters — Store entity-specific data for when you need advanced logic without hardcoding values

Switch between sections instantly. See all related settings together. Make changes and watch them take effect in real time.

Great animations make games feel polished. The Animation Editor gives you frame-level control without writing state machine code or wrestling with animation controllers.

What this means for your game: Your knight's running animation loops seamlessly. It switches to "attack" when the player clicks. Returns to idle after the action completes. All of this takes about 90 seconds to configure visually.

The alternative: Build a state machine, define transitions, handle edge cases, debug animation glitches. That's a day of work before your character even moves right.

• Frame sequences — with per-frame timing (down to milliseconds) for perfect rhythm and impact
• Loop behavior — with configurable start points so walk cycles transition smoothly from any frame
• Automatic state rules — walk when moving, idle when still, attack on combat—no conditional logic to write
• Weighted random selection — spawn enemies with variety by randomly choosing from multiple idle or spawn animations
• Intelligent sprite flipping — characters automatically face their movement direction without extra configuration

Generic full-body collision doesn't cut it for satisfying combat. Players notice when they take damage from attacks that clearly missed—or when their perfectly-timed strike passes through an enemy.

Per-Frame Hitboxes let you define damage zones on specific animation frames—the exact moment your sword connects, your fireball appears, or your boss slam lands.

Shape options — Circle for punches and explosions, rectangle for sword slashes, cone for breath attacks and area denial

Frame-perfect timing — Hitbox appears on frame 4, disappears on frame 7. No damage during windup or recovery.

Offset positioning — Extend hitboxes in front of, behind, or around your character to match the visual attack

Duration control — Specify exactly how many frames each hitbox stays active for tight, readable combat

Example: Your warrior's overhead slam has no hitbox during windup (frames 1-5), a large rectangle during impact (frames 6-8), then none during recovery. Enemies take damage only during those three frames. Fair, readable, satisfying—the kind of combat feel that took AAA studios years to figure out.

Without this: You're writing collision detection code, managing hitbox activation/deactivation, debugging phantom hits, and probably still getting complaints about unfair combat.

Build platformers, top-down adventures, racing games, or space shooters—all from the same entity system. Switch genres by changing a dropdown, not rewriting your movement code.

Top-down — Full 4-directional movement for RPGs, twin-stick shooters, action-adventures, and dungeon crawlers

Platformer — Horizontal movement with gravity-based jumping for side-scrollers and metroidvanias

Racing — Forward/backward thrust with steering controls for kart racers, boat games, and vehicle combat

Thrust — Rotate and thrust in facing direction for space games, asteroids-style arcade action, and submarine exploration

Physics modes give you even more control:

Configure speed, acceleration, damping, and rotation per entity. Your space fighter rotates with A/D and thrusts forward with W—coasting through space with realistic momentum. Your platformer hero moves instantly left/right. Same engine, completely different feel.

The payoff: Prototype multiple game ideas without rebuilding your movement system each time. Find the right feel through experimentation, not engineering.

• Direct velocity — for instant, responsive controls where players need precision
• Apply force — for momentum-based movement that feels weighty and realistic

Good enemy AI makes games engaging. Bad AI breaks immersion. Writing behavior trees, pathfinding algorithms, and state machines? That's a specialization unto itself.

The AI Controller system gives you intelligent, believable enemies through configuration:

Behavior controllers — Choose from aggressive pursuers, defensive guardians, wandering patrols, or define custom behaviors

Detection sensors — Spherical zones with configurable range, direction, and check intervals. Enemies see, hear, and react.

Patrol routes — Define waypoints for guard paths, patrol circuits, and idle wandering that makes your world feel alive

Reaction tuning — Control how quickly enemies notice and respond to players for difficulty balancing

Automatic pathfinding — Built-in A\* navigation means enemies route around obstacles without getting stuck on corners

Example: Your goblin spots players within 8 tiles, aggressively chases them around obstacles, and patrols between three waypoints when idle. Configure this in under a minute with dropdowns and sliders—not weeks learning behavior tree frameworks.

Players need visual feedback: health bars above enemies, status icons on party members, interaction prompts near NPCs. Manually positioning UI elements that follow moving entities? That's surprisingly complex code.

Entity-attached UI handles the complexity for you:

Health bars — Automatic damage visualization that updates in real time. Configure style, position, and visibility rules.

Status indicators — Display buffs, debuffs, cooldowns, and state information exactly where players need to see them

Custom UI components — Attach any UI element and it automatically follows, scales, and respects camera transformations

Position elements relative to the entity (above head, below feet, offset to the side). Set visibility conditions (only when damaged, only on hover, always visible). Style everything to match your game's aesthetic.

The result: Professional-looking UI feedback without writing coordinate transformation code or managing UI object lifecycles.

Games are built on cause and effect. When something happens, something else should respond. The event system lets you define those responses visually.

Spawn events — Play intro animations, activate abilities, or trigger dialogue when entities appear

Death events — Drop loot, spawn particles, play sounds, update scores, trigger achievements

Timer events — Periodic actions while entities exist: regeneration ticks, environmental damage, behavior changes

Animation events — Trigger actions at specific animation moments: footstep sounds, attack effects, transition cues

Collision events — Different responses for different entity types: damage from enemies, healing from pickups, triggers from zones

Chain multiple actions together: When an enemy dies, spawn three coins at random offsets, play a death animation, emit particles, shake the camera, play a sound effect, and increment the player's score. All visual configuration, all in one place.

Compare to code: You'd need event listeners, callback management, careful ordering, and debugging when things fire in the wrong sequence.

Collision detection is notoriously tricky to get right. Hitboxes that don't match sprites. Physics that feel floaty or heavy. Pass-through triggers that sometimes... don't.

The Visual Collision Editor shows you exactly what will happen:

Shape selection — Box for platforms and walls, sphere for characters and projectiles

Precise sizing — Width and height factors relative to entity size, adjustable with visual feedback

Trigger zones — Pass-through collision for area effects, checkpoints, and detection zones

Physics properties — Mass, damping, and rotation lock to get the exact feel you want

Real-time preview — See the collision shape overlaid on your entity sprite as you adjust settings

Drag the collision boundaries while watching the preview update. See exactly where hits will register. No more guessing if your hitbox matches your sprite, then playtesting for 20 minutes to figure out why collisions feel off.

Bullets, arrows, magic missiles, thrown objects—projectiles seem simple until you implement them. Velocity inheritance, lifetime management, collision filtering, damage application, cleanup... it adds up.

Dedicated projectile settings handle the complexity:

Speed and lifetime — How fast it travels and when it disappears (on timer or on impact)

Damage configuration — Resource-based damage with multipliers, types, and calculation rules

Target categories — What the projectile can and cannot hit. Friendly fire optional.

Spawn behavior — Inherit velocity from the shooter, face movement direction, offset from spawn point

Example: Your archer's arrow spawns facing forward, travels at 15 tiles per second, damages enemies on contact, and disappears after 3 seconds or on impact. Configure once, reuse across every bow-wielding enemy in your game.

Too many entities kill performance. Spawn-spam breaks game balance. Tracking entity counts in code means more state to manage and more bugs to chase.

Instance limiting solves this through configuration:

Maximum instances — Set hard limits on how many of each entity type can exist simultaneously

Scope control — Apply limits per world, per level, or globally across your game

Limit behavior — Prevent spawning when full, destroy oldest instances, or trigger custom logic

Example: Your boss spawns a maximum of 6 minions. When players kill some, the boss can spawn more. No counting code, no spawn management, no edge cases where 47 minions crash your game.

Bonus: This also helps you balance difficulty. Limit enemy counts to control challenge, limit collectibles to manage economy, limit particles to maintain performance.

You need regular skeletons and elite skeletons. Same animations, same behavior, different stats. In traditional development, that means duplicate files, inheritance hierarchies, or fragile prefab overrides.

Initial resource overrides let you create variants cleanly:

Starting health — Regular enemies at 50 HP, elites at 150 HP, bosses at 500 HP

Resource pools — Different mana, stamina, or custom resource values per variant

Per-entity customization — Override any resource default without touching the base definition

Your skeleton enemy definition works for every skeleton type. When you improve the animation or fix a behavior bug, every variant inherits the fix. When you need stat differences, override just those values.

This matters because: As your game grows, you'll have dozens of entity variants. Keeping them maintainable is the difference between finishing your game and drowning in technical debt.

Most no-code engines give you three or four generic entity types with fixed behaviors. Want something different? Hit a wall or start coding.

CraftMyGame's entity system is game-engine-grade. The same architecture powers turn-based RPGs, bullet-hell shooters, farming sims, and action platformers. Real games, shipped by real developers.

You get:

- The depth to build exactly what you imagine - The simplicity to build it in hours instead of months - The visual feedback to understand what you're creating - The flexibility to change direction without rewriting everything

You're not limited by templates. You're limited by imagination.