Couple Small-ish announcements

A quick few non-chompchomp related things to announce before we get into the meat of this article.

I like writing!

I’ve discovered that I really enjoy writing about coding, and I do a lot more coding than just chomp chomp. Soooo I’m planning to whip up a basic personal website and move this blog over there at some point. This won’t happen for a while, and won’t change much but it’s in the works.

Why am I doing this?

Well, as I said I’ve discovered that I really like this type of writing! It’s fun, it’s a good exercise, and I hope people enjoy it. That being said I do a bunch of coding outside of chompchomp and play a lot of games. I think those are both things I could write loads about so I wanna setup my personal website to have an all-encompassing blog!

Also also, I’m thinking of making a short-form monthly tiktok of the past month of progress for TikTok. So at the end of the month it’s like a quick recap of what was up. If anyone reading has any thoughts on that let me know!

Classic Many Projects

Me being me with ADHD I’m kinda impulsive, I think of something and I’m like “lemme go make that” and usually it’s nothing big but I actually got a pretty cool opportunity for a side project that I’m actively working on. I’m not gonna say much about it yet but I plan to potentially share it later on. That being said for the next couple weeks I’ll be balancing chompchomp and this other project, so progress on either side might be a bit slower.

If I do some work on the other project I might write about some of it if I think it’s worth sharing!

See, now that I wrote that I’m like “damn, should I pause everything and work on the basic personal site, where I can write about anything!?!?” haha it’s hard to decide. I might try to uber speed run it & just copy over a bunch of stuff from this site. We’ll see. I haven’t made an updated personal website since in my head I had some ‘grand plans’ for a crazy personal website but whenever I think about doing it I’m like “I could do it later.” The true classic. But I think I’m learning that sometimes it’s good to go with my impulsiveness and just jump onto things.

Update: I walked away for a few minutes and decided that yes I’m gonna make a basic personal website! I’m gonna try to speed run it for sure, but I think it makes sense since that way I won’t be missing out on content from stuff I could write about. I’ll even write about making that site!

Also as a side note, I’m going to make a choice to not take out bits of the writing where I was unsure of something, I think it’s cool to share my raw thought process! I might add some marker for it so it can be skipped if anyone reading doesn’t care.

Anyway, onto ChompChomp!

Last time on ChompChomp

Ok so it’s been a while. Let’s do a quick recap on the last bit of progress!

Taking a Bite!

At the start of the last article, I was working on getting the bite to work. It wasn’t working and instead left-clicking was freezing all animations. I slept on it, thought about the logic a bit, and realized the issue was a bit of a logic error.

I had a conditional checking if I was moving and if so it would play the default swim animation otherwise stop all animations. Whenever I was pressing “bite” that became false, and all animations stopped. I fixed this by adding a check for if I was biting, and if so it would play the bite animation. This fixed the issue and I was able to bite!

An unexpected setback

Then out of nowhere I had that crazy bad lag, with no clear reason why. I spent a couple days and tried a bunch of things to fix it, but nothing worked. I was really confused and frustrated, and it slowed me down and ruined my motivation for a day.

But after thinking about it hard, I realized the issue. It wasn’t my own code, it wasn’t my editor settings, it wasn’t some optimization issue. No, it was something much more simple. It was my mouse!

Classic polling rate, the culprit was my mouse! I realized that my mouses high polling rate was causing lag, a fairly common issue with polling rates above 500. I lowered it to 500 and the issue was fixed! I was so happy to have figured it out, and I ready to get back to work.

Last Weeks Goals

So here’s the copy-pasted goals from last week:

Alright here are my current goals:

• Spawn in some basic_fish out of sight from the player’s camera

Stretch goals:

• Spawn the basic_fish in clumps (fish swim in schools!)
• Apply boid based movement to basic_fish clusters.

…

Keep em in mind as we go through the progress!

---

Fish are friends, not food… Right?

Alright so Bruce is hungry, he’s gotta eat. It was time to start spawning in some fish, and working on getting the bite to work. That meant a new set of goals for this week to achieve that goal from last week.

Spawn in some basic_fish out of sight from the player’s camera

That’s an encompassing task, breaking it down a bit I got the following sub tasks:

• Full biting
  • bite fish
    • hit box
    • damage
    • health
    • death
  • fish should die when health hits zero
  • when killing a fish with bite it should count as ‘eating’ and should increase the player’s size
• Collision for fish
  • Shouldn’t phase through each other

The Spawnening

Eventually I want to spawn in clusters of fish, but for now I don’t need to worry about that. So I went back to that helpful starting godot article, it had small bit on spawning enemies that I figured I could use for this too.

Where fish spawn

The way the spawning was done in that article was by drawing a "path" on the bounds of the playable areas, and then spawning enemies along that path on a set timer. The path was trivial to do, just clicked each of the 4 corners I wanted and boom, square made where enemies can spawn on the edges.

This "path" is a Path2D which is literally just a line, coordinates in space and not visible when playing. Then to get things correctly spawning on different parts of it I needed a PathFollow2D node as a child of that Path2D, this would be used for spawning things along the path and orienting them.

