What's everyone working on? (tigsource inspired)

[HugoBDesigner]

Don't be offended or anything, since I really liked that concept, but this background reminds me of Ortho Robot a lot :T

[Ulydev]

Ha, yes, I didn't even notice that!
It kind of reminds me of VVVVVV as well.

[s-ol]

Working on a tweening/looping/scheduling library. First draft done, here's my current example:

(gfycat)

this is nearly the complete moonscript code running the demo: (stripped a bit of debug, setup and the random_color function)

Code: Select all

loop = Loop square, 1, {square.a, square.b, nil, 1}, (a, b, c, dir) ->
  new   = random_color!
  new_a = random_color!
  new_b = random_color!

  uuntil 0,    a: new,   b: a,     c: b
  colorease 1, a: new_a, b: new_b, c: a

  easeto 1, rot: dir * math.pi/4

  uuntil 0, size: max_size/2
  easeto 1, size: max_size

  new_a, new_b, a, -dir

time = 0
love.draw = ->
  {:a, :b, :c, :size, :rot} = square
  love.graphics.setColor c
  love.graphics.rectangle "fill", 0, 0, width, height

  mx, my = (love.math.noise(time/3)-.5)*width*0.7, (love.math.noise(time/4, 0.3)-.5)*height*0.7
  d = 1 - size/max_size

  love.graphics.push!
  love.graphics.setColor b
  love.graphics.translate width/2 + mx*d, height/2 + my*d
  love.graphics.rotate time/20
  love.graphics.rotate rot
  love.graphics.rectangle "fill", -size/2, -size/2, size, size
  love.graphics.pop!

  size -= max_size/2
  d = 1 - size/max_size
  love.graphics.setColor a
  love.graphics.translate width/2 + mx*d, height/2 + my*d
  love.graphics.rotate time/20
  love.graphics.rotate -rot
  love.graphics.rectangle "fill", -size/2, -size/2, size, size, (max_size/2-size)/4, (max_size/2-size/1.3)/3

love.update = (dt) ->
  loop\update dt
  time += dt

and in equivalent Lua:

Code: Select all

loop = Loop(square, 1, {square.a, square.b, nil, 1}, function (a, b, c, dir)
  local new, new_a, new_b
  new   = random_color()
  new_a = random_color()
  new_b = random_color()

  uuntil( 0,    a: new,   b: a,     c: b )
  colorease( 1, a: new_a, b: new_b, c: a )

  easeto( 1, rot: dir * math.pi/4 )

  uuntil( 0, size: max_size/2 )
  easeto( 1, size: max_size )

  return new_a, new_b, a, -dir
end

time = 0
function love.draw()
  local size = square.size
  love.graphics.setColor(square.c)
  love.graphics.rectangle("fill", 0, 0, width, height)

  local mx, my = (love.math.noise(time/3)-.5)*width*0.7, (love.math.noise(time/4, 0.3)-.5)*height*0.7
  local d = 1 - size/max_size

  love.graphics.push()
  love.graphics.setColor(square.b)
  love.graphics.translate(width/2 + mx*d, height/2 + my*d)
  love.graphics.rotate(time/20)
  love.graphics.rotate(square.rot)
  love.graphics.rectangle("fill", -size/2, -size/2, size, size)
  love.graphics.pop()

  size -= max_size/2
  d = 1 - size/max_size
  love.graphics.setColor(square.a)
  love.graphics.translate(width/2 + mx*d, height/2 + my*d)
  love.graphics.rotate(time/20)
  love.graphics.rotate(-square.rot)
  love.graphics.rectangle("fill", -size/2, -size/2, size, size, (max_size/2-size)/4, (max_size/2-size/1.3)/3)
end

function love.update(dt)
  loop:update(dt)
  time = time + dt
end

the API probably isn't self-explanatory enough to make full sense right now and the advantages that my API is supposed to have over regular tweening libraries probably aren't ovious (or there) right now, but this is a WIP thread after all

[alundaio]

I'm working on procedural dungeon generation for my next project. I create a graph of cells and this graph data is translated into tileset data for STI (https://github.com/karai17/Simple-Tiled-Implementation). The graph is completely disjointed from the actual map making process so it can be scaled to whatever size and double as a mini-map.

I probably won't stick isometric tiles, as it was just a test. Will probably go with an Earthbound-like or Zelda-like orthogonal.

As for the process it's pretty simple. Generate a bunch of cells of different widths and heights on a grid. Then use Delauney Triangulation to create a mesh between your largest cells ('rooms'). Using the edges from the triangles, iterate all the rooms to calculate all the adjacent rooms using these edges. Once you know each room's connected neighbor you can use any kind of tree algorithm like Minimal Spanning Tree to create a list of points between each room; navigating along the edges of the triangles. At the same time you can split these line segments into L-Shapes to create corridors. Once this process is complete, delete all the cells that do not intersect these lines using Liang Barsky Indices.

[MadByte]

Just started to redo my old Airtaxi project.
Still a lot work to do ...
(you can try it online here, huge thanks to tanner for his love.js port)

[marco.lizza]

Just started to redo my old Airtaxi project.

Nice one! I spent an awful amount of hours on the C64 (something like 30 years ago) with the original game! Good work!

[zorg]

Just started to redo my old Airtaxi project.
Still a lot work to do ...

Just an idea since it's relevant: taxi vs. über mode
Oh yeah, stay on topic, uhh, tossed my old bullet hell framework code out and started anew; nothing to show yet, but it'll be done whenever!

[davisdude]

...

You should make it more clear that you have to retract the landing gear in order to move. It took me a while to figure this out, having never played the original. Looks good, though.

[MadByte]

Thanks guys.

You should make it more clear that you have to retract the landing gear in order to move. It took me a while to figure this out, having never played the original...

I'll add a quick tutorial at some point since there are some more mechanics which may be importent to know e.g that a passenger who won't pay you (because you took to long) gonna jump out on any platform you land on.
btw. congrats in advance to 1000 posts, davisdude!

[davisdude]

btw. congrats in advance to 1000 posts, davisdude!

Thanks