john/prosperon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

probe

Browse Source
This commit is contained in:
John Alanbrook
2026-02-24 21:08:46 -06:00
parent f87854fca1
commit 3d87fdeb5f
23 changed files with 1551 additions and 1086 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
anim2d.cm Normal file
View File

@@ -0,0 +1,95 @@
var film2d = use('film2d')
var graphics = use('graphics')
var anim_proto = {
type: 'sprite',
play: function(name) {
var anim = name ? this._anims[name] : this._anims
if (!anim || !anim.frames) return this
this._anim = anim
this._frame = 0
this._elapsed = 0
this._playing = true
this.image = anim.frames[0].image
return this
},
stop: function() {
this._playing = false
return this
},
resume: function() {
this._playing = true
return this
},
update: function(dt) {
if (!this._playing || !this._anim) return
var frames = this._anim.frames
this._elapsed += dt
while (this._elapsed >= frames[this._frame].time) {
this._elapsed -= frames[this._frame].time
this._frame++
if (this._frame >= length(frames)) {
if (this._anim.loop) {
this._frame = 0
} else {
this._frame = length(frames) - 1
this._playing = false
break
}
}
}
this.image = frames[this._frame].image
},
destroy: function() {
film2d.unregister(this._id)
}
}
return function(props) {
var img = props.image || props.anim
var anims = graphics.texture(img)
var defaults = {
type: 'sprite',
pos: {x: 0, y: 0},
width: null,
height: null,
anchor_x: 0.5,
anchor_y: 0.5,
rotation: 0,
color: {r: 1, g: 1, b: 1, a: 1},
opacity: 1,
tint: {r: 1, g: 1, b: 1, a: 1},
filter: 'nearest',
plane: 'default',
layer: 0,
groups: [],
visible: true
}
var data = object(defaults, props)
data._anims = anims
data._anim = null
data._frame = 0
data._elapsed = 0
data._playing = false
data.image = null
var s = meme(anim_proto, data)
// Auto-play: if anims is a single animation, start it
if (anims && anims.frames) {
s._anim = anims
s._frame = 0
s._playing = true
s.image = anims.frames[0].image
}
film2d.register(s)
return s
}

5
camera.cm
View File

