supercurses [Lexaloffle Blog Feed]

Using vectors for 1000 entity movement

Tue, 08 Apr 2025 08:35:23 UTC

Hello,

I have a feeling I don't fully understand vectors. I am thinking of the optimal way to handle the updating of a large number of entities for something like a Vampire Survivors game. Right now, in my testing, parallel arrays appears to have the lowest impact on CPU. 1000 mobs move towards the player and cpu is 0.601, metatables go up to 0.823

I tried vectors this morning and my cpu stat is 1.4.

Vectors are a bit new to me and I'm wondering if I going about this the right way.

function _init()
	mobs={}
	player={}
	player.v = vec(240, 130)
	for i=1, 1000 do
		local spawn_radius = max(470, 270) / 2 + 50
		local player_x, player_y = player.v:get(0, 2)
		local spawn_x = player_x
		local spawn_y = player_y
		local angle = rnd(1)
		local x = spawn_x + spawn_radius * cos(angle)
		local y = spawn_y + spawn_radius * sin(angle)

		v = vec(x, y)
		add(mobs,{v=v,spd=rnd(0.5)})
	end

end

function _update()

	for mob in all(mobs) do
		-- Calculate direction vector (from mob to player)
		local direction = vec(0, 0)

		-- Get mob and player positions
		local mob_x, mob_y = mob.v:get(0, 2)
		local player_x, player_y = player.v:get(0, 2)

		-- Create direction vector
		direction = vec(player_x - mob_x, player_y - mob_y)

		-- Normalize the direction (make it length 1)
		local mag = direction:magnitude()
		if mag > 0 then
			direction = direction:div(mag)

			mob.v = mob.v:add(direction:mul(mob.spd))
		end
	end
end

function _draw()
    cls()
    for mob in all(mobs) do
        local x, y = mob.v:get(0, 2)
        spr(1, x, y)
    end
    print(stat(1), 0, 0, 8)
end

Simulating top-down ball rotation

Thu, 28 Nov 2024 10:57:30 UTC

Hello,

I am simulating a ball being dragged around by a player. I'd like to create some animation to simulate that the ball is rotating (top-down view). I am trying to do that with a light source on top of the ball but I can't quite get it working correctly.

Looking for advice or some pointers to good tutorials on this subject.

Thanks in advance

function _init()
	player = {x=64, y=64}

end

function _update()
 local move_x, move_y = 0, 0
 if btn(0) then move_x = -1 end
 if btn(1) then move_x = 1 end
 if btn(2) then move_y = -1 end
 if btn(3) then move_y = 1 end

 -- update player position and animation
 if move_x != 0 or move_y != 0 then
     player.x += move_x
     player.y += move_y 
	end
	update_ball()

end

function _draw()
	cls()
	rectfill(player.x,
		player.y,
		player.x+8,
		player.y+8,
		8)
	draw_ball()

end

--ball

ball = {x=80, y=80, vx=0, vy=0, length=24, friction=0.9, mass=5, pull_force=0.2}

ball.hitbox = {2,2,6,6}
ball.name = "ball"
ball.radius = 5

-- in ball initialization
ball.light_pos = {x = ball.x, y = ball.y}

function distance(x1, y1, x2, y2)
    return sqrt((x2-x1)^2 + (y2-y1)^2)
end

function update_ball()
    local dx = ball.x - player.x
    local dy = ball.y - player.y 
    local dist = distance(ball.x, ball.y, player.x, player.y)

    if dist > ball.length then
        local angle = atan2(dx, dy)
        local pull_strength = (dist - ball.length) * ball.pull_force

        ball.vx -= cos(angle) * pull_strength
        ball.vy -= sin(angle) * pull_strength
    end
    ball.vx *= ball.friction
    ball.vy *= ball.friction
    ball.x += ball.vx
    ball.y += ball.vy

    if ball.vx != 0 or ball.vy != 0 then
        local move_dir_x = ball.vx > 0 and 1 or (ball.vx < 0 and -1 or 0)
        local move_dir_y = ball.vy > 0 and 1 or (ball.vy < 0 and -1 or 0)

        ball.light_pos.x += move_dir_x * 0.5
        ball.light_pos.y += move_dir_y * 0.5

        -- check if light has reached ball edge
        local light_dist = distance(ball.x, ball.y, ball.light_pos.x, ball.light_pos.y)

        if light_dist >= ball.radius+1 then
             -- move light along the direction of movement
             ball.rolled_under = true
            ball.roll_under_timer = ball.roll_under_frames

            -- reposition light on opposite side of ball and continue moving
            ball.light_pos.x = ball.x - move_dir_x * ball.radius
            ball.light_pos.y = ball.y - move_dir_y * ball.radius

            -- immediately continue moving in the same direction
            ball.light_pos.x += move_dir_x * 0.5
            ball.light_pos.y += move_dir_y * 0.5
        end

    end