Timers

Next thing was a timer to have fish spawn periodically. Following the tutorial they add 3 timers, a StartTimer, SpawnTimer, and GameTimer. They do this since the game in the example is a time-based score type game where you have X seconds to get as many points as possible. I don’t need that, but a countdown until things started sounded nice, so I added a StartTimer and a SpawnTimer.

The StartTimer only needs to happen once, and that can be set in the editor, where I also set the duration to 2 seconds. Easy to adjust whenever so I didn’t think too hard on that. I didn’t set it to autostart since I’ll be controlling that through code instead! The SpawnTimer was similar, except I didn’t want it to happen only once, I wanted fish to keep spawning.

Alright time for some flowcharts!

If you don't see a flowchart try refreshing, not sure why but it sometimes doesn't initialize the chart, it's on my list of things to look into (classic).

First up basic timer logic.

graph TB
  s1[Game Starts]-->s2[Begin StartTimer]
  s2-- StartTimer ends -->s3[Begin SpawnTimer]
  s3-- SpawnTimer ends -->s4[Spawn Fish]

Alrighty next up spawn timer callback, so this is what’ll need to happen every time the SpawnTimer is done.

graph TB
  s0[Spawn Timer Done]-->s1[Create a new Fish]
  s1-->s2[Get the spawn path node]
  s2-->s3[Get a random position on the path]
  s3-->s4[Set the fish's position to the random position]
  s4-->s5[Set the fish's rotation to the path's rotation]
  s5-->s6[Get a random velocity]
  s6-->s7[Set the fish's velocity to the random velocity]
  s7-->s8[Add the fish to the scene]
  s8-- Repeats when timer done -->s0

And this might seem like quite a lot but it’s actually not as bad as it seems, it boils down to this:

func _on_basic_fish_timer_timeout():
	var basic_fish = fish_spawnscene.instantiate()

	var spawn_location = get_node("BasicFishPath/BasicFishSpawnLoc")
	spawn_location.progress_ratio = randf()

	var direction = spawn_location.rotation + PI/2

	basic_fish.position = spawn_location.position

	direction += randf_range(-PI/4, PI/4)
	basic_fish.rotation = -direction

	var velocity = Vector2(randf_range(10, 20), 0)
	basic_fish.linear_velocity = velocity.rotated(-direction)

	add_child(basic_fish)

Now we put it all together…

Aaaaaand boom!

And yes the fish do be drifting, but that’s not an issue now. Now I need to be able to “eat” them, and testing that we won’t have the fish move anyway. This was just a test of having the fish spawn in, move with animation, and collision. All of which worked!

Eating Fish

Now, the fish needs to be “eaten,” as in Biting should damage the fish, and when the fish’s health hits zero it should die.

Again we’ve got a large goal that I then tried to break down into smaller tasks:

• biting todos:
  • add health & damage attributes to fish & player
  • add hitbox to “bite” animation
    • should only be active when in the “bite” animation
  • calculate damage
    • damage calculation is something I’ll come back to
  • subtract damage from fish when attacked
  • despawn when dead

So I went at it! I did a bunch more research and came across something called a “state machine” which from my understanding is creating something that would be in charge of detecting + handling all the different states of an entity.

For example in an RPG there’s a lot of things the player might able to do, some simultaneously. Jumping + attacking + dashing, the state machine would be detecting that + calling on the right pieces of animations and whatever else needs to happen. But this seems to be a bit overkill for what I plan to do, I don’t thin there will be a ton of different states for the player so I’m not going to spend the time to implement some form of a state machine.

Here’s to hoping that I won’t regret not adding one now because it would be harder later.

Entity Stats & Damage Logic

There’s different names for this but as a player I think typically they’re thought of as “stats” since usually when visible they’re numbers - 100 str for example. In this case, I’ll need at minimum health and damage for both the player and the fish.

I actually already had some stats for Bruce, namely speed and size but I decided to throw on a couple more that I plan to use, so Bruce now looks like this:

@export var level = 1
@export var speed = 8
@export var damage = 10
@export var size = 0.5
@export var health = 100

The @export lets me interact with those values in other files, since not all the code is living in one single file. The fish just needs health for now so it’s just:

@export var health = 15

The reason for that is currently the fish doesn’t move on it’s own, before when I tested spawning I basically was just flinging them in a random direction 😆. So this fish will be one of various different things that can be "damaged", since a lot of things will be "damageable" I will make a class that handles taking damage. This way I don’t need to re-write math all over the place.

I also considered adding a "defense" stat but I decided against it. In the long run it would add complexity while not adding a whole lot to the game.

Now that we’ve got the numbers we need, it’s time for a bit of logic, and that means more flowcharts 😎. After a bit of fiddling with things & thinking I came up with something like this:

graph TB
  s1[Player Bites]
  s2[Mark hitbox active]
  s2a[Mark hitbox inactive]
  s3[Check if damageable in hitbox]
  s3a[Do nothing]
  s4[Calculate damage]
  s5[Apply damage]
  s6[Check health]
  s7[Despawn]
  s7a[Do nothing]

  subgraph bite
  s1-->s2
  s2-->s3
  s3-- Found -->s4
  s3-- Not Found -->s3a
  s3a-->s2a
  s4-->s2a
  end
  subgraph take damage
  s4-->s5
  s5-->s6
  s6-- Dead -->s7
  s6-- Alive -->s7a
  end

Later I’ll need to fit in a death animation and particles and stuff but this is just what I need now I think.

The Hitbox

So Bruce needs another hitbox, and this one should only be active when we need it to be, and that’s when Bruce is biting. So I added an Area2D node, which is just something that occupies space, and a child CollisionShape2D which I can use to specify the actual area the Area2D will take up, which is just a rectangle around Bruce’s mouth. It extends a bit past his mouth since the animation has Bruce biting forward a bit, and as a quality of life thing as it’d be annoying to really be on top of things when biting it.

This hitbox should also not physically collide with things, and should only be active when we need it. Luckily the Area2D node has some helpful things for achieving that and for checking if anything is in the Area2D.

Monitoring is a property we can set to check whether other bodies are entering & exiting the Area2D. This is something we’ll be toggling as needed because checking if things are in the Area2D when we don’t need to is a waste of resources.

I don’t know if I explained it before but Godot uses Signals which are basically handy functions that are built in, and are triggered when certain things happen. Area2D has one called body_entered which is exactly what I needed for this, we need to check if other bodies entered the hitbox when it’s active so I flipped that on too. And boom! Bite hitbox:

Bite Code

So first thing I did was when we’re biting we’ll also set the bite hitbox’s (which I’ve called bitebox in the code) monitoring property to true so it’ll check if anything enters it during the bite animation. Then when we’re not biting we’ll set it to not be monitoring. That bit is done in the script attached to the Player node.

	if Input.is_action_pressed("bite") and is_biting == false:
		is_biting = true
		bitebox.monitoring = true
		animated_sprite.play("bite")

Next up was to set that monitoring to false once we’re done biting:

# When an animation is done...
func _on_animated_sprite_2d_animation_finished():
	# if the animation that finished was "bite" (aka done biting)
	if animated_sprite.animation == "bite":
		# set the biting state to false
		is_biting = false
		# stop monitoring the bitebox
		bitebox.monitoring = false

Then in the script attached to the bitebox we need to:

• check if anything is in the bitebox
• check if those things that entered the bitebox are damageable
• calculate & apply damage

Things is intentional, given that there’ll be schools of fish I definitely want players to be able to damage more than a single thing at a time! Implementing this took a bit of fiddling and I’m sure I’ll come back to it but so far it looks like this:

# If something enters the bitebox
func _on_body_entered(entity):
  # Check all the pieces of it and see if it's part of the "damageable" group (since things are made up of multiple pieces)
	for entity in entity.get_children():
		if entity is Damageable:
      # if it is, calculate the damage
			var atk_dmg = calc_damage()
      # print statement for testing
			print_debug("Found damageable entity, dealing " + str(atk_dmg) + " damage")
      # and apply it
			entity.damage(atk_dmg)

Here’s what the damage calculation looks like now as well:

func calc_damage():
	var lower_bound = get_parent().damage - 1
	var upper_bound = get_parent().damage + 1
	return randf_range(lower_bound, upper_bound)

I added a tiny bit of randomness to spice things up, but I’ll definitely be testing that later and if it’s just annoying and not interesting I’ll make it a flat number. I’m also going to add a size comparison later. So if you’re overwhelmingly larger than your target you’ll do more damage. Crush them with your size!

The entity.damage(atk_dmg) is this:

func damage(dmg):
	print("Health was: ", str(health))
	health -= dmg
	print("Health is now: ", str(health))
	if health <= 0:
		get_parent().queue_free()

Which is also nice and simple. All the get_parent().queue_free() bit is doing is just a way of saying “delete the thing that this script is attached to.” So when the fish’s health hits zero it’ll be deleted. I’ll need to change this later to play a death animation and then delete it, but that’s for the future.

Aaaaaand!

It almost works. Things rarely work first try so I wasn’t expecting it to 100% work but this is already great. The only issue is that I needed to move away and come back to bite again which shouldn’t be the case. I stopped for the day and instead did some research on Godot “add-ons” which are just plugins that people have made for Godot. I found one that puts the console on top of the window for testing among other things that I quite like! You’ll see it from here on out.

Anyway did some tweaking aaaaaand!

mfw

Classic. More tweaking…

Not gonna lie but I’m writing this article nearly 2 weeks after I did this work so I don’t remember exactly what the issue was, but I’m pretty sure that it was something with the bitebox not being active when I thought it was or being switched off early.

But that’s it! It’s working! More to come soon!

Next goals

• Size increase
  • Didn’t get around to actually increasing Bruce’s size when you eat something but that’s important so it’s next!
• Fish movement
  • Should swim!
• Fish clumping
  • Should swim in schools!
• More fish types
  • Different fish should have different stats