@@ -128,9 +128,8 @@ var basecam = {
},
}
cam.make = function()
{
return meme(basecam)
cam.make = function(config) {
return meme(basecam, config || {})
}
return cam

108
collision2d.cm Normal file
View File

@@ -0,0 +1,108 @@
var collision2d = {}
collision2d.body = function(config) {
var c = config || {}
return {
type: c.type || 'aabb',
width: c.width || 0,
height: c.height || 0,
radius: c.radius || 0,
offset: c.offset || {x: 0, y: 0},
layer: c.layer || 0,
mask: c.mask || 0xFFFF
}
}
function body_center(body, pos) {
return {
x: pos.x + body.offset.x,
y: pos.y + body.offset.y
}
}
function test_aabb_aabb(a, ap, b, bp) {
var ac = body_center(a, ap)
var bc = body_center(b, bp)
var ahw = a.width * 0.5
var ahh = a.height * 0.5
var bhw = b.width * 0.5
var bhh = b.height * 0.5
return abs(ac.x - bc.x) < ahw + bhw && abs(ac.y - bc.y) < ahh + bhh
}
function test_circle_circle(a, ap, b, bp) {
var ac = body_center(a, ap)
var bc = body_center(b, bp)
var dx = ac.x - bc.x
var dy = ac.y - bc.y
var r = a.radius + b.radius
return dx * dx + dy * dy < r * r
}
function test_aabb_circle(aabb, ap, circ, cp) {
var ac = body_center(aabb, ap)
var cc = body_center(circ, cp)
var hw = aabb.width * 0.5
var hh = aabb.height * 0.5
var cx = max(ac.x - hw, min(cc.x, ac.x + hw))
var cy = max(ac.y - hh, min(cc.y, ac.y + hh))
var dx = cc.x - cx
var dy = cc.y - cy
return dx * dx + dy * dy < circ.radius * circ.radius
}
collision2d.test = function(a, a_pos, b, b_pos) {
if (a.layer & b.mask == 0 || b.layer & a.mask == 0)
return false
if (a.type == 'aabb' && b.type == 'aabb')
return test_aabb_aabb(a, a_pos, b, b_pos)
if (a.type == 'circle' && b.type == 'circle')
return test_circle_circle(a, a_pos, b, b_pos)
if (a.type == 'aabb' && b.type == 'circle')
return test_aabb_circle(a, a_pos, b, b_pos)
if (a.type == 'circle' && b.type == 'aabb')
return test_aabb_circle(b, b_pos, a, a_pos)
return false
}
collision2d.overlap = function(body, pos, others) {
var results = []
var i = 0
var other = null
for (i = 0; i < length(others); i++) {
other = others[i]
if (collision2d.test(body, pos, other.body, other.pos))
push(results, other)
}
return results
}
collision2d.overlap_point = function(point, bodies) {
var results = []
var i = 0
var b = null
var c = null
var hw = 0
var hh = 0
var dx = 0
var dy = 0
for (i = 0; i < length(bodies); i++) {
b = bodies[i]
c = body_center(b.body, b.pos)
if (b.body.type == 'aabb') {
hw = b.body.width * 0.5
hh = b.body.height * 0.5
if (abs(point.x - c.x) < hw && abs(point.y - c.y) < hh)
push(results, b)
} else if (b.body.type == 'circle') {
dx = point.x - c.x
dy = point.y - c.y
if (dx * dx + dy * dy < b.body.radius * b.body.radius)
push(results, b)
}
}
return results
}
return collision2d

35
compositor.cm
View File

@@ -410,4 +410,39 @@ function _calc_presentation(src, dst, mode) {
return {x: (dst.width - w) / 2, y: (dst.height - h) / 2, width: w, height: h}
}
var _last_plan = null
var _orig_compile = compositor.compile
compositor.compile = function(config) {
_last_plan = _orig_compile(config)
return _last_plan
}
compositor.snapshot = function() {
if (!_last_plan) return null
var planes = []
var i = 0
var pass = null
for (i = 0; i < length(_last_plan.passes); i++) {
pass = _last_plan.passes[i]
if (pass.type == 'render') {
push(planes, {
drawable_count: length(pass.drawables),
camera: pass.camera ? {
pos: pass.camera.pos,
width: pass.camera.width,
height: pass.camera.height
} : null,
target_size: pass.target_size
})
}
}
return {
pass_count: length(_last_plan.passes),
target_count: length(array(_last_plan.targets)),
screen_size: _last_plan.screen_size,
planes: planes
}
}
return compositor

103
core.cm
View File

@@ -9,11 +9,11 @@
// update: function(dt) { ... },
// render: function() { return graph }
// })
//
// Headless mode (no window, no input, no render, no audio):
// core.start({ headless: true, update: function(dt) { ... } })
var video = use('sdl3/video')
var events = use('sdl3/input')
var time_mod = use('time')
var debug_imgui = use('debug_imgui')
var core = {}
@@ -25,40 +25,56 @@ var _window = null
var _last_time = 0
var _framerate = 60
var imgui = use('imgui')
// Lazy-loaded modules (only in non-headless mode)
var video = null
var events = null
var imgui = null
var debug_imgui = null
// Start the application
core.start = function(config) {
_config = config
_framerate = config.framerate || 60
_running = true
_last_time = time_mod.number()
if (config.probe) _register_probes()
if (config.headless) {
_headless_loop()
return true
}
// Load SDL modules
video = use('sdl3/video')
events = use('sdl3/input')
imgui = use('imgui')
debug_imgui = use('debug_imgui')
// Initialize SDL GPU backend
var sdl_gpu = use('sdl_gpu')
_backend = sdl_gpu
var init_result = _backend.init({
width: config.width || 1280,
height: config.height || 720,
title: config.title || "Prosperon"
})
if (!init_result) {
log.console("core: Failed to initialize backend")
return false
}
_window = _backend.get_window()
if ((config.imgui || config.editor) && imgui.init) {
imgui.init(_window, _backend.get_device())
}
_running = true
_last_time = time_mod.number()
// Start main loop
_main_loop()
return true
}
@@ -105,6 +121,24 @@ function fps_get_avg() {
var _current_fps = 0
var _frame_time_ms = 0
// Headless loop — update only, no window/input/render/audio
function _headless_loop() {
if (!_running) return
var now = time_mod.number()
var dt = now - _last_time
_last_time = now
if (_config.update) _config.update(dt)
var frame_time = 1 / _framerate
var elapsed = time_mod.number() - now
var delay = frame_time - elapsed
if (delay < 0) delay = 0
$delay(_headless_loop, delay)
}
// Main loop
function _main_loop() {
var frame_start = time_mod.number()
@@ -232,4 +266,45 @@ function _main_loop() {
$delay(_main_loop, delay)
}
function _register_probes() {
var probe = use('probe')
var film2d = use('film2d')
var world = use('world')
var comp = use('compositor')
var input_mod = use('input')
var tween_mod = use('tween')
var graphics_mod = use('graphics')
probe.register("drawables", {
all: function(args) { return film2d.snapshot() }
})
probe.register("world", {
all: function(args) { return world.snapshot() },
count: function(args) { return world.count() }
})
probe.register("compositor", {
all: function(args) { return comp.snapshot() }
})
probe.register("input", {
all: function(args) { return input_mod.snapshot() }
})
probe.register("tweens", {
all: function(args) { return tween_mod.snapshot() }
})
probe.register("assets", {
all: function(args) { return graphics_mod.snapshot() }
})
probe.register("core", {
fps: function(args) {
return {fps: _current_fps, frame_time_ms: _frame_time_ms}
}
})
}
return core

268
docs/api/modules/draw2d.md
View File

@@ -5,229 +5,91 @@ type: docs
# draw2d
A collection of retained-mode 2D drawing factories. Each factory creates an object that auto-registers with `film2d` and renders via the compositor. Destroy objects when no longer needed.
A collection of 2D drawing functions that operate in screen space. Provides primitives
for lines, rectangles, text, sprite drawing, etc.
```javascript
var draw = use('draw2d')
```
## Factories
### point(pos, size, color) <sub>function</sub>
### draw.sprite(props)
Create a sprite from an image. Auto-registers with `film2d`.
```javascript
var s = draw.sprite({
image: "hero.png",
pos: {x: 100, y: 200},
width: 32, height: 32,
plane: 'game', layer: 0
})
s.destroy() // remove from renderer
```
See `sprite.cm` for full property list: `pos`, `image`, `width`, `height`, `anchor_x`, `anchor_y`, `rotation`, `color`, `opacity`, `tint`, `filter`, `plane`, `layer`, `groups`, `visible`, `flip`, `fit`, `uv`.
**pos**: A 2D position ([x, y]) where the point should be drawn.
### draw.shape.rect(props) / circle(props) / ellipse(props) / pill(props)
**size**: The size of the point (not currently affecting rendering).
Create SDF shapes. Supports fill, stroke, rounded corners, dashing, feathering, and texture fill.
**color**: The color of the point, defaults to Color.blue.
```javascript
var box = draw.shape.rect({
pos: {x: 50, y: 50}, width: 100, height: 60,
fill: {r: 1, g: 0, b: 0, a: 1},
stroke: {r: 1, g: 1, b: 1, a: 1}, stroke_thickness: 2,
radius: 8,
plane: 'game'
})
var ball = draw.shape.circle({
pos: {x: 200, y: 200}, radius: 16,
fill: {r: 0, g: 1, b: 0, a: 1},
plane: 'game', groups: ['glow']
})
```
**Returns**: None
Properties: `shape_type`, `pos`, `width`, `height`, `radius`, `corner_style`, `feather`, `stroke_thickness`, `stroke_align`, `dash_len`, `gap_len`, `dash_offset`, `cap`, `join`, `fill`, `stroke`, `blend`, `opacity`, `fill_tex`, `uv`, `plane`, `layer`, `groups`, `visible`.
### draw.text(props)
### line(points, color, thickness, pipeline) <sub>function</sub>
Create a text label. Updates live when you change `.text`.
```javascript
var label = draw.text({
text: "Score: 0",
pos: {x: 10, y: 500},
font: "fonts/dos", size: 16,
color: {r: 1, g: 1, b: 1, a: 1},
plane: 'hud'
})
label.text = "Score: 42" // updates on next frame
```
### draw.tilemap(props)
Create a tile-based map. See `tilemap2d.cm`.
**points**: An array of 2D positions representing the line vertices.
### draw.anim(props)
**color**: The color of the line, default Color.white.
Create an animated sprite from an aseprite/gif file. Auto-plays if the image has frames.
**thickness**: The line thickness, default 1.
```javascript
var anim = draw.anim({
image: "hero.aseprite",
pos: {x: 100, y: 100},
plane: 'game'
})
anim.play("walk") // play named animation
anim.stop() // pause
anim.resume() // resume
anim.update(dt) // advance frame (call from update loop)
```
**pipeline**: (Optional) A pipeline or rendering state object.
## Lifecycle
All draw2d objects register with `film2d` on creation. Call `.destroy()` to unregister and remove from rendering. Set `.visible = false` to hide without destroying.
**Returns**: None
### cross(pos, size, color, thickness, pipe) <sub>function</sub>
**pos**: The center of the cross as a 2D position ([x, y]).
**size**: Half the size of each cross arm.
**color**: The color of the cross, default Color.red.
**thickness**: The thickness of each line, default 1.
**pipe**: (Optional) A pipeline or rendering state object.
**Returns**: None
### arrow(start, end, color, wingspan, wingangle, pipe) <sub>function</sub>
**start**: The start position of the arrow ([x, y]).
**end**: The end (tip) position of the arrow ([x, y]).
**color**: The color, default Color.red.
**wingspan**: The length of each arrowhead 'wing', default 4.
**wingangle**: Wing rotation in degrees, default 10.
**pipe**: (Optional) A pipeline or rendering state object.
**Returns**: None
### rectangle(rect, color, pipeline) <sub>function</sub>
**rect**: A rectangle object with {x, y, width, height}.
**color**: The fill color, default Color.white.
**pipeline**: (Optional) A pipeline or rendering state object.
**Returns**: None
### tile(image, rect, color, tile, pipeline) <sub>function</sub>
:raises Error: If no image is provided.
**image**: An image object or string path to a texture.
**rect**: A rectangle specifying draw location/size ({x, y, width, height}).
**color**: The color tint, default Color.white.
**tile**: A tiling definition ({repeat_x, repeat_y}), default tile_def.
**pipeline**: (Optional) A pipeline or rendering state object.
**Returns**: None
### slice9(image, rect, slice, color, info, pipeline) <sub>function</sub>
:raises Error: If no image is provided.
**image**: An image object or string path to a texture.
**rect**: A rectangle specifying draw location/size, default [0, 0].
**slice**: The pixel inset or spacing for the 9-slice (number or object).
**color**: The color tint, default Color.white.
**info**: A slice9 info object controlling tiling of edges/corners.
**pipeline**: (Optional) A pipeline or rendering state object.
**Returns**: None
### image(image, rect, rotation, color, pipeline) <sub>function</sub>
:raises Error: If no image is provided.
**image**: An image object or string path to a texture.
**rect**: A rectangle specifying draw location/size, default [0,0]; width/height default to image size.
**rotation**: Rotation in degrees (not currently used).
**color**: The color tint, default none.
**pipeline**: (Optional) A pipeline or rendering state object.
**Returns**: A sprite object that was created for this draw call.
### images(image, rects, config) <sub>function</sub>
:raises Error: If no image is provided.
**image**: An image object or string path to a texture.
**rects**: An array of rectangle objects ({x, y, width, height}) to draw.
**config**: (Unused) Additional config data if needed.
**Returns**: An array of sprite objects created and queued for rendering.
### sprites(sprites, sort, pipeline) <sub>function</sub>
**sprites**: An array of sprite objects to draw.
**sort**: Sorting mode or order, default 0.
**pipeline**: (Optional) A pipeline or rendering state object.
**Returns**: None
### circle(pos, radius, color, inner_radius, pipeline) <sub>function</sub>
**pos**: Center of the circle ([x, y]).
**radius**: The circle radius.
**color**: The fill color of the circle, default none.
**inner_radius**: (Unused) Possibly ring thickness, default 1.
**pipeline**: (Optional) A pipeline or rendering state object.
**Returns**: None
### text(text, rect, font, size, color, wrap, pipeline) <sub>function</sub>
**text**: The string to draw.
**rect**: A rectangle specifying draw position (and possibly wrapping area).
**font**: A font object or string path, default sysfont.
**size**: (Unused) Possibly intended for scaling the font size.
**color**: The text color, default Color.white.
**wrap**: Pixel width for text wrapping, default 0 (no wrap).
**pipeline**: (Optional) A pipeline or rendering state object.
**Returns**: None
## Planes and Groups
Every drawable has a `plane` (string) and optional `groups` (array of strings). The compositor renders drawables per-plane. Groups route drawables through effects (bloom, mask, etc.).

51
docs/entities.md
View File

@@ -105,13 +105,58 @@ Each system module provides behavior that operates on the entity's data. No clas
## Querying Entities
The world module lets you find entities:
The world module provides several ways to find and iterate entities:
```javascript
var world = use('world')
// All entities are tracked internally
// Query patterns are still being developed
// Iterate all entities
world.each(function(entity) {
log.console(entity)
})
// Filter entities by predicate — returns array
var enemies = world.query(function(e) { return e.team == 'enemy' })
// Find first matching entity
var player = world.find(function(e) { return e.is_player })
// Get entity count
var n = world.count()
```
## Updating Entities
Call `world.update(dt)` each frame to tick all entities that have an `update(dt)` method:
```javascript
// In your core.start() update callback:
core.start({
update: function(dt) {
world.update(dt)
}
})
```
## Loading Levels
Load a level from a JSON array of entity definitions:
```javascript
world.load_level([
{"script": "entities/goblin", "pos": {"x": 100, "y": 200}},
{"script": "entities/tree", "pos": {"x": 300, "y": 100}}
])
```
Each entry's `script` field is loaded via `use()` as the prototype. All other fields are applied as overrides.
## Clearing the World
Remove and destroy all entities:
```javascript
world.clear()
```
## Override Rules

7
docs/prosperon.md
View File

@@ -28,10 +28,13 @@ Prosperon is not a monolithic engine with a global state object. It is a collect
| `compositor` | Build render plans from scene configs |
| `input` | Action mapping, device routing |
| `sound` | Audio playback |
| `world` | Entity management |
| `world` | Entity management (add, query, update, levels) |
| `camera` | Viewport into the world |
| `draw2d` | Re-exports sprite, shape, text, tilemap, anim |
| `text2d` | Text rendering |
| `shape2d` | SDF shapes |
| `shape2d` | SDF shapes (rect, circle, ellipse, pill) |
| `anim2d` | Sprite animation playback (aseprite/gif) |
| `collision2d` | AABB + circle overlap queries |
| `tilemap2d` | Grid-based tile rendering |
| `tween` | Value interpolation |
| `resources` | Asset path resolution |

6
draw2d.cm
View File

@@ -2,10 +2,12 @@ var sprite = use('sprite')
var tilemap = use('tilemap2d')
var text = use('text2d')
var shape = use('shape2d')
var anim = use('anim2d')
return {
sprite,
tilemap,
text,
shape
}
shape,
anim
}

6
examples/bunnymark/config.cm
View File

@@ -1,5 +1,5 @@
return {
title:"Bunnymark",
width:1200,
height:600,
title: "Bunnymark",
width: 1200,
height: 600
}

153
examples/bunnymark/main.ce
View File

@@ -1,59 +1,124 @@
var draw = use('draw2d')
var render = use('render')
var graphics = use('graphics')
var sprite = use('sprite')
var geom = use('geometry')
var config = use('config')
var color = use('color')
var core = use('core')
var camera = use('camera')
var compositor = use('compositor')
var input = use('input')
var sprite_factory = use('sprite')
var text2d = use('text2d')
var random = use('random')
var bunnyTex = graphics.texture("bunny")
var GW = 1200, GH = 600
// We'll store our bunnies in an array of objects: { x, y, vx, vy }
var game_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
var hud_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
input.configure({
action_map: {
spawn: ['mouse_button_left']
}
})
// Bunny tracking
var bunnies = []
var bunny_sprites = []
var BUNNY_W = 26, BUNNY_H = 37
// Start with some initial bunnies:
var i = 0;
for (i = 0; i < 100; i++) {
push(bunnies, {
x: random.random() * config.width,
y: random.random() * config.height,
// HUD
var count_label = text2d({
text: "Bunnies: 0", pos: {x: 10, y: GH - 25},
plane: 'hud', size: 16, color: {r: 1, g: 1, b: 1, a: 1}
})
var fps_label = text2d({
text: "FPS: 0", pos: {x: 10, y: GH - 45},
plane: 'hud', size: 16, color: {r: 1, g: 1, b: 1, a: 1}
})
var fps_timer = 0
var frame_count = 0
function add_bunny(x, y) {
var bunny = {
vx: (random.random() * 300) - 150,
vy: (random.random() * 300) - 150
}
var s = sprite_factory({
image: "bunny",
pos: {x: x, y: y},
width: BUNNY_W, height: BUNNY_H,
anchor_x: 0.5, anchor_y: 0.5,
plane: 'game'
})
push(bunnies, bunny)
push(bunny_sprites, s)
}
var update = function(dt) {
// If left mouse is down, spawn some more bunnies:
var mouse = input.mousestate()
var i = 0;
var b = null;
if (mouse.left)
for (i = 0; i < 50; i++) {
push(bunnies, {
x: mouse.x,
y: mouse.y,
vx: (random.random() * 300) - 150,
vy: (random.random() * 300) - 150
})
// Initial bunnies
var i = 0
for (i = 0; i < 100; i++) {
add_bunny(
random.random() * GW,
random.random() * GH
)
}
count_label.text = "Bunnies: " + length(bunnies)
// Mouse position tracking
var mouse_x = GW / 2, mouse_y = GH / 2
var comp_config = {
clear: {r: 0.2, g: 0.2, b: 0.3, a: 1},
planes: [
{name: 'game', camera: game_cam, resolution: {width: GW, height: GH}, presentation: 'letterbox'},
{name: 'hud', camera: hud_cam, resolution: {width: GW, height: GH}, presentation: 'stretch'}
]
}
core.start({
width: 1200, height: 600, title: "Bunnymark",
input: function(ev) {
if (ev.type == 'mouse_motion') {
mouse_x = ev.pos.x
mouse_y = ev.pos.y
}
},
update: function(dt) {
// Spawn bunnies while clicking
var down = input.player1().down()
if (down.spawn) {
var si = 0
for (si = 0; si < 50; si++) {
add_bunny(mouse_x, mouse_y)
}
count_label.text = "Bunnies: " + length(bunnies)
}
// Update bunny positions and bounce them inside the screen:
for (i = 0; i < length(bunnies); i++) {
b = bunnies[i]
b.x += b.vx * dt
b.y += b.vy * dt
// Update all bunnies
var b = null, s = null
for (i = 0; i < length(bunnies); i++) {
b = bunnies[i]
s = bunny_sprites[i]
// Bounce off left/right edges
if (b.x < 0) { b.x = 0; b.vx = -b.vx }
else if (b.x > config.width) { b.x = config.width; b.vx = -b.vx }
s.pos.x += b.vx * dt
s.pos.y += b.vy * dt
// Bounce off bottom/top edges
if (b.y < 0) { b.y = 0; b.vy = -b.vy }
else if (b.y > config.height) { b.y = config.height; b.vy = -b.vy }
if (s.pos.x < 0) { s.pos.x = 0; b.vx = -b.vx }
else if (s.pos.x > GW) { s.pos.x = GW; b.vx = -b.vx }
if (s.pos.y < 0) { s.pos.y = 0; b.vy = -b.vy }
else if (s.pos.y > GH) { s.pos.y = GH; b.vy = -b.vy }
}
// FPS counter
frame_count++
fps_timer += dt
if (fps_timer >= 1) {
fps_label.text = "FPS: " + frame_count
frame_count = 0
fps_timer -= 1
}
},
render: function() {
return compositor.execute(compositor.compile(comp_config))
}
}
var hud = function() {
draw.images(bunnyTex, bunnies)
}
})

623
examples/chess/chess.ce
View File

@@ -1,403 +1,232 @@
/* main.js – runs the demo with your prototype-based grid */
var core = use('core')
var camera = use('camera')
var compositor = use('compositor')
var input = use('input')
var shape = use('shape2d')
var sprite_factory = use('sprite')
var text2d = use('text2d')
var json = use('json')
var draw2d = use('prosperon/draw2d')
var Grid = use('grid')
var MovementSystem = use('movement').MovementSystem
var startingPos = use('pieces').startingPosition
var rules = use('rules')
var blob = use('blob')
var S = 60
var GW = S * 8, GH = S * 8
/*──── import our pieces + systems ───────────────────────────────────*/
var Grid = use('grid'); // your new ctor
var MovementSystem = use('movement').MovementSystem;
var startingPos = use('pieces').startingPosition;
var rules = use('rules');
var game_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
var hud_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
/*──── build board ───────────────────────────────────────────────────*/
var grid = Grid(8, 8);
grid.width = 8; // (the ctor didn't store them)
grid.height = 8;
var mover = MovementSystem(grid, rules);
startingPos(grid);
/*──── networking and game state ─────────────────────────────────────*/
var gameState = 'waiting'; // 'waiting', 'searching', 'server_waiting', 'connected'
var isServer = false;
var opponent = null;
var myColor = null; // 'white' or 'black'
var isMyTurn = false;
function updateTitle() {
var title = "Misty Chess - ";
if (gameState == 'waiting') {
title += "Press S to start server or J to join";
} else if (gameState == 'searching') {
title += "Searching for server...";
} else if (gameState == 'server_waiting') {
title += "Waiting for player to join...";
} else if (gameState == 'connected') {
if (myColor) {
title += (mover.turn == myColor ? "Your turn (" + myColor + ")" : "Opponent's turn (" + mover.turn + ")");
} else {
title += mover.turn + " turn";
}
}
log.console(title)
}
// Initialize title
updateTitle();
/*──── mouse → click-to-move ─────────────────────────────────────────*/
var selectPos = null;
var hoverPos = null;
var holdingPiece = false;
var opponentMousePos = null;
var opponentHoldingPiece = false;
var opponentSelectPos = null;
function handleMouseButtonDown(e) {
if (e.which != 0) return;
// Don't allow piece selection unless we have an opponent
if (gameState != 'connected' || !opponent) return;
var mx = e.mouse.x;
var my = e.mouse.y;
var c = [floor(mx / 60), floor(my / 60)];
if (!grid.inBounds(c)) return;
var cell = grid.at(c);
if (length(cell) && cell[0].colour == mover.turn) {
selectPos = c;
holdingPiece = true;
// Send pickup notification to opponent
if (opponent) {
send(opponent, {
type: 'piece_pickup',
pos: c
});
}
} else {
selectPos = null;
}
}
function handleMouseButtonUp(e) {
if (e.which != 0 || !holdingPiece || !selectPos) return;
// Don't allow moves unless we have an opponent and it's our turn
if (gameState != 'connected' || !opponent || !isMyTurn) {
holdingPiece = false;
return;
}
var mx = e.mouse.x;
var my = e.mouse.y;
var c = [floor(mx / 60), floor(my / 60)];
if (!grid.inBounds(c)) {
holdingPiece = false;
return;
}
if (mover.tryMove(grid.at(selectPos)[0], c)) {
log.console("Made move from", selectPos, "to", c);
// Send move to opponent
log.console("Sending move to opponent:", opponent);
send(opponent, {
type: 'move',
from: selectPos,
to: c
});
isMyTurn = false; // It's now opponent's turn
log.console("Move sent, now opponent's turn");
selectPos = null;
updateTitle();
}
holdingPiece = false;
// Send piece drop notification to opponent
if (opponent) {
send(opponent, {
type: 'piece_drop'
});
}
}
function handleMouseMotion(e) {
var mx = e.pos.x;
var my = e.pos.y;
var c = [floor(mx / 60), floor(my / 60)];
if (!grid.inBounds(c)) {
hoverPos = null;
return;
}
hoverPos = c;
// Send mouse position to opponent in real-time
if (opponent && gameState == 'connected') {
send(opponent, {
type: 'mouse_move',
pos: c,
holding: holdingPiece,
selectPos: selectPos
});
}
}
function handleKeyDown(e) {
// S key - start server
if (e.scancode == 22 && gameState == 'waiting') { // S key
startServer();
}
// J key - join server
else if (e.scancode == 13 && gameState == 'waiting') { // J key
joinServer();
}
}
/*──── drawing helpers ───────────────────────────────────────────────*/
/* ── constants ─────────────────────────────────────────────────── */
var S = 60; // square size in px
var light = [0.93,0.93,0.93,1];
var dark = [0.25,0.25,0.25,1];
var allowedColor = [1.0, 0.84, 0.0, 1.0]; // Gold for allowed moves
var myMouseColor = [0.0, 1.0, 0.0, 1.0]; // Green for my mouse
var opponentMouseColor = [1.0, 0.0, 0.0, 1.0]; // Red for opponent mouse
/* ── draw one 8×8 chess board ──────────────────────────────────── */
function drawBoard() {
var y = 0;
var x = 0;
var isMyHover = null;
var isOpponentHover = null;
var isValidMove = null;
var color = null;
for (y = 0; y < 8; ++y)
for (x = 0; x < 8; ++x) {
isMyHover = hoverPos && hoverPos[0] == x && hoverPos[1] == y;
isOpponentHover = opponentMousePos && opponentMousePos[0] == x && opponentMousePos[1] == y;
isValidMove = selectPos && holdingPiece && isValidMoveForTurn(selectPos, [x, y]);
color = ((x+y)&1) ? dark : light;
if (isValidMove) {
color = allowedColor; // Gold for allowed moves
} else if (isMyHover && !isOpponentHover) {
color = myMouseColor; // Green for my mouse
} else if (isOpponentHover) {
color = opponentMouseColor; // Red for opponent mouse
}
draw2d.rectangle(
{ x: x*S, y: y*S, width: S, height: S },
{ thickness: 0 },
{ color: color }
);
}
}
function isValidMoveForTurn(from, to) {
if (!grid.inBounds(to)) return false;
var piece = grid.at(from)[0];
if (!piece) return false;
// Check if the destination has a piece of the same color
var destCell = grid.at(to);
if (length(destCell) && destCell[0].colour == piece.colour) {
return false;
}
return rules.canMove(piece, from, to, grid);
}
/* ── draw every live piece ─────────────────────────────────────── */
function drawPieces() {
var piece = null;
var r = null;
var opponentPiece = null;
grid.each(function (p) {
if (p.captured) return;
// Skip drawing the piece being held (by me or opponent)
if (holdingPiece && selectPos &&
p.coord[0] == selectPos[0] &&
p.coord[1] == selectPos[1]) {
return;
}
// Skip drawing the piece being held by opponent
if (opponentHoldingPiece && opponentSelectPos &&
p.coord[0] == opponentSelectPos[0] &&
p.coord[1] == opponentSelectPos[1]) {
return;
}
var pr = { x: p.coord[0]*S, y: p.coord[1]*S,
width:S, height:S };
draw2d.image(p.sprite, pr);
});
// Draw the held piece at the mouse position if we're holding one
if (holdingPiece && selectPos && hoverPos) {
piece = grid.at(selectPos)[0];
if (piece) {
r = { x: hoverPos[0]*S, y: hoverPos[1]*S,
width:S, height:S };
draw2d.image(piece.sprite, r);
}
}
// Draw opponent's held piece if they're dragging one
if (opponentHoldingPiece && opponentSelectPos && opponentMousePos) {
opponentPiece = grid.at(opponentSelectPos)[0];
if (opponentPiece) {
r = { x: opponentMousePos[0]*S, y: opponentMousePos[1]*S,
width:S, height:S };
// Draw with slight transparency to show it's the opponent's piece
draw2d.image(opponentPiece.sprite, r);
}
}
}
function update(dt)
{
return {}
}
function draw()
{
draw2d.clear()
drawBoard()
drawPieces()
return draw2d.get_commands()
}
function startServer() {
gameState = 'server_waiting';
isServer = true;
myColor = 'white';
isMyTurn = true;
updateTitle();
$portal(e => {
log.console("Portal received contact message");
// Reply with this actor to establish connection
log.console ($self)
send(e, $self);
log.console("Portal replied with server actor");
}, 5678);
}
function joinServer() {
gameState = 'searching';
updateTitle();
function contact_fn(actor, reason) {
log.console("CONTACTED!", actor ? "SUCCESS" : "FAILED", reason);
if (actor) {
opponent = actor;
log.console("Connection established with server, sending join request");
// Send a greet message with our actor object
send(opponent, {
type: 'greet',
client_actor: $self
});
} else {
log.console(`Failed to connect: ${reason}`);
gameState = 'waiting';
updateTitle();
}
}
$contact(contact_fn, {
address: "192.168.0.149",
port: 5678
});
}
$receiver(e => {
var fromCell = null;
var piece = null;
if (e.kind == 'update')
send(e, update(e.dt))
else if (e.kind == 'draw')
send(e, draw())
else if (e.type == 'game_start' || e.type == 'move' || e.type == 'greet')
log.console("Receiver got message:", e.type, e);
if (e.type == 'greet') {
log.console("Server received greet from client");
// Store the client's actor object for ongoing communication
opponent = e.client_actor;
log.console("Stored client actor:", opponent);
gameState = 'connected';
updateTitle();
// Send game_start to the client
log.console("Sending game_start to client");
send(opponent, {
type: 'game_start',
your_color: 'black'
});
log.console("game_start message sent to client");
}
else if (e.type == 'game_start') {
log.console("Game starting, I am:", e.your_color);
myColor = e.your_color;
isMyTurn = (myColor == 'white');
gameState = 'connected';
updateTitle();
} else if (e.type == 'move') {
log.console("Received move from opponent:", e.from, "to", e.to);
// Apply opponent's move
fromCell = grid.at(e.from);
if (length(fromCell)) {
piece = fromCell[0];
if (mover.tryMove(piece, e.to)) {
isMyTurn = true; // It's now our turn
updateTitle();
log.console("Applied opponent move, now my turn");
} else {
log.console("Failed to apply opponent move");
}
} else {
log.console("No piece found at from position");
}
} else if (e.type == 'mouse_move') {
// Update opponent's mouse position
opponentMousePos = e.pos;
opponentHoldingPiece = e.holding;
opponentSelectPos = e.selectPos;
} else if (e.type == 'piece_pickup') {
// Opponent picked up a piece
opponentSelectPos = e.pos;
opponentHoldingPiece = true;
} else if (e.type == 'piece_drop') {
// Opponent dropped their piece
opponentHoldingPiece = false;
opponentSelectPos = null;
} else if (e.type == 'mouse_button_down') {
handleMouseButtonDown(e)
} else if (e.type == 'mouse_button_up') {
handleMouseButtonUp(e)
} else if (e.type == 'mouse_motion') {
handleMouseMotion(e)
} else if (e.type == 'key_down') {
handleKeyDown(e)
input.configure({
action_map: {
select: ['mouse_button_left'],
cancel: ['escape', 'mouse_button_right']
}
})
// Build board
var grid = Grid(8, 8)
grid.width = 8
grid.height = 8
var mover = MovementSystem(grid, rules)
startingPos(grid)
// Board squares (shape2d)
var light_color = {r: 0.93, g: 0.93, b: 0.85, a: 1}
var dark_color = {r: 0.45, g: 0.55, b: 0.35, a: 1}
var select_color = {r: 1, g: 0.84, b: 0, a: 1}
var valid_color = {r: 0.6, g: 0.8, b: 0.4, a: 1}
var board_shapes = []
var bx = 0, by = 0
for (by = 0; by < 8; by++) {
var row = []
for (bx = 0; bx < 8; bx++) {
var col = ((bx + by) & 1) ? dark_color : light_color
push(row, shape.rect({
pos: {x: bx * S + S / 2, y: by * S + S / 2},
width: S, height: S,
fill: {r: col.r, g: col.g, b: col.b, a: col.a},
plane: 'game', layer: 0
}))
}
push(board_shapes, row)
}
// Piece sprites — one per piece, keyed by piece object
var piece_sprites = {}
var piece_id = 0
grid.each(function(p) {
piece_id++
p._id = piece_id
piece_sprites[piece_id] = sprite_factory({
image: p.sprite,
pos: {x: p.coord[0] * S + S / 2, y: p.coord[1] * S + S / 2},
width: S, height: S,
anchor_x: 0.5, anchor_y: 0.5,
plane: 'game', layer: 1
})
})
// Selection state
var selectPos = null
var validMoves = []
// Mouse position in grid coords
var hover_gx = -1, hover_gy = -1
// Status text
var status_label = text2d({
text: "White's turn", pos: {x: 10, y: GH - 20},
plane: 'hud', size: 14, color: {r: 1, g: 1, b: 1, a: 1}
})
function update_status() {
status_label.text = mover.turn + "'s turn"
}
function reset_board_colors() {
var x = 0, y = 0
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) {
var col = ((x + y) & 1) ? dark_color : light_color
board_shapes[y][x].fill = {r: col.r, g: col.g, b: col.b, a: col.a}
}
}
}
function highlight_selection() {
reset_board_colors()
if (!selectPos) return
// Highlight selected square
board_shapes[selectPos[1]][selectPos[0]].fill = {
r: select_color.r, g: select_color.g, b: select_color.b, a: select_color.a
}
// Highlight valid moves
var i = 0
for (i = 0; i < length(validMoves); i++) {
var m = validMoves[i]
board_shapes[m[1]][m[0]].fill = {
r: valid_color.r, g: valid_color.g, b: valid_color.b, a: valid_color.a
}
}
}
function compute_valid_moves(from) {
validMoves = []
var piece = grid.at(from)[0]
if (!piece) return
var x = 0, y = 0, to = null, dest = null
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) {
to = [x, y]
dest = grid.at(to)
if (length(dest) && dest[0].colour == piece.colour) continue
if (rules.canMove(piece, from, to, grid))
push(validMoves, to)
}
}
}
function sync_piece_sprites() {
grid.each(function(p) {
var spr = piece_sprites[p._id]
if (!spr) return
if (p.captured) {
spr.visible = false
} else {
spr.pos.x = p.coord[0] * S + S / 2
spr.pos.y = p.coord[1] * S + S / 2
spr.visible = true
}
})
}
// Input handler
var game_input = {
on_input: function(action, data) {
if (!data.pressed) return
if (action == 'cancel') {
selectPos = null
validMoves = []
highlight_selection()
return
}
if (action == 'select' && hover_gx >= 0 && hover_gx < 8 && hover_gy >= 0 && hover_gy < 8) {
var clicked = [hover_gx, hover_gy]
var cell = grid.at(clicked)
if (selectPos) {
// Try to move
var is_valid = false
var i = 0
for (i = 0; i < length(validMoves); i++) {
if (validMoves[i][0] == clicked[0] && validMoves[i][1] == clicked[1]) {
is_valid = true
break
}
}
if (is_valid) {
var src_piece = grid.at(selectPos)[0]
if (src_piece && mover.tryMove(src_piece, clicked)) {
sync_piece_sprites()
update_status()
}
selectPos = null
validMoves = []
} else if (length(cell) && cell[0].colour == mover.turn) {
// Select different piece
selectPos = clicked
compute_valid_moves(selectPos)
} else {
selectPos = null
validMoves = []
}
} else {
// Select piece
if (length(cell) && cell[0].colour == mover.turn) {
selectPos = clicked
compute_valid_moves(selectPos)
}
}
highlight_selection()
}
}
}
input.player1().possess(game_input)
var comp_config = {
clear: {r: 0.15, g: 0.15, b: 0.2, a: 1},
planes: [
{name: 'game', camera: game_cam, resolution: {width: GW, height: GH}, presentation: 'letterbox'},
{name: 'hud', camera: hud_cam, resolution: {width: GW, height: GH}, presentation: 'stretch'}
]
}
core.start({
width: 640, height: 640, title: "Chess",
input: function(ev) {
if (ev.type == 'mouse_motion') {
// Convert pixel coords to grid coords via camera
var wp = game_cam.window_to_world(ev.pos.x, ev.pos.y)
if (wp) {
hover_gx = floor(wp.x / S)
hover_gy = floor(wp.y / S)
}
}
},
update: function(dt) {
},
render: function() {
return compositor.execute(compositor.compile(comp_config))
}
})

10
examples/chess/config.cm
View File

@@ -1,9 +1,5 @@
// Chess game configuration for Moth framework
return {
title: "Chess",
resolution: { width: 480, height: 480 },
internal_resolution: { width: 480, height: 480 },
fps: 60,
clearColor: [22/255, 120/255, 194/255, 1],
mode: 'stretch' // No letterboxing for chess
};
width: 640,
height: 640
}

4
examples/pong/config.cm
View File

@@ -1,5 +1,5 @@
return {
title: "Pong",
width: 858,
height: 525
width: 960,
height: 540
}

193
examples/pong/main.ce
View File

@@ -1,86 +1,127 @@
// main.js
var draw = use('draw2d')
var config = use('config')
var color = use('color')
var random = use('random')
var core = use('core')
var camera = use('camera')
var compositor = use('compositor')
var input = use('input')
var shape = use('shape2d')
var text2d = use('text2d')
prosperon.camera.transform.pos = [0,0]
var paddleW = 10, paddleH = 80
var p1 = {x: 30, y: config.height*0.5, speed: 300}
var p2 = {x: config.width-30, y: config.height*0.5, speed: 300}
var ball = {x: 0, y: 0, vx: 220, vy: 150, size: 10}
var GW = 480, GH = 270
var paddleW = 8, paddleH = 50, speed = 200
var ballSize = 8
var bvx = 220, bvy = 150
var score1 = 0, score2 = 0
function resetBall() {
ball.x = config.width*0.5
ball.y = config.height*0.5
// give it a random vertical bounce
ball.vy = (random.random()<0.5 ? -1:1)*150
// keep horizontal speed to the same magnitude
ball.vx = ball.vx>0 ? 220 : -220
// Cameras: game at pixel-art res, HUD at native
var game_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
var hud_cam = camera.make({width: 960, height: 540, pos: {x: 480, y: 270}})
// Action mapping
input.configure({
action_map: {
p1_up: ['w'],
p1_down: ['s'],
p2_up: ['up'],
p2_down: ['down']
}
})
// Retained shapes — game plane
var midline = shape.rect({
pos: {x: GW / 2, y: GH / 2}, width: 2, height: GH,
fill: {r: 0.3, g: 0.3, b: 0.3, a: 1}, plane: 'game'
})
var p1 = shape.rect({
pos: {x: 20, y: GH / 2}, width: paddleW, height: paddleH,
fill: {r: 1, g: 1, b: 1, a: 1}, plane: 'game'
})
var p2 = shape.rect({
pos: {x: GW - 20, y: GH / 2}, width: paddleW, height: paddleH,
fill: {r: 1, g: 1, b: 1, a: 1}, plane: 'game'
})
var ball = shape.rect({
pos: {x: GW / 2, y: GH / 2}, width: ballSize, height: ballSize,
fill: {r: 1, g: 1, b: 1, a: 1}, plane: 'game', groups: ['glow']
})
// HUD plane — score text
var score_label = text2d({
text: "0 0", pos: {x: 420, y: 490},
plane: 'hud', size: 32, color: {r: 1, g: 1, b: 1, a: 1}
})
function reset_ball() {
ball.pos.x = GW / 2
ball.pos.y = GH / 2
bvy = (bvy > 0 ? -1 : 1) * 150
bvx = bvx > 0 ? -220 : 220
}
resetBall()
var update = function(dt) {
// Move paddles: positive Y is up, so W/↑ means p.y += speed
if (input.keyboard.down('w')) p1.y += p1.speed*dt
if (input.keyboard.down('s')) p1.y -= p1.speed*dt
// Paddle 2 movement (ArrowUp = up, ArrowDown = down)
if (input.keyboard.down('i')) p2.y += p2.speed*dt
if (input.keyboard.down('k')) p2.y -= p2.speed*dt
// Clamp paddles to screen
if (p1.y < paddleH*0.5) p1.y = paddleH*0.5
if (p1.y > config.height - paddleH*0.5) p1.y = config.height - paddleH*0.5
if (p2.y < paddleH*0.5) p2.y = paddleH*0.5
if (p2.y > config.height - paddleH*0.5) p2.y = config.height - paddleH*0.5
// Move ball
ball.x += ball.vx*dt
ball.y += ball.vy*dt
// Bounce top/bottom
if (ball.y+ball.size*0.5>config.height || ball.y-ball.size*0.5<0) ball.vy = -ball.vy
// Check paddle collisions
// p1 bounding box
var left1 = p1.x - paddleW*0.5, right1 = p1.x + paddleW*0.5
var top1 = p1.y + paddleH*0.5, bottom1 = p1.y - paddleH*0.5
// p2 bounding box
var left2 = p2.x - paddleW*0.5, right2 = p2.x + paddleW*0.5
var top2 = p2.y + paddleH*0.5, bottom2 = p2.y - paddleH*0.5
// ball half-edges
var l = ball.x - ball.size*0.5, r = ball.x + ball.size*0.5
var b = ball.y - ball.size*0.5, t = ball.y + ball.size*0.5
// Collide with paddle 1?
if (r>left1 && l<right1 && t>bottom1 && b<top1)
ball.vx = abs(ball.vx)
// Collide with paddle 2?
if (r>left2 && l<right2 && t>bottom2 && b<top2)
ball.vx = -abs(ball.vx)
// Check left/right out-of-bounds
if (r<0) { score2++; resetBall() }
if (l>config.width) { score1++; resetBall() }
// Compositor: game plane with bloom on ball, HUD overlay
var comp_config = {
clear: {r: 0, g: 0, b: 0, a: 1},
planes: [
{name: 'game', camera: game_cam, resolution: {width: GW, height: GH}, presentation: 'letterbox'},
{name: 'hud', camera: hud_cam, resolution: {width: 960, height: 540}, presentation: 'stretch'}
],
group_effects: {
glow: {effects: [{type: 'bloom', threshold: 0.3, intensity: 2}]}
}
}
var hud = function() {
// Clear screen black
draw.rectangle({x:0, y:0, width:config.width, height:config.height}, [0,0,0,1])
core.start({
width: 960, height: 540, title: "Pong",
// Draw paddles
draw.rectangle({x:p1.x - paddleW*0.5, y:p1.y - paddleH*0.5, width:paddleW, height:paddleH}, color.white)
draw.rectangle({x:p2.x - paddleW*0.5, y:p2.y - paddleH*0.5, width:paddleW, height:paddleH}, color.white)
update: function(dt) {
var down = input.player1().down()
// Draw ball
draw.rectangle({x:ball.x - ball.size*0.5, y:ball.y - ball.size*0.5, width:ball.size, height:ball.size}, color.white)
// Move paddles
if (down.p1_up) p1.pos.y += speed * dt
if (down.p1_down) p1.pos.y -= speed * dt
if (down.p2_up) p2.pos.y += speed * dt
if (down.p2_down) p2.pos.y -= speed * dt
// Simple score display
var msg = score1 + " " + score2
draw.text(msg, {x:0, y:10, width:config.width, height:40}, null, 0, color.white, 0)
}
// Clamp paddles
var hh = paddleH / 2
if (p1.pos.y < hh) p1.pos.y = hh
if (p1.pos.y > GH - hh) p1.pos.y = GH - hh
if (p2.pos.y < hh) p2.pos.y = hh
if (p2.pos.y > GH - hh) p2.pos.y = GH - hh
// Move ball
ball.pos.x += bvx * dt
ball.pos.y += bvy * dt
// Bounce top/bottom
var bs = ballSize / 2
if (ball.pos.y - bs < 0 || ball.pos.y + bs > GH) bvy = -bvy
// Paddle collisions
var bx = ball.pos.x, by = ball.pos.y
var pw = paddleW / 2, ph = paddleH / 2
if (bx - bs < p1.pos.x + pw && bx + bs > p1.pos.x - pw &&
by + bs > p1.pos.y - ph && by - bs < p1.pos.y + ph)
bvx = abs(bvx)
if (bx + bs > p2.pos.x - pw && bx - bs < p2.pos.x + pw &&
by + bs > p2.pos.y - ph && by - bs < p2.pos.y + ph)
bvx = -abs(bvx)
// Scoring
if (bx < 0) {
score2++
score_label.text = score1 + " " + score2
reset_ball()
}
if (bx > GW) {
score1++
score_label.text = score1 + " " + score2
reset_ball()
}
},
render: function() {
return compositor.execute(compositor.compile(comp_config))
}
})

275
examples/snake/main.ce
View File

@@ -1,125 +1,192 @@
// main.js
var draw = use('draw2d')
var render = use('render')
var graphics = use('graphics')
var core = use('core')
var camera = use('camera')
var compositor = use('compositor')
var input = use('input')
var config = use('config')
var color = use('color')
var shape = use('shape2d')
var text2d = use('text2d')
var tw = use('tween')
var ease = use('ease')
var random = use('random')
prosperon.camera.transform.pos = [0,0]
var GW = 600, GH = 600
var cellSize = 20
var gridW = floor(config.width / cellSize)
var gridH = floor(config.height / cellSize)
var gridW = GW / cellSize
var gridH = GH / cellSize
var snake = null, direction = null, nextDirection = null, apple = null
var moveInterval = 0.1
var moveTimer = 0
var gameState = "playing"
var game_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
var hud_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
function resetGame() {
var cx = floor(gridW / 2)
var cy = floor(gridH / 2)
snake = [
{x: cx, y: cy},
{x: cx-1, y: cy},
{x: cx-2, y: cy}
]
direction = {x:1, y:0}
nextDirection = {x:1, y:0}
spawnApple()
gameState = "playing"
moveTimer = 0
// Action mapping with possession
input.configure({
action_map: {
up: ['w', 'up'],
down: ['s', 'down'],
left: ['a', 'left'],
right: ['d', 'right'],
restart: ['space']
}
})
// Game state
var snake_shapes = []
var snake_pos = []
var dir = {x: 1, y: 0}
var next_dir = {x: 1, y: 0}
var move_timer = 0
var move_interval = 0.12
var state = 'playing'
var gameover_label = null
var score = 0
var score_label = null
// Input handler entity — possessed by player1
var game_input = {
on_input: function(action, data) {
if (!data.pressed) return
if (state == 'playing') {
if (action == 'up' && dir.y != -1) next_dir = {x: 0, y: 1}
if (action == 'down' && dir.y != 1) next_dir = {x: 0, y: -1}
if (action == 'left' && dir.x != 1) next_dir = {x: -1, y: 0}
if (action == 'right' && dir.x != -1) next_dir = {x: 1, y: 0}
}
if (action == 'restart' && state == 'gameover') reset_game()
}
}
input.player1().possess(game_input)
function grid_to_world(gx, gy) {
return {x: gx * cellSize + cellSize / 2, y: gy * cellSize + cellSize / 2}
}
function spawnApple() {
apple = {x:floor(random.random()*gridW), y:floor(random.random()*gridH)}
// Re-spawn if apple lands on snake
var i = 0;
for (i=0; i<length(snake); i++)
if (snake[i].x == apple.x && snake[i].y == apple.y) { spawnApple(); return }
}
// Apple
var apple_gx = 0, apple_gy = 0
var apple_shape = shape.rect({
pos: {x: 0, y: 0}, width: cellSize - 2, height: cellSize - 2,
fill: {r: 1, g: 0.2, b: 0.2, a: 1}, plane: 'game'
})
function wrap(pos) {
if (pos.x < 0) pos.x = gridW - 1
if (pos.x >= gridW) pos.x = 0
if (pos.y < 0) pos.y = gridH - 1
if (pos.y >= gridH) pos.y = 0
}
resetGame()
var update = function(dt) {
if (gameState != "playing") return
moveTimer += dt
if (moveTimer < moveInterval) return
moveTimer -= moveInterval
// Update direction
direction = {x: nextDirection.x, y: nextDirection.y}
// New head
var head = {x: snake[0].x + direction.x, y: snake[0].y + direction.y}
wrap(head)
// Check collision with body
var i = 0;
for (i=0; i<length(snake); i++) {
if (snake[i].x == head.x && snake[i].y == head.y) {
gameState = "gameover"
function spawn_apple() {
apple_gx = floor(random.random() * gridW)
apple_gy = floor(random.random() * gridH)
var i = 0
for (i = 0; i < length(snake_pos); i++) {
if (snake_pos[i].x == apple_gx && snake_pos[i].y == apple_gy) {
spawn_apple()
return
}
}
// Place head
snake.unshift(head)
// Eat apple?
if (head.x == apple.x && head.y == apple.y) spawnApple()
else pop(snake)
var wp = grid_to_world(apple_gx, apple_gy)
apple_shape.pos.x = wp.x
apple_shape.pos.y = wp.y
}
var hud = function() {
// Optional clear screen
draw.rectangle({x:0, y:0, width:config.width, height:config.height}, [0,0,0,1])
function reset_game() {
var i = 0
for (i = 0; i < length(snake_shapes); i++)
snake_shapes[i].destroy()
snake_shapes = []
snake_pos = []
// Draw snake
var i = 0;
var s = null;
var msg = null;
for (i=0; i<length(snake); i++) {
s = snake[i]
draw.rectangle({x:s.x*cellSize, y:s.y*cellSize, width:cellSize, height:cellSize}, color.green)
var cx = floor(gridW / 2)
var cy = floor(gridH / 2)
var wp = null
for (i = 0; i < 3; i++) {
push(snake_pos, {x: cx - i, y: cy})
wp = grid_to_world(cx - i, cy)
push(snake_shapes, shape.rect({
pos: {x: wp.x, y: wp.y}, width: cellSize - 2, height: cellSize - 2,
fill: {r: 0, g: 1, b: 0.3, a: 1}, plane: 'game'
}))
}
// Draw apple
draw.rectangle({x:apple.x*cellSize, y:apple.y*cellSize, width:cellSize, height:cellSize}, color.red)
if (gameState == "gameover") {
msg = "GAME OVER! Press SPACE to restart."
draw.text(msg, {x:0, y:config.height*0.5-10, width:config.width, height:20}, null, 0, color.white)
}
dir = {x: 1, y: 0}
next_dir = {x: 1, y: 0}
state = 'playing'
move_timer = 0
score = 0
if (score_label) score_label.text = "Score: 0"
if (gameover_label) { gameover_label.destroy(); gameover_label = null }
spawn_apple()
}
// No immediate reversal
// "Up" means y=1, so going physically up on screen
var inputs = {
up: function() {
if (direction.y != -1) nextDirection = {x:0,y:1}
},
down: function() {
if (direction.y != 1) nextDirection = {x:0,y:-1}
},
left: function() {
if (direction.x != 1) nextDirection = {x:-1,y:0}
},
right: function() {
if (direction.x != -1) nextDirection = {x:1,y:0}
},
space: function() {
if (gameState=="gameover") resetGame()
}
// HUD
score_label = text2d({
text: "Score: 0", pos: {x: 10, y: GH - 30},
plane: 'hud', size: 16, color: {r: 1, g: 1, b: 1, a: 1}
})
reset_game()
var comp_config = {
clear: {r: 0.08, g: 0.08, b: 0.1, a: 1},
planes: [
{name: 'game', camera: game_cam, resolution: {width: GW, height: GH}, presentation: 'letterbox'},
{name: 'hud', camera: hud_cam, resolution: {width: GW, height: GH}, presentation: 'stretch'}
]
}
//input.player[0].control()
core.start({
width: 600, height: 600, title: "Snake",
update: function(dt) {
if (state != 'playing') return
move_timer += dt
if (move_timer < move_interval) return
move_timer -= move_interval
dir.x = next_dir.x
dir.y = next_dir.y
// New head position
var hx = snake_pos[0].x + dir.x
var hy = snake_pos[0].y + dir.y
// Wrap
if (hx < 0) hx = gridW - 1
if (hx >= gridW) hx = 0
if (hy < 0) hy = gridH - 1
if (hy >= gridH) hy = 0
// Self collision
var i = 0
for (i = 0; i < length(snake_pos); i++) {
if (snake_pos[i].x == hx && snake_pos[i].y == hy) {
state = 'gameover'
gameover_label = text2d({
text: "GAME OVER — SPACE to restart",
pos: {x: GW / 2 - 170, y: GH / 2},
plane: 'hud', size: 20, color: {r: 1, g: 0.3, b: 0.3, a: 1}
})
return
}
}
// Add head with tween from old head position
var old_wp = grid_to_world(snake_pos[0].x, snake_pos[0].y)
var new_wp = grid_to_world(hx, hy)
snake_pos.unshift({x: hx, y: hy})
var head = shape.rect({
pos: {x: old_wp.x, y: old_wp.y}, width: cellSize - 2, height: cellSize - 2,
fill: {r: 0, g: 1, b: 0.3, a: 1}, plane: 'game'
})
// Smooth tween from old position to new position
tw.tween(head.pos).to({x: new_wp.x, y: new_wp.y}, move_interval).ease(ease.linear)
snake_shapes.unshift(head)
// Eat apple?
if (hx == apple_gx && hy == apple_gy) {
score++
score_label.text = "Score: " + score
spawn_apple()
} else {
// Remove tail
var tail = pop(snake_shapes)
tail.destroy()
pop(snake_pos)
}
},
render: function() {
return compositor.execute(compositor.compile(comp_config))
}
})

491
examples/tetris/main.ce
View File

@@ -1,123 +1,151 @@
var draw = use('draw2d')
var core = use('core')
var camera = use('camera')
var compositor = use('compositor')
var input = use('input')
var config = use('config')
var color = use('color')
var shape = use('shape2d')
var text2d = use('text2d')
var random = use('random')
prosperon.camera.transform.pos = [0,0]
// Board constants
var COLS = 10, ROWS = 20
var TILE = 6 // each cell is 6x6
var TILE = 8
var GW = COLS * TILE + 80 // extra space for next piece + score
var GH = ROWS * TILE
// Board storage (2D), each cell is either 0 or a [r,g,b,a] color
var board = []
var game_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
var hud_cam = camera.make({width: GW, height: GH, pos: {x: GW / 2, y: GH / 2}})
// Gravity timing
var baseGravity = 0.8 // seconds between drops at level 0
var gravityTimer = 0
// Current piece & position
var piece = null
var pieceX = 0
var pieceY = 0
// Next piece
var nextPiece = null
// Score/lines/level
var score = 0
var linesCleared = 0
var level = 0
// Rotation lock to prevent spinning with W
var rotateHeld = false
var gameOver = false
// Horizontal movement gating
var hMoveTimer = 0
var hDelay = 0.2 // delay before repeated moves begin
var hRepeat = 0.05 // time between repeated moves
var prevLeft = false
var prevRight = false
// Action mapping with possession for discrete inputs
input.configure({
action_map: {
left: ['a', 'left'],
right: ['d', 'right'],
rotate: ['w', 'up'],
soft_drop: ['s', 'down'],
hard_drop: ['space']
}
})
// Tetrimino definitions
var SHAPES = {
I: { color:[0,1,1,1], blocks:[[0,0],[1,0],[2,0],[3,0]] },
O: { color:[1,1,0,1], blocks:[[0,0],[1,0],[0,1],[1,1]] },
T: { color:[1,0,1,1], blocks:[[0,0],[1,0],[2,0],[1,1]] },
S: { color:[0,1,0,1], blocks:[[1,0],[2,0],[0,1],[1,1]] },
Z: { color:[1,0,0,1], blocks:[[0,0],[1,0],[1,1],[2,1]] },
J: { color:[0,0,1,1], blocks:[[0,0],[0,1],[1,1],[2,1]] },
L: { color:[1,0.5,0,1], blocks:[[2,0],[0,1],[1,1],[2,1]] }
I: {color: {r: 0, g: 1, b: 1, a: 1}, blocks: [[0, 0], [1, 0], [2, 0], [3, 0]]},
O: {color: {r: 1, g: 1, b: 0, a: 1}, blocks: [[0, 0], [1, 0], [0, 1], [1, 1]]},
T: {color: {r: 1, g: 0, b: 1, a: 1}, blocks: [[0, 0], [1, 0], [2, 0], [1, 1]]},
S: {color: {r: 0, g: 1, b: 0, a: 1}, blocks: [[1, 0], [2, 0], [0, 1], [1, 1]]},
Z: {color: {r: 1, g: 0, b: 0, a: 1}, blocks: [[0, 0], [1, 0], [1, 1], [2, 1]]},
J: {color: {r: 0, g: 0, b: 1, a: 1}, blocks: [[0, 0], [0, 1], [1, 1], [2, 1]]},
L: {color: {r: 1, g: 0.5, b: 0, a: 1}, blocks: [[2, 0], [0, 1], [1, 1], [2, 1]]}
}
var shapeKeys = array(SHAPES)
// Initialize board with empty (0)
function initBoard() {
// Board: 2D array, null or color object
var board = []
// Board shapes: one shape per cell, toggled visible
var board_shapes = []
function init_board() {
board = []
var r = 0;
var row = null;
var c = 0;
for (r=0; r<ROWS; r++) {
row = []
for (c=0; c<COLS; c++) push(row, 0)
board_shapes = []
var r = 0, c = 0
for (r = 0; r < ROWS; r++) {
var row = []
var srow = []
for (c = 0; c < COLS; c++) {
push(row, null)
push(srow, shape.rect({
pos: {x: c * TILE + TILE / 2, y: r * TILE + TILE / 2},
width: TILE - 1, height: TILE - 1,
fill: {r: 0.5, g: 0.5, b: 0.5, a: 1},
plane: 'game', layer: 0, visible: false
}))
}
push(board, row)
push(board_shapes, srow)
}
}
initBoard()
function randomShape() {
var key = shapeKeys[floor(random.random()*length(shapeKeys))]
// Make a copy of the shape's blocks
// Active piece
var piece = null, pieceX = 0, pieceY = 0
var piece_shapes = []
var nextPiece = null
// Score
var score = 0, linesCleared = 0, level = 0
var gameOver = false
// Gravity
var baseGravity = 0.8
var gravityTimer = 0
var softDropping = false
// Horizontal DAS
var hMoveTimer = 0
var hDelay = 0.18
var hRepeat = 0.05
var hDir = 0
var hHeld = false
// Rotate lock
var rotateHeld = false
var score_label = text2d({
text: "Score: 0", pos: {x: COLS * TILE + 5, y: GH - 15},
plane: 'hud', size: 8, color: {r: 1, g: 1, b: 1, a: 1}
})
var level_label = text2d({
text: "Level: 0", pos: {x: COLS * TILE + 5, y: GH - 30},
plane: 'hud', size: 8, color: {r: 1, g: 1, b: 1, a: 1}
})
var next_label = text2d({
text: "Next:", pos: {x: COLS * TILE + 5, y: 50},
plane: 'hud', size: 8, color: {r: 1, g: 1, b: 1, a: 1}
})
// Next piece display shapes
var next_shapes = []
var ns = 0
for (ns = 0; ns < 4; ns++) {
push(next_shapes, shape.rect({
pos: {x: 0, y: 0}, width: TILE - 1, height: TILE - 1,
fill: {r: 1, g: 1, b: 1, a: 1}, plane: 'game', layer: 2, visible: false
}))
}
function random_shape() {
var key = shapeKeys[floor(random.random() * length(shapeKeys))]
return {
type: key,
color: SHAPES[key].color,
blocks: array(SHAPES[key].blocks, b => [b[0], b[1]])
blocks: array(SHAPES[key].blocks, function(b) { return [b[0], b[1]] })
}
}
function spawnPiece() {
piece = nextPiece || randomShape()
nextPiece = randomShape()
pieceX = 3
pieceY = 0
// Collision on spawn => game over
if (collides(pieceX, pieceY, piece.blocks)) gameOver = true
}
function collides(px, py, blocks) {
var i = 0;
var x = 0;
var y = 0;
for (i=0; i<length(blocks); i++) {
var i = 0, x = 0, y = 0
for (i = 0; i < length(blocks); i++) {
x = px + blocks[i][0]
y = py + blocks[i][1]
if (x<0 || x>=COLS || y<0 || y>=ROWS) return true
if (y>=0 && board[y][x]) return true
if (x < 0 || x >= COLS || y < 0 || y >= ROWS) return true
if (y >= 0 && board[y][x]) return true
}
return false
}
// Lock piece into board
function lockPiece() {
var i = 0;
var x = 0;
var y = 0;
for (i=0; i<length(piece.blocks); i++) {
function lock_piece() {
var i = 0, x = 0, y = 0
for (i = 0; i < length(piece.blocks); i++) {
x = pieceX + piece.blocks[i][0]
y = pieceY + piece.blocks[i][1]
if (y>=0) board[y][x] = piece.color
if (y >= 0 && y < ROWS && x >= 0 && x < COLS) {
board[y][x] = piece.color
board_shapes[y][x].fill = piece.color
board_shapes[y][x].visible = true
}
}
}
// Rotate 90° clockwise
function rotate(blocks) {
// (x,y) => (y,-x)
var i = 0;
var x = 0;
var y = 0;
for (i=0; i<length(blocks); i++) {
function rotate_blocks(blocks) {
var i = 0, x = 0, y = 0
for (i = 0; i < length(blocks); i++) {
x = blocks[i][0]
y = blocks[i][1]
blocks[i][0] = y
@@ -125,173 +153,190 @@ function rotate(blocks) {
}
}
function clearLines() {
function clear_lines() {
var lines = 0
var r = ROWS-1;
var newRow = null;
var c = 0;
for (r=ROWS-1; r>=0;) {
if (every(board[r], cell => cell)) {
var r = ROWS - 1, c = 0, full = false, newRow = null
while (r >= 0) {
full = true
for (c = 0; c < COLS; c++) {
if (!board[r][c]) { full = false; break }
}
if (full) {
lines++
// remove row
board = array(array(board, 0, r), array(board, r+1))
// add empty row on top
newRow = []
for (c=0; c<COLS; c++) push(newRow, 0)
board.unshift(newRow)
// Shift rows down
var sr = r
while (sr > 0) {
for (c = 0; c < COLS; c++) {
board[sr][c] = board[sr - 1][c]
if (board[sr][c]) {
board_shapes[sr][c].fill = board[sr][c]
board_shapes[sr][c].visible = true
} else {
board_shapes[sr][c].visible = false
}
}
sr--
}
for (c = 0; c < COLS; c++) {
board[0][c] = null
board_shapes[0][c].visible = false
}
} else {
r--
}
}
// Score
if (lines==1) score += 100
else if (lines==2) score += 300
else if (lines==3) score += 500
else if (lines==4) score += 800
if (lines == 1) score += 100
else if (lines == 2) score += 300
else if (lines == 3) score += 500
else if (lines == 4) score += 800
linesCleared += lines
level = floor(linesCleared/10)
level = floor(linesCleared / 10)
score_label.text = "Score: " + score
level_label.text = "Level: " + level
}
function placePiece() {
lockPiece()
clearLines()
spawnPiece()
function update_piece_shapes() {
var i = 0
for (i = 0; i < 4; i++) {
var bx = pieceX + piece.blocks[i][0]
var by = pieceY + piece.blocks[i][1]
piece_shapes[i].pos.x = bx * TILE + TILE / 2
piece_shapes[i].pos.y = by * TILE + TILE / 2
piece_shapes[i].fill = piece.color
piece_shapes[i].visible = true
}
}
// Hard drop
function hardDrop() {
while(!collides(pieceX, pieceY+1, piece.blocks)) pieceY++
placePiece()
function update_next_display() {
var i = 0
for (i = 0; i < 4; i++) {
var bx = nextPiece.blocks[i][0]
var by = nextPiece.blocks[i][1]
next_shapes[i].pos.x = (COLS + 1) * TILE + bx * TILE + TILE / 2
next_shapes[i].pos.y = 20 + by * TILE + TILE / 2
next_shapes[i].fill = nextPiece.color
next_shapes[i].visible = true
}
}
spawnPiece()
var update = function(dt) {
if (gameOver) return
// ======= Horizontal Movement Gate =======
var leftPressed = input.keyboard.down('a')
var rightPressed = input.keyboard.down('d')
var horizontalMove = 0
// If user just pressed A, move once & start gating
if (leftPressed && !prevLeft) {
horizontalMove = -1
hMoveTimer = hDelay
}
// If user is holding A & the timer is up, move again, then reset timer to repeat
else if (leftPressed && hMoveTimer <= 0) {
horizontalMove = -1
hMoveTimer = hRepeat
function spawn_piece() {
piece = nextPiece || random_shape()
nextPiece = random_shape()
pieceX = 3
pieceY = 0
if (collides(pieceX, pieceY, piece.blocks)) {
gameOver = true
var i = 0
for (i = 0; i < 4; i++) piece_shapes[i].visible = false
return
}
update_piece_shapes()
update_next_display()
}
// Same logic for D
if (rightPressed && !prevRight) {
horizontalMove = 1
hMoveTimer = hDelay
} else if (rightPressed && hMoveTimer <= 0) {
horizontalMove = 1
hMoveTimer = hRepeat
}
function place_piece() {
lock_piece()
clear_lines()
spawn_piece()
}
// Move horizontally if it doesn't collide
if (horizontalMove < 0 && !collides(pieceX-1, pieceY, piece.blocks)) pieceX--
else if (horizontalMove > 0 && !collides(pieceX+1, pieceY, piece.blocks)) pieceX++
// Create 4 shapes for active piece (layer 1 = on top of board)
var pi = 0
for (pi = 0; pi < 4; pi++) {
push(piece_shapes, shape.rect({
pos: {x: 0, y: 0}, width: TILE - 1, height: TILE - 1,
fill: {r: 1, g: 1, b: 1, a: 1}, plane: 'game', layer: 1, visible: false
}))
}
// If neither A nor D is pressed, reset the timer so next press is immediate
if (!leftPressed && !rightPressed) {
hMoveTimer = 0
}
init_board()
spawn_piece()
// Decrement horizontal timer
hMoveTimer -= dt
prevLeft = leftPressed
prevRight = rightPressed
// ======= End Horizontal Movement Gate =======
// Compositor
var comp_config = {
clear: {r: 0, g: 0, b: 0, a: 1},
planes: [
{name: 'game', camera: game_cam, resolution: {width: GW, height: GH}, presentation: 'letterbox'},
{name: 'hud', camera: hud_cam, resolution: {width: GW, height: GH}, presentation: 'stretch'}
]
}
// Rotate with W (once per press, no spinning)
var test = null;
if (input.keyboard.down('w')) {
if (!rotateHeld) {
rotateHeld = true
test = array(piece.blocks, b => [b[0], b[1]])
rotate(test)
if (!collides(pieceX, pieceY, test)) piece.blocks = test
}
} else {
rotateHeld = false
}
core.start({
width: 640, height: 480, title: "Tetris",
// Soft drop if S is held (accelerates gravity)
var fallSpeed = input.keyboard.down('s') ? 10 : 1
update: function(dt) {
if (gameOver) return
// Gravity
gravityTimer += dt * fallSpeed
var dropInterval = max(0.1, baseGravity - level*0.05)
if (gravityTimer >= dropInterval) {
gravityTimer = 0
if (!collides(pieceX, pieceY+1, piece.blocks)) {
pieceY++
var down = input.player1().down()
var test = null
// Horizontal movement with DAS
var wantLeft = down.left
var wantRight = down.right
var newDir = 0
if (wantLeft && !wantRight) newDir = -1
else if (wantRight && !wantLeft) newDir = 1
if (newDir != 0) {
if (newDir != hDir || !hHeld) {
// First press
if (!collides(pieceX + newDir, pieceY, piece.blocks)) pieceX += newDir
hMoveTimer = hDelay
hDir = newDir
hHeld = true
} else {
hMoveTimer -= dt
if (hMoveTimer <= 0) {
if (!collides(pieceX + newDir, pieceY, piece.blocks)) pieceX += newDir
hMoveTimer = hRepeat
}
}
} else {
placePiece()
hDir = 0
hHeld = false
hMoveTimer = 0
}
}
// Hard drop if space is held
if (input.keyboard.down('space')) {
// hardDrop()
}
}
var hud = function() {
// Clear screen
draw.rectangle({x:0, y:0, width:config.width, height:config.height}, [0,0,0,1])
// Draw board
var r = 0;
var c = 0;
var cell = null;
var i = 0;
var x = 0;
var y = 0;
var nx = 0;
var ny = 0;
var dx = 0;
var dy = 0;
for (r=0; r<ROWS; r++) {
for (c=0; c<COLS; c++) {
cell = board[r][c]
if (!cell) continue
draw.rectangle({x:c*TILE, y:(ROWS-1-r)*TILE, width:TILE, height:TILE}, cell)
// Rotate (once per press)
if (down.rotate) {
if (!rotateHeld) {
rotateHeld = true
test = array(piece.blocks, function(b) { return [b[0], b[1]] })
rotate_blocks(test)
if (!collides(pieceX, pieceY, test)) piece.blocks = test
}
} else {
rotateHeld = false
}
}
// Draw falling piece
if (!gameOver && piece) {
for (i=0; i<length(piece.blocks); i++) {
x = pieceX + piece.blocks[i][0]
y = pieceY + piece.blocks[i][1]
draw.rectangle({x:x*TILE, y:(ROWS-1-y)*TILE, width:TILE, height:TILE}, piece.color)
// Soft drop
softDropping = down.soft_drop
// Hard drop (once per press)
if (down.hard_drop) {
while (!collides(pieceX, pieceY + 1, piece.blocks)) pieceY++
place_piece()
update_piece_shapes()
return
}
}
// Next piece window
draw.text("Next", {x:70, y:5, width:50, height:10}, null, 0, color.white)
if (nextPiece) {
for (i=0; i<length(nextPiece.blocks); i++) {
nx = nextPiece.blocks[i][0]
ny = nextPiece.blocks[i][1]
dx = 12 + nx
dy = 16 - ny
draw.rectangle({x:dx*TILE, y:(ROWS-1-dy)*TILE, width:TILE, height:TILE}, nextPiece.color)
// Gravity
var fallSpeed = softDropping ? 10 : 1
gravityTimer += dt * fallSpeed
var dropInterval = max(0.05, baseGravity - level * 0.05)
if (gravityTimer >= dropInterval) {
gravityTimer = 0
if (!collides(pieceX, pieceY + 1, piece.blocks)) {
pieceY++
} else {
place_piece()
}
}
}
// Score & Level
var info = "Score: " + score + "\nLines: " + linesCleared + "\nLevel: " + level
draw.text(info, {x:70, y:30, width:90, height:50}, null, 0, color.white)
update_piece_shapes()
},
if (gameOver) {
draw.text("GAME OVER", {x:10, y:config.height*0.5-5, width:config.width-20, height:20}, null, 0, color.red)
render: function() {
return compositor.execute(compositor.compile(comp_config))
}
}
})

28
film2d.cm
View File

@@ -523,4 +523,32 @@ function _mat_eq(a, b) {
return a.blend == b.blend && a.sampler == b.sampler
}
film2d.snapshot = function() {
var result = []
var ids = array(registry)
var i = 0
var d = null
for (i = 0; i < length(ids); i++) {
d = registry[ids[i]]
if (!d) continue
push(result, {
id: ids[i],
type: d.type,
pos: d.pos ? {x: d.pos.x, y: d.pos.y} : null,
width: d.width,
height: d.height,
plane: d.plane || 'default',
layer: d.layer || 0,
groups: d.groups || [],
visible: d.visible != false,
fill: d.fill,
color: d.color,
opacity: d.opacity,
image: d.image ? (is_text(d.image) ? d.image : '(texture)') : null,
text: d.text
})
}
return result
}
return film2d

21
graphics.cm
View File

@@ -466,4 +466,25 @@ graphics.queue_sprite_mesh = function(queue) {
return [mesh.pos, mesh.uv, mesh.color, mesh.indices]
}
graphics.snapshot = function() {
var images = []
var fonts = []
arrfor(array(cache), function(k) {
var entry = cache[k]
var info = {name: k}
if (entry && entry.width) {
info.width = entry.width
info.height = entry.height
} else if (entry && entry.frames) {
info.frame_count = length(entry.frames)
info.type = 'animation'
}
push(images, info)
})
arrfor(array(fontcache), function(k) {
push(fonts, k)
})
return {images: images, fonts: fonts}
}
return graphics

31
input.cm
View File

@@ -260,16 +260,43 @@ function user(index) {
return _users[index]
}
function snapshot() {
var users = []
var i = 0
var u = null
var target = null
for (i = 0; i < length(_users); i++) {
u = _users[i]
target = u.target()
push(users, {
index: u.index,
device_kind: u.device_kind(),
active_device: u.active_device,
paired_devices: array(u.paired_devices),
down: u.down(),
control_stack_depth: length(u.control_stack),
target: target ? (target.name || '(entity)') : null
})
}
return {
max_users: _config.max_users,
pairing: _config.pairing,
action_map: _config.action_map,
users: users
}
}
return {
configure: configure,
ingest: ingest,
user: user,
snapshot: snapshot,
player1() { return _users[0] },
player2() { return _users[1] },
player3() { return _users[2] },
player4() { return _users[3] },
// Re-export for convenience
devices: devices,
backend: backend

45
snapshot.cm Normal file
View File

@@ -0,0 +1,45 @@
var film2d = use('film2d')
var world = use('world')
var compositor = use('compositor')
var input = use('input')
var tween = use('tween')
var graphics = use('graphics')
var snapshot = {}
snapshot.drawables = function() {
return film2d.snapshot()
}
snapshot.entities = function() {
return world.snapshot()
}
snapshot.compositor = function() {
return compositor.snapshot()
}
snapshot.input = function() {
return input.snapshot()
}
snapshot.tweens = function() {
return tween.snapshot()
}
snapshot.assets = function() {
return graphics.snapshot()
}
snapshot.all = function() {
return {
drawables: film2d.snapshot(),
entities: world.snapshot(),
compositor: compositor.snapshot(),
input: input.snapshot(),
tweens: tween.snapshot(),
assets: graphics.snapshot()
}
}
return snapshot

17
tween.cm
View File

@@ -254,11 +254,26 @@ $delay(() => {
}
}, 0)
function snapshot() {
var result = []
arrfor(TweenEngine.tweens, function(tw) {
push(result, {
startVals: tw.startVals,
endVals: tw.endVals,
duration: tw.duration,
startTime: tw.startTime,
easing: tw.easing ? (tw.easing.name || 'unknown') : 'none'
})
})
return {active_count: length(TweenEngine.tweens), tweens: result}
}
var tween_ret = {
init,
Timeline,
TweenEngine,
tween
tween,
snapshot
}
return tween_ret

62
world.cm
View File

@@ -16,4 +16,66 @@ world.destroy_entity = function(entity) {
delete entities[entity]
}
world.update = function(dt) {
arrfor(array(entities), function(e) {
if (is_function(e.update))
e.update(dt)
})
}
world.each = function(fn) {
arrfor(array(entities), fn)
}
world.query = function(filter_fn) {
return filter(array(entities), filter_fn)
}
world.find = function(predicate) {
var keys = array(entities)
var i = 0
for (i = 0; i < length(keys); i++) {
if (predicate(keys[i]))
return keys[i]
}
return null
}
world.clear = function() {
arrfor(array(entities), function(e) {
if (is_function(e.on_destroy))
e.on_destroy()
})
entities = {}
}
world.load_level = function(json_array) {
var i = 0
var entry = null
var proto = null
var entity = null
for (i = 0; i < length(json_array); i++) {
entry = json_array[i]
proto = entry.script ? use(entry.script) : {}
entity = world.add_entity(proto, entry)
}
}
world.count = function() {
return length(array(entities))
}
world.snapshot = function() {
var result = []
arrfor(array(entities), function(e) {
var snap = {}
arrfor(array(e), function(k) {
if (!is_function(e[k]))
snap[k] = e[k]
})
push(result, snap)
})
return result
}
return world