end

function draw_ball()
    line(player.x+4, player.y+4, ball.x, ball.y, 13)
    circfill(ball.x, ball.y, 5, 1)

    -- light spot
    circfill(ball.light_pos.x, ball.light_pos.y, 1, 7)

end

How to know what Lua is supported and isn't?

Fri, 27 Sep 2024 08:08:58 UTC

In the following code, everything works apart from table.sort(). How would I know that?

Also, the only keyword highlighted in the code editor is "sub"

s = "hello world"
i, j = string.find(s, "hello")
print(i..":"..j)
print(string.sub(s, i, j))
print(string.find(s, "world"))

local t = {}
table.insert(t, 1)
table.insert(t, 24)
for i=1, #t do
	print(t[i])
end
table.sort(t)

Separation of model / view

Sat, 31 Aug 2024 15:02:51 UTC

Hello,

I'm a beginner programmer, trying to figure out good practice. To be honest, I get a lot of joy out of refactoring code even though I know it's more important to create something of value. Seems to give my brain comfort.

I've been creating a card game and realised that one of my challenges is that I have a card object that has some game logic associated with it but I'm also mixing up a bunch of presentation information on that card. It's getting messy.

Which got me thinking about trying to separate concerns. Wondering what the community's view is on an approach like below?

The general idea here is that a card needs to know nothing about its presentation (but is linked to its presentation). It's a bidirectional link, a card_view is related to its card.

Obviously, in a game where there are not a lot of objects, this might be overkill.

function _init()
	renderer = Renderer:new()
	animator = Animator:new()
	deck = {}
	x_offset, y_offset, i = 0, 0, 0
	for i=1, 10 do
		local card = Card:new(i, "Hearts")
		local card_view = CardView:new{
			card=card, 
			x=15, 
			y=200, 
			target_x=15+x_offset, 
			target_y=106}
		card.view = card_view
		renderer:add_drawable(card_view)
		animator:add_moveable(card_view)
		add(deck, card)
		x_offset+=38
	end
end

