Lights, Camera, Action(?) (Devlog 5)

I made a house in the game! + I made the camera fallow the player! Oh yeah, I also changed the depth system a little bit! (All very thrilling)

Our House

I took the ramps stairs and physics AABB and put them together to make a house. It might look a little questionable at the moment, but it will (probably) look better when I add sprites and texture stuff.

In the Middle of Our Camera

I also updated the camera to follow the player. It’s a very small system but it works well .

More Depth Perception

I updated the depth system so that objects can fit in a specific range of depths instead of the old “all or one” depth style. So, now the depth component is an enumeration with Single, Range, and All states. This is useful for cases like when I want the base floor of a house to persist when going up stairs to the next floor or when going around a stair case (see the video).
Another exiting thing is that I made a macro for creating Depth components. It works like this: depth!() -> Depth::All, depth!(1) -> Depth::Single(1), depth!(1, 3) -> Depth::Range(1, 3). It’s simple, but it’s the first time I have ever made a macro !

The Here and Now

That’s it for now, next I will be working on a collectables system. I wonder, because it shouldn’t be very complex, if I could could post two devlogs in one day…

Bye for now!

Depth Perception (Devlog 4)

Today, I go over how I added a third dimension to my 2D game.

Idea

When running away from the blood axolotl, you may want to run inside a house or around a house. The game’s current setup doesn’t allow for this! So, by adding depth I can give the player more hiding spots, making them feel safe for longer, there for, making them play longer .

Execution (no, not the player, yet)

What I did was make a new component: Depth (how clever of a name). And in the collision reaction code, if two objects have different depth, than have them not collide. If one of the objects doesn’t have the Depth component, make the objects collide anyway. This makes Depth-less objects collide with everything, so I don’t need a bunch of different floor objects for each depth !
Than I also made a simple system so that the player can move depths. I’ll have to change it quite a bit in the future but it is fine for now.

Up next

Next I am going to take the parts I’ve been creating and make buildings a thing. Than I’ll make collectables and the blood axolotl , (probably collectables first).

Final thoughts

Things are going swimmingly. The project should be wrapping up in the coming weeks. The last few things I’ve coded for this project haven’t been supper hard by any means it’s just that I got school and my robotics team is doing a thing for homecoming so I’ve just been kind low on energy :/.

bye!

Stairs! (Devlog 3)

I have made “stairs” in my game Blood Axolotl!

Setup

To be honest, the idea is very simple. All that is happening is that the Physics Object is being displaced to sit on a line. That’s it.

What do you know of a little something called y = mx + b?

To make the Physics Object sit on a line, what I have to do is change the y value (stairs move you up/down). To get what the y value should be all I have to do is solve for y on a slop, such as y = mx + b (my 5th grade math teacher would be so proud of me). But, to be honest slope intercept form kinda sucks, (my 5th grade math teacher rn: ), so I’m using point slope: y - y_1 = m(x - x_1) more specifically, y = m(x - x_1) + y_1 to get just the y value.

Outcome

It works good, more like a ramp, but the game needs more development in every other aria before making the stairs more like stairs.

Bye also, point slope > slope intercept

OFFLINE starting NOW

I have had it up to HERE trying to get neat definition retrieval from the internet working. TODAY, I GO OFFLINE, WOOOOOOOOOOOOH. (I am going to vent a little in this log so if your not a fan of that stuff feel free to take a look at my other logs :)

Stage 1: Anger

Believe it or not, SpellCLI broke, again. And, believe it or not, it’s because of the INTERNET DEFINITION GET FUNCTIONS. There is now this new error. After that I had it, I was going off grid for this update.

Stage 2: Coding

I created a new project turn this epic database (you should check it out) into a rust struct. It works (after 3 and a half hours ;-;) but the out put hash map in-compile-able, it uses more ram than I have 🙏 .

Stage 3: More Coding

So I striped some of the code from that project and inserted it into SpellCLI (as you do) and it worked.

Stage 4: Victory 🍾

After removing the crates I used for web interface the CLI is now very lightweight (well, I compiles very quickly at least). And now, I have a feeling it won’t break this time🤞.

Stage 5: Even More Coding

Well, that’s it for now. SpellCLI is now (officially) THE BEST CLI EVER

BYE BYE

Playable Player (Devlog 2)

I added a simple player system!

Playable Person the Player Plays as

I set up a unit struct called Player that is used to make the object that all player systems will use as the player. Than I crated a system to query for the velocity of the player and change it based on pressed keys.
Not supper complex, but that’s nice some times

