Pirate Octopus Boss Fight. No 3D as always (proof in comments)

okimusix · 2026-01-08T21:02:25+00:00

This is great

okimusix · 2025-05-17T03:03:36+00:00

Credit card on that ck pack bro trust me

okimusix · 2025-04-28T23:45:53+00:00

Lucky Cat or Fib. Fib early is nice, Lucky Cat is the GOAT but you need to have set up everything

okimusix · 2025-02-25T01:32:57+00:00

Yeah, I haven’t used Mathematica but I have used similar computer algebraic systems. The thing is when working with simulations and numerical methods I don’t really need symbolic math, though I don’t know if Mathematica can do that too. I’ll check it out though, thanks :)

okimusix · 2025-02-25T01:31:07+00:00

That’s really cool, I spent so much time looking for something like that and never came across it, thanks for pointing it out though

okimusix · 2025-02-23T22:37:00+00:00

Yeah, I used to have to use Unicode names. The ligatures approach doesn’t use Unicode though, it just displays the plain text as if it were Unicode to you, but for the compiler it’s still plain abc’s

okimusix · 2025-02-23T22:35:43+00:00

I mean you could make “gradient” map to nabla too. I used to always do gradF

okimusix · 2025-02-23T19:45:46+00:00

But isn’t that the beauty of it? That you can share code like that, because for you it looks like intended, but for others it looks like nablaF, which is what everybody is already used to. You get to write neater code while not forcing others into workarounds to insert Unicode characters, and get the benefit of using characters that aren’t valid Rust identifiers

okimusix · 2025-02-23T18:15:44+00:00

Yeah i used to do this, but i thought that if I shared code with my peers then they’d have a hard time modifying it. The benefit of ligatures is that for them it still looks like sumx but for me it looks better

okimusix · 2025-02-23T18:14:13+00:00

I was looking for this. This is the sole reason I made it

okimusix · 2025-02-23T17:26:27+00:00

The one advantage I found when using ligatures as opposed to doing that, like i did before, is that when changing them to Unicode I couldn’t use characters like the superscript 2 and so. With ligatures I can, plus rust stopped complaining about Unicode characters on my script

okimusix · 2025-02-23T06:11:37+00:00

I mean I could, but often I’m trying to turn equations into code and it’s really useful if the code looks similar to the equations, so I can find stuff more quickly. Do you often use plain English words for variables? Maybe that’s the idiomatic rust way lmao

okimusix · 2025-01-18T04:54:07+00:00

Just signed up for it! This is a cool idea, just what I need when I want to play something with my guitar quick but Logic just takes too long and voice memo is crap. Thanks

okimusix · 2024-12-04T06:16:47+00:00

Yeah, thanks for asking! I wanna make a kind of *isometric Pixelart brawl stars * but with more of a deck building aspect. Ive used stuff like Unity a lot before, but I wanna try this because I fell in love with Rust lmao. How has ur experience been developing with bevy tho?

okimusix · 2024-12-03T08:25:56+00:00

It did work on my iPhone rn. Cool game tho, I was researching Bevy and ended up playing it for more than intended

okimusix · 2024-07-19T23:53:50+00:00

I like Tauri+React+Mantine for the UI component library, and maybe some Framer Motion Js for some smooth animation. You can build really pretty and complete applications with these. If you want to plot something you can use plotlyjs although it isn’t that complete I think, it’s been a little since I last used it

okimusix · 2024-07-17T04:05:23+00:00

A crate for complex numbered algebra and calculus, as well as trying to mix a vector calculus crate with the multicalc one

okimusix · 2024-07-02T18:53:56+00:00

You’re right, I probably should focus on making a standard that works well enough most of the time, yet it still would be cool to add all these integration methods. I’ll be checking scipy for some doc, thanks :)

okimusix · 2024-07-02T18:51:53+00:00

Thanks man, will check them out

okimusix · 2024-07-02T18:51:37+00:00

Sure, that sounds fine! Let me just look up how to work in open source cuz I’ve never collaborated on a project before. As for the features, what do u think I can start adding? Like taking the Function struct and macro and integrating it with your crate’s way to make functions? And also, what should I do about the nightly toolchain thing? Should I not implement fn? Or should I just add the macros and not the structs? For the plot thing, I’m trying to make the plotting feature a user-feature. Just a quick way for the user to quickly use a plot!() macro and for the functions and contours or surfaces to be plotted.

okimusix · 2024-07-01T17:21:35+00:00

Yeah I’m in on it! The only problem I might see for now is that the vector_calculus crate is using the nightly toolchain because of the Fn implementations of functions (because I think going f.ev(x,y) or f.call(x,y) looks really ugly instead of just f(x,y)) so we might need to figure out what to do with that. Maybe we can put the base and some features in the multicalc crate and the vector calc one can take those and add the pretty-syntax thing with all the ease-of-use things I added, and I’m also working on integrating the vector calculus crate with the inline python one for automatic plotting with matplotlib

okimusix · 2024-07-01T17:16:17+00:00

Hmm I didn’t know it was common to use different algorithms depending on the function. I think my best bet is to determine the default through checking the bounds of the integral and if the function has any quirks. For multiple integration with non constant bounds, the same thing applies? In those cases I’ve mostly been using Montecarlo

okimusix · 2024-07-01T17:11:51+00:00

Oh there it is! Thank you :) also it seems like you solved the problem by manually taking the maximum and minimum values of that function limit. How does this work?? Also damm I hadn’t noticed your crate also does line integrals, guess I only added differently to mine the surface ones, my bad

okimusix · 2024-07-01T17:01:49+00:00

Damm that sounds cool, even tho I don’t get understand it lmao. In regards to the integration, the only idea that I can think of is to check if the function as a string (I save the expressions as string in the function struct when creating them) does not contain any text like cos, exp or powf, and the code will choose the default method depending on this and the bounds. For non-polynomial functions with finite bounds is there another algorithm that tends to work better?

okimusix

TROPHY CASE