function _update()
	if btnp(5) and i<#deck then
		deck[#deck-i].view.moving = true
		i+=1
	end
	animator:animate_entities()
end

function _draw()
	cls(27)
	renderer:draw_entities()
end

Card = {}
Card.__index = Card
function Card:new(rank, suit)
	local self = setmetatable({}, CardView)
	self.name = "Card"
	self.rank = rank
	self.suit = suit
	self.view = nil
	return self
end

function Card:update()
	--lots of game logic to go here
end

CardView = {}
CardView.__index = CardView
function CardView:new(options)
	local self = setmetatable({}, CardView)
	self.name = "Card View"
	self.card = options.card
	self.x = options.x
	self.y = options.y
	self.start_x = options.x
	self.start_y = options.y
	self.target_x = options.target_x
	self.target_y = options.target_y
	self.sp = 1
	self.moving = false
	return self
end

function CardView:_dist(x1, y1, x2, y2)
    return sqrt((x2 - x1)^2 + (y2 - y1)^2)
end

function CardView:update()
    if self.moving then
        local dx = self.target_x - self.x
        local dy = self.target_y - self.y
        local remaining_distance = sqrt(dx*dx + dy*dy)
        local total_distance = self:_dist(self.start_x, self.start_y, self.target_x, self.target_y)
        local traveled_distance = total_distance - remaining_distance

        if remaining_distance > 1 then
            local progress = traveled_distance / total_distance

            -- Move the self
            self.x += dx * 0.2
            self.y += dy * 0.2

            -- Check if 85% of the journey is complete
            if progress >= 0.85 and not self.revealed then
                self.sp = 2
                self.revealed = true
            end
        else
            self.x = self.target_x
            self.y = self.target_y
            self.moving = false
        end
    end
end

function CardView:draw()
	spr(self.sp, self.x, self.y)
	if self.revealed then
		print(self.card.suit, self.x+2, self.y+4, 8)
		print(self.card.rank, self.x+2, self.y+12, 8)
	end
end

Renderer = {}
Renderer.__index = Renderer

function Renderer:new()
    local self = setmetatable({}, Renderer)
    self.drawables = {}
    return self
end

function Renderer:add_drawable(drawable, zIndex)
    if type(drawable.draw) ~= "function" then
        error("No draw function for "..drawable.name)
    end
    drawable.zIndex = zIndex or 0 -- Default to 0 if no zIndex is provided
    local index = #self.drawables + 1

    -- Find the correct position to insert based on zIndex
    for i=1,#self.drawables do
        if self.drawables[i].zIndex > drawable.zIndex then
            index = i
            break
        end
    end

    -- Insert drawable at the found position
    for i = #self.drawables + 1, index + 1, -1 do
        self.drawables[i] = self.drawables[i-1]
    end
    self.drawables[index] = drawable
end

function Renderer:draw_entities()
    for _, drawable in ipairs(self.drawables) do
        if type(drawable.draw) ~= "function" then
            error("No draw function for "..drawable.name)
        end
        drawable:draw()
    end
end

Animator = {}
Animator.__index = Animator

function Animator:new()
    local self = setmetatable({}, Animator)
    self.moveables = {}
    return self
end

function Animator:add_moveable(moveable)
    add(self.moveables, moveable)
end

function Animator:animate_entities()
    for _, moveable in ipairs(self.moveables) do
        moveable:update()
    end
end

WIP Slay the Spire style pathing map

Wed, 14 Aug 2024 17:47:17 UTC

Hello,

I've been working on trying to produce a randomly generated map like in Slay the Spire.

I used the rules documented here to generate the map:

https://steamcommunity.com/sharedfiles/filedetails/?id=2830078257

(not convinced these are the whole rules but it's good enough for now)

The map is a 7 x 15 grid.
6 paths are drawn through the grid, the first two paths must be at different starting points, others are random (which gives the branching effect)
Events are placed on the grid as per the weightings specified.
Some rules are obeyed to prevent certain events from appearing in certain places (for example, 2 rest sites in a row are not allowed)
I added some jittering to give the map rendering a more organic look.

Controls

1) You can scroll up and down the map with the up and down keys.
2) Hit left and right to select an originating path. Press X to lock in the selection.
3) Press up to move up that selected path.
4) While you have a path selected, press left and right to move between valid branches of the path.

Seems to be working, although it's an awful lot of code, I need to look for some optimisations next.

Any comments, or suggestions welcome.

yuzuhutuba

by supercurses

[Click to Play]

Minit Survivors WIP

Thu, 02 May 2024 13:30:30 UTC

Very much WIP using some of the graphical style/themes from Mint in a Vampire Survivors style game.

WIP has:

2 characters with different modifiers
6 weapons and 1 passive item. weapons and passives have level upgrade modifiers
A wave spawner (but it spawns the same stuff every wave - need more mob types)
Boss mobs drop a chest that will drop a random upgrade to an item in your inventory
Standard mobs drop xp, hitting the target xp for the level triggers a shop where you are offered 3 items (with some weighting towards items you already own)

"O" button does everything.

TODO:

refactor for performance, I think I can improve collision handling
a proper map, thinking an infinite map like vampire survivors
scaling of mobs with XP
more items
more enemy types
probably refactor how I am doing classes, it's getting messy.
bugs, probably lots of them
everything else

diphwezu

by supercurses

[Click to Play]

Have an object circle around a moving player

Tue, 30 Apr 2024 15:18:19 UTC

Hello, I have this code that circles an object around the player position.

It works well if the player stands still, but if the player moves the trajectory of the object goes a bit wonky. it sort of stops, or looks like it wants to go in the other direction for a bit.

How can I make it smoothly rotate around the player?

    local player = self.game_context.player
    local orbit_radius = 40  -- Distance from player to orbiting projectile
    local orbit_speed = self.speed  -- Normalized speed of orbit; consider this as fraction of a circle per frame

    for p in all(self.projectiles) do
        p.angle += orbit_speed
        if (p.angle > 360) p.angle = 0
        p.x = player.x + (player.attributes.w / 2) + orbit_radius * cos(p.angle/360)
        p.y = player.y + (player.attributes.h / 2) + orbit_radius * sin(p.angle/360)
        -- Handle projectile duration and collision
        p.duration -= 1	
    end

Problems importing a sprite sheet

Mon, 29 Apr 2024 09:35:30 UTC

Hello,

I feel like I am being a bit thick this morning.