The AABB system is my irl blood axolotl 😭

The AABB system strikes back and stopped working when ever it felt like it. Here is the code with the error:

if self.center().x < other.center().x{
     out *= -1.0;
}
if self.center().y < other.center().y{
     out *= -1.0;
}

the fix is to add .x and .y to the two use of out respectively. It took too long to figure that out .

Stay tuned

Up next, I am going to add buildings 🏙️, which I think is hype.

I’ll be back.

AABB = AAHHHHH (Devlog 1)

5 and a half new hours of coding time 🙏 , a fully functioning AABB collision , and maybe something else ¯\_(ツ)_/¯

AABB backwards is blood axolotl

I got the collision system working, only took a little bit. I ended up asking ChatGPT for some help after the fifth hour, turns out I had it all done hours ago and all I had to rely do was flip two >s to <s; my pain is located in the coding bone ;-;.

After allllllll that

Next I’ll try to make a simple player system and than after that building structures. I might also add a few things here or there for fun ;).

Bye, bye

I’m a little burnt out soooo, I’m going to take Friday off.
see y’all later

Well Well Well (Devlog 0)

I have this idea for a simple horror game that involves the apocalypse (maybe), a scary monster, and (you guessed it) an axolotl. This is going to be epic.

The scoped scope

With less than 5 week left of Stardance, I am going to have to think small and hustle. Here is the premise:
you are in the apocalypse and you are stopping at a town to resupply. You need to get three items and get out while not falling pray to the Blood Axolotl (the big scary monster that will provide challenge so the game isn’t boring). Sweet, simple, and to the point.

Gooooooooooals

This project is less about learning something new; I am going to try to increase my programing proficiency. Meaning that I am going to try to come up with systems at a faster pace than normal.

How I feel about school + this now

School started a little while back for me so development will be slowed. I don’t think this will be too much for me, the systems will likely somewhat simple. If I end up taking more than 5 week to finish this, feel free to bug me on Slack for updates on the project ;).

Conclusion

I feel good about this and I think I can do it!
(First image is an altered version of this one, more info in project description)

Bye!! See you soon!!!

My CLI caught a COLD

Today, I will take you through the crazy journey of how my CLI caught a “cold”, how I cured it, and how I ended up crating better error handling because of the whole adventure.

How dose a CLI catch a cold?

So, one day (yesterday), I was using SpellCLI and than suddenly a bunch of treads started to panic, for seemingly no reason! Than, I ran the program again, and it worked perfectly fine.
After a few more tests, the CLI seemed to very in the number and how often these threads panicked. It reminded me of how I am when I have a cold (working in varying efficiencies), so I thought to label the CLI as having a cold (I know it’s not the correct way of labeling a program with this status, but I though it would be funny) .

DON’T PANIC

And just like that I was off to debugging! First, I started with adding debug info like adding names to treads and printing a bunch of information.
After a little bit, I found out that the treads that are panicking are the ones that retrieve definition data from the internet. Specifically, the treads are not getting JSON data but “error code: 502”

Handling the errors

Turns out that error code: 502 means that a bad gateway has interfered with everything, and the best solution is to… try again later. I don’t know why this is just now showing up. If you know or have a guess, feel free to comment!
What this all means is that I had to handle internet errors now. So, I changed the get_word_defs function to return a Result and made the treads handle the result: if a tread got the error 502, it would try again up to 3 times, and it would display any other error to the user! It might not be the most perfect or cleanest fix but it works for the most part!

And with that I am done! Right?

I patched up the CLI and published the new version on crates.io! but, I sometimes get the error 1015 (meaning I set too many requests) and there are a few other things that could be worked on… For now, I’m going to go back to the bevel gears.

Bye, and see you soon!

Bevel gear, oh bevel gear

I have spent the past hour of code time trying to make bevel gears…

Grinding gears

Bevel gears, as it turns out, are somewhat complex. All that haves to
happen is that the teeth need to mesh, but getting there is difficult.
The biggest problem that I have is that to make the teeth fit with the
angle of the gear (45 degrees), the teeth have to shrink the farther
up they go.

My flawless idea

What I’m going to try next is to have the teeth built to always mash at a
specific angle (20 degrees) and than change the angle of the base of
the bevel gear to add up to 90 degrees.

That’s about it

That’s it for this devlog. My bad for the large amount of time this log
covered. It’s just that I am very new to CAD so, the fallowing devlogs
may also cover a lot of time.

