Log In  
Log In  

@selfsame

Follow
Follow

Cart [#44917#] | Code | 2017-10-04 | License: CC4-BY-NC-SA | Embed
3

This is a tiny (47 token!) Entity Component System library.

Entity Component Systems are design patterns where entities are generic collections of components and logic is written for specific component types. It's popular for game design as we often have many 'things' that don't always fall within clear cut types.

There's different approaches to ECS, here we'll consider a table to be an entity, and the key/value pairs to be component names and values.

This library is basically a single function, system, which creates a function that selects every entity with the specified components and calls the user provided function on each one.

function _has(e, ks)
  for n in all(ks) do
    if not e[n] then
      return false
    end
  end
  return true
end

function system(ks, f)
  return function(es)
    for e in all(es) do
      if _has(e, ks) then
        f(e)
      end
    end
  end
end

To use it we'll need a collection of entities:

world = {}

add(world, {pos={x=32, y=64}, color=12})
add(world, {pos={x=64, y=64}, sprite=0})
add(world, {pos={x=96, y=64}, color=8, sprite=1})

Now we define a couple system functions, one for things with position and color components, and one for position and sprite.

circles = system({"pos", "color"}, 
  function(e)
    circfill(e.pos.x, e.pos.y, 8, e.color)
  end)

sprites = system({"pos", "sprite"}, 
  function(e)
    spr(e.sprite, e.pos.x-4, e.pos.y-4)
  end)

Finally, we call our systems on our entity collection:

function _draw()
  cls()
  circles(world)
  sprites(world)
end
P#44926 2017-10-05 09:17 ( Edited 2018-02-04 16:16)

Cart [#41492#] | Code | 2017-06-09 | License: CC4-BY-NC-SA | Embed
4

This is a small (259 token) library for finding entities close to a point.

A bucket hash (also called a spatial or grid hash) breaks up space by a grid size, and maintains a sparse table of "buckets" representing a grid location. When entity membership in these buckets is updated, you can quickly
retrieve entities near a given point.

-- usage

-- create a data 'store' {size=30,prop="pos"}
-- store.prop should match your entities' position property name, 
-- which should be a 'point' value like {x=0,y=0}
-- store.size should be tuned to the max neighbor distance you'll be finding

-- periodically call bstore(store, entity) to update their bucket membership

-- bget(store, point) returns stored entities from a 3x3 square of buckets around 
-- the given point, filter these by a distance function if you need more precision

-- remember you can maintain multiple stores based on the needs of your game!
P#41493 2017-06-09 15:26 ( Edited 2018-08-08 06:23)

Cart [#41463#] | Code | 2017-06-09 | License: CC4-BY-NC-SA | Embed
11

This is a small (257 token) tweening library. It allows you to tween any value over time, and can be extended
by supplying your own easing and lerping functions. It also allows callbacks, functions that are called when the tween has finished, letting you sequence animations and code.

quick start:

tween(player.position, "x", 64, 100, {e=pow(2)})

-- tween(object, prop_name, target_value, duration, options_table)
-- options are 
-- "e" dual in+out easing fn
-- "ei","eo" in,out easing fn
-- "f" tween callback (takes 1 argument - the object)
-- "l" lerping function, default lerp works with number values

Please check the cart code for further examples.

Advanced tips:

If you need to stop a tween, keep a reference to it (the return value of "tween") and set it's "o" prop to nil.

Changelog:

v 1.0 - shaved off 7 tokens, moved bbs post to "code snippets"

P#41337 2017-06-06 15:02 ( Edited 2017-06-09 15:07)

X
About | Contact | Updates | Terms of Use
Follow Lexaloffle:        
Generated 2019-02-18 13:55 | 0.059s | 4194k | Q:38