I have a 128 x 128 sprite sheet as a .png.

I've tried importpng and the pictron exporter from asesprite. both exhibit the same behaviour, when I paste from the clipboard the whole image fills sprite 0 and sets its size to 128 x 128, I'm expecting the image to start at sprite 0 and fill outwards. Am I missing something obvious?

thanks in advance

Referencing tables before they are created

Wed, 24 Apr 2024 10:32:02 UTC

Hello, considering the following:

Trying to remake Vampire Survivors and a fun project
I have a character class
Characters have effects that are applied to a target. In this example my target = player
I have a character that is an instance of that class. Let's call him "Antonio"
I have a "run", Antonio is copied into run.player
I set player to be run.player

My problem is that I have to initiate the character class and Antonio before I create "player". But player is not yet created so player referenced on the character class is nil.

I hope this makes sense, I have a workaround but it feels clunky and I'm wondering if there are other solutions.

Here is my code before the workaround:

character = {}
character.__index = character
function character:new(name)
	local o = setmetatable({}, character)
	o.name = name
	o.x = 0
	o.y = 0
	o.sp_scale = 1
	o.w = 16
	o.h = 16
	o.effects = effects
	o.original_invincibility_frames = 10
	o.invincibility_frames = 0
	o.max_health = 100
	o.health = 20
	o.recovery = 0
	o.armor = 0
	o.move_speed = 1
	o.might = 1
	o.weapon_projectile_speed = 0
	o.weapon_duration = 0
	o.weapon_area = 0
	o.weapon_cooldown = 0
	o.weapon_projectiles_amount = 0
	o.revival = 0
	o.magnet = 0
	o.luck = 0
	o.growth = 0
	o.greed = 0
	o.curse = 0
	o.reroll = 0
	o.skip = 0
	o.banish = 0
	return o
end

function character:set_effects(effects)
	self.effects = effects
end

function character:apply_effects(level)

	local effects = self.effects
	for _, effect in pairs(effects) do
		if level % effect.level_increment == 0 and 
			level <= effect.max_level_increment then 
			local target = effect.target	
			if effect.mode == "percent" then
				target[effect.stat] += (target[effect.stat] or 0) * effect.value
			else
				target[effect.stat] = (target[effect.stat] or 0) + effect.value
			end
		end

	end
end

antonio = character:new("antonio")
antonio.recovery = 0.5
antonio:set_effects( {

	    			{	description="Gains 10% Might every 2 Levels",  
	    				stat = "might", 
	    				value = 1,
	    				target = player, -- here is the problem, player doesn't exist
	    				level_increment = 2,
	    				max_level_increment = 10,
	    				mode = "percent"
	    			},
	    			{	description="Gains 0.5 Recovery every 1 level", 

	    				stat = "recovery", 
	    				value = 0.5,
	    				target = player,
	    				level_increment = 1,
	    				max_level_increment = 5
	    			}

	    		}

)

function _init()
	t = 0
	run = {}
	run.player = {}
	run.level = 1
	add(run.player, deepcopy(antonio))

	player = run.player[1]

end

function _update()

	if t % 60 == 0 then player.health += player.recovery end 
	if btnp(4) then
		run.level += 1
		player:apply_effects(run.level)
	end
	t += 1
end

function _draw()
	local y = 0
	cls(0)
	for entry in all(run.player) do
		for k, v in pairs(entry) do
			if type(v) == "number" then
				print(k..":"..v, 0, y)
				y += 8
			end
		end
	end
	local y = 0
	print("Level: "..run.level, 240, y)

end

function deepcopy(orig)
	local orig_type = type(orig)
    local copy
    if orig_type == 'table' then
        copy = {}
        for orig_key, orig_value in next, orig, nil do
            copy[deepcopy(orig_key)] = deepcopy(orig_value)
        end
        setmetatable(copy, getmetatable(orig))
    else -- for numbers, strings, booleans, etc
        copy = orig
    end
    return copy

end

And here is my code with the workaround, in short, once player is created I go and apply player as the target of the effects: player:update_effects_target(player)