Thank you for reading!!! Bye!!!

Analog Log 1

This is my first devlog on this wonderful little project of mine!

The Vision

The idea it that there will be two input vector displays that can be moved about and the sum of the vectors is shown in a third vector display.

No more Rust scopes

Because this idea is kind big for my first CAD project I might have to shrink the scope to only having 1D vector inputs instead of 2D.

The here and now

I am currently working on a differential like gear system that add the drive shaft’s rotation to the output shaft but not the other way around!

The not here nor now

I have absolutely no clue how long this project will take or how difficult this will be, so, I might need some help along the way!

Until next time, Bye!

Compare the words! ++

I have reworked how words are compared (again)!

The best CLI EVER (well, now at least)

SpellCLI has been out for some time! I have been using it and I have found a problem. Words that are anagrams of each other often flood the top results and if the word is spelled incorrectly, give (seemingly) completely random words. This is because the placement of a word was not considered at all in the algorithm described in Compare the words! +

The Great Algorithm

The new algorithm now considers the placement of words (how much they moved) and if words are missing!
Take the words “great” and “rat”. ‘r’ haves to move 1 place and ‘a’ and ‘t’ move 2:

G|R|E|A|T 
-|R|   |   |
_|- |- |A|
_|_ |- |- |T

For a total of 5 movements. Than, the ‘g’ and ‘e’ are left, for a total of 2 leftovers.
Leftovers than get a ×max_len multiplier, this wights them so that moving letters is “more similar” that extra letters.
This gives a total of 15 points of differences. The max amount of difference is calculated as (len1+len2) * max_len (40 in this case). this gives a total of 0.375 difference or 0.625 similarity (63% similar)!

The future of SpellCLI

I don’t know how common devlogs will be for SpellCLI now that the project is done. I don’t have any plans to ship the project again, if I make several changes by the end of the summer I might.

See you in my next project 👀, bye!

Out Now!

SpellCLI is out on crates.io!
The program can be installed with

cargo install spellcli

See you soon(er than you think)!

Output and away!

I have reconfigured how information is outputted and I am very close to shipping.

Out(put)

I have changed the output to display

Is the input word correct?
- if so it's definition
Definitions of similar words

Not a very complex addition but definitely a needed one!

And Out!

Now that everything is cleaned up and working, the project is just about ready to ship! All I need to do now is a few more tests, to work on the README, and get the CLI on crates.io/downloadable with cargo intall SpellCLI!

Good bye!

Multi-threaded Optimizations and a life time of lifetimes

The project is now multi-threaded, there is no more acync code, and there are way fewer lifetimes. I can’t wait to show you all of it!

Taking our time

When I started 3 hours and 44 minutes ago (this is the most amount of coding time I’ve added in a devlog this project!) I tested the speed of the program using the word “anagram”, set to give the top 5 results, I got the speeds: 6314, 5514, and 5488 milliseconds, (from input of anagram to end of program) that’s about 5.5 seconds! That is not very fast, at all.

My Client

The first optimization I implemented is the use (or reuse) of a Client when requesting definitions from the web. A Client is like a connection to the internet (I think). And every time I got a word’s definition, I created a new Client. (You could imagine how inefficient that can get)
Moving over to reuse a Client was very easy (compared to what’s next )
After this change, anagram returned 4332, 3944, and 4038 milliseconds; about 4 seconds, getting better!

My Client requested multiple threads

Next I made each search for a definition run on a separate thread. Implementing this wasn’t too bad. I did have some trouble with lifetimes but a few .clone()s patched up those errors! But, when the code ran, nothing happened. After panting plenty println!()s I found out that the threads weren’t running, at all . I came to the conclusion that the threads weren’t running because they were using acync closures, and everything acync in rust in lazy and needs to be told to ran. After getting frustrated with tokio I switched the acync part of the acync function with it’s blocking equivalent and everything worked! And with that, I didn’t need tokio anymore ¯\_(ツ)_/¯.
This change returned 3628, 3659, and 3982 milliseconds; about 3.5 seconds, good.

My teacher never thought me how to read a dictionary.

Lastly, I decided to make the code that checks every word against the input word, you guessed it, I’m tired multi-threaded!
This is where lifetimes decided to step in .
(in 2 secs: a reference (ref or &) points to an owned value; so if the owned value 💥, the ref . To stop this, lifetimes say: “just don’t 💥 when there’s a ref (+ some 🪄 so things aren’t easy))
I made the code that splits dictionary searching into multiple jobs, easy.
Than, I tried to make the the system run on multi-threaded, not easy.
After fighting &str for too long I finally decided to just turn all the interrupting &strs into Strings (making the values owned; owned values have no lifetimes (I mean, well…)).
The results after all that are 1769, 1666, and 1665 milliseconds; a little over 1.5 seconds, this is very good!

4 paragraphs, 3 improvements, 2 seconds to run, 1 week to launch.

That was a wild ride! I hope you enjoyed! I do have some after thoughts if you would like to continue reading:
When running with run --release, “anagram” took 800 milliseconds, which I consider fast enough. I do have an idea for something that could make the app run even faster, but I’ll add it if I feel like it.
And I am thinking of shipping within the coming 7 days (maybe, sooner).

Bye!!!

Definitions and JSON

I have completed the code that gets definitions for words. Even though the idea is simple, the code is not!

Dictionary

The long journey of getting definitions starts at dictionaryapi.dev. This site allows anyone get a large amount of info on any given word!
At the end of the URL I can add a word and it will give me a word’s synonyms, example uses, and definitions.
Getting the website data is easy enough using reqwest :

reqwest::get(/* URL */).await.unwrap()
        .text().await.unwrap();

This gets all the data that I need (oh, ya, I’ll explain the use of async code later)!

Info

But, the real tricky part is that the data is in JSON and not Rust (who would have though).
Luckily enough, there is a library, serde_json, that helps with Rust-JSON communication!
interfacing with JSON wasn’t too hard, I just find it unusual how everything was wrapped in a vector; I had to access the data like this:

let word_map = &json_body[0]["meanings"][def_num as usize];

let word_def = &word_map["definitions"][0]["definition"];
let part_of_speech = &word_map["partOfSpeech"];

This could be completely normal but, I don’t know. By the way, [def_num as usize] was originally just [def_num] witch is invalid and silently, always returns null. This took too long to find out .

Async and whats next

And now, about the async code. The program is taking longer than I would like to run, so, I’m planing on adding some async and multi-threaded code next.

Bye!

Compare the words! +

I have reworked how words are compared!
before, if I tried to compare “different” and “diferent”
the code would see

| d | i | f | f | e | r | e | n | t |
| d | i | f | e | r | e | n | t |
| ^ | ^ | ^ |X |X | X | X | X | X |

For a total of 33% accuracy (very wrong)!
Now, the new code only compares the difference in letters, without caring about where each letter is placed!
The code now sees:

| d | i | f  | r | e | n | t |  <- all letters used
| 1 | 1 | 2  | 1 | 2 | 1 | 1 |  <- count for "different"
| 1 | 1 | 1  | 1 | 2 | 1 | 1 |   <- count for "diferent"

then calculates the accuracy per letter:

| d | i | f  | r | e | n | t |
| 1 | 1 | .5  | 1 | 1 | 1 | 1 |

witch gives an average (aka accuracy) of 0.928(93%)! This is far better than before!
This can give some results that you wouldn’t think like how the code sees “rustq” as most similar to “quarts” (as seen in the image below).
You can see the function code here.
Now, I’m thinking of getting word definitions for the top i most similar words.
Can’t wait for next time, bye!

Every word in the dictionary

I have created a function that compares an input word against every word in the library wordnik_list (very useful! you should check it out!) and retrieves the top n most similar words. The function is very fast already so I probably won’t need to do anything multi-threaded, but the term “multi-threaded” in a project’s description generally creates a better vibe!
I’m planing on reworking how words are compared because there is an issue with how the current comparison works (I’ll go into more detail once the fix is implemented).
See you later!

Compare the words!

I have added a struct that allows words to be compared for similarity!
It works by checking if each letter in two strings are the same.
So, if I compare “tall” and “wall”: the code will see
t | a| l | l |
w | a | l | l |
❌|✅|✅|✅
for a total of ¾/0.75/75% similarity!
I’m planing on using this functionality to compare the input word against every English word to get the word the user is most likely trying to spell. So I might have to get into multi-threaded code down the line (or should I say twine XD).
Bye!

Setup

I set up a basic utility for the app, being the first_word function. The function isn’t supper complex. What it dose is goes through each character in a string, adds the character to the output if it isn’t white space. If it is white space that the output string is returned.

Idea

My vision for this app is that you will input a word and the CLI will tell you if it is spelled correctly, and definitions of similarly spelled words. It isn’t supper complex but I do see myself using it in the future quite a bit.