character = {}
character.__index = character
function character:new(name)
	local o = setmetatable({}, character)
	o.name = name
	o.x = 0
	o.y = 0
	o.sp_scale = 1
	o.w = 16
	o.h = 16
	o.effects = effects
	o.original_invincibility_frames = 10
	o.invincibility_frames = 0
	o.max_health = 100
	o.health = 20
	o.recovery = 0
	o.armor = 0
	o.move_speed = 1
	o.might = 1
	o.weapon_projectile_speed = 0
	o.weapon_duration = 0
	o.weapon_area = 0
	o.weapon_cooldown = 0
	o.weapon_projectiles_amount = 0
	o.revival = 0
	o.magnet = 0
	o.luck = 0
	o.growth = 0
	o.greed = 0
	o.curse = 0
	o.reroll = 0
	o.skip = 0
	o.banish = 0
	return o
end

function character:set_effects(effects)
	self.effects = effects
end

function character:update_effects_target(target)
    for _, effect in pairs(self.effects) do
        effect.target = target
    end
end

function character:apply_effects(level)

	local effects = self.effects
	for _, effect in pairs(effects) do
		if level % effect.level_increment == 0 and 
			level <= effect.max_level_increment then 
			local target = effect.target	
			if effect.mode == "percent" then
				target[effect.stat] += (target[effect.stat] or 0) * effect.value
			else
				target[effect.stat] = (target[effect.stat] or 0) + effect.value
			end
		end

	end
end

antonio = character:new("antonio")
antonio.recovery = 0.5
antonio:set_effects( {

	    			{	description="Gains 10% Might every 2 Levels",  
	    				stat = "might", 
	    				value = 1,
	    				target = player, -- here is the problem, player doesn't exist
	    				level_increment = 2,
	    				max_level_increment = 10,
	    				mode = "percent"
	    			},
	    			{	description="Gains 0.5 Recovery every 1 level", 

	    				stat = "recovery", 
	    				value = 0.5,
	    				target = player,
	    				level_increment = 1,
	    				max_level_increment = 5
	    			}

	    		}

)

function _init()
	t = 0
	run = {}
	run.player = {}
	run.level = 1
	add(run.player, deepcopy(antonio))

	player = run.player[1]
	player:update_effects_target(player)
end

function _update()

	if t % 60 == 0 then player.health += player.recovery end 
	if btnp(4) then
		run.level += 1
		player:apply_effects(run.level)
	end
	t += 1
end

function _draw()
	local y = 0
	cls(0)
	for entry in all(run.player) do
		for k, v in pairs(entry) do
			if type(v) == "number" then
				print(k..":"..v, 0, y)
				y += 8
			end
		end
	end
	local y = 0
	print("Level: "..run.level, 240, y)

end

function deepcopy(orig)
	local orig_type = type(orig)
    local copy
    if orig_type == 'table' then
        copy = {}
        for orig_key, orig_value in next, orig, nil do
            copy[deepcopy(orig_key)] = deepcopy(orig_value)
        end
        setmetatable(copy, getmetatable(orig))
    else -- for numbers, strings, booleans, etc
        copy = orig
    end
    return copy

end

Grid based partitioning for collision detection

Wed, 17 Apr 2024 15:45:15 UTC

Hello,

For fun, I'm building a Vampire Survivors style game. There will be a lot of mobs on screen, so I've built a grid partitioning system and each weapon only checks for collisions with mobs nearby.

The grid size is 30, so that's a 16 x 9 grid.

My question is this, currently, I'm initialising the grid on every frame and re-populating all the mob positions into their grids.

Should I move to initialising just once and updating mob positions in the grid on every frame? I'm not sure whether that will actually be quicker because I will have to delete the mob from one grid position and add it to another.

Also, that seems hard to implement :-)

Thanks in advance

Russ

Knuckle Dice v1.3

Wed, 08 Mar 2023 16:14:07 UTC

Knuckle Dice v1.3

by supercurses

[Click to Play]

Knuckle Dice v1.3

Knuckle Dice is an attempt to recreate Knuckle Bones from Cult of the Lamb. This is my first programming project ever so there's no AI yet - it's two player only to begin with.

In the future I will try to add:

CPU AI (DONE)
I want to experiment with perfect information. In other words, remove the randomness and tell the player exactly what the opponent is about to play.

Controls

z to start/restart
x to play a dice

Rules/Game Logic

Maximum 3 dice in one column
Playing a die in a column that matches dice in the opposing player's column removes all instances of that dice
When nine dice are played by either player the game ends

Scoring

You receive points equivalent to the die played multiplied by the number of instances of that dice. (e.g a 5 played twice in one column will give you twenty points - 2*(5+5)
The player with the most points wins

v1.1 Updates

Changed GFX to more of a 1bit style

v1.3 Updates

Now it's a single player game with some rudimentary AI for P2